Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
483 rajveer 74 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
483 rajveer 77 
     - status
78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
4444 rajveer 219 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 220 
    """
221 
    Parameters:
4394 rajveer 222 
     - type
4444 rajveer 223 
     - warehouseId
4394 rajveer 224 
     - status
225 
     - timestamp
3064 chandransh 226 
    """
227 
    pass
228 
 
4444 rajveer 229 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 230 
    """
231 
    Parameters:
232 
     - type
4444 rajveer 233 
     - warehouseId
4394 rajveer 234 
     - description
3064 chandransh 235 
    """
236 
    pass
237 
 
4444 rajveer 238 
  def markAlertsAsSeen(self, warehouseId):
239 
    """
240 
    Parameters:
241 
     - warehouseId
242 
    """
243 
    pass
244 
 
3064 chandransh 245 
  def getValidOrderCount(self, ):
246 
    """
247 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
248 
    """
249 
    pass
250 
 
251 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
252 
    """
253 
    Returns the number of distinct customers who have done successful transactions
254 
    """
255 
    pass
256 
 
257 
  def getValidOrdersAmountRange(self, ):
258 
    """
259 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
260 
    List contains two values, first minimum amount and second maximum amount.
261 
    """
262 
    pass
263 
 
264 
  def getValidOrders(self, limit):
265 
    """
266 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
267 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 268 
 
3064 chandransh 269 
    Parameters:
270 
     - limit
271 
    """
272 
    pass
273 
 
1220 chandransh 274 
  def batchOrders(self, warehouseId):
275 
    """
276 
    Create a batch of all the pending orders for the given warehouse.
277 
    The returned list is orderd by created_timestamp.
278 
    If there are no pending orders, an empty list is returned.
3431 rajveer 279 
 
1220 chandransh 280 
    Parameters:
281 
     - warehouseId
282 
    """
283 
    pass
284 
 
1208 chandransh 285 
  def markOrderAsOutOfStock(self, orderId):
286 
    """
287 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 288 
 
1208 chandransh 289 
    Parameters:
290 
     - orderId
291 
    """
292 
    pass
293 
 
3064 chandransh 294 
  def verifyOrder(self, orderId):
759 chandransh 295 
    """
3064 chandransh 296 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
297 
    timestamp. It is intended to be used for COD orders but can be harmlessly
298 
    used for all other orders as well.
299 
    Throws an exception if no such order exists.
3431 rajveer 300 
 
759 chandransh 301 
    Parameters:
3064 chandransh 302 
     - orderId
303 
    """
304 
    pass
305 
 
306 
  def acceptOrder(self, orderId):
307 
    """
308 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
309 
    given order is not a COD order, it also captures the payment if the same has
310 
    not been captured.
311 
    Throws an exception if no such order exists.
3431 rajveer 312 
 
3064 chandransh 313 
    Parameters:
314 
     - orderId
315 
    """
316 
    pass
317 
 
4658 mandeep.dh 318 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 319 
    """
320 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 321 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 322 
    the IMEI no. if a -1 is supplied.
323 
    Also, it generates an invoice number for the order, marks the order as
324 
    BILLED and sets the billing timestamp.
325 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 326 
 
3064 chandransh 327 
    Parameters:
328 
     - orderId
4283 anupam.sin 329 
     - invoice_number
4658 mandeep.dh 330 
     - serialNumber
3064 chandransh 331 
     - itemNumber
4283 anupam.sin 332 
     - billed_by
333 
     - jacketNumber
3064 chandransh 334 
     - billingType
4283 anupam.sin 335 
     - vendorId
3064 chandransh 336 
    """
337 
    pass
338 
 
4579 rajveer 339 
  def addInvoiceNumber(self, orderId, invoiceNumber):
340 
    """
341 
    Add the invoice number to the order.
342 
 
343 
    Parameters:
344 
     - orderId
345 
     - invoiceNumber
346 
    """
347 
    pass
348 
 
3064 chandransh 349 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
350 
    """
351 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 352 
    given warehouse and were picked up by the given provider as MANIFESTED.
353 
 
354 
    Parameters:
355 
     - warehouseId
356 
     - providerId
357 
     - cod
358 
    """
359 
    pass
360 
 
361 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
362 
    """
363 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
3064 chandransh 364 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 365 
 
3064 chandransh 366 
    Parameters:
759 chandransh 367 
     - warehouseId
368 
     - providerId
3064 chandransh 369 
     - cod
759 chandransh 370 
    """
371 
    pass
372 
 
1113 chandransh 373 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
374 
    """
375 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
376 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
377 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 378 
 
1113 chandransh 379 
    Parameters:
380 
     - providerId
381 
     - pickupDetails
382 
    """
383 
    pass
384 
 
1132 chandransh 385 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
386 
    """
387 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
388 
    the name of the receiver.
389 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 390 
 
1132 chandransh 391 
    Parameters:
392 
     - providerId
393 
     - deliveredOrders
394 
    """
395 
    pass
396 
 
1135 chandransh 397 
  def markOrdersAsFailed(self, providerId, returnedOrders):
398 
    """
399 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
400 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 401 
 
1135 chandransh 402 
    Parameters:
403 
     - providerId
404 
     - returnedOrders
405 
    """
406 
    pass
407 
 
1246 chandransh 408 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
409 
    """
410 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 411 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 412 
 
1246 chandransh 413 
    Parameters:
414 
     - providerId
415 
     - undeliveredOrders
416 
    """
417 
    pass
418 
 
1408 ankur.sing 419 
  def getUndeliveredOrders(self, providerId, warehouseId):
420 
    """
421 
    Returns the list of orders whose delivery time has passed but have not been
422 
    delivered yet for the given provider and warehouse. To get a complete list of
423 
    undelivered orders, pass them as -1.
424 
    Returns an empty list if no such orders exist.
3431 rajveer 425 
 
1408 ankur.sing 426 
    Parameters:
427 
     - providerId
428 
     - warehouseId
429 
    """
430 
    pass
431 
 
2536 chandransh 432 
  def toggleDOAFlag(self, orderId):
433 
    """
434 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
435 
    Returns the final flag status.
436 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 437 
 
2536 chandransh 438 
    Parameters:
439 
     - orderId
440 
    """
441 
    pass
1886 ankur.sing 442 
 
4454 rajveer 443 
  def markOrderDoaRequestReceived(self, orderId):
444 
    """
445 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
446 
 
447 
    Parameters:
448 
     - orderId
449 
    """
450 
    pass
451 
 
452 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
453 
    """
454 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
455 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
456 
 
457 
    Parameters:
458 
     - orderId
459 
     - isAuthorized
460 
    """
461 
    pass
462 
 
4488 rajveer 463 
  def markOrderReturnRequestReceived(self, orderId):
464 
    """
465 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
466 
 
467 
    Parameters:
468 
     - orderId
469 
    """
470 
    pass
471 
 
472 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
473 
    """
474 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
475 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
476 
 
477 
    Parameters:
478 
     - orderId
479 
     - isAuthorized
480 
    """
481 
    pass
482 
 
4579 rajveer 483 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 484 
    """
485 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 486 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
487 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 488 
    For any other status, it returns false.
489 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 490 
 
2536 chandransh 491 
    Parameters:
492 
     - orderId
4579 rajveer 493 
     - providerId
2536 chandransh 494 
    """
495 
    pass
496 
 
4602 rajveer 497 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 498 
    """
4452 rajveer 499 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 500 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
501 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
502 
    	3. Returns true
2591 chandransh 503 
    If the order is in any other status, it returns false.
2536 chandransh 504 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 505 
 
2536 chandransh 506 
    Parameters:
507 
     - orderId
508 
     - pickupNumber
4602 rajveer 509 
     - providerId
2536 chandransh 510 
    """
511 
    pass
512 
 
2764 chandransh 513 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
514 
    """
515 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
516 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 517 
 
2764 chandransh 518 
    Parameters:
519 
     - providerId
520 
     - pickupDetails
521 
    """
522 
    pass
523 
 
4479 rajveer 524 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 525 
    """
4452 rajveer 526 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 527 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 528 
    If the order is in any other state, it returns false.
529 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 530 
 
2591 chandransh 531 
    Parameters:
532 
     - orderId
4479 rajveer 533 
     - receiveCondition
2591 chandransh 534 
    """
535 
    pass
2536 chandransh 536 
 
2591 chandransh 537 
  def validateDoa(self, orderId, isValid):
538 
    """
4452 rajveer 539 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 540 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 541 
    If the order is in any other state, it returns false.
542 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 543 
 
2591 chandransh 544 
    Parameters:
545 
     - orderId
546 
     - isValid
547 
    """
548 
    pass
549 
 
4495 rajveer 550 
  def validateReturnProduct(self, orderId, isUsable):
551 
    """
552 
    Parameters:
553 
     - orderId
554 
     - isUsable
555 
    """
556 
    pass
557 
 
2616 chandransh 558 
  def reshipOrder(self, orderId):
559 
    """
4484 rajveer 560 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 561 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 562 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 563 
 
564 
    If the order is in DOA_CERT_VALID state, it does the following:
565 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
566 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 567 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 568 
 
2616 chandransh 569 
    Returns the id of the newly created order.
3431 rajveer 570 
 
2616 chandransh 571 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 572 
 
2616 chandransh 573 
    Parameters:
574 
     - orderId
575 
    """
576 
    pass
2591 chandransh 577 
 
3226 chandransh 578 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 579 
    """
4484 rajveer 580 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 581 
    	1. Creates a refund request for batch processing.
582 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 583 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 584 
 
2616 chandransh 585 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
586 
    	1. Creates a refund request for batch processing.
3226 chandransh 587 
    	2. Cancels the reservation of the item in the warehouse.
588 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 589 
 
3226 chandransh 590 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
591 
    	1. Cancels the reservation of the item in the warehouse.
592 
    	2. Marks the current order as CANCELED.
593 
 
594 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
595 
 
2616 chandransh 596 
    Returns True if it is successful, False otherwise.
3431 rajveer 597 
 
2616 chandransh 598 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 599 
 
2616 chandransh 600 
    Parameters:
601 
     - orderId
3226 chandransh 602 
     - refundedBy
603 
     - reason
2616 chandransh 604 
    """
605 
    pass
606 
 
2690 chandransh 607 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
608 
    """
609 
    Get all return orders created between the from and to dates for the given warehouse.
610 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 611 
 
2690 chandransh 612 
    Parameters:
613 
     - warehouseId
614 
     - fromDate
615 
     - toDate
616 
    """
617 
    pass
2616 chandransh 618 
 
2700 chandransh 619 
  def getReturnOrder(self, id):
620 
    """
621 
    Returns the ReturnOrder corresponding to the given id.
622 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 623 
 
2700 chandransh 624 
    Parameters:
625 
     - id
626 
    """
627 
    pass
628 
 
2690 chandransh 629 
  def processReturn(self, returnOrderId):
630 
    """
631 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 632 
 
2690 chandransh 633 
    Parameters:
634 
     - returnOrderId
635 
    """
636 
    pass
637 
 
2819 chandransh 638 
  def createPurchaseOrder(self, warehouseId):
639 
    """
4586 mandeep.dh 640 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
641 
    Returns the list of PO no. of the newly created purchase order.
642 
    Returns null if no new purchase order had to be created.
3431 rajveer 643 
 
2819 chandransh 644 
    Parameters:
645 
     - warehouseId
646 
    """
647 
    pass
2690 chandransh 648 
 
3451 chandransh 649 
  def updateWeight(self, orderId, weight):
650 
    """
651 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 652 
 
3451 chandransh 653 
    Parameters:
654 
     - orderId
655 
     - weight
656 
    """
657 
    pass
658 
 
3469 chandransh 659 
  def changeItem(self, orderId, itemId):
660 
    """
661 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
662 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 663 
 
3469 chandransh 664 
    Parameters:
665 
     - orderId
666 
     - itemId
667 
    """
668 
    pass
669 
 
670 
  def shiftToWarehouse(self, orderId, warehouseId):
671 
    """
672 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
673 
 
674 
    Parameters:
675 
     - orderId
676 
     - warehouseId
677 
    """
678 
    pass
679 
 
4647 rajveer 680 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 681 
    """
682 
    Adds the given delay reason to the given order.
3986 chandransh 683 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 684 
    Raises an exception if no order with the given id can be found.
3469 chandransh 685 
 
3553 chandransh 686 
    Parameters:
687 
     - orderId
688 
     - delayReason
3986 chandransh 689 
     - furtherDelay
4647 rajveer 690 
     - delayReasonText
3553 chandransh 691 
    """
692 
    pass
693 
 
3956 chandransh 694 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
695 
    """
696 
    Marks the COD orders with given AWB nos. as having been processed.
697 
    Updates the captured amount for the corresponding payment.
3553 chandransh 698 
 
3956 chandransh 699 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
700 
    1. There is no order corresponding to an AWB number.
701 
    2. The captured amount for a payment exceeds the total payment.
702 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
703 
 
704 
    Parameters:
705 
     - collectedAmountMap
706 
     - xferBy
707 
     - xferTxnId
708 
     - xferDate
709 
    """
710 
    pass
711 
 
4008 mandeep.dh 712 
  def getTransactionsRequiringExtraProcessing(self, category):
713 
    """
4065 mandeep.dh 714 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 715 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 716 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 717 
 
4008 mandeep.dh 718 
    Parameters:
719 
     - category
720 
    """
721 
    pass
722 
 
723 
  def markTransactionAsProcessed(self, transactionId, category):
724 
    """
725 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 726 
    It essentially deletes the transaction id record for a particular
727 
    processing type category (if present) from DB.
728 
    This is currently used by CRM application.
4008 mandeep.dh 729 
 
730 
    Parameters:
731 
     - transactionId
732 
     - category
733 
    """
734 
    pass
735 
 
4018 chandransh 736 
  def getItemWiseRiskyOrdersCount(self, ):
737 
    """
738 
    Returns a map containing the number of risky orders keyed by item id. A risky order
739 
    is defined as one whose shipping date is about to expire.
740 
    """
741 
    pass
4008 mandeep.dh 742 
 
4295 varun.gupt 743 
  def getOrdersForItemIds(self, itemIds):
744 
    """
745 
    Returns a list of all orders which have items with given id
746 
 
747 
    Parameters:
748 
     - itemIds
749 
    """
750 
    pass
751 
 
4247 rajveer 752 
  def markOrderCancellationRequestReceived(self, orderId):
753 
    """
754 
    Mark order as cancellation request received. If customer sends request of cancellation of
755 
    a particular order, this method will be called. It will just change status of the order
756 
    depending on its current status. It also records the previous status, so that we can move
757 
    back to that status if cancellation request is denied.
4018 chandransh 758 
 
4247 rajveer 759 
    Parameters:
760 
     - orderId
761 
    """
762 
    pass
763 
 
764 
  def markOrderCancellationRequestConfirmed(self, orderId):
765 
    """
766 
    If we decide to to cancel order, CRM will call this method to move the status of order to
767 
    cancellation request confirmed. After this OM will be able to cancel the order.
768 
 
769 
    Parameters:
770 
     - orderId
771 
    """
772 
    pass
773 
 
774 
  def markOrderCancellationRequestDenied(self, orderId):
775 
    """
776 
    If we decide to not to cancel order, we will move the order ro previous status.
777 
 
778 
    Parameters:
779 
     - orderId
780 
    """
781 
    pass
782 
 
4258 rajveer 783 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 784 
    """
4258 rajveer 785 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
786 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 787 
 
788 
    Parameters:
4258 rajveer 789 
     - transactionId
4247 rajveer 790 
    """
791 
    pass
792 
 
4259 anupam.sin 793 
  def refundTransaction(self, transactionId, refundedBy, reason):
794 
    """
795 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
796 
    need to be cancelled
4247 rajveer 797 
 
4259 anupam.sin 798 
    Parameters:
799 
     - transactionId
800 
     - refundedBy
801 
     - reason
802 
    """
803 
    pass
804 
 
4324 mandeep.dh 805 
  def updateShipmentAddress(self, orderId, addressId):
806 
    """
807 
    Updates shipment address of an order. Delivery and shipping date estimates
808 
    etc. are also updated here.
809 
 
810 
    Throws TransactionServiceException in case address change is not
811 
    possible due to certain reasons such as new pincode in address is
812 
    not serviceable etc.
813 
 
814 
    Parameters:
815 
     - orderId
816 
     - addressId
817 
    """
818 
    pass
819 
 
4285 rajveer 820 
  def acceptOrdersForItemId(self, itemId, inventory):
821 
    """
822 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
823 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 824 
 
4285 rajveer 825 
    Parameters:
826 
     - itemId
827 
     - inventory
828 
    """
829 
    pass
830 
 
4369 rajveer 831 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 832 
    """
833 
    Parameters:
834 
     - vendorId
835 
     - itemId
836 
     - quantity
837 
     - estimate
4369 rajveer 838 
     - isReminder
4303 rajveer 839 
    """
840 
    pass
4285 rajveer 841 
 
4369 rajveer 842 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 843 
    """
844 
    Parameters:
845 
     - vendorId
846 
     - itemId
847 
     - quantity
848 
     - estimate
4369 rajveer 849 
     - isReminder
4303 rajveer 850 
    """
851 
    pass
852 
 
4369 rajveer 853 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 854 
    """
855 
    Parameters:
856 
     - vendorId
857 
     - itemId
858 
     - quantity
859 
     - estimate
4369 rajveer 860 
     - isReminder
4303 rajveer 861 
    """
862 
    pass
863 
 
4369 rajveer 864 
  def markOrdersAsTimeout(self, vendorId):
865 
    """
866 
    Parameters:
867 
     - vendorId
868 
    """
869 
    pass
4303 rajveer 870 
 
4662 rajveer 871 
  def markOrderAsLostInTransit(self, orderId):
872 
    """
873 
    Mark order as LOST_IN_TRANSIT
874 
 
875 
    Parameters:
876 
     - orderId
877 
    """
878 
    pass
879 
 
4386 anupam.sin 880 
  def getOrderForAwb(self, awb):
881 
    """
882 
    Returns the order corresponding to an AWB number
4369 rajveer 883 
 
4386 anupam.sin 884 
    Parameters:
885 
     - awb
886 
    """
887 
    pass
888 
 
4506 phani.kuma 889 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
890 
    """
891 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 892 
 
4506 phani.kuma 893 
    Parameters:
894 
     - logistics_provider_id
895 
     - order_status
896 
    """
897 
    pass
898 
 
4600 varun.gupt 899 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
900 
    """
901 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 902 
 
4600 varun.gupt 903 
    Parameters:
904 
     - vendorId
905 
     - billingDateFrom
906 
     - billingDateTo
907 
    """
908 
    pass
909 
 
4607 rajveer 910 
  def getSlippedSippingDateOrders(self, ):
911 
    pass
912 
 
4709 rajveer 913 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
914 
    """
915 
    Parameters:
916 
     - cancelDateFrom
917 
     - cancelDateTo
918 
    """
919 
    pass
920 
 
4600 varun.gupt 921 
  def saveBluedartSettlements(self, mapAWBAndAmount):
922 
    """
923 
    Parameters:
924 
     - mapAWBAndAmount
925 
    """
926 
    pass
927 
 
928 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
929 
    """
930 
    Parameters:
931 
     - settlementDate
932 
     - paymentGatewayId
933 
     - paymentId
934 
     - serviceTax
935 
     - otherCharges
936 
     - netCollection
937 
    """
938 
    pass
939 
 
940 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
941 
    """
942 
    Parameters:
943 
     - settlementId
944 
     - settlementDate
945 
     - transactionDateFrom
946 
     - transactionDateTo
947 
     - amount
948 
    """
949 
    pass
950 
 
951 
  def getSettlementForPaymentId(self, paymentId):
952 
    """
953 
    Parameters:
954 
     - paymentId
955 
    """
956 
    pass
957 
 
958 
  def getEBSSettlementSummaries(self, ):
959 
    pass
960 
 
961 
  def markEBSSettlementUploaded(self, settlementId):
962 
    """
963 
    Parameters:
964 
     - settlementId
965 
    """
966 
    pass
967 
 
968 
  def getEBSSettlementDate(self, settlementId):
969 
    """
970 
    Parameters:
971 
     - settlementId
972 
    """
973 
    pass
974 
 
975 
 
3376 rajveer 976 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 977 
  def __init__(self, iprot, oprot=None):
3376 rajveer 978 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 979 
 
980 
  def createTransaction(self, transaction):
981 
    """
982 
    Parameters:
983 
     - transaction
984 
    """
985 
    self.send_createTransaction(transaction)
132 ashish 986 
    return self.recv_createTransaction()
94 ashish 987 
 
988 
  def send_createTransaction(self, transaction):
989 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
990 
    args = createTransaction_args()
991 
    args.transaction = transaction
992 
    args.write(self._oprot)
993 
    self._oprot.writeMessageEnd()
994 
    self._oprot.trans.flush()
995 
 
996 
  def recv_createTransaction(self, ):
997 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
998 
    if mtype == TMessageType.EXCEPTION:
999 
      x = TApplicationException()
1000 
      x.read(self._iprot)
1001 
      self._iprot.readMessageEnd()
1002 
      raise x
1003 
    result = createTransaction_result()
1004 
    result.read(self._iprot)
1005 
    self._iprot.readMessageEnd()
3431 rajveer 1006 
    if result.success is not None:
132 ashish 1007 
      return result.success
3431 rajveer 1008 
    if result.ex is not None:
94 ashish 1009 
      raise result.ex
132 ashish 1010 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1011 
 
1012 
  def getTransaction(self, id):
1013 
    """
1014 
    Parameters:
1015 
     - id
1016 
    """
1017 
    self.send_getTransaction(id)
1018 
    return self.recv_getTransaction()
1019 
 
1020 
  def send_getTransaction(self, id):
1021 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1022 
    args = getTransaction_args()
1023 
    args.id = id
1024 
    args.write(self._oprot)
1025 
    self._oprot.writeMessageEnd()
1026 
    self._oprot.trans.flush()
1027 
 
1028 
  def recv_getTransaction(self, ):
1029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1030 
    if mtype == TMessageType.EXCEPTION:
1031 
      x = TApplicationException()
1032 
      x.read(self._iprot)
1033 
      self._iprot.readMessageEnd()
1034 
      raise x
1035 
    result = getTransaction_result()
1036 
    result.read(self._iprot)
1037 
    self._iprot.readMessageEnd()
3431 rajveer 1038 
    if result.success is not None:
94 ashish 1039 
      return result.success
3431 rajveer 1040 
    if result.ex is not None:
94 ashish 1041 
      raise result.ex
1042 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1043 
 
1044 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1045 
    """
1046 
    Parameters:
1047 
     - customerId
1048 
     - from_date
1049 
     - to_date
1050 
     - status
1051 
    """
1052 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1053 
    return self.recv_getTransactionsForCustomer()
1054 
 
1055 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1056 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1057 
    args = getTransactionsForCustomer_args()
1058 
    args.customerId = customerId
1059 
    args.from_date = from_date
1060 
    args.to_date = to_date
1061 
    args.status = status
1062 
    args.write(self._oprot)
1063 
    self._oprot.writeMessageEnd()
1064 
    self._oprot.trans.flush()
1065 
 
1066 
  def recv_getTransactionsForCustomer(self, ):
1067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1068 
    if mtype == TMessageType.EXCEPTION:
1069 
      x = TApplicationException()
1070 
      x.read(self._iprot)
1071 
      self._iprot.readMessageEnd()
1072 
      raise x
1073 
    result = getTransactionsForCustomer_result()
1074 
    result.read(self._iprot)
1075 
    self._iprot.readMessageEnd()
3431 rajveer 1076 
    if result.success is not None:
94 ashish 1077 
      return result.success
3431 rajveer 1078 
    if result.ex is not None:
94 ashish 1079 
      raise result.ex
1080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1081 
 
132 ashish 1082 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1083 
    """
1084 
    Parameters:
1085 
     - shoppingCartId
1086 
    """
1087 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1088 
    return self.recv_getTransactionsForShoppingCartId()
1089 
 
1090 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1091 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1092 
    args = getTransactionsForShoppingCartId_args()
1093 
    args.shoppingCartId = shoppingCartId
1094 
    args.write(self._oprot)
1095 
    self._oprot.writeMessageEnd()
1096 
    self._oprot.trans.flush()
1097 
 
1098 
  def recv_getTransactionsForShoppingCartId(self, ):
1099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1100 
    if mtype == TMessageType.EXCEPTION:
1101 
      x = TApplicationException()
1102 
      x.read(self._iprot)
1103 
      self._iprot.readMessageEnd()
1104 
      raise x
1105 
    result = getTransactionsForShoppingCartId_result()
1106 
    result.read(self._iprot)
1107 
    self._iprot.readMessageEnd()
3431 rajveer 1108 
    if result.success is not None:
132 ashish 1109 
      return result.success
3431 rajveer 1110 
    if result.ex is not None:
132 ashish 1111 
      raise result.ex
1112 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1113 
 
94 ashish 1114 
  def getTransactionStatus(self, transactionId):
1115 
    """
1116 
    Parameters:
1117 
     - transactionId
1118 
    """
1119 
    self.send_getTransactionStatus(transactionId)
1120 
    return self.recv_getTransactionStatus()
1121 
 
1122 
  def send_getTransactionStatus(self, transactionId):
1123 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1124 
    args = getTransactionStatus_args()
1125 
    args.transactionId = transactionId
1126 
    args.write(self._oprot)
1127 
    self._oprot.writeMessageEnd()
1128 
    self._oprot.trans.flush()
1129 
 
1130 
  def recv_getTransactionStatus(self, ):
1131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1132 
    if mtype == TMessageType.EXCEPTION:
1133 
      x = TApplicationException()
1134 
      x.read(self._iprot)
1135 
      self._iprot.readMessageEnd()
1136 
      raise x
1137 
    result = getTransactionStatus_result()
1138 
    result.read(self._iprot)
1139 
    self._iprot.readMessageEnd()
3431 rajveer 1140 
    if result.success is not None:
94 ashish 1141 
      return result.success
3431 rajveer 1142 
    if result.ex is not None:
94 ashish 1143 
      raise result.ex
1144 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1145 
 
1146 
  def changeTransactionStatus(self, transactionId, status, description):
1147 
    """
1148 
    Parameters:
1149 
     - transactionId
1150 
     - status
1151 
     - description
1152 
    """
1153 
    self.send_changeTransactionStatus(transactionId, status, description)
1154 
    return self.recv_changeTransactionStatus()
1155 
 
1156 
  def send_changeTransactionStatus(self, transactionId, status, description):
1157 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1158 
    args = changeTransactionStatus_args()
1159 
    args.transactionId = transactionId
1160 
    args.status = status
1161 
    args.description = description
1162 
    args.write(self._oprot)
1163 
    self._oprot.writeMessageEnd()
1164 
    self._oprot.trans.flush()
1165 
 
1166 
  def recv_changeTransactionStatus(self, ):
1167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1168 
    if mtype == TMessageType.EXCEPTION:
1169 
      x = TApplicationException()
1170 
      x.read(self._iprot)
1171 
      self._iprot.readMessageEnd()
1172 
      raise x
1173 
    result = changeTransactionStatus_result()
1174 
    result.read(self._iprot)
1175 
    self._iprot.readMessageEnd()
3431 rajveer 1176 
    if result.success is not None:
94 ashish 1177 
      return result.success
3431 rajveer 1178 
    if result.ex is not None:
94 ashish 1179 
      raise result.ex
1180 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1181 
 
1398 varun.gupt 1182 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1183 
    """
1184 
    Parameters:
1185 
     - transactionId
1186 
    """
1398 varun.gupt 1187 
    self.send_enqueueTransactionInfoEmail(transactionId)
1188 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1189 
 
1398 varun.gupt 1190 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1191 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1192 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1193 
    args.transactionId = transactionId
1194 
    args.write(self._oprot)
1195 
    self._oprot.writeMessageEnd()
1196 
    self._oprot.trans.flush()
1197 
 
1398 varun.gupt 1198 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1200 
    if mtype == TMessageType.EXCEPTION:
1201 
      x = TApplicationException()
1202 
      x.read(self._iprot)
1203 
      self._iprot.readMessageEnd()
1204 
      raise x
1398 varun.gupt 1205 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1206 
    result.read(self._iprot)
1207 
    self._iprot.readMessageEnd()
3431 rajveer 1208 
    if result.success is not None:
1382 varun.gupt 1209 
      return result.success
3431 rajveer 1210 
    if result.ex is not None:
1382 varun.gupt 1211 
      raise result.ex
1398 varun.gupt 1212 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1213 
 
483 rajveer 1214 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1215 
    """
1216 
    Parameters:
483 rajveer 1217 
     - status
1218 
     - from_date
1219 
     - to_date
1220 
     - warehouse_id
94 ashish 1221 
    """
483 rajveer 1222 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1223 
    return self.recv_getAllOrders()
94 ashish 1224 
 
483 rajveer 1225 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1226 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1227 
    args = getAllOrders_args()
1228 
    args.status = status
1229 
    args.from_date = from_date
1230 
    args.to_date = to_date
1231 
    args.warehouse_id = warehouse_id
94 ashish 1232 
    args.write(self._oprot)
1233 
    self._oprot.writeMessageEnd()
1234 
    self._oprot.trans.flush()
1235 
 
483 rajveer 1236 
  def recv_getAllOrders(self, ):
94 ashish 1237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1238 
    if mtype == TMessageType.EXCEPTION:
1239 
      x = TApplicationException()
1240 
      x.read(self._iprot)
1241 
      self._iprot.readMessageEnd()
1242 
      raise x
483 rajveer 1243 
    result = getAllOrders_result()
94 ashish 1244 
    result.read(self._iprot)
1245 
    self._iprot.readMessageEnd()
3431 rajveer 1246 
    if result.success is not None:
94 ashish 1247 
      return result.success
3431 rajveer 1248 
    if result.ex is not None:
94 ashish 1249 
      raise result.ex
483 rajveer 1250 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1251 
 
4133 chandransh 1252 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1253 
    """
1254 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1255 
    Pass the status as null and the limit as 0 to ignore them.
1256 
 
1257 
    Parameters:
1258 
     - statuses
1259 
     - offset
1260 
     - limit
1261 
     - warehouse_id
1262 
    """
1263 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1264 
    return self.recv_getOrdersInBatch()
1265 
 
1266 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1267 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1268 
    args = getOrdersInBatch_args()
1269 
    args.statuses = statuses
1270 
    args.offset = offset
1271 
    args.limit = limit
1272 
    args.warehouse_id = warehouse_id
1273 
    args.write(self._oprot)
1274 
    self._oprot.writeMessageEnd()
1275 
    self._oprot.trans.flush()
1276 
 
1277 
  def recv_getOrdersInBatch(self, ):
1278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1279 
    if mtype == TMessageType.EXCEPTION:
1280 
      x = TApplicationException()
1281 
      x.read(self._iprot)
1282 
      self._iprot.readMessageEnd()
1283 
      raise x
1284 
    result = getOrdersInBatch_result()
1285 
    result.read(self._iprot)
1286 
    self._iprot.readMessageEnd()
1287 
    if result.success is not None:
1288 
      return result.success
1289 
    if result.ex is not None:
1290 
      raise result.ex
1291 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1292 
 
1293 
  def getOrderCount(self, statuses, warehouseId):
1294 
    """
1295 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1296 
 
1297 
    Parameters:
1298 
     - statuses
1299 
     - warehouseId
1300 
    """
1301 
    self.send_getOrderCount(statuses, warehouseId)
1302 
    return self.recv_getOrderCount()
1303 
 
1304 
  def send_getOrderCount(self, statuses, warehouseId):
1305 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1306 
    args = getOrderCount_args()
1307 
    args.statuses = statuses
1308 
    args.warehouseId = warehouseId
1309 
    args.write(self._oprot)
1310 
    self._oprot.writeMessageEnd()
1311 
    self._oprot.trans.flush()
1312 
 
1313 
  def recv_getOrderCount(self, ):
1314 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1315 
    if mtype == TMessageType.EXCEPTION:
1316 
      x = TApplicationException()
1317 
      x.read(self._iprot)
1318 
      self._iprot.readMessageEnd()
1319 
      raise x
1320 
    result = getOrderCount_result()
1321 
    result.read(self._iprot)
1322 
    self._iprot.readMessageEnd()
1323 
    if result.success is not None:
1324 
      return result.success
1325 
    if result.ex is not None:
1326 
      raise result.ex
1327 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1328 
 
999 varun.gupt 1329 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1330 
    """
1132 chandransh 1331 
    Returns orders within a range of their billing dates
3431 rajveer 1332 
 
999 varun.gupt 1333 
    Parameters:
1334 
     - status
1335 
     - start_billing_date
1336 
     - end_billing_date
1337 
     - warehouse_id
1338 
    """
1339 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1340 
    return self.recv_getOrdersByBillingDate()
1341 
 
1342 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1343 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1344 
    args = getOrdersByBillingDate_args()
1345 
    args.status = status
1346 
    args.start_billing_date = start_billing_date
1347 
    args.end_billing_date = end_billing_date
1348 
    args.warehouse_id = warehouse_id
1349 
    args.write(self._oprot)
1350 
    self._oprot.writeMessageEnd()
1351 
    self._oprot.trans.flush()
1352 
 
1353 
  def recv_getOrdersByBillingDate(self, ):
1354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1355 
    if mtype == TMessageType.EXCEPTION:
1356 
      x = TApplicationException()
1357 
      x.read(self._iprot)
1358 
      self._iprot.readMessageEnd()
1359 
      raise x
1360 
    result = getOrdersByBillingDate_result()
1361 
    result.read(self._iprot)
1362 
    self._iprot.readMessageEnd()
3431 rajveer 1363 
    if result.success is not None:
999 varun.gupt 1364 
      return result.success
3431 rajveer 1365 
    if result.ex is not None:
999 varun.gupt 1366 
      raise result.ex
1367 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1368 
 
3451 chandransh 1369 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1370 
    """
1371 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1372 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1373 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1374 
 
3427 chandransh 1375 
    Parameters:
1376 
     - fromShippingDate
1377 
     - toShippingDate
1378 
     - providerId
1379 
     - warehouseId
3451 chandransh 1380 
     - cod
3427 chandransh 1381 
    """
3451 chandransh 1382 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1383 
    return self.recv_getOrdersByShippingDate()
1384 
 
3451 chandransh 1385 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1386 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1387 
    args = getOrdersByShippingDate_args()
1388 
    args.fromShippingDate = fromShippingDate
1389 
    args.toShippingDate = toShippingDate
1390 
    args.providerId = providerId
1391 
    args.warehouseId = warehouseId
3451 chandransh 1392 
    args.cod = cod
3427 chandransh 1393 
    args.write(self._oprot)
1394 
    self._oprot.writeMessageEnd()
1395 
    self._oprot.trans.flush()
1396 
 
1397 
  def recv_getOrdersByShippingDate(self, ):
1398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1399 
    if mtype == TMessageType.EXCEPTION:
1400 
      x = TApplicationException()
1401 
      x.read(self._iprot)
1402 
      self._iprot.readMessageEnd()
1403 
      raise x
1404 
    result = getOrdersByShippingDate_result()
1405 
    result.read(self._iprot)
1406 
    self._iprot.readMessageEnd()
3431 rajveer 1407 
    if result.success is not None:
3427 chandransh 1408 
      return result.success
3431 rajveer 1409 
    if result.ex is not None:
3427 chandransh 1410 
      raise result.ex
1411 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1412 
 
1382 varun.gupt 1413 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1414 
    """
1415 
    Returns order ids for orders which can be returned
3431 rajveer 1416 
 
1382 varun.gupt 1417 
    Parameters:
1418 
     - customer_id
1419 
     - limit
1420 
    """
1421 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1422 
    return self.recv_getReturnableOrdersForCustomer()
1423 
 
1424 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1425 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1426 
    args = getReturnableOrdersForCustomer_args()
1427 
    args.customer_id = customer_id
1428 
    args.limit = limit
1429 
    args.write(self._oprot)
1430 
    self._oprot.writeMessageEnd()
1431 
    self._oprot.trans.flush()
1432 
 
1433 
  def recv_getReturnableOrdersForCustomer(self, ):
1434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1435 
    if mtype == TMessageType.EXCEPTION:
1436 
      x = TApplicationException()
1437 
      x.read(self._iprot)
1438 
      self._iprot.readMessageEnd()
1439 
      raise x
1440 
    result = getReturnableOrdersForCustomer_result()
1441 
    result.read(self._iprot)
1442 
    self._iprot.readMessageEnd()
3431 rajveer 1443 
    if result.success is not None:
1382 varun.gupt 1444 
      return result.success
3431 rajveer 1445 
    if result.ex is not None:
1382 varun.gupt 1446 
      raise result.ex
1447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1448 
 
1449 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1450 
    """
1451 
    Returns order ids for orders which can be cancelled
3431 rajveer 1452 
 
1382 varun.gupt 1453 
    Parameters:
1454 
     - customer_id
1455 
     - limit
1456 
    """
1457 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1458 
    return self.recv_getCancellableOrdersForCustomer()
1459 
 
1460 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1461 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1462 
    args = getCancellableOrdersForCustomer_args()
1463 
    args.customer_id = customer_id
1464 
    args.limit = limit
1465 
    args.write(self._oprot)
1466 
    self._oprot.writeMessageEnd()
1467 
    self._oprot.trans.flush()
1468 
 
1469 
  def recv_getCancellableOrdersForCustomer(self, ):
1470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1471 
    if mtype == TMessageType.EXCEPTION:
1472 
      x = TApplicationException()
1473 
      x.read(self._iprot)
1474 
      self._iprot.readMessageEnd()
1475 
      raise x
1476 
    result = getCancellableOrdersForCustomer_result()
1477 
    result.read(self._iprot)
1478 
    self._iprot.readMessageEnd()
3431 rajveer 1479 
    if result.success is not None:
1382 varun.gupt 1480 
      return result.success
3431 rajveer 1481 
    if result.ex is not None:
1382 varun.gupt 1482 
      raise result.ex
1483 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1484 
 
483 rajveer 1485 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1486 
    """
1487 
    Parameters:
483 rajveer 1488 
     - orderId
1489 
     - status
1490 
     - description
94 ashish 1491 
    """
483 rajveer 1492 
    self.send_changeOrderStatus(orderId, status, description)
1493 
    return self.recv_changeOrderStatus()
94 ashish 1494 
 
483 rajveer 1495 
  def send_changeOrderStatus(self, orderId, status, description):
1496 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1497 
    args = changeOrderStatus_args()
1498 
    args.orderId = orderId
1499 
    args.status = status
1500 
    args.description = description
94 ashish 1501 
    args.write(self._oprot)
1502 
    self._oprot.writeMessageEnd()
1503 
    self._oprot.trans.flush()
1504 
 
483 rajveer 1505 
  def recv_changeOrderStatus(self, ):
94 ashish 1506 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1507 
    if mtype == TMessageType.EXCEPTION:
1508 
      x = TApplicationException()
1509 
      x.read(self._iprot)
1510 
      self._iprot.readMessageEnd()
1511 
      raise x
483 rajveer 1512 
    result = changeOrderStatus_result()
94 ashish 1513 
    result.read(self._iprot)
1514 
    self._iprot.readMessageEnd()
3431 rajveer 1515 
    if result.success is not None:
94 ashish 1516 
      return result.success
3431 rajveer 1517 
    if result.ex is not None:
94 ashish 1518 
      raise result.ex
483 rajveer 1519 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1520 
 
1528 ankur.sing 1521 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1522 
    """
1528 ankur.sing 1523 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1524 
    only user who owns the transaction can view its order details.
3431 rajveer 1525 
 
94 ashish 1526 
    Parameters:
1527 
     - transactionId
1528 ankur.sing 1528 
     - customerId
94 ashish 1529 
    """
1528 ankur.sing 1530 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1531 
    return self.recv_getOrdersForTransaction()
94 ashish 1532 
 
1528 ankur.sing 1533 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1534 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1535 
    args = getOrdersForTransaction_args()
94 ashish 1536 
    args.transactionId = transactionId
1528 ankur.sing 1537 
    args.customerId = customerId
94 ashish 1538 
    args.write(self._oprot)
1539 
    self._oprot.writeMessageEnd()
1540 
    self._oprot.trans.flush()
1541 
 
483 rajveer 1542 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1544 
    if mtype == TMessageType.EXCEPTION:
1545 
      x = TApplicationException()
1546 
      x.read(self._iprot)
1547 
      self._iprot.readMessageEnd()
1548 
      raise x
483 rajveer 1549 
    result = getOrdersForTransaction_result()
94 ashish 1550 
    result.read(self._iprot)
1551 
    self._iprot.readMessageEnd()
3431 rajveer 1552 
    if result.success is not None:
94 ashish 1553 
      return result.success
3431 rajveer 1554 
    if result.ex is not None:
94 ashish 1555 
      raise result.ex
483 rajveer 1556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1557 
 
3014 chandransh 1558 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1559 
    """
3014 chandransh 1560 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1561 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1562 
 
94 ashish 1563 
    Parameters:
483 rajveer 1564 
     - customerId
1565 
     - from_date
1566 
     - to_date
3014 chandransh 1567 
     - statuses
94 ashish 1568 
    """
3014 chandransh 1569 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1570 
    return self.recv_getOrdersForCustomer()
94 ashish 1571 
 
3014 chandransh 1572 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1573 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1574 
    args = getOrdersForCustomer_args()
1575 
    args.customerId = customerId
1576 
    args.from_date = from_date
1577 
    args.to_date = to_date
3014 chandransh 1578 
    args.statuses = statuses
94 ashish 1579 
    args.write(self._oprot)
1580 
    self._oprot.writeMessageEnd()
1581 
    self._oprot.trans.flush()
1582 
 
483 rajveer 1583 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1584 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1585 
    if mtype == TMessageType.EXCEPTION:
1586 
      x = TApplicationException()
1587 
      x.read(self._iprot)
1588 
      self._iprot.readMessageEnd()
1589 
      raise x
483 rajveer 1590 
    result = getOrdersForCustomer_result()
94 ashish 1591 
    result.read(self._iprot)
1592 
    self._iprot.readMessageEnd()
3431 rajveer 1593 
    if result.success is not None:
94 ashish 1594 
      return result.success
3431 rajveer 1595 
    if result.ex is not None:
94 ashish 1596 
      raise result.ex
483 rajveer 1597 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1598 
 
483 rajveer 1599 
  def createOrder(self, order):
94 ashish 1600 
    """
1601 
    Parameters:
483 rajveer 1602 
     - order
94 ashish 1603 
    """
483 rajveer 1604 
    self.send_createOrder(order)
1605 
    return self.recv_createOrder()
94 ashish 1606 
 
483 rajveer 1607 
  def send_createOrder(self, order):
1608 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1609 
    args = createOrder_args()
1610 
    args.order = order
94 ashish 1611 
    args.write(self._oprot)
1612 
    self._oprot.writeMessageEnd()
1613 
    self._oprot.trans.flush()
1614 
 
483 rajveer 1615 
  def recv_createOrder(self, ):
94 ashish 1616 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1617 
    if mtype == TMessageType.EXCEPTION:
1618 
      x = TApplicationException()
1619 
      x.read(self._iprot)
1620 
      self._iprot.readMessageEnd()
1621 
      raise x
483 rajveer 1622 
    result = createOrder_result()
94 ashish 1623 
    result.read(self._iprot)
1624 
    self._iprot.readMessageEnd()
3431 rajveer 1625 
    if result.success is not None:
94 ashish 1626 
      return result.success
3431 rajveer 1627 
    if result.ex is not None:
94 ashish 1628 
      raise result.ex
483 rajveer 1629 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1630 
 
483 rajveer 1631 
  def getOrder(self, id):
94 ashish 1632 
    """
1633 
    Parameters:
483 rajveer 1634 
     - id
94 ashish 1635 
    """
483 rajveer 1636 
    self.send_getOrder(id)
1637 
    return self.recv_getOrder()
94 ashish 1638 
 
483 rajveer 1639 
  def send_getOrder(self, id):
1640 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1641 
    args = getOrder_args()
1642 
    args.id = id
94 ashish 1643 
    args.write(self._oprot)
1644 
    self._oprot.writeMessageEnd()
1645 
    self._oprot.trans.flush()
1646 
 
483 rajveer 1647 
  def recv_getOrder(self, ):
94 ashish 1648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1649 
    if mtype == TMessageType.EXCEPTION:
1650 
      x = TApplicationException()
1651 
      x.read(self._iprot)
1652 
      self._iprot.readMessageEnd()
1653 
      raise x
483 rajveer 1654 
    result = getOrder_result()
94 ashish 1655 
    result.read(self._iprot)
1656 
    self._iprot.readMessageEnd()
3431 rajveer 1657 
    if result.success is not None:
94 ashish 1658 
      return result.success
3431 rajveer 1659 
    if result.ex is not None:
94 ashish 1660 
      raise result.ex
483 rajveer 1661 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1662 
 
483 rajveer 1663 
  def getLineItemsForOrder(self, orderId):
94 ashish 1664 
    """
1665 
    Parameters:
483 rajveer 1666 
     - orderId
94 ashish 1667 
    """
483 rajveer 1668 
    self.send_getLineItemsForOrder(orderId)
1669 
    return self.recv_getLineItemsForOrder()
94 ashish 1670 
 
483 rajveer 1671 
  def send_getLineItemsForOrder(self, orderId):
1672 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1673 
    args = getLineItemsForOrder_args()
1674 
    args.orderId = orderId
94 ashish 1675 
    args.write(self._oprot)
1676 
    self._oprot.writeMessageEnd()
1677 
    self._oprot.trans.flush()
1678 
 
483 rajveer 1679 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1681 
    if mtype == TMessageType.EXCEPTION:
1682 
      x = TApplicationException()
1683 
      x.read(self._iprot)
1684 
      self._iprot.readMessageEnd()
1685 
      raise x
483 rajveer 1686 
    result = getLineItemsForOrder_result()
94 ashish 1687 
    result.read(self._iprot)
1688 
    self._iprot.readMessageEnd()
3431 rajveer 1689 
    if result.success is not None:
94 ashish 1690 
      return result.success
3431 rajveer 1691 
    if result.ex is not None:
94 ashish 1692 
      raise result.ex
483 rajveer 1693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1694 
 
1528 ankur.sing 1695 
  def getOrderForCustomer(self, orderId, customerId):
1696 
    """
1697 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1698 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1699 
 
1528 ankur.sing 1700 
    Parameters:
1701 
     - orderId
1702 
     - customerId
1703 
    """
1704 
    self.send_getOrderForCustomer(orderId, customerId)
1705 
    return self.recv_getOrderForCustomer()
1706 
 
1707 
  def send_getOrderForCustomer(self, orderId, customerId):
1708 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1709 
    args = getOrderForCustomer_args()
1710 
    args.orderId = orderId
1711 
    args.customerId = customerId
1712 
    args.write(self._oprot)
1713 
    self._oprot.writeMessageEnd()
1714 
    self._oprot.trans.flush()
1715 
 
1716 
  def recv_getOrderForCustomer(self, ):
1717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1718 
    if mtype == TMessageType.EXCEPTION:
1719 
      x = TApplicationException()
1720 
      x.read(self._iprot)
1721 
      self._iprot.readMessageEnd()
1722 
      raise x
1723 
    result = getOrderForCustomer_result()
1724 
    result.read(self._iprot)
1725 
    self._iprot.readMessageEnd()
3431 rajveer 1726 
    if result.success is not None:
1528 ankur.sing 1727 
      return result.success
3431 rajveer 1728 
    if result.ex is not None:
1528 ankur.sing 1729 
      raise result.ex
1730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1731 
 
4444 rajveer 1732 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1733 
    """
1734 
    Parameters:
4394 rajveer 1735 
     - type
4444 rajveer 1736 
     - warehouseId
4394 rajveer 1737 
     - status
1738 
     - timestamp
3064 chandransh 1739 
    """
4444 rajveer 1740 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1741 
    return self.recv_getAlerts()
1742 
 
4444 rajveer 1743 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1744 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1745 
    args = getAlerts_args()
4394 rajveer 1746 
    args.type = type
4444 rajveer 1747 
    args.warehouseId = warehouseId
4394 rajveer 1748 
    args.status = status
1749 
    args.timestamp = timestamp
3064 chandransh 1750 
    args.write(self._oprot)
1751 
    self._oprot.writeMessageEnd()
1752 
    self._oprot.trans.flush()
1753 
 
1754 
  def recv_getAlerts(self, ):
1755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1756 
    if mtype == TMessageType.EXCEPTION:
1757 
      x = TApplicationException()
1758 
      x.read(self._iprot)
1759 
      self._iprot.readMessageEnd()
1760 
      raise x
1761 
    result = getAlerts_result()
1762 
    result.read(self._iprot)
1763 
    self._iprot.readMessageEnd()
3431 rajveer 1764 
    if result.success is not None:
3064 chandransh 1765 
      return result.success
1766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1767 
 
4444 rajveer 1768 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1769 
    """
1770 
    Parameters:
1771 
     - type
4444 rajveer 1772 
     - warehouseId
4394 rajveer 1773 
     - description
3064 chandransh 1774 
    """
4444 rajveer 1775 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1776 
    self.recv_addAlert()
3064 chandransh 1777 
 
4444 rajveer 1778 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1779 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1780 
    args = addAlert_args()
3064 chandransh 1781 
    args.type = type
4444 rajveer 1782 
    args.warehouseId = warehouseId
4394 rajveer 1783 
    args.description = description
3064 chandransh 1784 
    args.write(self._oprot)
1785 
    self._oprot.writeMessageEnd()
1786 
    self._oprot.trans.flush()
1787 
 
4394 rajveer 1788 
  def recv_addAlert(self, ):
3064 chandransh 1789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1790 
    if mtype == TMessageType.EXCEPTION:
1791 
      x = TApplicationException()
1792 
      x.read(self._iprot)
1793 
      self._iprot.readMessageEnd()
1794 
      raise x
4394 rajveer 1795 
    result = addAlert_result()
3064 chandransh 1796 
    result.read(self._iprot)
1797 
    self._iprot.readMessageEnd()
1798 
    return
1799 
 
4444 rajveer 1800 
  def markAlertsAsSeen(self, warehouseId):
1801 
    """
1802 
    Parameters:
1803 
     - warehouseId
1804 
    """
1805 
    self.send_markAlertsAsSeen(warehouseId)
1806 
    self.recv_markAlertsAsSeen()
1807 
 
1808 
  def send_markAlertsAsSeen(self, warehouseId):
1809 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1810 
    args = markAlertsAsSeen_args()
1811 
    args.warehouseId = warehouseId
1812 
    args.write(self._oprot)
1813 
    self._oprot.writeMessageEnd()
1814 
    self._oprot.trans.flush()
1815 
 
1816 
  def recv_markAlertsAsSeen(self, ):
1817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1818 
    if mtype == TMessageType.EXCEPTION:
1819 
      x = TApplicationException()
1820 
      x.read(self._iprot)
1821 
      self._iprot.readMessageEnd()
1822 
      raise x
1823 
    result = markAlertsAsSeen_result()
1824 
    result.read(self._iprot)
1825 
    self._iprot.readMessageEnd()
1826 
    return
1827 
 
3064 chandransh 1828 
  def getValidOrderCount(self, ):
1829 
    """
1830 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1831 
    """
1832 
    self.send_getValidOrderCount()
1833 
    return self.recv_getValidOrderCount()
1834 
 
1835 
  def send_getValidOrderCount(self, ):
1836 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1837 
    args = getValidOrderCount_args()
1838 
    args.write(self._oprot)
1839 
    self._oprot.writeMessageEnd()
1840 
    self._oprot.trans.flush()
1841 
 
1842 
  def recv_getValidOrderCount(self, ):
1843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1844 
    if mtype == TMessageType.EXCEPTION:
1845 
      x = TApplicationException()
1846 
      x.read(self._iprot)
1847 
      self._iprot.readMessageEnd()
1848 
      raise x
1849 
    result = getValidOrderCount_result()
1850 
    result.read(self._iprot)
1851 
    self._iprot.readMessageEnd()
3431 rajveer 1852 
    if result.success is not None:
3064 chandransh 1853 
      return result.success
1854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1855 
 
1856 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1857 
    """
1858 
    Returns the number of distinct customers who have done successful transactions
1859 
    """
1860 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1861 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1862 
 
1863 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1864 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1865 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1866 
    args.write(self._oprot)
1867 
    self._oprot.writeMessageEnd()
1868 
    self._oprot.trans.flush()
1869 
 
1870 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1871 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1872 
    if mtype == TMessageType.EXCEPTION:
1873 
      x = TApplicationException()
1874 
      x.read(self._iprot)
1875 
      self._iprot.readMessageEnd()
1876 
      raise x
1877 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1878 
    result.read(self._iprot)
1879 
    self._iprot.readMessageEnd()
3431 rajveer 1880 
    if result.success is not None:
3064 chandransh 1881 
      return result.success
1882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1883 
 
1884 
  def getValidOrdersAmountRange(self, ):
1885 
    """
1886 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1887 
    List contains two values, first minimum amount and second maximum amount.
1888 
    """
1889 
    self.send_getValidOrdersAmountRange()
1890 
    return self.recv_getValidOrdersAmountRange()
1891 
 
1892 
  def send_getValidOrdersAmountRange(self, ):
1893 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1894 
    args = getValidOrdersAmountRange_args()
1895 
    args.write(self._oprot)
1896 
    self._oprot.writeMessageEnd()
1897 
    self._oprot.trans.flush()
1898 
 
1899 
  def recv_getValidOrdersAmountRange(self, ):
1900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1901 
    if mtype == TMessageType.EXCEPTION:
1902 
      x = TApplicationException()
1903 
      x.read(self._iprot)
1904 
      self._iprot.readMessageEnd()
1905 
      raise x
1906 
    result = getValidOrdersAmountRange_result()
1907 
    result.read(self._iprot)
1908 
    self._iprot.readMessageEnd()
3431 rajveer 1909 
    if result.success is not None:
3064 chandransh 1910 
      return result.success
1911 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1912 
 
1913 
  def getValidOrders(self, limit):
1914 
    """
1915 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1916 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1917 
 
3064 chandransh 1918 
    Parameters:
1919 
     - limit
1920 
    """
1921 
    self.send_getValidOrders(limit)
1922 
    return self.recv_getValidOrders()
1923 
 
1924 
  def send_getValidOrders(self, limit):
1925 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1926 
    args = getValidOrders_args()
1927 
    args.limit = limit
1928 
    args.write(self._oprot)
1929 
    self._oprot.writeMessageEnd()
1930 
    self._oprot.trans.flush()
1931 
 
1932 
  def recv_getValidOrders(self, ):
1933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1934 
    if mtype == TMessageType.EXCEPTION:
1935 
      x = TApplicationException()
1936 
      x.read(self._iprot)
1937 
      self._iprot.readMessageEnd()
1938 
      raise x
1939 
    result = getValidOrders_result()
1940 
    result.read(self._iprot)
1941 
    self._iprot.readMessageEnd()
3431 rajveer 1942 
    if result.success is not None:
3064 chandransh 1943 
      return result.success
1944 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1945 
 
1220 chandransh 1946 
  def batchOrders(self, warehouseId):
1947 
    """
1948 
    Create a batch of all the pending orders for the given warehouse.
1949 
    The returned list is orderd by created_timestamp.
1950 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1951 
 
1220 chandransh 1952 
    Parameters:
1953 
     - warehouseId
1954 
    """
1955 
    self.send_batchOrders(warehouseId)
1956 
    return self.recv_batchOrders()
1957 
 
1958 
  def send_batchOrders(self, warehouseId):
1959 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1960 
    args = batchOrders_args()
1961 
    args.warehouseId = warehouseId
1962 
    args.write(self._oprot)
1963 
    self._oprot.writeMessageEnd()
1964 
    self._oprot.trans.flush()
1965 
 
1966 
  def recv_batchOrders(self, ):
1967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1968 
    if mtype == TMessageType.EXCEPTION:
1969 
      x = TApplicationException()
1970 
      x.read(self._iprot)
1971 
      self._iprot.readMessageEnd()
1972 
      raise x
1973 
    result = batchOrders_result()
1974 
    result.read(self._iprot)
1975 
    self._iprot.readMessageEnd()
3431 rajveer 1976 
    if result.success is not None:
1220 chandransh 1977 
      return result.success
3431 rajveer 1978 
    if result.ex is not None:
1220 chandransh 1979 
      raise result.ex
1980 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1981 
 
1208 chandransh 1982 
  def markOrderAsOutOfStock(self, orderId):
1983 
    """
1984 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1985 
 
1208 chandransh 1986 
    Parameters:
1987 
     - orderId
1988 
    """
1989 
    self.send_markOrderAsOutOfStock(orderId)
1990 
    return self.recv_markOrderAsOutOfStock()
1991 
 
1992 
  def send_markOrderAsOutOfStock(self, orderId):
1993 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1994 
    args = markOrderAsOutOfStock_args()
1995 
    args.orderId = orderId
1996 
    args.write(self._oprot)
1997 
    self._oprot.writeMessageEnd()
1998 
    self._oprot.trans.flush()
1999 
 
2000 
  def recv_markOrderAsOutOfStock(self, ):
2001 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2002 
    if mtype == TMessageType.EXCEPTION:
2003 
      x = TApplicationException()
2004 
      x.read(self._iprot)
2005 
      self._iprot.readMessageEnd()
2006 
      raise x
2007 
    result = markOrderAsOutOfStock_result()
2008 
    result.read(self._iprot)
2009 
    self._iprot.readMessageEnd()
3431 rajveer 2010 
    if result.success is not None:
1208 chandransh 2011 
      return result.success
3431 rajveer 2012 
    if result.ex is not None:
1208 chandransh 2013 
      raise result.ex
2014 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2015 
 
3064 chandransh 2016 
  def verifyOrder(self, orderId):
759 chandransh 2017 
    """
3064 chandransh 2018 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2019 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2020 
    used for all other orders as well.
2021 
    Throws an exception if no such order exists.
3431 rajveer 2022 
 
759 chandransh 2023 
    Parameters:
3064 chandransh 2024 
     - orderId
759 chandransh 2025 
    """
3064 chandransh 2026 
    self.send_verifyOrder(orderId)
2027 
    return self.recv_verifyOrder()
759 chandransh 2028 
 
3064 chandransh 2029 
  def send_verifyOrder(self, orderId):
2030 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2031 
    args = verifyOrder_args()
2032 
    args.orderId = orderId
759 chandransh 2033 
    args.write(self._oprot)
2034 
    self._oprot.writeMessageEnd()
2035 
    self._oprot.trans.flush()
2036 
 
3064 chandransh 2037 
  def recv_verifyOrder(self, ):
759 chandransh 2038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2039 
    if mtype == TMessageType.EXCEPTION:
2040 
      x = TApplicationException()
2041 
      x.read(self._iprot)
2042 
      self._iprot.readMessageEnd()
2043 
      raise x
3064 chandransh 2044 
    result = verifyOrder_result()
759 chandransh 2045 
    result.read(self._iprot)
2046 
    self._iprot.readMessageEnd()
3431 rajveer 2047 
    if result.success is not None:
759 chandransh 2048 
      return result.success
3431 rajveer 2049 
    if result.ex is not None:
759 chandransh 2050 
      raise result.ex
3064 chandransh 2051 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2052 
 
3064 chandransh 2053 
  def acceptOrder(self, orderId):
1113 chandransh 2054 
    """
3064 chandransh 2055 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2056 
    given order is not a COD order, it also captures the payment if the same has
2057 
    not been captured.
2058 
    Throws an exception if no such order exists.
3431 rajveer 2059 
 
1113 chandransh 2060 
    Parameters:
3064 chandransh 2061 
     - orderId
1113 chandransh 2062 
    """
3064 chandransh 2063 
    self.send_acceptOrder(orderId)
2064 
    return self.recv_acceptOrder()
1113 chandransh 2065 
 
3064 chandransh 2066 
  def send_acceptOrder(self, orderId):
2067 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2068 
    args = acceptOrder_args()
2069 
    args.orderId = orderId
1113 chandransh 2070 
    args.write(self._oprot)
2071 
    self._oprot.writeMessageEnd()
2072 
    self._oprot.trans.flush()
2073 
 
3064 chandransh 2074 
  def recv_acceptOrder(self, ):
1113 chandransh 2075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2076 
    if mtype == TMessageType.EXCEPTION:
2077 
      x = TApplicationException()
2078 
      x.read(self._iprot)
2079 
      self._iprot.readMessageEnd()
2080 
      raise x
3064 chandransh 2081 
    result = acceptOrder_result()
1113 chandransh 2082 
    result.read(self._iprot)
2083 
    self._iprot.readMessageEnd()
3431 rajveer 2084 
    if result.success is not None:
1113 chandransh 2085 
      return result.success
3431 rajveer 2086 
    if result.ex is not None:
1113 chandransh 2087 
      raise result.ex
3064 chandransh 2088 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2089 
 
4658 mandeep.dh 2090 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 2091 
    """
3064 chandransh 2092 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2093 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2094 
    the IMEI no. if a -1 is supplied.
2095 
    Also, it generates an invoice number for the order, marks the order as
2096 
    BILLED and sets the billing timestamp.
2097 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2098 
 
1135 chandransh 2099 
    Parameters:
3064 chandransh 2100 
     - orderId
2101 
     - invoice_number
4658 mandeep.dh 2102 
     - serialNumber
4283 anupam.sin 2103 
     - itemNumber
3064 chandransh 2104 
     - billed_by
4264 rajveer 2105 
     - jacketNumber
4283 anupam.sin 2106 
     - billingType
2107 
     - vendorId
1135 chandransh 2108 
    """
4658 mandeep.dh 2109 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 2110 
    return self.recv_addBillingDetails()
1135 chandransh 2111 
 
4658 mandeep.dh 2112 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 2113 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2114 
    args = addBillingDetails_args()
2115 
    args.orderId = orderId
2116 
    args.invoice_number = invoice_number
4658 mandeep.dh 2117 
    args.serialNumber = serialNumber
4283 anupam.sin 2118 
    args.itemNumber = itemNumber
3064 chandransh 2119 
    args.billed_by = billed_by
4264 rajveer 2120 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2121 
    args.billingType = billingType
2122 
    args.vendorId = vendorId
1135 chandransh 2123 
    args.write(self._oprot)
2124 
    self._oprot.writeMessageEnd()
2125 
    self._oprot.trans.flush()
2126 
 
3064 chandransh 2127 
  def recv_addBillingDetails(self, ):
1135 chandransh 2128 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2129 
    if mtype == TMessageType.EXCEPTION:
2130 
      x = TApplicationException()
2131 
      x.read(self._iprot)
2132 
      self._iprot.readMessageEnd()
2133 
      raise x
3064 chandransh 2134 
    result = addBillingDetails_result()
1135 chandransh 2135 
    result.read(self._iprot)
2136 
    self._iprot.readMessageEnd()
3431 rajveer 2137 
    if result.success is not None:
3064 chandransh 2138 
      return result.success
3431 rajveer 2139 
    if result.ex is not None:
1135 chandransh 2140 
      raise result.ex
3064 chandransh 2141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2142 
 
4579 rajveer 2143 
  def addInvoiceNumber(self, orderId, invoiceNumber):
2144 
    """
2145 
    Add the invoice number to the order.
2146 
 
2147 
    Parameters:
2148 
     - orderId
2149 
     - invoiceNumber
2150 
    """
2151 
    self.send_addInvoiceNumber(orderId, invoiceNumber)
2152 
    self.recv_addInvoiceNumber()
2153 
 
2154 
  def send_addInvoiceNumber(self, orderId, invoiceNumber):
2155 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2156 
    args = addInvoiceNumber_args()
2157 
    args.orderId = orderId
2158 
    args.invoiceNumber = invoiceNumber
2159 
    args.write(self._oprot)
2160 
    self._oprot.writeMessageEnd()
2161 
    self._oprot.trans.flush()
2162 
 
2163 
  def recv_addInvoiceNumber(self, ):
2164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2165 
    if mtype == TMessageType.EXCEPTION:
2166 
      x = TApplicationException()
2167 
      x.read(self._iprot)
2168 
      self._iprot.readMessageEnd()
2169 
      raise x
2170 
    result = addInvoiceNumber_result()
2171 
    result.read(self._iprot)
2172 
    self._iprot.readMessageEnd()
2173 
    if result.ex is not None:
2174 
      raise result.ex
2175 
    return
2176 
 
3064 chandransh 2177 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2178 
    """
3064 chandransh 2179 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2180 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2181 
 
1408 ankur.sing 2182 
    Parameters:
3064 chandransh 2183 
     - warehouseId
1408 ankur.sing 2184 
     - providerId
3064 chandransh 2185 
     - cod
1408 ankur.sing 2186 
    """
3064 chandransh 2187 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2188 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2189 
 
3064 chandransh 2190 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2191 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2192 
    args = markOrdersAsManifested_args()
2193 
    args.warehouseId = warehouseId
1408 ankur.sing 2194 
    args.providerId = providerId
3064 chandransh 2195 
    args.cod = cod
1408 ankur.sing 2196 
    args.write(self._oprot)
2197 
    self._oprot.writeMessageEnd()
2198 
    self._oprot.trans.flush()
2199 
 
3064 chandransh 2200 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2201 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2202 
    if mtype == TMessageType.EXCEPTION:
2203 
      x = TApplicationException()
2204 
      x.read(self._iprot)
2205 
      self._iprot.readMessageEnd()
2206 
      raise x
3064 chandransh 2207 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2208 
    result.read(self._iprot)
2209 
    self._iprot.readMessageEnd()
3431 rajveer 2210 
    if result.success is not None:
1408 ankur.sing 2211 
      return result.success
3431 rajveer 2212 
    if result.ex is not None:
3064 chandransh 2213 
      raise result.ex
2214 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2215 
 
4410 rajveer 2216 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2217 
    """
2218 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2219 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2220 
 
2221 
    Parameters:
2222 
     - warehouseId
2223 
     - providerId
2224 
     - cod
2225 
    """
2226 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2227 
    return self.recv_markOrdersAsShippedFromWarehouse()
2228 
 
2229 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2230 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2231 
    args = markOrdersAsShippedFromWarehouse_args()
2232 
    args.warehouseId = warehouseId
2233 
    args.providerId = providerId
2234 
    args.cod = cod
2235 
    args.write(self._oprot)
2236 
    self._oprot.writeMessageEnd()
2237 
    self._oprot.trans.flush()
2238 
 
2239 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2241 
    if mtype == TMessageType.EXCEPTION:
2242 
      x = TApplicationException()
2243 
      x.read(self._iprot)
2244 
      self._iprot.readMessageEnd()
2245 
      raise x
2246 
    result = markOrdersAsShippedFromWarehouse_result()
2247 
    result.read(self._iprot)
2248 
    self._iprot.readMessageEnd()
2249 
    if result.success is not None:
2250 
      return result.success
2251 
    if result.ex is not None:
2252 
      raise result.ex
2253 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2254 
 
3064 chandransh 2255 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2256 
    """
3064 chandransh 2257 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2258 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2259 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2260 
 
94 ashish 2261 
    Parameters:
3064 chandransh 2262 
     - providerId
2263 
     - pickupDetails
304 ashish 2264 
    """
3064 chandransh 2265 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2266 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2267 
 
3064 chandransh 2268 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2269 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2270 
    args = markOrdersAsPickedUp_args()
2271 
    args.providerId = providerId
2272 
    args.pickupDetails = pickupDetails
304 ashish 2273 
    args.write(self._oprot)
2274 
    self._oprot.writeMessageEnd()
2275 
    self._oprot.trans.flush()
2276 
 
3064 chandransh 2277 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2279 
    if mtype == TMessageType.EXCEPTION:
2280 
      x = TApplicationException()
2281 
      x.read(self._iprot)
2282 
      self._iprot.readMessageEnd()
2283 
      raise x
3064 chandransh 2284 
    result = markOrdersAsPickedUp_result()
304 ashish 2285 
    result.read(self._iprot)
2286 
    self._iprot.readMessageEnd()
3431 rajveer 2287 
    if result.success is not None:
304 ashish 2288 
      return result.success
3431 rajveer 2289 
    if result.ex is not None:
3064 chandransh 2290 
      raise result.ex
2291 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2292 
 
3064 chandransh 2293 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2294 
    """
3064 chandransh 2295 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2296 
    the name of the receiver.
2297 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2298 
 
304 ashish 2299 
    Parameters:
3064 chandransh 2300 
     - providerId
2301 
     - deliveredOrders
304 ashish 2302 
    """
3064 chandransh 2303 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2304 
    self.recv_markOrdersAsDelivered()
304 ashish 2305 
 
3064 chandransh 2306 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2307 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2308 
    args = markOrdersAsDelivered_args()
2309 
    args.providerId = providerId
2310 
    args.deliveredOrders = deliveredOrders
304 ashish 2311 
    args.write(self._oprot)
2312 
    self._oprot.writeMessageEnd()
2313 
    self._oprot.trans.flush()
2314 
 
3064 chandransh 2315 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2317 
    if mtype == TMessageType.EXCEPTION:
2318 
      x = TApplicationException()
2319 
      x.read(self._iprot)
2320 
      self._iprot.readMessageEnd()
2321 
      raise x
3064 chandransh 2322 
    result = markOrdersAsDelivered_result()
304 ashish 2323 
    result.read(self._iprot)
2324 
    self._iprot.readMessageEnd()
3431 rajveer 2325 
    if result.ex is not None:
3064 chandransh 2326 
      raise result.ex
304 ashish 2327 
    return
2328 
 
3064 chandransh 2329 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2330 
    """
3064 chandransh 2331 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2332 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2333 
 
3064 chandransh 2334 
    Parameters:
2335 
     - providerId
2336 
     - returnedOrders
1596 ankur.sing 2337 
    """
3064 chandransh 2338 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2339 
    self.recv_markOrdersAsFailed()
304 ashish 2340 
 
3064 chandransh 2341 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2342 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2343 
    args = markOrdersAsFailed_args()
2344 
    args.providerId = providerId
2345 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2346 
    args.write(self._oprot)
2347 
    self._oprot.writeMessageEnd()
2348 
    self._oprot.trans.flush()
2349 
 
3064 chandransh 2350 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2351 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2352 
    if mtype == TMessageType.EXCEPTION:
2353 
      x = TApplicationException()
2354 
      x.read(self._iprot)
2355 
      self._iprot.readMessageEnd()
2356 
      raise x
3064 chandransh 2357 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2358 
    result.read(self._iprot)
2359 
    self._iprot.readMessageEnd()
3431 rajveer 2360 
    if result.ex is not None:
3064 chandransh 2361 
      raise result.ex
2362 
    return
1596 ankur.sing 2363 
 
3064 chandransh 2364 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2365 
    """
3064 chandransh 2366 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2367 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2368 
 
3064 chandransh 2369 
    Parameters:
2370 
     - providerId
2371 
     - undeliveredOrders
1627 ankur.sing 2372 
    """
3064 chandransh 2373 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2374 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2375 
 
3064 chandransh 2376 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2377 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2378 
    args = updateNonDeliveryReason_args()
2379 
    args.providerId = providerId
2380 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2381 
    args.write(self._oprot)
2382 
    self._oprot.writeMessageEnd()
2383 
    self._oprot.trans.flush()
2384 
 
3064 chandransh 2385 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2387 
    if mtype == TMessageType.EXCEPTION:
2388 
      x = TApplicationException()
2389 
      x.read(self._iprot)
2390 
      self._iprot.readMessageEnd()
2391 
      raise x
3064 chandransh 2392 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2393 
    result.read(self._iprot)
2394 
    self._iprot.readMessageEnd()
4581 phani.kuma 2395 
    if result.success is not None:
2396 
      return result.success
3431 rajveer 2397 
    if result.ex is not None:
3064 chandransh 2398 
      raise result.ex
4581 phani.kuma 2399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2400 
 
3064 chandransh 2401 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2402 
    """
3064 chandransh 2403 
    Returns the list of orders whose delivery time has passed but have not been
2404 
    delivered yet for the given provider and warehouse. To get a complete list of
2405 
    undelivered orders, pass them as -1.
2406 
    Returns an empty list if no such orders exist.
3431 rajveer 2407 
 
1886 ankur.sing 2408 
    Parameters:
3064 chandransh 2409 
     - providerId
2410 
     - warehouseId
1886 ankur.sing 2411 
    """
3064 chandransh 2412 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2413 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2414 
 
3064 chandransh 2415 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2416 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2417 
    args = getUndeliveredOrders_args()
2418 
    args.providerId = providerId
2419 
    args.warehouseId = warehouseId
1886 ankur.sing 2420 
    args.write(self._oprot)
2421 
    self._oprot.writeMessageEnd()
2422 
    self._oprot.trans.flush()
2423 
 
3064 chandransh 2424 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2426 
    if mtype == TMessageType.EXCEPTION:
2427 
      x = TApplicationException()
2428 
      x.read(self._iprot)
2429 
      self._iprot.readMessageEnd()
2430 
      raise x
3064 chandransh 2431 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2432 
    result.read(self._iprot)
2433 
    self._iprot.readMessageEnd()
3431 rajveer 2434 
    if result.success is not None:
1886 ankur.sing 2435 
      return result.success
3064 chandransh 2436 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2437 
 
2536 chandransh 2438 
  def toggleDOAFlag(self, orderId):
2439 
    """
2440 
    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.
2441 
    Returns the final flag status.
2442 
    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 2443 
 
2536 chandransh 2444 
    Parameters:
2445 
     - orderId
2446 
    """
2447 
    self.send_toggleDOAFlag(orderId)
2448 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2449 
 
2536 chandransh 2450 
  def send_toggleDOAFlag(self, orderId):
2451 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2452 
    args = toggleDOAFlag_args()
2453 
    args.orderId = orderId
2454 
    args.write(self._oprot)
2455 
    self._oprot.writeMessageEnd()
2456 
    self._oprot.trans.flush()
2457 
 
2458 
  def recv_toggleDOAFlag(self, ):
2459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2460 
    if mtype == TMessageType.EXCEPTION:
2461 
      x = TApplicationException()
2462 
      x.read(self._iprot)
2463 
      self._iprot.readMessageEnd()
2464 
      raise x
2465 
    result = toggleDOAFlag_result()
2466 
    result.read(self._iprot)
2467 
    self._iprot.readMessageEnd()
3431 rajveer 2468 
    if result.success is not None:
2536 chandransh 2469 
      return result.success
3431 rajveer 2470 
    if result.ex is not None:
2536 chandransh 2471 
      raise result.ex
2472 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2473 
 
4454 rajveer 2474 
  def markOrderDoaRequestReceived(self, orderId):
2475 
    """
2476 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2477 
 
2478 
    Parameters:
2479 
     - orderId
2480 
    """
2481 
    self.send_markOrderDoaRequestReceived(orderId)
2482 
    return self.recv_markOrderDoaRequestReceived()
2483 
 
2484 
  def send_markOrderDoaRequestReceived(self, orderId):
2485 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2486 
    args = markOrderDoaRequestReceived_args()
2487 
    args.orderId = orderId
2488 
    args.write(self._oprot)
2489 
    self._oprot.writeMessageEnd()
2490 
    self._oprot.trans.flush()
2491 
 
2492 
  def recv_markOrderDoaRequestReceived(self, ):
2493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2494 
    if mtype == TMessageType.EXCEPTION:
2495 
      x = TApplicationException()
2496 
      x.read(self._iprot)
2497 
      self._iprot.readMessageEnd()
2498 
      raise x
2499 
    result = markOrderDoaRequestReceived_result()
2500 
    result.read(self._iprot)
2501 
    self._iprot.readMessageEnd()
2502 
    if result.success is not None:
2503 
      return result.success
2504 
    if result.ex is not None:
2505 
      raise result.ex
2506 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2507 
 
2508 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2509 
    """
2510 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2511 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2512 
 
2513 
    Parameters:
2514 
     - orderId
2515 
     - isAuthorized
2516 
    """
2517 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2518 
    return self.recv_markOrderDoaRequestAuthorized()
2519 
 
2520 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2521 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2522 
    args = markOrderDoaRequestAuthorized_args()
2523 
    args.orderId = orderId
2524 
    args.isAuthorized = isAuthorized
2525 
    args.write(self._oprot)
2526 
    self._oprot.writeMessageEnd()
2527 
    self._oprot.trans.flush()
2528 
 
2529 
  def recv_markOrderDoaRequestAuthorized(self, ):
2530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2531 
    if mtype == TMessageType.EXCEPTION:
2532 
      x = TApplicationException()
2533 
      x.read(self._iprot)
2534 
      self._iprot.readMessageEnd()
2535 
      raise x
2536 
    result = markOrderDoaRequestAuthorized_result()
2537 
    result.read(self._iprot)
2538 
    self._iprot.readMessageEnd()
2539 
    if result.success is not None:
2540 
      return result.success
2541 
    if result.ex is not None:
2542 
      raise result.ex
2543 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2544 
 
4488 rajveer 2545 
  def markOrderReturnRequestReceived(self, orderId):
2546 
    """
2547 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2548 
 
2549 
    Parameters:
2550 
     - orderId
2551 
    """
2552 
    self.send_markOrderReturnRequestReceived(orderId)
2553 
    return self.recv_markOrderReturnRequestReceived()
2554 
 
2555 
  def send_markOrderReturnRequestReceived(self, orderId):
2556 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2557 
    args = markOrderReturnRequestReceived_args()
2558 
    args.orderId = orderId
2559 
    args.write(self._oprot)
2560 
    self._oprot.writeMessageEnd()
2561 
    self._oprot.trans.flush()
2562 
 
2563 
  def recv_markOrderReturnRequestReceived(self, ):
2564 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2565 
    if mtype == TMessageType.EXCEPTION:
2566 
      x = TApplicationException()
2567 
      x.read(self._iprot)
2568 
      self._iprot.readMessageEnd()
2569 
      raise x
2570 
    result = markOrderReturnRequestReceived_result()
2571 
    result.read(self._iprot)
2572 
    self._iprot.readMessageEnd()
2573 
    if result.success is not None:
2574 
      return result.success
2575 
    if result.ex is not None:
2576 
      raise result.ex
2577 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2578 
 
2579 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2580 
    """
2581 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2582 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2583 
 
2584 
    Parameters:
2585 
     - orderId
2586 
     - isAuthorized
2587 
    """
2588 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2589 
    return self.recv_markOrderReturnRequestAuthorized()
2590 
 
2591 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2592 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2593 
    args = markOrderReturnRequestAuthorized_args()
2594 
    args.orderId = orderId
2595 
    args.isAuthorized = isAuthorized
2596 
    args.write(self._oprot)
2597 
    self._oprot.writeMessageEnd()
2598 
    self._oprot.trans.flush()
2599 
 
2600 
  def recv_markOrderReturnRequestAuthorized(self, ):
2601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2602 
    if mtype == TMessageType.EXCEPTION:
2603 
      x = TApplicationException()
2604 
      x.read(self._iprot)
2605 
      self._iprot.readMessageEnd()
2606 
      raise x
2607 
    result = markOrderReturnRequestAuthorized_result()
2608 
    result.read(self._iprot)
2609 
    self._iprot.readMessageEnd()
2610 
    if result.success is not None:
2611 
      return result.success
2612 
    if result.ex is not None:
2613 
      raise result.ex
2614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2615 
 
4579 rajveer 2616 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2617 
    """
2618 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2619 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2620 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2621 
    For any other status, it returns false.
2622 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2623 
 
2536 chandransh 2624 
    Parameters:
2625 
     - orderId
4579 rajveer 2626 
     - providerId
2536 chandransh 2627 
    """
4579 rajveer 2628 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2629 
    return self.recv_requestPickupNumber()
2630 
 
4579 rajveer 2631 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2632 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2633 
    args = requestPickupNumber_args()
2634 
    args.orderId = orderId
4579 rajveer 2635 
    args.providerId = providerId
2536 chandransh 2636 
    args.write(self._oprot)
2637 
    self._oprot.writeMessageEnd()
2638 
    self._oprot.trans.flush()
2639 
 
2640 
  def recv_requestPickupNumber(self, ):
2641 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2642 
    if mtype == TMessageType.EXCEPTION:
2643 
      x = TApplicationException()
2644 
      x.read(self._iprot)
2645 
      self._iprot.readMessageEnd()
2646 
      raise x
2647 
    result = requestPickupNumber_result()
2648 
    result.read(self._iprot)
2649 
    self._iprot.readMessageEnd()
3431 rajveer 2650 
    if result.success is not None:
2536 chandransh 2651 
      return result.success
3431 rajveer 2652 
    if result.ex is not None:
2536 chandransh 2653 
      raise result.ex
2654 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2655 
 
4602 rajveer 2656 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2657 
    """
4452 rajveer 2658 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2659 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2660 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2661 
    	3. Returns true
2591 chandransh 2662 
    If the order is in any other status, it returns false.
2536 chandransh 2663 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2664 
 
2536 chandransh 2665 
    Parameters:
2666 
     - orderId
2667 
     - pickupNumber
4602 rajveer 2668 
     - providerId
2536 chandransh 2669 
    """
4602 rajveer 2670 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 2671 
    return self.recv_authorizePickup()
2672 
 
4602 rajveer 2673 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2674 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2675 
    args = authorizePickup_args()
2676 
    args.orderId = orderId
2677 
    args.pickupNumber = pickupNumber
4602 rajveer 2678 
    args.providerId = providerId
2536 chandransh 2679 
    args.write(self._oprot)
2680 
    self._oprot.writeMessageEnd()
2681 
    self._oprot.trans.flush()
2682 
 
2683 
  def recv_authorizePickup(self, ):
2684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2685 
    if mtype == TMessageType.EXCEPTION:
2686 
      x = TApplicationException()
2687 
      x.read(self._iprot)
2688 
      self._iprot.readMessageEnd()
2689 
      raise x
2690 
    result = authorizePickup_result()
2691 
    result.read(self._iprot)
2692 
    self._iprot.readMessageEnd()
3431 rajveer 2693 
    if result.success is not None:
2536 chandransh 2694 
      return result.success
3431 rajveer 2695 
    if result.ex is not None:
2536 chandransh 2696 
      raise result.ex
2697 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2698 
 
2764 chandransh 2699 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2700 
    """
2701 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2702 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2703 
 
2764 chandransh 2704 
    Parameters:
2705 
     - providerId
2706 
     - pickupDetails
2707 
    """
2708 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2709 
    return self.recv_markDoasAsPickedUp()
2710 
 
2711 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2712 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2713 
    args = markDoasAsPickedUp_args()
2714 
    args.providerId = providerId
2715 
    args.pickupDetails = pickupDetails
2716 
    args.write(self._oprot)
2717 
    self._oprot.writeMessageEnd()
2718 
    self._oprot.trans.flush()
2719 
 
2720 
  def recv_markDoasAsPickedUp(self, ):
2721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2722 
    if mtype == TMessageType.EXCEPTION:
2723 
      x = TApplicationException()
2724 
      x.read(self._iprot)
2725 
      self._iprot.readMessageEnd()
2726 
      raise x
2727 
    result = markDoasAsPickedUp_result()
2728 
    result.read(self._iprot)
2729 
    self._iprot.readMessageEnd()
3431 rajveer 2730 
    if result.success is not None:
2764 chandransh 2731 
      return result.success
2732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2733 
 
4479 rajveer 2734 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2735 
    """
4452 rajveer 2736 
    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 2737 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2738 
    If the order is in any other state, it returns false.
2739 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2740 
 
2591 chandransh 2741 
    Parameters:
2742 
     - orderId
4479 rajveer 2743 
     - receiveCondition
2591 chandransh 2744 
    """
4479 rajveer 2745 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2746 
    return self.recv_receiveReturn()
2536 chandransh 2747 
 
4479 rajveer 2748 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2749 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2750 
    args = receiveReturn_args()
2591 chandransh 2751 
    args.orderId = orderId
4479 rajveer 2752 
    args.receiveCondition = receiveCondition
2591 chandransh 2753 
    args.write(self._oprot)
2754 
    self._oprot.writeMessageEnd()
2755 
    self._oprot.trans.flush()
2756 
 
2616 chandransh 2757 
  def recv_receiveReturn(self, ):
2591 chandransh 2758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2759 
    if mtype == TMessageType.EXCEPTION:
2760 
      x = TApplicationException()
2761 
      x.read(self._iprot)
2762 
      self._iprot.readMessageEnd()
2763 
      raise x
2616 chandransh 2764 
    result = receiveReturn_result()
2591 chandransh 2765 
    result.read(self._iprot)
2766 
    self._iprot.readMessageEnd()
3431 rajveer 2767 
    if result.success is not None:
2591 chandransh 2768 
      return result.success
3431 rajveer 2769 
    if result.ex is not None:
2591 chandransh 2770 
      raise result.ex
2616 chandransh 2771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2772 
 
2773 
  def validateDoa(self, orderId, isValid):
2774 
    """
4452 rajveer 2775 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2776 
    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 2777 
    If the order is in any other state, it returns false.
2778 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2779 
 
2591 chandransh 2780 
    Parameters:
2781 
     - orderId
2782 
     - isValid
2783 
    """
2784 
    self.send_validateDoa(orderId, isValid)
2785 
    return self.recv_validateDoa()
2786 
 
2787 
  def send_validateDoa(self, orderId, isValid):
2788 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2789 
    args = validateDoa_args()
2790 
    args.orderId = orderId
2791 
    args.isValid = isValid
2792 
    args.write(self._oprot)
2793 
    self._oprot.writeMessageEnd()
2794 
    self._oprot.trans.flush()
2795 
 
2796 
  def recv_validateDoa(self, ):
2797 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2798 
    if mtype == TMessageType.EXCEPTION:
2799 
      x = TApplicationException()
2800 
      x.read(self._iprot)
2801 
      self._iprot.readMessageEnd()
2802 
      raise x
2803 
    result = validateDoa_result()
2804 
    result.read(self._iprot)
2805 
    self._iprot.readMessageEnd()
3431 rajveer 2806 
    if result.success is not None:
2591 chandransh 2807 
      return result.success
3431 rajveer 2808 
    if result.ex is not None:
2591 chandransh 2809 
      raise result.ex
2810 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2811 
 
4495 rajveer 2812 
  def validateReturnProduct(self, orderId, isUsable):
2813 
    """
2814 
    Parameters:
2815 
     - orderId
2816 
     - isUsable
2817 
    """
2818 
    self.send_validateReturnProduct(orderId, isUsable)
2819 
    return self.recv_validateReturnProduct()
2820 
 
2821 
  def send_validateReturnProduct(self, orderId, isUsable):
2822 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2823 
    args = validateReturnProduct_args()
2824 
    args.orderId = orderId
2825 
    args.isUsable = isUsable
2826 
    args.write(self._oprot)
2827 
    self._oprot.writeMessageEnd()
2828 
    self._oprot.trans.flush()
2829 
 
2830 
  def recv_validateReturnProduct(self, ):
2831 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2832 
    if mtype == TMessageType.EXCEPTION:
2833 
      x = TApplicationException()
2834 
      x.read(self._iprot)
2835 
      self._iprot.readMessageEnd()
2836 
      raise x
2837 
    result = validateReturnProduct_result()
2838 
    result.read(self._iprot)
2839 
    self._iprot.readMessageEnd()
2840 
    if result.success is not None:
2841 
      return result.success
2842 
    if result.ex is not None:
2843 
      raise result.ex
2844 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2845 
 
2616 chandransh 2846 
  def reshipOrder(self, orderId):
2847 
    """
4484 rajveer 2848 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2849 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2850 
    	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 2851 
 
2852 
    If the order is in DOA_CERT_VALID state, it does the following:
2853 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2854 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2855 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2856 
 
2616 chandransh 2857 
    Returns the id of the newly created order.
3431 rajveer 2858 
 
2616 chandransh 2859 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2860 
 
2616 chandransh 2861 
    Parameters:
2862 
     - orderId
2863 
    """
2864 
    self.send_reshipOrder(orderId)
2865 
    return self.recv_reshipOrder()
2591 chandransh 2866 
 
2616 chandransh 2867 
  def send_reshipOrder(self, orderId):
2868 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2869 
    args = reshipOrder_args()
2870 
    args.orderId = orderId
2871 
    args.write(self._oprot)
2872 
    self._oprot.writeMessageEnd()
2873 
    self._oprot.trans.flush()
2874 
 
2875 
  def recv_reshipOrder(self, ):
2876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2877 
    if mtype == TMessageType.EXCEPTION:
2878 
      x = TApplicationException()
2879 
      x.read(self._iprot)
2880 
      self._iprot.readMessageEnd()
2881 
      raise x
2882 
    result = reshipOrder_result()
2883 
    result.read(self._iprot)
2884 
    self._iprot.readMessageEnd()
3431 rajveer 2885 
    if result.success is not None:
2616 chandransh 2886 
      return result.success
3431 rajveer 2887 
    if result.ex is not None:
2616 chandransh 2888 
      raise result.ex
2889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2890 
 
3226 chandransh 2891 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2892 
    """
4484 rajveer 2893 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2894 
    	1. Creates a refund request for batch processing.
2895 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 2896 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2897 
 
2616 chandransh 2898 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2899 
    	1. Creates a refund request for batch processing.
3226 chandransh 2900 
    	2. Cancels the reservation of the item in the warehouse.
2901 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2902 
 
3226 chandransh 2903 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2904 
    	1. Cancels the reservation of the item in the warehouse.
2905 
    	2. Marks the current order as CANCELED.
2906 
 
2907 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2908 
 
2616 chandransh 2909 
    Returns True if it is successful, False otherwise.
3431 rajveer 2910 
 
2616 chandransh 2911 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2912 
 
2616 chandransh 2913 
    Parameters:
2914 
     - orderId
3226 chandransh 2915 
     - refundedBy
2916 
     - reason
2616 chandransh 2917 
    """
3226 chandransh 2918 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2919 
    return self.recv_refundOrder()
2920 
 
3226 chandransh 2921 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2922 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2923 
    args = refundOrder_args()
2924 
    args.orderId = orderId
3226 chandransh 2925 
    args.refundedBy = refundedBy
2926 
    args.reason = reason
2616 chandransh 2927 
    args.write(self._oprot)
2928 
    self._oprot.writeMessageEnd()
2929 
    self._oprot.trans.flush()
2930 
 
2931 
  def recv_refundOrder(self, ):
2932 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2933 
    if mtype == TMessageType.EXCEPTION:
2934 
      x = TApplicationException()
2935 
      x.read(self._iprot)
2936 
      self._iprot.readMessageEnd()
2937 
      raise x
2938 
    result = refundOrder_result()
2939 
    result.read(self._iprot)
2940 
    self._iprot.readMessageEnd()
3431 rajveer 2941 
    if result.success is not None:
2616 chandransh 2942 
      return result.success
3431 rajveer 2943 
    if result.ex is not None:
2616 chandransh 2944 
      raise result.ex
2945 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2946 
 
2690 chandransh 2947 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2948 
    """
2949 
    Get all return orders created between the from and to dates for the given warehouse.
2950 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2951 
 
2690 chandransh 2952 
    Parameters:
2953 
     - warehouseId
2954 
     - fromDate
2955 
     - toDate
2956 
    """
2957 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2958 
    return self.recv_getReturnOrders()
2616 chandransh 2959 
 
2690 chandransh 2960 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2961 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2962 
    args = getReturnOrders_args()
2963 
    args.warehouseId = warehouseId
2964 
    args.fromDate = fromDate
2965 
    args.toDate = toDate
2966 
    args.write(self._oprot)
2967 
    self._oprot.writeMessageEnd()
2968 
    self._oprot.trans.flush()
2969 
 
2970 
  def recv_getReturnOrders(self, ):
2971 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2972 
    if mtype == TMessageType.EXCEPTION:
2973 
      x = TApplicationException()
2974 
      x.read(self._iprot)
2975 
      self._iprot.readMessageEnd()
2976 
      raise x
2977 
    result = getReturnOrders_result()
2978 
    result.read(self._iprot)
2979 
    self._iprot.readMessageEnd()
3431 rajveer 2980 
    if result.success is not None:
2690 chandransh 2981 
      return result.success
2982 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2983 
 
2700 chandransh 2984 
  def getReturnOrder(self, id):
2985 
    """
2986 
    Returns the ReturnOrder corresponding to the given id.
2987 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2988 
 
2700 chandransh 2989 
    Parameters:
2990 
     - id
2991 
    """
2992 
    self.send_getReturnOrder(id)
2993 
    return self.recv_getReturnOrder()
2994 
 
2995 
  def send_getReturnOrder(self, id):
2996 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2997 
    args = getReturnOrder_args()
2998 
    args.id = id
2999 
    args.write(self._oprot)
3000 
    self._oprot.writeMessageEnd()
3001 
    self._oprot.trans.flush()
3002 
 
3003 
  def recv_getReturnOrder(self, ):
3004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3005 
    if mtype == TMessageType.EXCEPTION:
3006 
      x = TApplicationException()
3007 
      x.read(self._iprot)
3008 
      self._iprot.readMessageEnd()
3009 
      raise x
3010 
    result = getReturnOrder_result()
3011 
    result.read(self._iprot)
3012 
    self._iprot.readMessageEnd()
3431 rajveer 3013 
    if result.success is not None:
2700 chandransh 3014 
      return result.success
3431 rajveer 3015 
    if result.ex is not None:
2700 chandransh 3016 
      raise result.ex
3017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3018 
 
2690 chandransh 3019 
  def processReturn(self, returnOrderId):
3020 
    """
3021 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3022 
 
2690 chandransh 3023 
    Parameters:
3024 
     - returnOrderId
3025 
    """
3026 
    self.send_processReturn(returnOrderId)
3027 
    self.recv_processReturn()
3028 
 
3029 
  def send_processReturn(self, returnOrderId):
3030 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3031 
    args = processReturn_args()
3032 
    args.returnOrderId = returnOrderId
3033 
    args.write(self._oprot)
3034 
    self._oprot.writeMessageEnd()
3035 
    self._oprot.trans.flush()
3036 
 
3037 
  def recv_processReturn(self, ):
3038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3039 
    if mtype == TMessageType.EXCEPTION:
3040 
      x = TApplicationException()
3041 
      x.read(self._iprot)
3042 
      self._iprot.readMessageEnd()
3043 
      raise x
3044 
    result = processReturn_result()
3045 
    result.read(self._iprot)
3046 
    self._iprot.readMessageEnd()
3431 rajveer 3047 
    if result.ex is not None:
2690 chandransh 3048 
      raise result.ex
3049 
    return
3050 
 
2819 chandransh 3051 
  def createPurchaseOrder(self, warehouseId):
3052 
    """
4586 mandeep.dh 3053 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
3054 
    Returns the list of PO no. of the newly created purchase order.
3055 
    Returns null if no new purchase order had to be created.
3431 rajveer 3056 
 
2819 chandransh 3057 
    Parameters:
3058 
     - warehouseId
3059 
    """
3060 
    self.send_createPurchaseOrder(warehouseId)
3061 
    return self.recv_createPurchaseOrder()
2690 chandransh 3062 
 
2819 chandransh 3063 
  def send_createPurchaseOrder(self, warehouseId):
3064 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
3065 
    args = createPurchaseOrder_args()
3066 
    args.warehouseId = warehouseId
3067 
    args.write(self._oprot)
3068 
    self._oprot.writeMessageEnd()
3069 
    self._oprot.trans.flush()
3070 
 
3071 
  def recv_createPurchaseOrder(self, ):
3072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3073 
    if mtype == TMessageType.EXCEPTION:
3074 
      x = TApplicationException()
3075 
      x.read(self._iprot)
3076 
      self._iprot.readMessageEnd()
3077 
      raise x
3078 
    result = createPurchaseOrder_result()
3079 
    result.read(self._iprot)
3080 
    self._iprot.readMessageEnd()
3431 rajveer 3081 
    if result.success is not None:
2819 chandransh 3082 
      return result.success
3431 rajveer 3083 
    if result.ex is not None:
2819 chandransh 3084 
      raise result.ex
3085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
3086 
 
3451 chandransh 3087 
  def updateWeight(self, orderId, weight):
3088 
    """
3089 
    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 3090 
 
3451 chandransh 3091 
    Parameters:
3092 
     - orderId
3093 
     - weight
3094 
    """
3095 
    self.send_updateWeight(orderId, weight)
3096 
    return self.recv_updateWeight()
3097 
 
3098 
  def send_updateWeight(self, orderId, weight):
3099 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3100 
    args = updateWeight_args()
3101 
    args.orderId = orderId
3102 
    args.weight = weight
3103 
    args.write(self._oprot)
3104 
    self._oprot.writeMessageEnd()
3105 
    self._oprot.trans.flush()
3106 
 
3107 
  def recv_updateWeight(self, ):
3108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3109 
    if mtype == TMessageType.EXCEPTION:
3110 
      x = TApplicationException()
3111 
      x.read(self._iprot)
3112 
      self._iprot.readMessageEnd()
3113 
      raise x
3114 
    result = updateWeight_result()
3115 
    result.read(self._iprot)
3116 
    self._iprot.readMessageEnd()
3117 
    if result.success is not None:
3118 
      return result.success
3119 
    if result.ex is not None:
3120 
      raise result.ex
3121 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3122 
 
3469 chandransh 3123 
  def changeItem(self, orderId, itemId):
3124 
    """
3125 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3126 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3127 
 
3469 chandransh 3128 
    Parameters:
3129 
     - orderId
3130 
     - itemId
3131 
    """
3132 
    self.send_changeItem(orderId, itemId)
3133 
    return self.recv_changeItem()
3134 
 
3135 
  def send_changeItem(self, orderId, itemId):
3136 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3137 
    args = changeItem_args()
3138 
    args.orderId = orderId
3139 
    args.itemId = itemId
3140 
    args.write(self._oprot)
3141 
    self._oprot.writeMessageEnd()
3142 
    self._oprot.trans.flush()
3143 
 
3144 
  def recv_changeItem(self, ):
3145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3146 
    if mtype == TMessageType.EXCEPTION:
3147 
      x = TApplicationException()
3148 
      x.read(self._iprot)
3149 
      self._iprot.readMessageEnd()
3150 
      raise x
3151 
    result = changeItem_result()
3152 
    result.read(self._iprot)
3153 
    self._iprot.readMessageEnd()
3154 
    if result.success is not None:
3155 
      return result.success
3156 
    if result.ex is not None:
3157 
      raise result.ex
3158 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3159 
 
3160 
  def shiftToWarehouse(self, orderId, warehouseId):
3161 
    """
3162 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3163 
 
3164 
    Parameters:
3165 
     - orderId
3166 
     - warehouseId
3167 
    """
3168 
    self.send_shiftToWarehouse(orderId, warehouseId)
3169 
    return self.recv_shiftToWarehouse()
3170 
 
3171 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3172 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3173 
    args = shiftToWarehouse_args()
3174 
    args.orderId = orderId
3175 
    args.warehouseId = warehouseId
3176 
    args.write(self._oprot)
3177 
    self._oprot.writeMessageEnd()
3178 
    self._oprot.trans.flush()
3179 
 
3180 
  def recv_shiftToWarehouse(self, ):
3181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3182 
    if mtype == TMessageType.EXCEPTION:
3183 
      x = TApplicationException()
3184 
      x.read(self._iprot)
3185 
      self._iprot.readMessageEnd()
3186 
      raise x
3187 
    result = shiftToWarehouse_result()
3188 
    result.read(self._iprot)
3189 
    self._iprot.readMessageEnd()
3190 
    if result.success is not None:
3191 
      return result.success
3192 
    if result.ex is not None:
3193 
      raise result.ex
3194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3195 
 
4647 rajveer 3196 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3197 
    """
3198 
    Adds the given delay reason to the given order.
3986 chandransh 3199 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3200 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3201 
 
3553 chandransh 3202 
    Parameters:
3203 
     - orderId
3204 
     - delayReason
3986 chandransh 3205 
     - furtherDelay
4647 rajveer 3206 
     - delayReasonText
3553 chandransh 3207 
    """
4647 rajveer 3208 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3209 
    return self.recv_addDelayReason()
3210 
 
4647 rajveer 3211 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3212 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3213 
    args = addDelayReason_args()
3214 
    args.orderId = orderId
3215 
    args.delayReason = delayReason
3986 chandransh 3216 
    args.furtherDelay = furtherDelay
4647 rajveer 3217 
    args.delayReasonText = delayReasonText
3553 chandransh 3218 
    args.write(self._oprot)
3219 
    self._oprot.writeMessageEnd()
3220 
    self._oprot.trans.flush()
3221 
 
3222 
  def recv_addDelayReason(self, ):
3223 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3224 
    if mtype == TMessageType.EXCEPTION:
3225 
      x = TApplicationException()
3226 
      x.read(self._iprot)
3227 
      self._iprot.readMessageEnd()
3228 
      raise x
3229 
    result = addDelayReason_result()
3230 
    result.read(self._iprot)
3231 
    self._iprot.readMessageEnd()
3232 
    if result.success is not None:
3233 
      return result.success
3234 
    if result.ex is not None:
3235 
      raise result.ex
3236 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3237 
 
3956 chandransh 3238 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3239 
    """
3240 
    Marks the COD orders with given AWB nos. as having been processed.
3241 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3242 
 
3956 chandransh 3243 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3244 
    1. There is no order corresponding to an AWB number.
3245 
    2. The captured amount for a payment exceeds the total payment.
3246 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3247 
 
3248 
    Parameters:
3249 
     - collectedAmountMap
3250 
     - xferBy
3251 
     - xferTxnId
3252 
     - xferDate
3253 
    """
3254 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3255 
    return self.recv_reconcileCodCollection()
3256 
 
3257 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3258 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3259 
    args = reconcileCodCollection_args()
3260 
    args.collectedAmountMap = collectedAmountMap
3261 
    args.xferBy = xferBy
3262 
    args.xferTxnId = xferTxnId
3263 
    args.xferDate = xferDate
3264 
    args.write(self._oprot)
3265 
    self._oprot.writeMessageEnd()
3266 
    self._oprot.trans.flush()
3267 
 
3268 
  def recv_reconcileCodCollection(self, ):
3269 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3270 
    if mtype == TMessageType.EXCEPTION:
3271 
      x = TApplicationException()
3272 
      x.read(self._iprot)
3273 
      self._iprot.readMessageEnd()
3274 
      raise x
3275 
    result = reconcileCodCollection_result()
3276 
    result.read(self._iprot)
3277 
    self._iprot.readMessageEnd()
3278 
    if result.success is not None:
3279 
      return result.success
3280 
    if result.ex is not None:
3281 
      raise result.ex
3282 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3283 
 
4008 mandeep.dh 3284 
  def getTransactionsRequiringExtraProcessing(self, category):
3285 
    """
4065 mandeep.dh 3286 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3287 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3288 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3289 
 
4008 mandeep.dh 3290 
    Parameters:
3291 
     - category
3292 
    """
3293 
    self.send_getTransactionsRequiringExtraProcessing(category)
3294 
    return self.recv_getTransactionsRequiringExtraProcessing()
3295 
 
3296 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3297 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3298 
    args = getTransactionsRequiringExtraProcessing_args()
3299 
    args.category = category
3300 
    args.write(self._oprot)
3301 
    self._oprot.writeMessageEnd()
3302 
    self._oprot.trans.flush()
3303 
 
3304 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3306 
    if mtype == TMessageType.EXCEPTION:
3307 
      x = TApplicationException()
3308 
      x.read(self._iprot)
3309 
      self._iprot.readMessageEnd()
3310 
      raise x
3311 
    result = getTransactionsRequiringExtraProcessing_result()
3312 
    result.read(self._iprot)
3313 
    self._iprot.readMessageEnd()
3314 
    if result.success is not None:
3315 
      return result.success
3316 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3317 
 
3318 
  def markTransactionAsProcessed(self, transactionId, category):
3319 
    """
3320 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3321 
    It essentially deletes the transaction id record for a particular
3322 
    processing type category (if present) from DB.
3323 
    This is currently used by CRM application.
4008 mandeep.dh 3324 
 
3325 
    Parameters:
3326 
     - transactionId
3327 
     - category
3328 
    """
3329 
    self.send_markTransactionAsProcessed(transactionId, category)
3330 
    self.recv_markTransactionAsProcessed()
3331 
 
3332 
  def send_markTransactionAsProcessed(self, transactionId, category):
3333 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3334 
    args = markTransactionAsProcessed_args()
3335 
    args.transactionId = transactionId
3336 
    args.category = category
3337 
    args.write(self._oprot)
3338 
    self._oprot.writeMessageEnd()
3339 
    self._oprot.trans.flush()
3340 
 
3341 
  def recv_markTransactionAsProcessed(self, ):
3342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3343 
    if mtype == TMessageType.EXCEPTION:
3344 
      x = TApplicationException()
3345 
      x.read(self._iprot)
3346 
      self._iprot.readMessageEnd()
3347 
      raise x
3348 
    result = markTransactionAsProcessed_result()
3349 
    result.read(self._iprot)
3350 
    self._iprot.readMessageEnd()
3351 
    return
3352 
 
4018 chandransh 3353 
  def getItemWiseRiskyOrdersCount(self, ):
3354 
    """
3355 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3356 
    is defined as one whose shipping date is about to expire.
3357 
    """
3358 
    self.send_getItemWiseRiskyOrdersCount()
3359 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3360 
 
4018 chandransh 3361 
  def send_getItemWiseRiskyOrdersCount(self, ):
3362 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3363 
    args = getItemWiseRiskyOrdersCount_args()
3364 
    args.write(self._oprot)
3365 
    self._oprot.writeMessageEnd()
3366 
    self._oprot.trans.flush()
3367 
 
3368 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3370 
    if mtype == TMessageType.EXCEPTION:
3371 
      x = TApplicationException()
3372 
      x.read(self._iprot)
3373 
      self._iprot.readMessageEnd()
3374 
      raise x
3375 
    result = getItemWiseRiskyOrdersCount_result()
3376 
    result.read(self._iprot)
3377 
    self._iprot.readMessageEnd()
3378 
    if result.success is not None:
3379 
      return result.success
3380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3381 
 
4295 varun.gupt 3382 
  def getOrdersForItemIds(self, itemIds):
3383 
    """
3384 
    Returns a list of all orders which have items with given id
3385 
 
3386 
    Parameters:
3387 
     - itemIds
3388 
    """
3389 
    self.send_getOrdersForItemIds(itemIds)
3390 
    return self.recv_getOrdersForItemIds()
3391 
 
3392 
  def send_getOrdersForItemIds(self, itemIds):
3393 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3394 
    args = getOrdersForItemIds_args()
3395 
    args.itemIds = itemIds
3396 
    args.write(self._oprot)
3397 
    self._oprot.writeMessageEnd()
3398 
    self._oprot.trans.flush()
3399 
 
3400 
  def recv_getOrdersForItemIds(self, ):
3401 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3402 
    if mtype == TMessageType.EXCEPTION:
3403 
      x = TApplicationException()
3404 
      x.read(self._iprot)
3405 
      self._iprot.readMessageEnd()
3406 
      raise x
3407 
    result = getOrdersForItemIds_result()
3408 
    result.read(self._iprot)
3409 
    self._iprot.readMessageEnd()
3410 
    if result.success is not None:
3411 
      return result.success
3412 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3413 
 
4247 rajveer 3414 
  def markOrderCancellationRequestReceived(self, orderId):
3415 
    """
3416 
    Mark order as cancellation request received. If customer sends request of cancellation of
3417 
    a particular order, this method will be called. It will just change status of the order
3418 
    depending on its current status. It also records the previous status, so that we can move
3419 
    back to that status if cancellation request is denied.
4018 chandransh 3420 
 
4247 rajveer 3421 
    Parameters:
3422 
     - orderId
3423 
    """
3424 
    self.send_markOrderCancellationRequestReceived(orderId)
3425 
    self.recv_markOrderCancellationRequestReceived()
3426 
 
3427 
  def send_markOrderCancellationRequestReceived(self, orderId):
3428 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3429 
    args = markOrderCancellationRequestReceived_args()
3430 
    args.orderId = orderId
3431 
    args.write(self._oprot)
3432 
    self._oprot.writeMessageEnd()
3433 
    self._oprot.trans.flush()
3434 
 
3435 
  def recv_markOrderCancellationRequestReceived(self, ):
3436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3437 
    if mtype == TMessageType.EXCEPTION:
3438 
      x = TApplicationException()
3439 
      x.read(self._iprot)
3440 
      self._iprot.readMessageEnd()
3441 
      raise x
3442 
    result = markOrderCancellationRequestReceived_result()
3443 
    result.read(self._iprot)
3444 
    self._iprot.readMessageEnd()
3445 
    if result.ex is not None:
3446 
      raise result.ex
3447 
    return
3448 
 
3449 
  def markOrderCancellationRequestConfirmed(self, orderId):
3450 
    """
3451 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3452 
    cancellation request confirmed. After this OM will be able to cancel the order.
3453 
 
3454 
    Parameters:
3455 
     - orderId
3456 
    """
3457 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3458 
    self.recv_markOrderCancellationRequestConfirmed()
3459 
 
3460 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3461 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3462 
    args = markOrderCancellationRequestConfirmed_args()
3463 
    args.orderId = orderId
3464 
    args.write(self._oprot)
3465 
    self._oprot.writeMessageEnd()
3466 
    self._oprot.trans.flush()
3467 
 
3468 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3470 
    if mtype == TMessageType.EXCEPTION:
3471 
      x = TApplicationException()
3472 
      x.read(self._iprot)
3473 
      self._iprot.readMessageEnd()
3474 
      raise x
3475 
    result = markOrderCancellationRequestConfirmed_result()
3476 
    result.read(self._iprot)
3477 
    self._iprot.readMessageEnd()
3478 
    if result.ex is not None:
3479 
      raise result.ex
3480 
    return
3481 
 
3482 
  def markOrderCancellationRequestDenied(self, orderId):
3483 
    """
3484 
    If we decide to not to cancel order, we will move the order ro previous status.
3485 
 
3486 
    Parameters:
3487 
     - orderId
3488 
    """
3489 
    self.send_markOrderCancellationRequestDenied(orderId)
3490 
    self.recv_markOrderCancellationRequestDenied()
3491 
 
3492 
  def send_markOrderCancellationRequestDenied(self, orderId):
3493 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3494 
    args = markOrderCancellationRequestDenied_args()
3495 
    args.orderId = orderId
3496 
    args.write(self._oprot)
3497 
    self._oprot.writeMessageEnd()
3498 
    self._oprot.trans.flush()
3499 
 
3500 
  def recv_markOrderCancellationRequestDenied(self, ):
3501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3502 
    if mtype == TMessageType.EXCEPTION:
3503 
      x = TApplicationException()
3504 
      x.read(self._iprot)
3505 
      self._iprot.readMessageEnd()
3506 
      raise x
3507 
    result = markOrderCancellationRequestDenied_result()
3508 
    result.read(self._iprot)
3509 
    self._iprot.readMessageEnd()
3510 
    if result.ex is not None:
3511 
      raise result.ex
3512 
    return
3513 
 
4258 rajveer 3514 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3515 
    """
4258 rajveer 3516 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3517 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3518 
 
3519 
    Parameters:
4258 rajveer 3520 
     - transactionId
4247 rajveer 3521 
    """
4258 rajveer 3522 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3523 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3524 
 
4258 rajveer 3525 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3526 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3527 
    args = markTransactionAsPaymentFlagRemoved_args()
3528 
    args.transactionId = transactionId
4247 rajveer 3529 
    args.write(self._oprot)
3530 
    self._oprot.writeMessageEnd()
3531 
    self._oprot.trans.flush()
3532 
 
4258 rajveer 3533 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3535 
    if mtype == TMessageType.EXCEPTION:
3536 
      x = TApplicationException()
3537 
      x.read(self._iprot)
3538 
      self._iprot.readMessageEnd()
3539 
      raise x
4258 rajveer 3540 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3541 
    result.read(self._iprot)
3542 
    self._iprot.readMessageEnd()
3543 
    if result.ex is not None:
3544 
      raise result.ex
3545 
    return
3546 
 
4259 anupam.sin 3547 
  def refundTransaction(self, transactionId, refundedBy, reason):
3548 
    """
3549 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3550 
    need to be cancelled
4247 rajveer 3551 
 
4259 anupam.sin 3552 
    Parameters:
3553 
     - transactionId
3554 
     - refundedBy
3555 
     - reason
3556 
    """
3557 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3558 
    self.recv_refundTransaction()
3559 
 
3560 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3561 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3562 
    args = refundTransaction_args()
3563 
    args.transactionId = transactionId
3564 
    args.refundedBy = refundedBy
3565 
    args.reason = reason
3566 
    args.write(self._oprot)
3567 
    self._oprot.writeMessageEnd()
3568 
    self._oprot.trans.flush()
3569 
 
3570 
  def recv_refundTransaction(self, ):
3571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3572 
    if mtype == TMessageType.EXCEPTION:
3573 
      x = TApplicationException()
3574 
      x.read(self._iprot)
3575 
      self._iprot.readMessageEnd()
3576 
      raise x
3577 
    result = refundTransaction_result()
3578 
    result.read(self._iprot)
3579 
    self._iprot.readMessageEnd()
3580 
    if result.ex is not None:
3581 
      raise result.ex
3582 
    return
3583 
 
4324 mandeep.dh 3584 
  def updateShipmentAddress(self, orderId, addressId):
3585 
    """
3586 
    Updates shipment address of an order. Delivery and shipping date estimates
3587 
    etc. are also updated here.
3588 
 
3589 
    Throws TransactionServiceException in case address change is not
3590 
    possible due to certain reasons such as new pincode in address is
3591 
    not serviceable etc.
3592 
 
3593 
    Parameters:
3594 
     - orderId
3595 
     - addressId
3596 
    """
3597 
    self.send_updateShipmentAddress(orderId, addressId)
3598 
    self.recv_updateShipmentAddress()
3599 
 
3600 
  def send_updateShipmentAddress(self, orderId, addressId):
3601 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3602 
    args = updateShipmentAddress_args()
3603 
    args.orderId = orderId
3604 
    args.addressId = addressId
3605 
    args.write(self._oprot)
3606 
    self._oprot.writeMessageEnd()
3607 
    self._oprot.trans.flush()
3608 
 
3609 
  def recv_updateShipmentAddress(self, ):
3610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3611 
    if mtype == TMessageType.EXCEPTION:
3612 
      x = TApplicationException()
3613 
      x.read(self._iprot)
3614 
      self._iprot.readMessageEnd()
3615 
      raise x
3616 
    result = updateShipmentAddress_result()
3617 
    result.read(self._iprot)
3618 
    self._iprot.readMessageEnd()
3619 
    if result.ex is not None:
3620 
      raise result.ex
3621 
    return
3622 
 
4285 rajveer 3623 
  def acceptOrdersForItemId(self, itemId, inventory):
3624 
    """
3625 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3626 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3627 
 
4285 rajveer 3628 
    Parameters:
3629 
     - itemId
3630 
     - inventory
3631 
    """
3632 
    self.send_acceptOrdersForItemId(itemId, inventory)
3633 
    return self.recv_acceptOrdersForItemId()
3634 
 
3635 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3636 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3637 
    args = acceptOrdersForItemId_args()
3638 
    args.itemId = itemId
3639 
    args.inventory = inventory
3640 
    args.write(self._oprot)
3641 
    self._oprot.writeMessageEnd()
3642 
    self._oprot.trans.flush()
3643 
 
3644 
  def recv_acceptOrdersForItemId(self, ):
3645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3646 
    if mtype == TMessageType.EXCEPTION:
3647 
      x = TApplicationException()
3648 
      x.read(self._iprot)
3649 
      self._iprot.readMessageEnd()
3650 
      raise x
3651 
    result = acceptOrdersForItemId_result()
3652 
    result.read(self._iprot)
3653 
    self._iprot.readMessageEnd()
3654 
    if result.success is not None:
3655 
      return result.success
3656 
    if result.ex is not None:
3657 
      raise result.ex
3658 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3659 
 
4369 rajveer 3660 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3661 
    """
3662 
    Parameters:
3663 
     - vendorId
3664 
     - itemId
3665 
     - quantity
3666 
     - estimate
4369 rajveer 3667 
     - isReminder
4303 rajveer 3668 
    """
4369 rajveer 3669 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3670 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3671 
 
4369 rajveer 3672 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3673 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3674 
    args = markOrdersAsPORaised_args()
3675 
    args.vendorId = vendorId
3676 
    args.itemId = itemId
3677 
    args.quantity = quantity
3678 
    args.estimate = estimate
4369 rajveer 3679 
    args.isReminder = isReminder
4303 rajveer 3680 
    args.write(self._oprot)
3681 
    self._oprot.writeMessageEnd()
3682 
    self._oprot.trans.flush()
3683 
 
3684 
  def recv_markOrdersAsPORaised(self, ):
3685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3686 
    if mtype == TMessageType.EXCEPTION:
3687 
      x = TApplicationException()
3688 
      x.read(self._iprot)
3689 
      self._iprot.readMessageEnd()
3690 
      raise x
3691 
    result = markOrdersAsPORaised_result()
3692 
    result.read(self._iprot)
3693 
    self._iprot.readMessageEnd()
3694 
    if result.ex is not None:
3695 
      raise result.ex
3696 
    return
3697 
 
4369 rajveer 3698 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3699 
    """
3700 
    Parameters:
3701 
     - vendorId
3702 
     - itemId
3703 
     - quantity
3704 
     - estimate
4369 rajveer 3705 
     - isReminder
4303 rajveer 3706 
    """
4369 rajveer 3707 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3708 
    self.recv_markOrdersAsReversalInitiated()
3709 
 
4369 rajveer 3710 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3711 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3712 
    args = markOrdersAsReversalInitiated_args()
3713 
    args.vendorId = vendorId
3714 
    args.itemId = itemId
3715 
    args.quantity = quantity
3716 
    args.estimate = estimate
4369 rajveer 3717 
    args.isReminder = isReminder
4303 rajveer 3718 
    args.write(self._oprot)
3719 
    self._oprot.writeMessageEnd()
3720 
    self._oprot.trans.flush()
3721 
 
3722 
  def recv_markOrdersAsReversalInitiated(self, ):
3723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3724 
    if mtype == TMessageType.EXCEPTION:
3725 
      x = TApplicationException()
3726 
      x.read(self._iprot)
3727 
      self._iprot.readMessageEnd()
3728 
      raise x
3729 
    result = markOrdersAsReversalInitiated_result()
3730 
    result.read(self._iprot)
3731 
    self._iprot.readMessageEnd()
3732 
    if result.ex is not None:
3733 
      raise result.ex
3734 
    return
3735 
 
4369 rajveer 3736 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3737 
    """
3738 
    Parameters:
3739 
     - vendorId
3740 
     - itemId
3741 
     - quantity
3742 
     - estimate
4369 rajveer 3743 
     - isReminder
4303 rajveer 3744 
    """
4369 rajveer 3745 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3746 
    self.recv_markOrdersAsNotAvailabke()
3747 
 
4369 rajveer 3748 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3749 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3750 
    args = markOrdersAsNotAvailabke_args()
3751 
    args.vendorId = vendorId
3752 
    args.itemId = itemId
3753 
    args.quantity = quantity
3754 
    args.estimate = estimate
4369 rajveer 3755 
    args.isReminder = isReminder
4303 rajveer 3756 
    args.write(self._oprot)
3757 
    self._oprot.writeMessageEnd()
3758 
    self._oprot.trans.flush()
3759 
 
3760 
  def recv_markOrdersAsNotAvailabke(self, ):
3761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3762 
    if mtype == TMessageType.EXCEPTION:
3763 
      x = TApplicationException()
3764 
      x.read(self._iprot)
3765 
      self._iprot.readMessageEnd()
3766 
      raise x
3767 
    result = markOrdersAsNotAvailabke_result()
3768 
    result.read(self._iprot)
3769 
    self._iprot.readMessageEnd()
3770 
    if result.ex is not None:
3771 
      raise result.ex
3772 
    return
3773 
 
4369 rajveer 3774 
  def markOrdersAsTimeout(self, vendorId):
3775 
    """
3776 
    Parameters:
3777 
     - vendorId
3778 
    """
3779 
    self.send_markOrdersAsTimeout(vendorId)
3780 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3781 
 
4369 rajveer 3782 
  def send_markOrdersAsTimeout(self, vendorId):
3783 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3784 
    args = markOrdersAsTimeout_args()
3785 
    args.vendorId = vendorId
3786 
    args.write(self._oprot)
3787 
    self._oprot.writeMessageEnd()
3788 
    self._oprot.trans.flush()
3789 
 
3790 
  def recv_markOrdersAsTimeout(self, ):
3791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3792 
    if mtype == TMessageType.EXCEPTION:
3793 
      x = TApplicationException()
3794 
      x.read(self._iprot)
3795 
      self._iprot.readMessageEnd()
3796 
      raise x
3797 
    result = markOrdersAsTimeout_result()
3798 
    result.read(self._iprot)
3799 
    self._iprot.readMessageEnd()
3800 
    if result.success is not None:
3801 
      return result.success
3802 
    if result.ex is not None:
3803 
      raise result.ex
3804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3805 
 
4662 rajveer 3806 
  def markOrderAsLostInTransit(self, orderId):
3807 
    """
3808 
    Mark order as LOST_IN_TRANSIT
3809 
 
3810 
    Parameters:
3811 
     - orderId
3812 
    """
3813 
    self.send_markOrderAsLostInTransit(orderId)
3814 
    return self.recv_markOrderAsLostInTransit()
3815 
 
3816 
  def send_markOrderAsLostInTransit(self, orderId):
3817 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
3818 
    args = markOrderAsLostInTransit_args()
3819 
    args.orderId = orderId
3820 
    args.write(self._oprot)
3821 
    self._oprot.writeMessageEnd()
3822 
    self._oprot.trans.flush()
3823 
 
3824 
  def recv_markOrderAsLostInTransit(self, ):
3825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3826 
    if mtype == TMessageType.EXCEPTION:
3827 
      x = TApplicationException()
3828 
      x.read(self._iprot)
3829 
      self._iprot.readMessageEnd()
3830 
      raise x
3831 
    result = markOrderAsLostInTransit_result()
3832 
    result.read(self._iprot)
3833 
    self._iprot.readMessageEnd()
3834 
    if result.success is not None:
3835 
      return result.success
3836 
    if result.ex is not None:
3837 
      raise result.ex
3838 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
3839 
 
4386 anupam.sin 3840 
  def getOrderForAwb(self, awb):
3841 
    """
3842 
    Returns the order corresponding to an AWB number
4369 rajveer 3843 
 
4386 anupam.sin 3844 
    Parameters:
3845 
     - awb
3846 
    """
3847 
    self.send_getOrderForAwb(awb)
3848 
    return self.recv_getOrderForAwb()
3849 
 
3850 
  def send_getOrderForAwb(self, awb):
3851 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3852 
    args = getOrderForAwb_args()
3853 
    args.awb = awb
3854 
    args.write(self._oprot)
3855 
    self._oprot.writeMessageEnd()
3856 
    self._oprot.trans.flush()
3857 
 
3858 
  def recv_getOrderForAwb(self, ):
3859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3860 
    if mtype == TMessageType.EXCEPTION:
3861 
      x = TApplicationException()
3862 
      x.read(self._iprot)
3863 
      self._iprot.readMessageEnd()
3864 
      raise x
3865 
    result = getOrderForAwb_result()
3866 
    result.read(self._iprot)
3867 
    self._iprot.readMessageEnd()
3868 
    if result.success is not None:
3869 
      return result.success
3870 
    if result.ex is not None:
3871 
      raise result.ex
3872 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3873 
 
4506 phani.kuma 3874 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3875 
    """
3876 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3877 
 
4506 phani.kuma 3878 
    Parameters:
3879 
     - logistics_provider_id
3880 
     - order_status
3881 
    """
3882 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
3883 
    return self.recv_getOrdersForProviderForStatus()
3884 
 
3885 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3886 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
3887 
    args = getOrdersForProviderForStatus_args()
3888 
    args.logistics_provider_id = logistics_provider_id
3889 
    args.order_status = order_status
3890 
    args.write(self._oprot)
3891 
    self._oprot.writeMessageEnd()
3892 
    self._oprot.trans.flush()
3893 
 
3894 
  def recv_getOrdersForProviderForStatus(self, ):
3895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3896 
    if mtype == TMessageType.EXCEPTION:
3897 
      x = TApplicationException()
3898 
      x.read(self._iprot)
3899 
      self._iprot.readMessageEnd()
3900 
      raise x
3901 
    result = getOrdersForProviderForStatus_result()
3902 
    result.read(self._iprot)
3903 
    self._iprot.readMessageEnd()
3904 
    if result.success is not None:
3905 
      return result.success
3906 
    if result.ex is not None:
3907 
      raise result.ex
3908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
3909 
 
4600 varun.gupt 3910 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3911 
    """
3912 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 3913 
 
4600 varun.gupt 3914 
    Parameters:
3915 
     - vendorId
3916 
     - billingDateFrom
3917 
     - billingDateTo
3918 
    """
3919 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
3920 
    return self.recv_getBilledOrdersForVendor()
3921 
 
3922 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3923 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
3924 
    args = getBilledOrdersForVendor_args()
3925 
    args.vendorId = vendorId
3926 
    args.billingDateFrom = billingDateFrom
3927 
    args.billingDateTo = billingDateTo
3928 
    args.write(self._oprot)
3929 
    self._oprot.writeMessageEnd()
3930 
    self._oprot.trans.flush()
3931 
 
3932 
  def recv_getBilledOrdersForVendor(self, ):
3933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3934 
    if mtype == TMessageType.EXCEPTION:
3935 
      x = TApplicationException()
3936 
      x.read(self._iprot)
3937 
      self._iprot.readMessageEnd()
3938 
      raise x
3939 
    result = getBilledOrdersForVendor_result()
3940 
    result.read(self._iprot)
3941 
    self._iprot.readMessageEnd()
3942 
    if result.success is not None:
3943 
      return result.success
3944 
    if result.ex is not None:
3945 
      raise result.ex
3946 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
3947 
 
4607 rajveer 3948 
  def getSlippedSippingDateOrders(self, ):
3949 
    self.send_getSlippedSippingDateOrders()
3950 
    return self.recv_getSlippedSippingDateOrders()
3951 
 
3952 
  def send_getSlippedSippingDateOrders(self, ):
3953 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
3954 
    args = getSlippedSippingDateOrders_args()
3955 
    args.write(self._oprot)
3956 
    self._oprot.writeMessageEnd()
3957 
    self._oprot.trans.flush()
3958 
 
3959 
  def recv_getSlippedSippingDateOrders(self, ):
3960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3961 
    if mtype == TMessageType.EXCEPTION:
3962 
      x = TApplicationException()
3963 
      x.read(self._iprot)
3964 
      self._iprot.readMessageEnd()
3965 
      raise x
3966 
    result = getSlippedSippingDateOrders_result()
3967 
    result.read(self._iprot)
3968 
    self._iprot.readMessageEnd()
3969 
    if result.success is not None:
3970 
      return result.success
3971 
    if result.ex is not None:
3972 
      raise result.ex
3973 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
3974 
 
4709 rajveer 3975 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
3976 
    """
3977 
    Parameters:
3978 
     - cancelDateFrom
3979 
     - cancelDateTo
3980 
    """
3981 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
3982 
    return self.recv_getCancelledOrders()
3983 
 
3984 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
3985 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
3986 
    args = getCancelledOrders_args()
3987 
    args.cancelDateFrom = cancelDateFrom
3988 
    args.cancelDateTo = cancelDateTo
3989 
    args.write(self._oprot)
3990 
    self._oprot.writeMessageEnd()
3991 
    self._oprot.trans.flush()
3992 
 
3993 
  def recv_getCancelledOrders(self, ):
3994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3995 
    if mtype == TMessageType.EXCEPTION:
3996 
      x = TApplicationException()
3997 
      x.read(self._iprot)
3998 
      self._iprot.readMessageEnd()
3999 
      raise x
4000 
    result = getCancelledOrders_result()
4001 
    result.read(self._iprot)
4002 
    self._iprot.readMessageEnd()
4003 
    if result.success is not None:
4004 
      return result.success
4005 
    if result.ex is not None:
4006 
      raise result.ex
4007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4008 
 
4600 varun.gupt 4009 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4010 
    """
4011 
    Parameters:
4012 
     - mapAWBAndAmount
4013 
    """
4014 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4015 
    self.recv_saveBluedartSettlements()
4016 
 
4017 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4018 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4019 
    args = saveBluedartSettlements_args()
4020 
    args.mapAWBAndAmount = mapAWBAndAmount
4021 
    args.write(self._oprot)
4022 
    self._oprot.writeMessageEnd()
4023 
    self._oprot.trans.flush()
4024 
 
4025 
  def recv_saveBluedartSettlements(self, ):
4026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4027 
    if mtype == TMessageType.EXCEPTION:
4028 
      x = TApplicationException()
4029 
      x.read(self._iprot)
4030 
      self._iprot.readMessageEnd()
4031 
      raise x
4032 
    result = saveBluedartSettlements_result()
4033 
    result.read(self._iprot)
4034 
    self._iprot.readMessageEnd()
4035 
    if result.ex is not None:
4036 
      raise result.ex
4037 
    return
4038 
 
4039 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4040 
    """
4041 
    Parameters:
4042 
     - settlementDate
4043 
     - paymentGatewayId
4044 
     - paymentId
4045 
     - serviceTax
4046 
     - otherCharges
4047 
     - netCollection
4048 
    """
4049 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection)
4050 
    self.recv_savePaymentSettlements()
4051 
 
4052 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4053 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4054 
    args = savePaymentSettlements_args()
4055 
    args.settlementDate = settlementDate
4056 
    args.paymentGatewayId = paymentGatewayId
4057 
    args.paymentId = paymentId
4058 
    args.serviceTax = serviceTax
4059 
    args.otherCharges = otherCharges
4060 
    args.netCollection = netCollection
4061 
    args.write(self._oprot)
4062 
    self._oprot.writeMessageEnd()
4063 
    self._oprot.trans.flush()
4064 
 
4065 
  def recv_savePaymentSettlements(self, ):
4066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4067 
    if mtype == TMessageType.EXCEPTION:
4068 
      x = TApplicationException()
4069 
      x.read(self._iprot)
4070 
      self._iprot.readMessageEnd()
4071 
      raise x
4072 
    result = savePaymentSettlements_result()
4073 
    result.read(self._iprot)
4074 
    self._iprot.readMessageEnd()
4075 
    if result.ex is not None:
4076 
      raise result.ex
4077 
    return
4078 
 
4079 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4080 
    """
4081 
    Parameters:
4082 
     - settlementId
4083 
     - settlementDate
4084 
     - transactionDateFrom
4085 
     - transactionDateTo
4086 
     - amount
4087 
    """
4088 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4089 
    self.recv_saveEBSSettlementSummary()
4090 
 
4091 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4092 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4093 
    args = saveEBSSettlementSummary_args()
4094 
    args.settlementId = settlementId
4095 
    args.settlementDate = settlementDate
4096 
    args.transactionDateFrom = transactionDateFrom
4097 
    args.transactionDateTo = transactionDateTo
4098 
    args.amount = amount
4099 
    args.write(self._oprot)
4100 
    self._oprot.writeMessageEnd()
4101 
    self._oprot.trans.flush()
4102 
 
4103 
  def recv_saveEBSSettlementSummary(self, ):
4104 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4105 
    if mtype == TMessageType.EXCEPTION:
4106 
      x = TApplicationException()
4107 
      x.read(self._iprot)
4108 
      self._iprot.readMessageEnd()
4109 
      raise x
4110 
    result = saveEBSSettlementSummary_result()
4111 
    result.read(self._iprot)
4112 
    self._iprot.readMessageEnd()
4113 
    if result.ex is not None:
4114 
      raise result.ex
4115 
    return
4116 
 
4117 
  def getSettlementForPaymentId(self, paymentId):
4118 
    """
4119 
    Parameters:
4120 
     - paymentId
4121 
    """
4122 
    self.send_getSettlementForPaymentId(paymentId)
4123 
    return self.recv_getSettlementForPaymentId()
4124 
 
4125 
  def send_getSettlementForPaymentId(self, paymentId):
4126 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4127 
    args = getSettlementForPaymentId_args()
4128 
    args.paymentId = paymentId
4129 
    args.write(self._oprot)
4130 
    self._oprot.writeMessageEnd()
4131 
    self._oprot.trans.flush()
4132 
 
4133 
  def recv_getSettlementForPaymentId(self, ):
4134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4135 
    if mtype == TMessageType.EXCEPTION:
4136 
      x = TApplicationException()
4137 
      x.read(self._iprot)
4138 
      self._iprot.readMessageEnd()
4139 
      raise x
4140 
    result = getSettlementForPaymentId_result()
4141 
    result.read(self._iprot)
4142 
    self._iprot.readMessageEnd()
4143 
    if result.success is not None:
4144 
      return result.success
4145 
    if result.ex is not None:
4146 
      raise result.ex
4147 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4148 
 
4149 
  def getEBSSettlementSummaries(self, ):
4150 
    self.send_getEBSSettlementSummaries()
4151 
    return self.recv_getEBSSettlementSummaries()
4152 
 
4153 
  def send_getEBSSettlementSummaries(self, ):
4154 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4155 
    args = getEBSSettlementSummaries_args()
4156 
    args.write(self._oprot)
4157 
    self._oprot.writeMessageEnd()
4158 
    self._oprot.trans.flush()
4159 
 
4160 
  def recv_getEBSSettlementSummaries(self, ):
4161 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4162 
    if mtype == TMessageType.EXCEPTION:
4163 
      x = TApplicationException()
4164 
      x.read(self._iprot)
4165 
      self._iprot.readMessageEnd()
4166 
      raise x
4167 
    result = getEBSSettlementSummaries_result()
4168 
    result.read(self._iprot)
4169 
    self._iprot.readMessageEnd()
4170 
    if result.success is not None:
4171 
      return result.success
4172 
    if result.ex is not None:
4173 
      raise result.ex
4174 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4175 
 
4176 
  def markEBSSettlementUploaded(self, settlementId):
4177 
    """
4178 
    Parameters:
4179 
     - settlementId
4180 
    """
4181 
    self.send_markEBSSettlementUploaded(settlementId)
4182 
    self.recv_markEBSSettlementUploaded()
4183 
 
4184 
  def send_markEBSSettlementUploaded(self, settlementId):
4185 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4186 
    args = markEBSSettlementUploaded_args()
4187 
    args.settlementId = settlementId
4188 
    args.write(self._oprot)
4189 
    self._oprot.writeMessageEnd()
4190 
    self._oprot.trans.flush()
4191 
 
4192 
  def recv_markEBSSettlementUploaded(self, ):
4193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4194 
    if mtype == TMessageType.EXCEPTION:
4195 
      x = TApplicationException()
4196 
      x.read(self._iprot)
4197 
      self._iprot.readMessageEnd()
4198 
      raise x
4199 
    result = markEBSSettlementUploaded_result()
4200 
    result.read(self._iprot)
4201 
    self._iprot.readMessageEnd()
4202 
    if result.ex is not None:
4203 
      raise result.ex
4204 
    return
4205 
 
4206 
  def getEBSSettlementDate(self, settlementId):
4207 
    """
4208 
    Parameters:
4209 
     - settlementId
4210 
    """
4211 
    self.send_getEBSSettlementDate(settlementId)
4212 
    return self.recv_getEBSSettlementDate()
4213 
 
4214 
  def send_getEBSSettlementDate(self, settlementId):
4215 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4216 
    args = getEBSSettlementDate_args()
4217 
    args.settlementId = settlementId
4218 
    args.write(self._oprot)
4219 
    self._oprot.writeMessageEnd()
4220 
    self._oprot.trans.flush()
4221 
 
4222 
  def recv_getEBSSettlementDate(self, ):
4223 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4224 
    if mtype == TMessageType.EXCEPTION:
4225 
      x = TApplicationException()
4226 
      x.read(self._iprot)
4227 
      self._iprot.readMessageEnd()
4228 
      raise x
4229 
    result = getEBSSettlementDate_result()
4230 
    result.read(self._iprot)
4231 
    self._iprot.readMessageEnd()
4232 
    if result.success is not None:
4233 
      return result.success
4234 
    if result.ex is not None:
4235 
      raise result.ex
4236 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4237 
 
4238 
 
3376 rajveer 4239 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4240 
  def __init__(self, handler):
3376 rajveer 4241 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4242 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4243 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4244 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4245 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4246 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4247 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4248 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4249 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4250 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4251 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4252 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4253 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4254 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4255 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4256 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4257 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4258 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4259 
    self._processMap["createOrder"] = Processor.process_createOrder
4260 
    self._processMap["getOrder"] = Processor.process_getOrder
4261 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4262 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4263 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4264 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4265 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4266 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4267 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4268 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4269 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4270 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4271 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4272 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4273 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4274 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4275 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 4276 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 4277 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4278 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 4279 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 4280 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 4281 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 4282 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 4283 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4454 rajveer 4284 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4285 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4286 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4287 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4288 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4289 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4290 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 4291 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4292 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4293 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4294 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4295 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4296 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4297 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4298 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 4299 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 4300 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4301 
    self._processMap["changeItem"] = Processor.process_changeItem
4302 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4303 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4304 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4305 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4306 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4307 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4308 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4309 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4310 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4311 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4312 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4313 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4314 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4315 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4316 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4317 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4318 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4319 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 4320 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 4321 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4322 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4323 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4324 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 4325 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 4326 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4327 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4328 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4329 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4330 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4331 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4332 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
94 ashish 4333 
 
4334 
  def process(self, iprot, oprot):
4335 
    (name, type, seqid) = iprot.readMessageBegin()
4336 
    if name not in self._processMap:
4337 
      iprot.skip(TType.STRUCT)
4338 
      iprot.readMessageEnd()
4339 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4340 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4341 
      x.write(oprot)
4342 
      oprot.writeMessageEnd()
4343 
      oprot.trans.flush()
4344 
      return
4345 
    else:
4346 
      self._processMap[name](self, seqid, iprot, oprot)
4347 
    return True
4348 
 
4349 
  def process_createTransaction(self, seqid, iprot, oprot):
4350 
    args = createTransaction_args()
4351 
    args.read(iprot)
4352 
    iprot.readMessageEnd()
4353 
    result = createTransaction_result()
4354 
    try:
132 ashish 4355 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4356 
    except TransactionServiceException, ex:
4357 
      result.ex = ex
4358 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4359 
    result.write(oprot)
4360 
    oprot.writeMessageEnd()
4361 
    oprot.trans.flush()
4362 
 
4363 
  def process_getTransaction(self, seqid, iprot, oprot):
4364 
    args = getTransaction_args()
4365 
    args.read(iprot)
4366 
    iprot.readMessageEnd()
4367 
    result = getTransaction_result()
4368 
    try:
4369 
      result.success = self._handler.getTransaction(args.id)
4370 
    except TransactionServiceException, ex:
4371 
      result.ex = ex
4372 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4373 
    result.write(oprot)
4374 
    oprot.writeMessageEnd()
4375 
    oprot.trans.flush()
4376 
 
4377 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4378 
    args = getTransactionsForCustomer_args()
4379 
    args.read(iprot)
4380 
    iprot.readMessageEnd()
4381 
    result = getTransactionsForCustomer_result()
4382 
    try:
4383 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4384 
    except TransactionServiceException, ex:
4385 
      result.ex = ex
4386 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4387 
    result.write(oprot)
4388 
    oprot.writeMessageEnd()
4389 
    oprot.trans.flush()
4390 
 
132 ashish 4391 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4392 
    args = getTransactionsForShoppingCartId_args()
4393 
    args.read(iprot)
4394 
    iprot.readMessageEnd()
4395 
    result = getTransactionsForShoppingCartId_result()
4396 
    try:
4397 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4398 
    except TransactionServiceException, ex:
4399 
      result.ex = ex
4400 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4401 
    result.write(oprot)
4402 
    oprot.writeMessageEnd()
4403 
    oprot.trans.flush()
4404 
 
94 ashish 4405 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4406 
    args = getTransactionStatus_args()
4407 
    args.read(iprot)
4408 
    iprot.readMessageEnd()
4409 
    result = getTransactionStatus_result()
4410 
    try:
4411 
      result.success = self._handler.getTransactionStatus(args.transactionId)
4412 
    except TransactionServiceException, ex:
4413 
      result.ex = ex
4414 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
4415 
    result.write(oprot)
4416 
    oprot.writeMessageEnd()
4417 
    oprot.trans.flush()
4418 
 
4419 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
4420 
    args = changeTransactionStatus_args()
4421 
    args.read(iprot)
4422 
    iprot.readMessageEnd()
4423 
    result = changeTransactionStatus_result()
4424 
    try:
4425 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
4426 
    except TransactionServiceException, ex:
4427 
      result.ex = ex
4428 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
4429 
    result.write(oprot)
4430 
    oprot.writeMessageEnd()
4431 
    oprot.trans.flush()
4432 
 
1398 varun.gupt 4433 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
4434 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 4435 
    args.read(iprot)
4436 
    iprot.readMessageEnd()
1398 varun.gupt 4437 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 4438 
    try:
1398 varun.gupt 4439 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 4440 
    except TransactionServiceException, ex:
4441 
      result.ex = ex
1398 varun.gupt 4442 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 4443 
    result.write(oprot)
4444 
    oprot.writeMessageEnd()
4445 
    oprot.trans.flush()
4446 
 
483 rajveer 4447 
  def process_getAllOrders(self, seqid, iprot, oprot):
4448 
    args = getAllOrders_args()
94 ashish 4449 
    args.read(iprot)
4450 
    iprot.readMessageEnd()
483 rajveer 4451 
    result = getAllOrders_result()
94 ashish 4452 
    try:
483 rajveer 4453 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 4454 
    except TransactionServiceException, ex:
4455 
      result.ex = ex
483 rajveer 4456 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 4457 
    result.write(oprot)
4458 
    oprot.writeMessageEnd()
4459 
    oprot.trans.flush()
4460 
 
4133 chandransh 4461 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
4462 
    args = getOrdersInBatch_args()
4463 
    args.read(iprot)
4464 
    iprot.readMessageEnd()
4465 
    result = getOrdersInBatch_result()
4466 
    try:
4467 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4468 
    except TransactionServiceException, ex:
4469 
      result.ex = ex
4470 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4471 
    result.write(oprot)
4472 
    oprot.writeMessageEnd()
4473 
    oprot.trans.flush()
4474 
 
4475 
  def process_getOrderCount(self, seqid, iprot, oprot):
4476 
    args = getOrderCount_args()
4477 
    args.read(iprot)
4478 
    iprot.readMessageEnd()
4479 
    result = getOrderCount_result()
4480 
    try:
4481 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4482 
    except TransactionServiceException, ex:
4483 
      result.ex = ex
4484 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4485 
    result.write(oprot)
4486 
    oprot.writeMessageEnd()
4487 
    oprot.trans.flush()
4488 
 
999 varun.gupt 4489 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4490 
    args = getOrdersByBillingDate_args()
4491 
    args.read(iprot)
4492 
    iprot.readMessageEnd()
4493 
    result = getOrdersByBillingDate_result()
4494 
    try:
4495 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4496 
    except TransactionServiceException, ex:
4497 
      result.ex = ex
4498 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4499 
    result.write(oprot)
4500 
    oprot.writeMessageEnd()
4501 
    oprot.trans.flush()
4502 
 
3427 chandransh 4503 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4504 
    args = getOrdersByShippingDate_args()
4505 
    args.read(iprot)
4506 
    iprot.readMessageEnd()
4507 
    result = getOrdersByShippingDate_result()
4508 
    try:
3451 chandransh 4509 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4510 
    except TransactionServiceException, ex:
4511 
      result.ex = ex
4512 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4513 
    result.write(oprot)
4514 
    oprot.writeMessageEnd()
4515 
    oprot.trans.flush()
4516 
 
1382 varun.gupt 4517 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4518 
    args = getReturnableOrdersForCustomer_args()
4519 
    args.read(iprot)
4520 
    iprot.readMessageEnd()
4521 
    result = getReturnableOrdersForCustomer_result()
4522 
    try:
4523 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4524 
    except TransactionServiceException, ex:
4525 
      result.ex = ex
4526 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4527 
    result.write(oprot)
4528 
    oprot.writeMessageEnd()
4529 
    oprot.trans.flush()
4530 
 
4531 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4532 
    args = getCancellableOrdersForCustomer_args()
4533 
    args.read(iprot)
4534 
    iprot.readMessageEnd()
4535 
    result = getCancellableOrdersForCustomer_result()
4536 
    try:
4537 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4538 
    except TransactionServiceException, ex:
4539 
      result.ex = ex
4540 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4541 
    result.write(oprot)
4542 
    oprot.writeMessageEnd()
4543 
    oprot.trans.flush()
4544 
 
483 rajveer 4545 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4546 
    args = changeOrderStatus_args()
94 ashish 4547 
    args.read(iprot)
4548 
    iprot.readMessageEnd()
483 rajveer 4549 
    result = changeOrderStatus_result()
94 ashish 4550 
    try:
483 rajveer 4551 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4552 
    except TransactionServiceException, ex:
4553 
      result.ex = ex
483 rajveer 4554 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4555 
    result.write(oprot)
4556 
    oprot.writeMessageEnd()
4557 
    oprot.trans.flush()
4558 
 
483 rajveer 4559 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4560 
    args = getOrdersForTransaction_args()
94 ashish 4561 
    args.read(iprot)
4562 
    iprot.readMessageEnd()
483 rajveer 4563 
    result = getOrdersForTransaction_result()
94 ashish 4564 
    try:
1528 ankur.sing 4565 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4566 
    except TransactionServiceException, ex:
4567 
      result.ex = ex
483 rajveer 4568 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4569 
    result.write(oprot)
4570 
    oprot.writeMessageEnd()
4571 
    oprot.trans.flush()
4572 
 
483 rajveer 4573 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4574 
    args = getOrdersForCustomer_args()
94 ashish 4575 
    args.read(iprot)
4576 
    iprot.readMessageEnd()
483 rajveer 4577 
    result = getOrdersForCustomer_result()
94 ashish 4578 
    try:
3014 chandransh 4579 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4580 
    except TransactionServiceException, ex:
4581 
      result.ex = ex
483 rajveer 4582 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4583 
    result.write(oprot)
4584 
    oprot.writeMessageEnd()
4585 
    oprot.trans.flush()
4586 
 
483 rajveer 4587 
  def process_createOrder(self, seqid, iprot, oprot):
4588 
    args = createOrder_args()
94 ashish 4589 
    args.read(iprot)
4590 
    iprot.readMessageEnd()
483 rajveer 4591 
    result = createOrder_result()
94 ashish 4592 
    try:
483 rajveer 4593 
      result.success = self._handler.createOrder(args.order)
94 ashish 4594 
    except TransactionServiceException, ex:
4595 
      result.ex = ex
483 rajveer 4596 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4597 
    result.write(oprot)
4598 
    oprot.writeMessageEnd()
4599 
    oprot.trans.flush()
4600 
 
483 rajveer 4601 
  def process_getOrder(self, seqid, iprot, oprot):
4602 
    args = getOrder_args()
94 ashish 4603 
    args.read(iprot)
4604 
    iprot.readMessageEnd()
483 rajveer 4605 
    result = getOrder_result()
94 ashish 4606 
    try:
483 rajveer 4607 
      result.success = self._handler.getOrder(args.id)
94 ashish 4608 
    except TransactionServiceException, ex:
4609 
      result.ex = ex
483 rajveer 4610 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4611 
    result.write(oprot)
4612 
    oprot.writeMessageEnd()
4613 
    oprot.trans.flush()
4614 
 
483 rajveer 4615 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4616 
    args = getLineItemsForOrder_args()
94 ashish 4617 
    args.read(iprot)
4618 
    iprot.readMessageEnd()
483 rajveer 4619 
    result = getLineItemsForOrder_result()
94 ashish 4620 
    try:
483 rajveer 4621 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4622 
    except TransactionServiceException, ex:
4623 
      result.ex = ex
483 rajveer 4624 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4625 
    result.write(oprot)
4626 
    oprot.writeMessageEnd()
4627 
    oprot.trans.flush()
4628 
 
1528 ankur.sing 4629 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4630 
    args = getOrderForCustomer_args()
4631 
    args.read(iprot)
4632 
    iprot.readMessageEnd()
4633 
    result = getOrderForCustomer_result()
4634 
    try:
4635 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4636 
    except TransactionServiceException, ex:
4637 
      result.ex = ex
4638 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4639 
    result.write(oprot)
4640 
    oprot.writeMessageEnd()
4641 
    oprot.trans.flush()
4642 
 
3064 chandransh 4643 
  def process_getAlerts(self, seqid, iprot, oprot):
4644 
    args = getAlerts_args()
4645 
    args.read(iprot)
4646 
    iprot.readMessageEnd()
4647 
    result = getAlerts_result()
4444 rajveer 4648 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4649 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4650 
    result.write(oprot)
4651 
    oprot.writeMessageEnd()
4652 
    oprot.trans.flush()
4653 
 
4394 rajveer 4654 
  def process_addAlert(self, seqid, iprot, oprot):
4655 
    args = addAlert_args()
3064 chandransh 4656 
    args.read(iprot)
4657 
    iprot.readMessageEnd()
4394 rajveer 4658 
    result = addAlert_result()
4444 rajveer 4659 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4660 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4661 
    result.write(oprot)
4662 
    oprot.writeMessageEnd()
4663 
    oprot.trans.flush()
4664 
 
4444 rajveer 4665 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4666 
    args = markAlertsAsSeen_args()
4667 
    args.read(iprot)
4668 
    iprot.readMessageEnd()
4669 
    result = markAlertsAsSeen_result()
4670 
    self._handler.markAlertsAsSeen(args.warehouseId)
4671 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4672 
    result.write(oprot)
4673 
    oprot.writeMessageEnd()
4674 
    oprot.trans.flush()
4675 
 
3064 chandransh 4676 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4677 
    args = getValidOrderCount_args()
4678 
    args.read(iprot)
4679 
    iprot.readMessageEnd()
4680 
    result = getValidOrderCount_result()
4681 
    result.success = self._handler.getValidOrderCount()
4682 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4683 
    result.write(oprot)
4684 
    oprot.writeMessageEnd()
4685 
    oprot.trans.flush()
4686 
 
4687 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4688 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4689 
    args.read(iprot)
4690 
    iprot.readMessageEnd()
4691 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4692 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4693 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4694 
    result.write(oprot)
4695 
    oprot.writeMessageEnd()
4696 
    oprot.trans.flush()
4697 
 
4698 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4699 
    args = getValidOrdersAmountRange_args()
4700 
    args.read(iprot)
4701 
    iprot.readMessageEnd()
4702 
    result = getValidOrdersAmountRange_result()
4703 
    result.success = self._handler.getValidOrdersAmountRange()
4704 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4705 
    result.write(oprot)
4706 
    oprot.writeMessageEnd()
4707 
    oprot.trans.flush()
4708 
 
4709 
  def process_getValidOrders(self, seqid, iprot, oprot):
4710 
    args = getValidOrders_args()
4711 
    args.read(iprot)
4712 
    iprot.readMessageEnd()
4713 
    result = getValidOrders_result()
4714 
    result.success = self._handler.getValidOrders(args.limit)
4715 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4716 
    result.write(oprot)
4717 
    oprot.writeMessageEnd()
4718 
    oprot.trans.flush()
4719 
 
1220 chandransh 4720 
  def process_batchOrders(self, seqid, iprot, oprot):
4721 
    args = batchOrders_args()
4722 
    args.read(iprot)
4723 
    iprot.readMessageEnd()
4724 
    result = batchOrders_result()
4725 
    try:
4726 
      result.success = self._handler.batchOrders(args.warehouseId)
4727 
    except TransactionServiceException, ex:
4728 
      result.ex = ex
4729 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4730 
    result.write(oprot)
4731 
    oprot.writeMessageEnd()
4732 
    oprot.trans.flush()
4733 
 
1208 chandransh 4734 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4735 
    args = markOrderAsOutOfStock_args()
4736 
    args.read(iprot)
4737 
    iprot.readMessageEnd()
4738 
    result = markOrderAsOutOfStock_result()
4739 
    try:
4740 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4741 
    except TransactionServiceException, ex:
4742 
      result.ex = ex
4743 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4744 
    result.write(oprot)
4745 
    oprot.writeMessageEnd()
4746 
    oprot.trans.flush()
4747 
 
3064 chandransh 4748 
  def process_verifyOrder(self, seqid, iprot, oprot):
4749 
    args = verifyOrder_args()
759 chandransh 4750 
    args.read(iprot)
4751 
    iprot.readMessageEnd()
3064 chandransh 4752 
    result = verifyOrder_result()
759 chandransh 4753 
    try:
3064 chandransh 4754 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4755 
    except TransactionServiceException, ex:
4756 
      result.ex = ex
3064 chandransh 4757 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4758 
    result.write(oprot)
4759 
    oprot.writeMessageEnd()
4760 
    oprot.trans.flush()
4761 
 
3064 chandransh 4762 
  def process_acceptOrder(self, seqid, iprot, oprot):
4763 
    args = acceptOrder_args()
1113 chandransh 4764 
    args.read(iprot)
4765 
    iprot.readMessageEnd()
3064 chandransh 4766 
    result = acceptOrder_result()
1113 chandransh 4767 
    try:
3064 chandransh 4768 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4769 
    except TransactionServiceException, ex:
4770 
      result.ex = ex
3064 chandransh 4771 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4772 
    result.write(oprot)
4773 
    oprot.writeMessageEnd()
4774 
    oprot.trans.flush()
4775 
 
3064 chandransh 4776 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4777 
    args = addBillingDetails_args()
1135 chandransh 4778 
    args.read(iprot)
4779 
    iprot.readMessageEnd()
3064 chandransh 4780 
    result = addBillingDetails_result()
1135 chandransh 4781 
    try:
4658 mandeep.dh 4782 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.serialNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.vendorId)
1135 chandransh 4783 
    except TransactionServiceException, ex:
4784 
      result.ex = ex
3064 chandransh 4785 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4786 
    result.write(oprot)
4787 
    oprot.writeMessageEnd()
4788 
    oprot.trans.flush()
4789 
 
4579 rajveer 4790 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
4791 
    args = addInvoiceNumber_args()
4792 
    args.read(iprot)
4793 
    iprot.readMessageEnd()
4794 
    result = addInvoiceNumber_result()
4795 
    try:
4796 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber)
4797 
    except TransactionServiceException, ex:
4798 
      result.ex = ex
4799 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
4800 
    result.write(oprot)
4801 
    oprot.writeMessageEnd()
4802 
    oprot.trans.flush()
4803 
 
3064 chandransh 4804 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4805 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4806 
    args.read(iprot)
4807 
    iprot.readMessageEnd()
3064 chandransh 4808 
    result = markOrdersAsManifested_result()
4809 
    try:
4810 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4811 
    except TransactionServiceException, ex:
4812 
      result.ex = ex
4813 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4814 
    result.write(oprot)
4815 
    oprot.writeMessageEnd()
4816 
    oprot.trans.flush()
4817 
 
4410 rajveer 4818 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4819 
    args = markOrdersAsShippedFromWarehouse_args()
4820 
    args.read(iprot)
4821 
    iprot.readMessageEnd()
4822 
    result = markOrdersAsShippedFromWarehouse_result()
4823 
    try:
4824 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4825 
    except TransactionServiceException, ex:
4826 
      result.ex = ex
4827 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4828 
    result.write(oprot)
4829 
    oprot.writeMessageEnd()
4830 
    oprot.trans.flush()
4831 
 
3064 chandransh 4832 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4833 
    args = markOrdersAsPickedUp_args()
304 ashish 4834 
    args.read(iprot)
4835 
    iprot.readMessageEnd()
3064 chandransh 4836 
    result = markOrdersAsPickedUp_result()
4837 
    try:
4838 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4839 
    except TransactionServiceException, ex:
4840 
      result.ex = ex
4841 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4842 
    result.write(oprot)
4843 
    oprot.writeMessageEnd()
4844 
    oprot.trans.flush()
94 ashish 4845 
 
3064 chandransh 4846 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4847 
    args = markOrdersAsDelivered_args()
304 ashish 4848 
    args.read(iprot)
4849 
    iprot.readMessageEnd()
3064 chandransh 4850 
    result = markOrdersAsDelivered_result()
4851 
    try:
4852 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4853 
    except TransactionServiceException, ex:
4854 
      result.ex = ex
4855 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4856 
    result.write(oprot)
4857 
    oprot.writeMessageEnd()
4858 
    oprot.trans.flush()
4859 
 
3064 chandransh 4860 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4861 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4862 
    args.read(iprot)
4863 
    iprot.readMessageEnd()
3064 chandransh 4864 
    result = markOrdersAsFailed_result()
4865 
    try:
4866 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4867 
    except TransactionServiceException, ex:
4868 
      result.ex = ex
4869 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4870 
    result.write(oprot)
4871 
    oprot.writeMessageEnd()
4872 
    oprot.trans.flush()
304 ashish 4873 
 
3064 chandransh 4874 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4875 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4876 
    args.read(iprot)
4877 
    iprot.readMessageEnd()
3064 chandransh 4878 
    result = updateNonDeliveryReason_result()
4879 
    try:
4581 phani.kuma 4880 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 4881 
    except TransactionServiceException, ex:
4882 
      result.ex = ex
4883 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4884 
    result.write(oprot)
4885 
    oprot.writeMessageEnd()
4886 
    oprot.trans.flush()
1596 ankur.sing 4887 
 
3064 chandransh 4888 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4889 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4890 
    args.read(iprot)
4891 
    iprot.readMessageEnd()
3064 chandransh 4892 
    result = getUndeliveredOrders_result()
4893 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4894 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4895 
    result.write(oprot)
4896 
    oprot.writeMessageEnd()
4897 
    oprot.trans.flush()
4898 
 
2536 chandransh 4899 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4900 
    args = toggleDOAFlag_args()
4901 
    args.read(iprot)
4902 
    iprot.readMessageEnd()
4903 
    result = toggleDOAFlag_result()
4904 
    try:
4905 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4906 
    except TransactionServiceException, ex:
4907 
      result.ex = ex
4908 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4909 
    result.write(oprot)
4910 
    oprot.writeMessageEnd()
4911 
    oprot.trans.flush()
1886 ankur.sing 4912 
 
4454 rajveer 4913 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
4914 
    args = markOrderDoaRequestReceived_args()
4915 
    args.read(iprot)
4916 
    iprot.readMessageEnd()
4917 
    result = markOrderDoaRequestReceived_result()
4918 
    try:
4919 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
4920 
    except TransactionServiceException, ex:
4921 
      result.ex = ex
4922 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
4923 
    result.write(oprot)
4924 
    oprot.writeMessageEnd()
4925 
    oprot.trans.flush()
4926 
 
4927 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
4928 
    args = markOrderDoaRequestAuthorized_args()
4929 
    args.read(iprot)
4930 
    iprot.readMessageEnd()
4931 
    result = markOrderDoaRequestAuthorized_result()
4932 
    try:
4933 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
4934 
    except TransactionServiceException, ex:
4935 
      result.ex = ex
4936 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
4937 
    result.write(oprot)
4938 
    oprot.writeMessageEnd()
4939 
    oprot.trans.flush()
4940 
 
4488 rajveer 4941 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
4942 
    args = markOrderReturnRequestReceived_args()
4943 
    args.read(iprot)
4944 
    iprot.readMessageEnd()
4945 
    result = markOrderReturnRequestReceived_result()
4946 
    try:
4947 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
4948 
    except TransactionServiceException, ex:
4949 
      result.ex = ex
4950 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
4951 
    result.write(oprot)
4952 
    oprot.writeMessageEnd()
4953 
    oprot.trans.flush()
4954 
 
4955 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
4956 
    args = markOrderReturnRequestAuthorized_args()
4957 
    args.read(iprot)
4958 
    iprot.readMessageEnd()
4959 
    result = markOrderReturnRequestAuthorized_result()
4960 
    try:
4961 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
4962 
    except TransactionServiceException, ex:
4963 
      result.ex = ex
4964 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
4965 
    result.write(oprot)
4966 
    oprot.writeMessageEnd()
4967 
    oprot.trans.flush()
4968 
 
2536 chandransh 4969 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
4970 
    args = requestPickupNumber_args()
4971 
    args.read(iprot)
4972 
    iprot.readMessageEnd()
4973 
    result = requestPickupNumber_result()
4974 
    try:
4579 rajveer 4975 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 4976 
    except TransactionServiceException, ex:
4977 
      result.ex = ex
4978 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
4979 
    result.write(oprot)
4980 
    oprot.writeMessageEnd()
4981 
    oprot.trans.flush()
4982 
 
4983 
  def process_authorizePickup(self, seqid, iprot, oprot):
4984 
    args = authorizePickup_args()
4985 
    args.read(iprot)
4986 
    iprot.readMessageEnd()
4987 
    result = authorizePickup_result()
4988 
    try:
4602 rajveer 4989 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 4990 
    except TransactionServiceException, ex:
4991 
      result.ex = ex
4992 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4993 
    result.write(oprot)
4994 
    oprot.writeMessageEnd()
4995 
    oprot.trans.flush()
4996 
 
2764 chandransh 4997 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4998 
    args = markDoasAsPickedUp_args()
4999 
    args.read(iprot)
5000 
    iprot.readMessageEnd()
5001 
    result = markDoasAsPickedUp_result()
5002 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
5003 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5004 
    result.write(oprot)
5005 
    oprot.writeMessageEnd()
5006 
    oprot.trans.flush()
5007 
 
2616 chandransh 5008 
  def process_receiveReturn(self, seqid, iprot, oprot):
5009 
    args = receiveReturn_args()
2591 chandransh 5010 
    args.read(iprot)
5011 
    iprot.readMessageEnd()
2616 chandransh 5012 
    result = receiveReturn_result()
2591 chandransh 5013 
    try:
4479 rajveer 5014 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5015 
    except TransactionServiceException, ex:
5016 
      result.ex = ex
2616 chandransh 5017 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5018 
    result.write(oprot)
5019 
    oprot.writeMessageEnd()
5020 
    oprot.trans.flush()
2536 chandransh 5021 
 
2591 chandransh 5022 
  def process_validateDoa(self, seqid, iprot, oprot):
5023 
    args = validateDoa_args()
5024 
    args.read(iprot)
5025 
    iprot.readMessageEnd()
5026 
    result = validateDoa_result()
5027 
    try:
5028 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5029 
    except TransactionServiceException, ex:
5030 
      result.ex = ex
5031 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5032 
    result.write(oprot)
5033 
    oprot.writeMessageEnd()
5034 
    oprot.trans.flush()
5035 
 
4495 rajveer 5036 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5037 
    args = validateReturnProduct_args()
5038 
    args.read(iprot)
5039 
    iprot.readMessageEnd()
5040 
    result = validateReturnProduct_result()
5041 
    try:
5042 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5043 
    except TransactionServiceException, ex:
5044 
      result.ex = ex
5045 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5046 
    result.write(oprot)
5047 
    oprot.writeMessageEnd()
5048 
    oprot.trans.flush()
5049 
 
2616 chandransh 5050 
  def process_reshipOrder(self, seqid, iprot, oprot):
5051 
    args = reshipOrder_args()
5052 
    args.read(iprot)
5053 
    iprot.readMessageEnd()
5054 
    result = reshipOrder_result()
5055 
    try:
5056 
      result.success = self._handler.reshipOrder(args.orderId)
5057 
    except TransactionServiceException, ex:
5058 
      result.ex = ex
5059 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5060 
    result.write(oprot)
5061 
    oprot.writeMessageEnd()
5062 
    oprot.trans.flush()
2591 chandransh 5063 
 
2616 chandransh 5064 
  def process_refundOrder(self, seqid, iprot, oprot):
5065 
    args = refundOrder_args()
5066 
    args.read(iprot)
5067 
    iprot.readMessageEnd()
5068 
    result = refundOrder_result()
5069 
    try:
3226 chandransh 5070 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5071 
    except TransactionServiceException, ex:
5072 
      result.ex = ex
5073 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5074 
    result.write(oprot)
5075 
    oprot.writeMessageEnd()
5076 
    oprot.trans.flush()
5077 
 
2690 chandransh 5078 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5079 
    args = getReturnOrders_args()
5080 
    args.read(iprot)
5081 
    iprot.readMessageEnd()
5082 
    result = getReturnOrders_result()
5083 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5084 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5085 
    result.write(oprot)
5086 
    oprot.writeMessageEnd()
5087 
    oprot.trans.flush()
2616 chandransh 5088 
 
2700 chandransh 5089 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5090 
    args = getReturnOrder_args()
5091 
    args.read(iprot)
5092 
    iprot.readMessageEnd()
5093 
    result = getReturnOrder_result()
5094 
    try:
5095 
      result.success = self._handler.getReturnOrder(args.id)
5096 
    except TransactionServiceException, ex:
5097 
      result.ex = ex
5098 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5099 
    result.write(oprot)
5100 
    oprot.writeMessageEnd()
5101 
    oprot.trans.flush()
5102 
 
2690 chandransh 5103 
  def process_processReturn(self, seqid, iprot, oprot):
5104 
    args = processReturn_args()
5105 
    args.read(iprot)
5106 
    iprot.readMessageEnd()
5107 
    result = processReturn_result()
5108 
    try:
5109 
      self._handler.processReturn(args.returnOrderId)
5110 
    except TransactionServiceException, ex:
5111 
      result.ex = ex
5112 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5113 
    result.write(oprot)
5114 
    oprot.writeMessageEnd()
5115 
    oprot.trans.flush()
5116 
 
2819 chandransh 5117 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
5118 
    args = createPurchaseOrder_args()
5119 
    args.read(iprot)
5120 
    iprot.readMessageEnd()
5121 
    result = createPurchaseOrder_result()
5122 
    try:
5123 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
5124 
    except TransactionServiceException, ex:
5125 
      result.ex = ex
5126 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
5127 
    result.write(oprot)
5128 
    oprot.writeMessageEnd()
5129 
    oprot.trans.flush()
2690 chandransh 5130 
 
3451 chandransh 5131 
  def process_updateWeight(self, seqid, iprot, oprot):
5132 
    args = updateWeight_args()
5133 
    args.read(iprot)
5134 
    iprot.readMessageEnd()
5135 
    result = updateWeight_result()
5136 
    try:
5137 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5138 
    except TransactionServiceException, ex:
5139 
      result.ex = ex
5140 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5141 
    result.write(oprot)
5142 
    oprot.writeMessageEnd()
5143 
    oprot.trans.flush()
2819 chandransh 5144 
 
3469 chandransh 5145 
  def process_changeItem(self, seqid, iprot, oprot):
5146 
    args = changeItem_args()
5147 
    args.read(iprot)
5148 
    iprot.readMessageEnd()
5149 
    result = changeItem_result()
5150 
    try:
5151 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5152 
    except TransactionServiceException, ex:
5153 
      result.ex = ex
5154 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5155 
    result.write(oprot)
5156 
    oprot.writeMessageEnd()
5157 
    oprot.trans.flush()
3451 chandransh 5158 
 
3469 chandransh 5159 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5160 
    args = shiftToWarehouse_args()
5161 
    args.read(iprot)
5162 
    iprot.readMessageEnd()
5163 
    result = shiftToWarehouse_result()
5164 
    try:
5165 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5166 
    except TransactionServiceException, ex:
5167 
      result.ex = ex
5168 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5169 
    result.write(oprot)
5170 
    oprot.writeMessageEnd()
5171 
    oprot.trans.flush()
5172 
 
3553 chandransh 5173 
  def process_addDelayReason(self, seqid, iprot, oprot):
5174 
    args = addDelayReason_args()
5175 
    args.read(iprot)
5176 
    iprot.readMessageEnd()
5177 
    result = addDelayReason_result()
5178 
    try:
4647 rajveer 5179 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 5180 
    except TransactionServiceException, ex:
5181 
      result.ex = ex
5182 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5183 
    result.write(oprot)
5184 
    oprot.writeMessageEnd()
5185 
    oprot.trans.flush()
3469 chandransh 5186 
 
3956 chandransh 5187 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5188 
    args = reconcileCodCollection_args()
5189 
    args.read(iprot)
5190 
    iprot.readMessageEnd()
5191 
    result = reconcileCodCollection_result()
5192 
    try:
5193 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5194 
    except TransactionServiceException, ex:
5195 
      result.ex = ex
5196 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5197 
    result.write(oprot)
5198 
    oprot.writeMessageEnd()
5199 
    oprot.trans.flush()
3553 chandransh 5200 
 
4008 mandeep.dh 5201 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5202 
    args = getTransactionsRequiringExtraProcessing_args()
5203 
    args.read(iprot)
5204 
    iprot.readMessageEnd()
5205 
    result = getTransactionsRequiringExtraProcessing_result()
5206 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5207 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5208 
    result.write(oprot)
5209 
    oprot.writeMessageEnd()
5210 
    oprot.trans.flush()
3956 chandransh 5211 
 
4008 mandeep.dh 5212 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5213 
    args = markTransactionAsProcessed_args()
5214 
    args.read(iprot)
5215 
    iprot.readMessageEnd()
5216 
    result = markTransactionAsProcessed_result()
5217 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5218 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5219 
    result.write(oprot)
5220 
    oprot.writeMessageEnd()
5221 
    oprot.trans.flush()
5222 
 
4018 chandransh 5223 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5224 
    args = getItemWiseRiskyOrdersCount_args()
5225 
    args.read(iprot)
5226 
    iprot.readMessageEnd()
5227 
    result = getItemWiseRiskyOrdersCount_result()
5228 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5229 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5230 
    result.write(oprot)
5231 
    oprot.writeMessageEnd()
5232 
    oprot.trans.flush()
4008 mandeep.dh 5233 
 
4295 varun.gupt 5234 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5235 
    args = getOrdersForItemIds_args()
5236 
    args.read(iprot)
5237 
    iprot.readMessageEnd()
5238 
    result = getOrdersForItemIds_result()
5239 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5240 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5241 
    result.write(oprot)
5242 
    oprot.writeMessageEnd()
5243 
    oprot.trans.flush()
5244 
 
4247 rajveer 5245 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5246 
    args = markOrderCancellationRequestReceived_args()
5247 
    args.read(iprot)
5248 
    iprot.readMessageEnd()
5249 
    result = markOrderCancellationRequestReceived_result()
5250 
    try:
5251 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5252 
    except TransactionServiceException, ex:
5253 
      result.ex = ex
5254 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5255 
    result.write(oprot)
5256 
    oprot.writeMessageEnd()
5257 
    oprot.trans.flush()
4018 chandransh 5258 
 
4247 rajveer 5259 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5260 
    args = markOrderCancellationRequestConfirmed_args()
5261 
    args.read(iprot)
5262 
    iprot.readMessageEnd()
5263 
    result = markOrderCancellationRequestConfirmed_result()
5264 
    try:
5265 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5266 
    except TransactionServiceException, ex:
5267 
      result.ex = ex
5268 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5269 
    result.write(oprot)
5270 
    oprot.writeMessageEnd()
5271 
    oprot.trans.flush()
5272 
 
5273 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5274 
    args = markOrderCancellationRequestDenied_args()
5275 
    args.read(iprot)
5276 
    iprot.readMessageEnd()
5277 
    result = markOrderCancellationRequestDenied_result()
5278 
    try:
5279 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5280 
    except TransactionServiceException, ex:
5281 
      result.ex = ex
5282 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5283 
    result.write(oprot)
5284 
    oprot.writeMessageEnd()
5285 
    oprot.trans.flush()
5286 
 
4258 rajveer 5287 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5288 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5289 
    args.read(iprot)
5290 
    iprot.readMessageEnd()
4258 rajveer 5291 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5292 
    try:
4258 rajveer 5293 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 5294 
    except TransactionServiceException, ex:
5295 
      result.ex = ex
4258 rajveer 5296 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 5297 
    result.write(oprot)
5298 
    oprot.writeMessageEnd()
5299 
    oprot.trans.flush()
5300 
 
4259 anupam.sin 5301 
  def process_refundTransaction(self, seqid, iprot, oprot):
5302 
    args = refundTransaction_args()
5303 
    args.read(iprot)
5304 
    iprot.readMessageEnd()
5305 
    result = refundTransaction_result()
5306 
    try:
5307 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
5308 
    except TransactionServiceException, ex:
5309 
      result.ex = ex
5310 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
5311 
    result.write(oprot)
5312 
    oprot.writeMessageEnd()
5313 
    oprot.trans.flush()
4247 rajveer 5314 
 
4324 mandeep.dh 5315 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
5316 
    args = updateShipmentAddress_args()
5317 
    args.read(iprot)
5318 
    iprot.readMessageEnd()
5319 
    result = updateShipmentAddress_result()
5320 
    try:
5321 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
5322 
    except TransactionServiceException, ex:
5323 
      result.ex = ex
5324 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
5325 
    result.write(oprot)
5326 
    oprot.writeMessageEnd()
5327 
    oprot.trans.flush()
5328 
 
4285 rajveer 5329 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
5330 
    args = acceptOrdersForItemId_args()
5331 
    args.read(iprot)
5332 
    iprot.readMessageEnd()
5333 
    result = acceptOrdersForItemId_result()
5334 
    try:
5335 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
5336 
    except TransactionServiceException, ex:
5337 
      result.ex = ex
5338 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
5339 
    result.write(oprot)
5340 
    oprot.writeMessageEnd()
5341 
    oprot.trans.flush()
4259 anupam.sin 5342 
 
4303 rajveer 5343 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
5344 
    args = markOrdersAsPORaised_args()
5345 
    args.read(iprot)
5346 
    iprot.readMessageEnd()
5347 
    result = markOrdersAsPORaised_result()
5348 
    try:
4369 rajveer 5349 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5350 
    except TransactionServiceException, ex:
5351 
      result.ex = ex
5352 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
5353 
    result.write(oprot)
5354 
    oprot.writeMessageEnd()
5355 
    oprot.trans.flush()
4285 rajveer 5356 
 
4303 rajveer 5357 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
5358 
    args = markOrdersAsReversalInitiated_args()
5359 
    args.read(iprot)
5360 
    iprot.readMessageEnd()
5361 
    result = markOrdersAsReversalInitiated_result()
5362 
    try:
4369 rajveer 5363 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5364 
    except TransactionServiceException, ex:
5365 
      result.ex = ex
5366 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
5367 
    result.write(oprot)
5368 
    oprot.writeMessageEnd()
5369 
    oprot.trans.flush()
5370 
 
5371 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
5372 
    args = markOrdersAsNotAvailabke_args()
5373 
    args.read(iprot)
5374 
    iprot.readMessageEnd()
5375 
    result = markOrdersAsNotAvailabke_result()
5376 
    try:
4369 rajveer 5377 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5378 
    except TransactionServiceException, ex:
5379 
      result.ex = ex
5380 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
5381 
    result.write(oprot)
5382 
    oprot.writeMessageEnd()
5383 
    oprot.trans.flush()
5384 
 
4369 rajveer 5385 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
5386 
    args = markOrdersAsTimeout_args()
5387 
    args.read(iprot)
5388 
    iprot.readMessageEnd()
5389 
    result = markOrdersAsTimeout_result()
5390 
    try:
5391 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
5392 
    except TransactionServiceException, ex:
5393 
      result.ex = ex
5394 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
5395 
    result.write(oprot)
5396 
    oprot.writeMessageEnd()
5397 
    oprot.trans.flush()
4303 rajveer 5398 
 
4662 rajveer 5399 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
5400 
    args = markOrderAsLostInTransit_args()
5401 
    args.read(iprot)
5402 
    iprot.readMessageEnd()
5403 
    result = markOrderAsLostInTransit_result()
5404 
    try:
5405 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
5406 
    except TransactionServiceException, ex:
5407 
      result.ex = ex
5408 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
5409 
    result.write(oprot)
5410 
    oprot.writeMessageEnd()
5411 
    oprot.trans.flush()
5412 
 
4386 anupam.sin 5413 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
5414 
    args = getOrderForAwb_args()
5415 
    args.read(iprot)
5416 
    iprot.readMessageEnd()
5417 
    result = getOrderForAwb_result()
5418 
    try:
5419 
      result.success = self._handler.getOrderForAwb(args.awb)
5420 
    except TransactionServiceException, ex:
5421 
      result.ex = ex
5422 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
5423 
    result.write(oprot)
5424 
    oprot.writeMessageEnd()
5425 
    oprot.trans.flush()
4369 rajveer 5426 
 
4506 phani.kuma 5427 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
5428 
    args = getOrdersForProviderForStatus_args()
5429 
    args.read(iprot)
5430 
    iprot.readMessageEnd()
5431 
    result = getOrdersForProviderForStatus_result()
5432 
    try:
5433 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
5434 
    except TransactionServiceException, ex:
5435 
      result.ex = ex
5436 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
5437 
    result.write(oprot)
5438 
    oprot.writeMessageEnd()
5439 
    oprot.trans.flush()
4386 anupam.sin 5440 
 
4600 varun.gupt 5441 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
5442 
    args = getBilledOrdersForVendor_args()
5443 
    args.read(iprot)
5444 
    iprot.readMessageEnd()
5445 
    result = getBilledOrdersForVendor_result()
5446 
    try:
5447 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
5448 
    except TransactionServiceException, ex:
5449 
      result.ex = ex
5450 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
5451 
    result.write(oprot)
5452 
    oprot.writeMessageEnd()
5453 
    oprot.trans.flush()
4506 phani.kuma 5454 
 
4607 rajveer 5455 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
5456 
    args = getSlippedSippingDateOrders_args()
5457 
    args.read(iprot)
5458 
    iprot.readMessageEnd()
5459 
    result = getSlippedSippingDateOrders_result()
5460 
    try:
5461 
      result.success = self._handler.getSlippedSippingDateOrders()
5462 
    except TransactionServiceException, ex:
5463 
      result.ex = ex
5464 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
5465 
    result.write(oprot)
5466 
    oprot.writeMessageEnd()
5467 
    oprot.trans.flush()
5468 
 
4709 rajveer 5469 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
5470 
    args = getCancelledOrders_args()
5471 
    args.read(iprot)
5472 
    iprot.readMessageEnd()
5473 
    result = getCancelledOrders_result()
5474 
    try:
5475 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
5476 
    except TransactionServiceException, ex:
5477 
      result.ex = ex
5478 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
5479 
    result.write(oprot)
5480 
    oprot.writeMessageEnd()
5481 
    oprot.trans.flush()
5482 
 
4600 varun.gupt 5483 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
5484 
    args = saveBluedartSettlements_args()
5485 
    args.read(iprot)
5486 
    iprot.readMessageEnd()
5487 
    result = saveBluedartSettlements_result()
5488 
    try:
5489 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
5490 
    except TransactionServiceException, ex:
5491 
      result.ex = ex
5492 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
5493 
    result.write(oprot)
5494 
    oprot.writeMessageEnd()
5495 
    oprot.trans.flush()
5496 
 
5497 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
5498 
    args = savePaymentSettlements_args()
5499 
    args.read(iprot)
5500 
    iprot.readMessageEnd()
5501 
    result = savePaymentSettlements_result()
5502 
    try:
5503 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.paymentId, args.serviceTax, args.otherCharges, args.netCollection)
5504 
    except TransactionServiceException, ex:
5505 
      result.ex = ex
5506 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
5507 
    result.write(oprot)
5508 
    oprot.writeMessageEnd()
5509 
    oprot.trans.flush()
5510 
 
5511 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
5512 
    args = saveEBSSettlementSummary_args()
5513 
    args.read(iprot)
5514 
    iprot.readMessageEnd()
5515 
    result = saveEBSSettlementSummary_result()
5516 
    try:
5517 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
5518 
    except TransactionServiceException, ex:
5519 
      result.ex = ex
5520 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
5521 
    result.write(oprot)
5522 
    oprot.writeMessageEnd()
5523 
    oprot.trans.flush()
5524 
 
5525 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
5526 
    args = getSettlementForPaymentId_args()
5527 
    args.read(iprot)
5528 
    iprot.readMessageEnd()
5529 
    result = getSettlementForPaymentId_result()
5530 
    try:
5531 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
5532 
    except TransactionServiceException, ex:
5533 
      result.ex = ex
5534 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
5535 
    result.write(oprot)
5536 
    oprot.writeMessageEnd()
5537 
    oprot.trans.flush()
5538 
 
5539 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
5540 
    args = getEBSSettlementSummaries_args()
5541 
    args.read(iprot)
5542 
    iprot.readMessageEnd()
5543 
    result = getEBSSettlementSummaries_result()
5544 
    try:
5545 
      result.success = self._handler.getEBSSettlementSummaries()
5546 
    except TransactionServiceException, ex:
5547 
      result.ex = ex
5548 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
5549 
    result.write(oprot)
5550 
    oprot.writeMessageEnd()
5551 
    oprot.trans.flush()
5552 
 
5553 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
5554 
    args = markEBSSettlementUploaded_args()
5555 
    args.read(iprot)
5556 
    iprot.readMessageEnd()
5557 
    result = markEBSSettlementUploaded_result()
5558 
    try:
5559 
      self._handler.markEBSSettlementUploaded(args.settlementId)
5560 
    except TransactionServiceException, ex:
5561 
      result.ex = ex
5562 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
5563 
    result.write(oprot)
5564 
    oprot.writeMessageEnd()
5565 
    oprot.trans.flush()
5566 
 
5567 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
5568 
    args = getEBSSettlementDate_args()
5569 
    args.read(iprot)
5570 
    iprot.readMessageEnd()
5571 
    result = getEBSSettlementDate_result()
5572 
    try:
5573 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
5574 
    except TransactionServiceException, ex:
5575 
      result.ex = ex
5576 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
5577 
    result.write(oprot)
5578 
    oprot.writeMessageEnd()
5579 
    oprot.trans.flush()
5580 
 
5581 
 
94 ashish 5582 
# HELPER FUNCTIONS AND STRUCTURES
5583 
 
5584 
class createTransaction_args:
5585 
  """
5586 
  Attributes:
5587 
   - transaction
5588 
  """
5589 
 
5590 
  thrift_spec = (
5591 
    None, # 0
5592 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
5593 
  )
5594 
 
5595 
  def __init__(self, transaction=None,):
5596 
    self.transaction = transaction
5597 
 
5598 
  def read(self, iprot):
5599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5601 
      return
5602 
    iprot.readStructBegin()
5603 
    while True:
5604 
      (fname, ftype, fid) = iprot.readFieldBegin()
5605 
      if ftype == TType.STOP:
5606 
        break
5607 
      if fid == 1:
5608 
        if ftype == TType.STRUCT:
5609 
          self.transaction = Transaction()
5610 
          self.transaction.read(iprot)
5611 
        else:
5612 
          iprot.skip(ftype)
5613 
      else:
5614 
        iprot.skip(ftype)
5615 
      iprot.readFieldEnd()
5616 
    iprot.readStructEnd()
5617 
 
5618 
  def write(self, oprot):
5619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5621 
      return
5622 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 5623 
    if self.transaction is not None:
94 ashish 5624 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5625 
      self.transaction.write(oprot)
5626 
      oprot.writeFieldEnd()
5627 
    oprot.writeFieldStop()
5628 
    oprot.writeStructEnd()
5629 
 
3431 rajveer 5630 
  def validate(self):
5631 
    return
5632 
 
5633 
 
94 ashish 5634 
  def __repr__(self):
5635 
    L = ['%s=%r' % (key, value)
5636 
      for key, value in self.__dict__.iteritems()]
5637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5638 
 
5639 
  def __eq__(self, other):
5640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5641 
 
5642 
  def __ne__(self, other):
5643 
    return not (self == other)
5644 
 
5645 
class createTransaction_result:
5646 
  """
5647 
  Attributes:
132 ashish 5648 
   - success
94 ashish 5649 
   - ex
5650 
  """
5651 
 
5652 
  thrift_spec = (
132 ashish 5653 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5654 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5655 
  )
5656 
 
132 ashish 5657 
  def __init__(self, success=None, ex=None,):
5658 
    self.success = success
94 ashish 5659 
    self.ex = ex
5660 
 
5661 
  def read(self, iprot):
5662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5664 
      return
5665 
    iprot.readStructBegin()
5666 
    while True:
5667 
      (fname, ftype, fid) = iprot.readFieldBegin()
5668 
      if ftype == TType.STOP:
5669 
        break
132 ashish 5670 
      if fid == 0:
5671 
        if ftype == TType.I64:
5672 
          self.success = iprot.readI64();
5673 
        else:
5674 
          iprot.skip(ftype)
5675 
      elif fid == 1:
94 ashish 5676 
        if ftype == TType.STRUCT:
5677 
          self.ex = TransactionServiceException()
5678 
          self.ex.read(iprot)
5679 
        else:
5680 
          iprot.skip(ftype)
5681 
      else:
5682 
        iprot.skip(ftype)
5683 
      iprot.readFieldEnd()
5684 
    iprot.readStructEnd()
5685 
 
5686 
  def write(self, oprot):
5687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5689 
      return
5690 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5691 
    if self.success is not None:
132 ashish 5692 
      oprot.writeFieldBegin('success', TType.I64, 0)
5693 
      oprot.writeI64(self.success)
5694 
      oprot.writeFieldEnd()
3431 rajveer 5695 
    if self.ex is not None:
94 ashish 5696 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5697 
      self.ex.write(oprot)
5698 
      oprot.writeFieldEnd()
5699 
    oprot.writeFieldStop()
5700 
    oprot.writeStructEnd()
5701 
 
3431 rajveer 5702 
  def validate(self):
5703 
    return
5704 
 
5705 
 
94 ashish 5706 
  def __repr__(self):
5707 
    L = ['%s=%r' % (key, value)
5708 
      for key, value in self.__dict__.iteritems()]
5709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5710 
 
5711 
  def __eq__(self, other):
5712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5713 
 
5714 
  def __ne__(self, other):
5715 
    return not (self == other)
5716 
 
5717 
class getTransaction_args:
5718 
  """
5719 
  Attributes:
5720 
   - id
5721 
  """
5722 
 
5723 
  thrift_spec = (
5724 
    None, # 0
5725 
    (1, TType.I64, 'id', None, None, ), # 1
5726 
  )
5727 
 
5728 
  def __init__(self, id=None,):
5729 
    self.id = id
5730 
 
5731 
  def read(self, iprot):
5732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5734 
      return
5735 
    iprot.readStructBegin()
5736 
    while True:
5737 
      (fname, ftype, fid) = iprot.readFieldBegin()
5738 
      if ftype == TType.STOP:
5739 
        break
5740 
      if fid == 1:
5741 
        if ftype == TType.I64:
5742 
          self.id = iprot.readI64();
5743 
        else:
5744 
          iprot.skip(ftype)
5745 
      else:
5746 
        iprot.skip(ftype)
5747 
      iprot.readFieldEnd()
5748 
    iprot.readStructEnd()
5749 
 
5750 
  def write(self, oprot):
5751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5753 
      return
5754 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 5755 
    if self.id is not None:
94 ashish 5756 
      oprot.writeFieldBegin('id', TType.I64, 1)
5757 
      oprot.writeI64(self.id)
5758 
      oprot.writeFieldEnd()
5759 
    oprot.writeFieldStop()
5760 
    oprot.writeStructEnd()
5761 
 
3431 rajveer 5762 
  def validate(self):
5763 
    return
5764 
 
5765 
 
94 ashish 5766 
  def __repr__(self):
5767 
    L = ['%s=%r' % (key, value)
5768 
      for key, value in self.__dict__.iteritems()]
5769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5770 
 
5771 
  def __eq__(self, other):
5772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5773 
 
5774 
  def __ne__(self, other):
5775 
    return not (self == other)
5776 
 
5777 
class getTransaction_result:
5778 
  """
5779 
  Attributes:
5780 
   - success
5781 
   - ex
5782 
  """
5783 
 
5784 
  thrift_spec = (
5785 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
5786 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5787 
  )
5788 
 
5789 
  def __init__(self, success=None, ex=None,):
5790 
    self.success = success
5791 
    self.ex = ex
5792 
 
5793 
  def read(self, iprot):
5794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5796 
      return
5797 
    iprot.readStructBegin()
5798 
    while True:
5799 
      (fname, ftype, fid) = iprot.readFieldBegin()
5800 
      if ftype == TType.STOP:
5801 
        break
5802 
      if fid == 0:
5803 
        if ftype == TType.STRUCT:
5804 
          self.success = Transaction()
5805 
          self.success.read(iprot)
5806 
        else:
5807 
          iprot.skip(ftype)
5808 
      elif fid == 1:
5809 
        if ftype == TType.STRUCT:
5810 
          self.ex = TransactionServiceException()
5811 
          self.ex.read(iprot)
5812 
        else:
5813 
          iprot.skip(ftype)
5814 
      else:
5815 
        iprot.skip(ftype)
5816 
      iprot.readFieldEnd()
5817 
    iprot.readStructEnd()
5818 
 
5819 
  def write(self, oprot):
5820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5822 
      return
5823 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 5824 
    if self.success is not None:
94 ashish 5825 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5826 
      self.success.write(oprot)
5827 
      oprot.writeFieldEnd()
3431 rajveer 5828 
    if self.ex is not None:
94 ashish 5829 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5830 
      self.ex.write(oprot)
5831 
      oprot.writeFieldEnd()
5832 
    oprot.writeFieldStop()
5833 
    oprot.writeStructEnd()
5834 
 
3431 rajveer 5835 
  def validate(self):
5836 
    return
5837 
 
5838 
 
94 ashish 5839 
  def __repr__(self):
5840 
    L = ['%s=%r' % (key, value)
5841 
      for key, value in self.__dict__.iteritems()]
5842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5843 
 
5844 
  def __eq__(self, other):
5845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5846 
 
5847 
  def __ne__(self, other):
5848 
    return not (self == other)
5849 
 
5850 
class getTransactionsForCustomer_args:
5851 
  """
5852 
  Attributes:
5853 
   - customerId
5854 
   - from_date
5855 
   - to_date
5856 
   - status
5857 
  """
5858 
 
5859 
  thrift_spec = (
5860 
    None, # 0
5861 
    (1, TType.I64, 'customerId', None, None, ), # 1
5862 
    (2, TType.I64, 'from_date', None, None, ), # 2
5863 
    (3, TType.I64, 'to_date', None, None, ), # 3
5864 
    (4, TType.I32, 'status', None, None, ), # 4
5865 
  )
5866 
 
5867 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
5868 
    self.customerId = customerId
5869 
    self.from_date = from_date
5870 
    self.to_date = to_date
5871 
    self.status = status
5872 
 
5873 
  def read(self, iprot):
5874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5876 
      return
5877 
    iprot.readStructBegin()
5878 
    while True:
5879 
      (fname, ftype, fid) = iprot.readFieldBegin()
5880 
      if ftype == TType.STOP:
5881 
        break
5882 
      if fid == 1:
5883 
        if ftype == TType.I64:
5884 
          self.customerId = iprot.readI64();
5885 
        else:
5886 
          iprot.skip(ftype)
5887 
      elif fid == 2:
5888 
        if ftype == TType.I64:
5889 
          self.from_date = iprot.readI64();
5890 
        else:
5891 
          iprot.skip(ftype)
5892 
      elif fid == 3:
5893 
        if ftype == TType.I64:
5894 
          self.to_date = iprot.readI64();
5895 
        else:
5896 
          iprot.skip(ftype)
5897 
      elif fid == 4:
5898 
        if ftype == TType.I32:
5899 
          self.status = iprot.readI32();
5900 
        else:
5901 
          iprot.skip(ftype)
5902 
      else:
5903 
        iprot.skip(ftype)
5904 
      iprot.readFieldEnd()
5905 
    iprot.readStructEnd()
5906 
 
5907 
  def write(self, oprot):
5908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5910 
      return
5911 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 5912 
    if self.customerId is not None:
94 ashish 5913 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5914 
      oprot.writeI64(self.customerId)
5915 
      oprot.writeFieldEnd()
3431 rajveer 5916 
    if self.from_date is not None:
94 ashish 5917 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5918 
      oprot.writeI64(self.from_date)
5919 
      oprot.writeFieldEnd()
3431 rajveer 5920 
    if self.to_date is not None:
94 ashish 5921 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5922 
      oprot.writeI64(self.to_date)
5923 
      oprot.writeFieldEnd()
3431 rajveer 5924 
    if self.status is not None:
94 ashish 5925 
      oprot.writeFieldBegin('status', TType.I32, 4)
5926 
      oprot.writeI32(self.status)
5927 
      oprot.writeFieldEnd()
5928 
    oprot.writeFieldStop()
5929 
    oprot.writeStructEnd()
5930 
 
3431 rajveer 5931 
  def validate(self):
5932 
    return
5933 
 
5934 
 
94 ashish 5935 
  def __repr__(self):
5936 
    L = ['%s=%r' % (key, value)
5937 
      for key, value in self.__dict__.iteritems()]
5938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5939 
 
5940 
  def __eq__(self, other):
5941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5942 
 
5943 
  def __ne__(self, other):
5944 
    return not (self == other)
5945 
 
5946 
class getTransactionsForCustomer_result:
5947 
  """
5948 
  Attributes:
5949 
   - success
5950 
   - ex
5951 
  """
5952 
 
5953 
  thrift_spec = (
5954 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5955 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5956 
  )
5957 
 
5958 
  def __init__(self, success=None, ex=None,):
5959 
    self.success = success
5960 
    self.ex = ex
5961 
 
5962 
  def read(self, iprot):
5963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5965 
      return
5966 
    iprot.readStructBegin()
5967 
    while True:
5968 
      (fname, ftype, fid) = iprot.readFieldBegin()
5969 
      if ftype == TType.STOP:
5970 
        break
5971 
      if fid == 0:
5972 
        if ftype == TType.LIST:
5973 
          self.success = []
685 chandransh 5974 
          (_etype17, _size14) = iprot.readListBegin()
5975 
          for _i18 in xrange(_size14):
5976 
            _elem19 = Transaction()
5977 
            _elem19.read(iprot)
5978 
            self.success.append(_elem19)
94 ashish 5979 
          iprot.readListEnd()
5980 
        else:
5981 
          iprot.skip(ftype)
5982 
      elif fid == 1:
5983 
        if ftype == TType.STRUCT:
5984 
          self.ex = TransactionServiceException()
5985 
          self.ex.read(iprot)
5986 
        else:
5987 
          iprot.skip(ftype)
5988 
      else:
5989 
        iprot.skip(ftype)
5990 
      iprot.readFieldEnd()
5991 
    iprot.readStructEnd()
5992 
 
5993 
  def write(self, oprot):
5994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5996 
      return
5997 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 5998 
    if self.success is not None:
94 ashish 5999 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6000 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6001 
      for iter20 in self.success:
6002 
        iter20.write(oprot)
94 ashish 6003 
      oprot.writeListEnd()
6004 
      oprot.writeFieldEnd()
3431 rajveer 6005 
    if self.ex is not None:
94 ashish 6006 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6007 
      self.ex.write(oprot)
6008 
      oprot.writeFieldEnd()
6009 
    oprot.writeFieldStop()
6010 
    oprot.writeStructEnd()
6011 
 
3431 rajveer 6012 
  def validate(self):
6013 
    return
6014 
 
6015 
 
94 ashish 6016 
  def __repr__(self):
6017 
    L = ['%s=%r' % (key, value)
6018 
      for key, value in self.__dict__.iteritems()]
6019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6020 
 
6021 
  def __eq__(self, other):
6022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6023 
 
6024 
  def __ne__(self, other):
6025 
    return not (self == other)
6026 
 
132 ashish 6027 
class getTransactionsForShoppingCartId_args:
6028 
  """
6029 
  Attributes:
6030 
   - shoppingCartId
6031 
  """
6032 
 
6033 
  thrift_spec = (
6034 
    None, # 0
6035 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
6036 
  )
6037 
 
6038 
  def __init__(self, shoppingCartId=None,):
6039 
    self.shoppingCartId = shoppingCartId
6040 
 
6041 
  def read(self, iprot):
6042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6044 
      return
6045 
    iprot.readStructBegin()
6046 
    while True:
6047 
      (fname, ftype, fid) = iprot.readFieldBegin()
6048 
      if ftype == TType.STOP:
6049 
        break
6050 
      if fid == 1:
6051 
        if ftype == TType.I64:
6052 
          self.shoppingCartId = iprot.readI64();
6053 
        else:
6054 
          iprot.skip(ftype)
6055 
      else:
6056 
        iprot.skip(ftype)
6057 
      iprot.readFieldEnd()
6058 
    iprot.readStructEnd()
6059 
 
6060 
  def write(self, oprot):
6061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6063 
      return
6064 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 6065 
    if self.shoppingCartId is not None:
132 ashish 6066 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
6067 
      oprot.writeI64(self.shoppingCartId)
6068 
      oprot.writeFieldEnd()
6069 
    oprot.writeFieldStop()
6070 
    oprot.writeStructEnd()
6071 
 
3431 rajveer 6072 
  def validate(self):
6073 
    return
6074 
 
6075 
 
132 ashish 6076 
  def __repr__(self):
6077 
    L = ['%s=%r' % (key, value)
6078 
      for key, value in self.__dict__.iteritems()]
6079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6080 
 
6081 
  def __eq__(self, other):
6082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6083 
 
6084 
  def __ne__(self, other):
6085 
    return not (self == other)
6086 
 
6087 
class getTransactionsForShoppingCartId_result:
6088 
  """
6089 
  Attributes:
6090 
   - success
6091 
   - ex
6092 
  """
6093 
 
6094 
  thrift_spec = (
6095 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6096 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6097 
  )
6098 
 
6099 
  def __init__(self, success=None, ex=None,):
6100 
    self.success = success
6101 
    self.ex = ex
6102 
 
6103 
  def read(self, iprot):
6104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6106 
      return
6107 
    iprot.readStructBegin()
6108 
    while True:
6109 
      (fname, ftype, fid) = iprot.readFieldBegin()
6110 
      if ftype == TType.STOP:
6111 
        break
6112 
      if fid == 0:
6113 
        if ftype == TType.LIST:
6114 
          self.success = []
685 chandransh 6115 
          (_etype24, _size21) = iprot.readListBegin()
6116 
          for _i25 in xrange(_size21):
6117 
            _elem26 = Transaction()
6118 
            _elem26.read(iprot)
6119 
            self.success.append(_elem26)
132 ashish 6120 
          iprot.readListEnd()
6121 
        else:
6122 
          iprot.skip(ftype)
6123 
      elif fid == 1:
6124 
        if ftype == TType.STRUCT:
6125 
          self.ex = TransactionServiceException()
6126 
          self.ex.read(iprot)
6127 
        else:
6128 
          iprot.skip(ftype)
6129 
      else:
6130 
        iprot.skip(ftype)
6131 
      iprot.readFieldEnd()
6132 
    iprot.readStructEnd()
6133 
 
6134 
  def write(self, oprot):
6135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6137 
      return
6138 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 6139 
    if self.success is not None:
132 ashish 6140 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6141 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6142 
      for iter27 in self.success:
6143 
        iter27.write(oprot)
132 ashish 6144 
      oprot.writeListEnd()
6145 
      oprot.writeFieldEnd()
3431 rajveer 6146 
    if self.ex is not None:
132 ashish 6147 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6148 
      self.ex.write(oprot)
6149 
      oprot.writeFieldEnd()
6150 
    oprot.writeFieldStop()
6151 
    oprot.writeStructEnd()
6152 
 
3431 rajveer 6153 
  def validate(self):
6154 
    return
6155 
 
6156 
 
132 ashish 6157 
  def __repr__(self):
6158 
    L = ['%s=%r' % (key, value)
6159 
      for key, value in self.__dict__.iteritems()]
6160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6161 
 
6162 
  def __eq__(self, other):
6163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6164 
 
6165 
  def __ne__(self, other):
6166 
    return not (self == other)
6167 
 
94 ashish 6168 
class getTransactionStatus_args:
6169 
  """
6170 
  Attributes:
6171 
   - transactionId
6172 
  """
6173 
 
6174 
  thrift_spec = (
6175 
    None, # 0
6176 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6177 
  )
6178 
 
6179 
  def __init__(self, transactionId=None,):
6180 
    self.transactionId = transactionId
6181 
 
6182 
  def read(self, iprot):
6183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6185 
      return
6186 
    iprot.readStructBegin()
6187 
    while True:
6188 
      (fname, ftype, fid) = iprot.readFieldBegin()
6189 
      if ftype == TType.STOP:
6190 
        break
6191 
      if fid == 1:
6192 
        if ftype == TType.I64:
6193 
          self.transactionId = iprot.readI64();
6194 
        else:
6195 
          iprot.skip(ftype)
6196 
      else:
6197 
        iprot.skip(ftype)
6198 
      iprot.readFieldEnd()
6199 
    iprot.readStructEnd()
6200 
 
6201 
  def write(self, oprot):
6202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6204 
      return
6205 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6206 
    if self.transactionId is not None:
94 ashish 6207 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6208 
      oprot.writeI64(self.transactionId)
6209 
      oprot.writeFieldEnd()
6210 
    oprot.writeFieldStop()
6211 
    oprot.writeStructEnd()
6212 
 
3431 rajveer 6213 
  def validate(self):
6214 
    return
6215 
 
6216 
 
94 ashish 6217 
  def __repr__(self):
6218 
    L = ['%s=%r' % (key, value)
6219 
      for key, value in self.__dict__.iteritems()]
6220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6221 
 
6222 
  def __eq__(self, other):
6223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6224 
 
6225 
  def __ne__(self, other):
6226 
    return not (self == other)
6227 
 
6228 
class getTransactionStatus_result:
6229 
  """
6230 
  Attributes:
6231 
   - success
6232 
   - ex
6233 
  """
6234 
 
6235 
  thrift_spec = (
6236 
    (0, TType.I32, 'success', None, None, ), # 0
6237 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6238 
  )
6239 
 
6240 
  def __init__(self, success=None, ex=None,):
6241 
    self.success = success
6242 
    self.ex = ex
6243 
 
6244 
  def read(self, iprot):
6245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6247 
      return
6248 
    iprot.readStructBegin()
6249 
    while True:
6250 
      (fname, ftype, fid) = iprot.readFieldBegin()
6251 
      if ftype == TType.STOP:
6252 
        break
6253 
      if fid == 0:
6254 
        if ftype == TType.I32:
6255 
          self.success = iprot.readI32();
6256 
        else:
6257 
          iprot.skip(ftype)
6258 
      elif fid == 1:
6259 
        if ftype == TType.STRUCT:
6260 
          self.ex = TransactionServiceException()
6261 
          self.ex.read(iprot)
6262 
        else:
6263 
          iprot.skip(ftype)
6264 
      else:
6265 
        iprot.skip(ftype)
6266 
      iprot.readFieldEnd()
6267 
    iprot.readStructEnd()
6268 
 
6269 
  def write(self, oprot):
6270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6272 
      return
6273 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 6274 
    if self.success is not None:
94 ashish 6275 
      oprot.writeFieldBegin('success', TType.I32, 0)
6276 
      oprot.writeI32(self.success)
6277 
      oprot.writeFieldEnd()
3431 rajveer 6278 
    if self.ex is not None:
94 ashish 6279 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6280 
      self.ex.write(oprot)
6281 
      oprot.writeFieldEnd()
6282 
    oprot.writeFieldStop()
6283 
    oprot.writeStructEnd()
6284 
 
3431 rajveer 6285 
  def validate(self):
6286 
    return
6287 
 
6288 
 
94 ashish 6289 
  def __repr__(self):
6290 
    L = ['%s=%r' % (key, value)
6291 
      for key, value in self.__dict__.iteritems()]
6292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6293 
 
6294 
  def __eq__(self, other):
6295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6296 
 
6297 
  def __ne__(self, other):
6298 
    return not (self == other)
6299 
 
6300 
class changeTransactionStatus_args:
6301 
  """
6302 
  Attributes:
6303 
   - transactionId
6304 
   - status
6305 
   - description
6306 
  """
6307 
 
6308 
  thrift_spec = (
6309 
    None, # 0
6310 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6311 
    (2, TType.I32, 'status', None, None, ), # 2
6312 
    (3, TType.STRING, 'description', None, None, ), # 3
6313 
  )
6314 
 
6315 
  def __init__(self, transactionId=None, status=None, description=None,):
6316 
    self.transactionId = transactionId
6317 
    self.status = status
6318 
    self.description = description
6319 
 
6320 
  def read(self, iprot):
6321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6323 
      return
6324 
    iprot.readStructBegin()
6325 
    while True:
6326 
      (fname, ftype, fid) = iprot.readFieldBegin()
6327 
      if ftype == TType.STOP:
6328 
        break
6329 
      if fid == 1:
6330 
        if ftype == TType.I64:
6331 
          self.transactionId = iprot.readI64();
6332 
        else:
6333 
          iprot.skip(ftype)
6334 
      elif fid == 2:
6335 
        if ftype == TType.I32:
6336 
          self.status = iprot.readI32();
6337 
        else:
6338 
          iprot.skip(ftype)
6339 
      elif fid == 3:
6340 
        if ftype == TType.STRING:
6341 
          self.description = iprot.readString();
6342 
        else:
6343 
          iprot.skip(ftype)
6344 
      else:
6345 
        iprot.skip(ftype)
6346 
      iprot.readFieldEnd()
6347 
    iprot.readStructEnd()
6348 
 
6349 
  def write(self, oprot):
6350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6352 
      return
6353 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 6354 
    if self.transactionId is not None:
94 ashish 6355 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6356 
      oprot.writeI64(self.transactionId)
6357 
      oprot.writeFieldEnd()
3431 rajveer 6358 
    if self.status is not None:
94 ashish 6359 
      oprot.writeFieldBegin('status', TType.I32, 2)
6360 
      oprot.writeI32(self.status)
6361 
      oprot.writeFieldEnd()
3431 rajveer 6362 
    if self.description is not None:
94 ashish 6363 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6364 
      oprot.writeString(self.description)
6365 
      oprot.writeFieldEnd()
6366 
    oprot.writeFieldStop()
6367 
    oprot.writeStructEnd()
6368 
 
3431 rajveer 6369 
  def validate(self):
6370 
    return
6371 
 
6372 
 
94 ashish 6373 
  def __repr__(self):
6374 
    L = ['%s=%r' % (key, value)
6375 
      for key, value in self.__dict__.iteritems()]
6376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6377 
 
6378 
  def __eq__(self, other):
6379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6380 
 
6381 
  def __ne__(self, other):
6382 
    return not (self == other)
6383 
 
6384 
class changeTransactionStatus_result:
6385 
  """
6386 
  Attributes:
6387 
   - success
6388 
   - ex
6389 
  """
6390 
 
6391 
  thrift_spec = (
6392 
    (0, TType.BOOL, 'success', None, None, ), # 0
6393 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6394 
  )
6395 
 
6396 
  def __init__(self, success=None, ex=None,):
6397 
    self.success = success
6398 
    self.ex = ex
6399 
 
6400 
  def read(self, iprot):
6401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6403 
      return
6404 
    iprot.readStructBegin()
6405 
    while True:
6406 
      (fname, ftype, fid) = iprot.readFieldBegin()
6407 
      if ftype == TType.STOP:
6408 
        break
6409 
      if fid == 0:
6410 
        if ftype == TType.BOOL:
6411 
          self.success = iprot.readBool();
6412 
        else:
6413 
          iprot.skip(ftype)
6414 
      elif fid == 1:
6415 
        if ftype == TType.STRUCT:
6416 
          self.ex = TransactionServiceException()
6417 
          self.ex.read(iprot)
6418 
        else:
6419 
          iprot.skip(ftype)
6420 
      else:
6421 
        iprot.skip(ftype)
6422 
      iprot.readFieldEnd()
6423 
    iprot.readStructEnd()
6424 
 
6425 
  def write(self, oprot):
6426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6428 
      return
6429 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 6430 
    if self.success is not None:
94 ashish 6431 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6432 
      oprot.writeBool(self.success)
6433 
      oprot.writeFieldEnd()
3431 rajveer 6434 
    if self.ex is not None:
94 ashish 6435 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6436 
      self.ex.write(oprot)
6437 
      oprot.writeFieldEnd()
6438 
    oprot.writeFieldStop()
6439 
    oprot.writeStructEnd()
6440 
 
3431 rajveer 6441 
  def validate(self):
6442 
    return
6443 
 
6444 
 
94 ashish 6445 
  def __repr__(self):
6446 
    L = ['%s=%r' % (key, value)
6447 
      for key, value in self.__dict__.iteritems()]
6448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6449 
 
6450 
  def __eq__(self, other):
6451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6452 
 
6453 
  def __ne__(self, other):
6454 
    return not (self == other)
6455 
 
1398 varun.gupt 6456 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 6457 
  """
6458 
  Attributes:
6459 
   - transactionId
6460 
  """
6461 
 
6462 
  thrift_spec = (
6463 
    None, # 0
6464 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6465 
  )
6466 
 
6467 
  def __init__(self, transactionId=None,):
6468 
    self.transactionId = transactionId
6469 
 
6470 
  def read(self, iprot):
6471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6473 
      return
6474 
    iprot.readStructBegin()
6475 
    while True:
6476 
      (fname, ftype, fid) = iprot.readFieldBegin()
6477 
      if ftype == TType.STOP:
6478 
        break
6479 
      if fid == 1:
6480 
        if ftype == TType.I64:
6481 
          self.transactionId = iprot.readI64();
6482 
        else:
6483 
          iprot.skip(ftype)
6484 
      else:
6485 
        iprot.skip(ftype)
6486 
      iprot.readFieldEnd()
6487 
    iprot.readStructEnd()
6488 
 
6489 
  def write(self, oprot):
6490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6492 
      return
1398 varun.gupt 6493 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 6494 
    if self.transactionId is not None:
1382 varun.gupt 6495 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6496 
      oprot.writeI64(self.transactionId)
6497 
      oprot.writeFieldEnd()
6498 
    oprot.writeFieldStop()
6499 
    oprot.writeStructEnd()
6500 
 
3431 rajveer 6501 
  def validate(self):
6502 
    return
6503 
 
6504 
 
1382 varun.gupt 6505 
  def __repr__(self):
6506 
    L = ['%s=%r' % (key, value)
6507 
      for key, value in self.__dict__.iteritems()]
6508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6509 
 
6510 
  def __eq__(self, other):
6511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6512 
 
6513 
  def __ne__(self, other):
6514 
    return not (self == other)
6515 
 
1398 varun.gupt 6516 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 6517 
  """
6518 
  Attributes:
6519 
   - success
6520 
   - ex
6521 
  """
6522 
 
6523 
  thrift_spec = (
6524 
    (0, TType.BOOL, 'success', None, None, ), # 0
6525 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6526 
  )
6527 
 
6528 
  def __init__(self, success=None, ex=None,):
6529 
    self.success = success
6530 
    self.ex = ex
6531 
 
6532 
  def read(self, iprot):
6533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6535 
      return
6536 
    iprot.readStructBegin()
6537 
    while True:
6538 
      (fname, ftype, fid) = iprot.readFieldBegin()
6539 
      if ftype == TType.STOP:
6540 
        break
6541 
      if fid == 0:
6542 
        if ftype == TType.BOOL:
6543 
          self.success = iprot.readBool();
6544 
        else:
6545 
          iprot.skip(ftype)
6546 
      elif fid == 1:
6547 
        if ftype == TType.STRUCT:
6548 
          self.ex = TransactionServiceException()
6549 
          self.ex.read(iprot)
6550 
        else:
6551 
          iprot.skip(ftype)
6552 
      else:
6553 
        iprot.skip(ftype)
6554 
      iprot.readFieldEnd()
6555 
    iprot.readStructEnd()
6556 
 
6557 
  def write(self, oprot):
6558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6560 
      return
1398 varun.gupt 6561 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 6562 
    if self.success is not None:
1382 varun.gupt 6563 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6564 
      oprot.writeBool(self.success)
6565 
      oprot.writeFieldEnd()
3431 rajveer 6566 
    if self.ex is not None:
1382 varun.gupt 6567 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6568 
      self.ex.write(oprot)
6569 
      oprot.writeFieldEnd()
6570 
    oprot.writeFieldStop()
6571 
    oprot.writeStructEnd()
6572 
 
3431 rajveer 6573 
  def validate(self):
6574 
    return
6575 
 
6576 
 
1382 varun.gupt 6577 
  def __repr__(self):
6578 
    L = ['%s=%r' % (key, value)
6579 
      for key, value in self.__dict__.iteritems()]
6580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6581 
 
6582 
  def __eq__(self, other):
6583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6584 
 
6585 
  def __ne__(self, other):
6586 
    return not (self == other)
6587 
 
483 rajveer 6588 
class getAllOrders_args:
94 ashish 6589 
  """
6590 
  Attributes:
483 rajveer 6591 
   - status
6592 
   - from_date
6593 
   - to_date
6594 
   - warehouse_id
94 ashish 6595 
  """
6596 
 
6597 
  thrift_spec = (
6598 
    None, # 0
483 rajveer 6599 
    (1, TType.I32, 'status', None, None, ), # 1
6600 
    (2, TType.I64, 'from_date', None, None, ), # 2
6601 
    (3, TType.I64, 'to_date', None, None, ), # 3
6602 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 6603 
  )
6604 
 
483 rajveer 6605 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
6606 
    self.status = status
6607 
    self.from_date = from_date
6608 
    self.to_date = to_date
6609 
    self.warehouse_id = warehouse_id
94 ashish 6610 
 
6611 
  def read(self, iprot):
6612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6614 
      return
6615 
    iprot.readStructBegin()
6616 
    while True:
6617 
      (fname, ftype, fid) = iprot.readFieldBegin()
6618 
      if ftype == TType.STOP:
6619 
        break
6620 
      if fid == 1:
483 rajveer 6621 
        if ftype == TType.I32:
6622 
          self.status = iprot.readI32();
94 ashish 6623 
        else:
6624 
          iprot.skip(ftype)
483 rajveer 6625 
      elif fid == 2:
6626 
        if ftype == TType.I64:
6627 
          self.from_date = iprot.readI64();
94 ashish 6628 
        else:
6629 
          iprot.skip(ftype)
483 rajveer 6630 
      elif fid == 3:
6631 
        if ftype == TType.I64:
6632 
          self.to_date = iprot.readI64();
94 ashish 6633 
        else:
6634 
          iprot.skip(ftype)
483 rajveer 6635 
      elif fid == 4:
94 ashish 6636 
        if ftype == TType.I64:
483 rajveer 6637 
          self.warehouse_id = iprot.readI64();
94 ashish 6638 
        else:
6639 
          iprot.skip(ftype)
6640 
      else:
6641 
        iprot.skip(ftype)
6642 
      iprot.readFieldEnd()
6643 
    iprot.readStructEnd()
6644 
 
6645 
  def write(self, oprot):
6646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6648 
      return
483 rajveer 6649 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 6650 
    if self.status is not None:
483 rajveer 6651 
      oprot.writeFieldBegin('status', TType.I32, 1)
6652 
      oprot.writeI32(self.status)
94 ashish 6653 
      oprot.writeFieldEnd()
3431 rajveer 6654 
    if self.from_date is not None:
483 rajveer 6655 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6656 
      oprot.writeI64(self.from_date)
94 ashish 6657 
      oprot.writeFieldEnd()
3431 rajveer 6658 
    if self.to_date is not None:
483 rajveer 6659 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6660 
      oprot.writeI64(self.to_date)
94 ashish 6661 
      oprot.writeFieldEnd()
3431 rajveer 6662 
    if self.warehouse_id is not None:
483 rajveer 6663 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6664 
      oprot.writeI64(self.warehouse_id)
94 ashish 6665 
      oprot.writeFieldEnd()
6666 
    oprot.writeFieldStop()
6667 
    oprot.writeStructEnd()
6668 
 
3431 rajveer 6669 
  def validate(self):
6670 
    return
6671 
 
6672 
 
94 ashish 6673 
  def __repr__(self):
6674 
    L = ['%s=%r' % (key, value)
6675 
      for key, value in self.__dict__.iteritems()]
6676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6677 
 
6678 
  def __eq__(self, other):
6679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6680 
 
6681 
  def __ne__(self, other):
6682 
    return not (self == other)
6683 
 
483 rajveer 6684 
class getAllOrders_result:
94 ashish 6685 
  """
6686 
  Attributes:
6687 
   - success
6688 
   - ex
6689 
  """
6690 
 
6691 
  thrift_spec = (
483 rajveer 6692 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6693 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6694 
  )
6695 
 
6696 
  def __init__(self, success=None, ex=None,):
6697 
    self.success = success
6698 
    self.ex = ex
6699 
 
6700 
  def read(self, iprot):
6701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6703 
      return
6704 
    iprot.readStructBegin()
6705 
    while True:
6706 
      (fname, ftype, fid) = iprot.readFieldBegin()
6707 
      if ftype == TType.STOP:
6708 
        break
6709 
      if fid == 0:
483 rajveer 6710 
        if ftype == TType.LIST:
6711 
          self.success = []
685 chandransh 6712 
          (_etype31, _size28) = iprot.readListBegin()
6713 
          for _i32 in xrange(_size28):
6714 
            _elem33 = Order()
6715 
            _elem33.read(iprot)
6716 
            self.success.append(_elem33)
483 rajveer 6717 
          iprot.readListEnd()
94 ashish 6718 
        else:
6719 
          iprot.skip(ftype)
6720 
      elif fid == 1:
6721 
        if ftype == TType.STRUCT:
6722 
          self.ex = TransactionServiceException()
6723 
          self.ex.read(iprot)
6724 
        else:
6725 
          iprot.skip(ftype)
6726 
      else:
6727 
        iprot.skip(ftype)
6728 
      iprot.readFieldEnd()
6729 
    iprot.readStructEnd()
6730 
 
6731 
  def write(self, oprot):
6732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6734 
      return
483 rajveer 6735 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 6736 
    if self.success is not None:
483 rajveer 6737 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6738 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6739 
      for iter34 in self.success:
6740 
        iter34.write(oprot)
483 rajveer 6741 
      oprot.writeListEnd()
94 ashish 6742 
      oprot.writeFieldEnd()
3431 rajveer 6743 
    if self.ex is not None:
94 ashish 6744 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6745 
      self.ex.write(oprot)
6746 
      oprot.writeFieldEnd()
6747 
    oprot.writeFieldStop()
6748 
    oprot.writeStructEnd()
6749 
 
3431 rajveer 6750 
  def validate(self):
6751 
    return
6752 
 
6753 
 
94 ashish 6754 
  def __repr__(self):
6755 
    L = ['%s=%r' % (key, value)
6756 
      for key, value in self.__dict__.iteritems()]
6757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6758 
 
6759 
  def __eq__(self, other):
6760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6761 
 
6762 
  def __ne__(self, other):
6763 
    return not (self == other)
6764 
 
4133 chandransh 6765 
class getOrdersInBatch_args:
6766 
  """
6767 
  Attributes:
6768 
   - statuses
6769 
   - offset
6770 
   - limit
6771 
   - warehouse_id
6772 
  """
6773 
 
6774 
  thrift_spec = (
6775 
    None, # 0
6776 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6777 
    (2, TType.I64, 'offset', None, None, ), # 2
6778 
    (3, TType.I64, 'limit', None, None, ), # 3
6779 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6780 
  )
6781 
 
6782 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
6783 
    self.statuses = statuses
6784 
    self.offset = offset
6785 
    self.limit = limit
6786 
    self.warehouse_id = warehouse_id
6787 
 
6788 
  def read(self, iprot):
6789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6791 
      return
6792 
    iprot.readStructBegin()
6793 
    while True:
6794 
      (fname, ftype, fid) = iprot.readFieldBegin()
6795 
      if ftype == TType.STOP:
6796 
        break
6797 
      if fid == 1:
6798 
        if ftype == TType.LIST:
6799 
          self.statuses = []
6800 
          (_etype38, _size35) = iprot.readListBegin()
6801 
          for _i39 in xrange(_size35):
6802 
            _elem40 = iprot.readI32();
6803 
            self.statuses.append(_elem40)
6804 
          iprot.readListEnd()
6805 
        else:
6806 
          iprot.skip(ftype)
6807 
      elif fid == 2:
6808 
        if ftype == TType.I64:
6809 
          self.offset = iprot.readI64();
6810 
        else:
6811 
          iprot.skip(ftype)
6812 
      elif fid == 3:
6813 
        if ftype == TType.I64:
6814 
          self.limit = iprot.readI64();
6815 
        else:
6816 
          iprot.skip(ftype)
6817 
      elif fid == 4:
6818 
        if ftype == TType.I64:
6819 
          self.warehouse_id = iprot.readI64();
6820 
        else:
6821 
          iprot.skip(ftype)
6822 
      else:
6823 
        iprot.skip(ftype)
6824 
      iprot.readFieldEnd()
6825 
    iprot.readStructEnd()
6826 
 
6827 
  def write(self, oprot):
6828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6830 
      return
6831 
    oprot.writeStructBegin('getOrdersInBatch_args')
6832 
    if self.statuses is not None:
6833 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6834 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6835 
      for iter41 in self.statuses:
6836 
        oprot.writeI32(iter41)
6837 
      oprot.writeListEnd()
6838 
      oprot.writeFieldEnd()
6839 
    if self.offset is not None:
6840 
      oprot.writeFieldBegin('offset', TType.I64, 2)
6841 
      oprot.writeI64(self.offset)
6842 
      oprot.writeFieldEnd()
6843 
    if self.limit is not None:
6844 
      oprot.writeFieldBegin('limit', TType.I64, 3)
6845 
      oprot.writeI64(self.limit)
6846 
      oprot.writeFieldEnd()
6847 
    if self.warehouse_id is not None:
6848 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6849 
      oprot.writeI64(self.warehouse_id)
6850 
      oprot.writeFieldEnd()
6851 
    oprot.writeFieldStop()
6852 
    oprot.writeStructEnd()
6853 
 
6854 
  def validate(self):
6855 
    return
6856 
 
6857 
 
6858 
  def __repr__(self):
6859 
    L = ['%s=%r' % (key, value)
6860 
      for key, value in self.__dict__.iteritems()]
6861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6862 
 
6863 
  def __eq__(self, other):
6864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6865 
 
6866 
  def __ne__(self, other):
6867 
    return not (self == other)
6868 
 
6869 
class getOrdersInBatch_result:
6870 
  """
6871 
  Attributes:
6872 
   - success
6873 
   - ex
6874 
  """
6875 
 
6876 
  thrift_spec = (
6877 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6878 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6879 
  )
6880 
 
6881 
  def __init__(self, success=None, ex=None,):
6882 
    self.success = success
6883 
    self.ex = ex
6884 
 
6885 
  def read(self, iprot):
6886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6888 
      return
6889 
    iprot.readStructBegin()
6890 
    while True:
6891 
      (fname, ftype, fid) = iprot.readFieldBegin()
6892 
      if ftype == TType.STOP:
6893 
        break
6894 
      if fid == 0:
6895 
        if ftype == TType.LIST:
6896 
          self.success = []
6897 
          (_etype45, _size42) = iprot.readListBegin()
6898 
          for _i46 in xrange(_size42):
6899 
            _elem47 = Order()
6900 
            _elem47.read(iprot)
6901 
            self.success.append(_elem47)
6902 
          iprot.readListEnd()
6903 
        else:
6904 
          iprot.skip(ftype)
6905 
      elif fid == 1:
6906 
        if ftype == TType.STRUCT:
6907 
          self.ex = TransactionServiceException()
6908 
          self.ex.read(iprot)
6909 
        else:
6910 
          iprot.skip(ftype)
6911 
      else:
6912 
        iprot.skip(ftype)
6913 
      iprot.readFieldEnd()
6914 
    iprot.readStructEnd()
6915 
 
6916 
  def write(self, oprot):
6917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6919 
      return
6920 
    oprot.writeStructBegin('getOrdersInBatch_result')
6921 
    if self.success is not None:
6922 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6923 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6924 
      for iter48 in self.success:
6925 
        iter48.write(oprot)
6926 
      oprot.writeListEnd()
6927 
      oprot.writeFieldEnd()
6928 
    if self.ex is not None:
6929 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6930 
      self.ex.write(oprot)
6931 
      oprot.writeFieldEnd()
6932 
    oprot.writeFieldStop()
6933 
    oprot.writeStructEnd()
6934 
 
6935 
  def validate(self):
6936 
    return
6937 
 
6938 
 
6939 
  def __repr__(self):
6940 
    L = ['%s=%r' % (key, value)
6941 
      for key, value in self.__dict__.iteritems()]
6942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6943 
 
6944 
  def __eq__(self, other):
6945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6946 
 
6947 
  def __ne__(self, other):
6948 
    return not (self == other)
6949 
 
6950 
class getOrderCount_args:
6951 
  """
6952 
  Attributes:
6953 
   - statuses
6954 
   - warehouseId
6955 
  """
6956 
 
6957 
  thrift_spec = (
6958 
    None, # 0
6959 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6960 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6961 
  )
6962 
 
6963 
  def __init__(self, statuses=None, warehouseId=None,):
6964 
    self.statuses = statuses
6965 
    self.warehouseId = warehouseId
6966 
 
6967 
  def read(self, iprot):
6968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6970 
      return
6971 
    iprot.readStructBegin()
6972 
    while True:
6973 
      (fname, ftype, fid) = iprot.readFieldBegin()
6974 
      if ftype == TType.STOP:
6975 
        break
6976 
      if fid == 1:
6977 
        if ftype == TType.LIST:
6978 
          self.statuses = []
6979 
          (_etype52, _size49) = iprot.readListBegin()
6980 
          for _i53 in xrange(_size49):
6981 
            _elem54 = iprot.readI32();
6982 
            self.statuses.append(_elem54)
6983 
          iprot.readListEnd()
6984 
        else:
6985 
          iprot.skip(ftype)
6986 
      elif fid == 2:
6987 
        if ftype == TType.I64:
6988 
          self.warehouseId = iprot.readI64();
6989 
        else:
6990 
          iprot.skip(ftype)
6991 
      else:
6992 
        iprot.skip(ftype)
6993 
      iprot.readFieldEnd()
6994 
    iprot.readStructEnd()
6995 
 
6996 
  def write(self, oprot):
6997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6999 
      return
7000 
    oprot.writeStructBegin('getOrderCount_args')
7001 
    if self.statuses is not None:
7002 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7003 
      oprot.writeListBegin(TType.I32, len(self.statuses))
7004 
      for iter55 in self.statuses:
7005 
        oprot.writeI32(iter55)
7006 
      oprot.writeListEnd()
7007 
      oprot.writeFieldEnd()
7008 
    if self.warehouseId is not None:
7009 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7010 
      oprot.writeI64(self.warehouseId)
7011 
      oprot.writeFieldEnd()
7012 
    oprot.writeFieldStop()
7013 
    oprot.writeStructEnd()
7014 
 
7015 
  def validate(self):
7016 
    return
7017 
 
7018 
 
7019 
  def __repr__(self):
7020 
    L = ['%s=%r' % (key, value)
7021 
      for key, value in self.__dict__.iteritems()]
7022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7023 
 
7024 
  def __eq__(self, other):
7025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7026 
 
7027 
  def __ne__(self, other):
7028 
    return not (self == other)
7029 
 
7030 
class getOrderCount_result:
7031 
  """
7032 
  Attributes:
7033 
   - success
7034 
   - ex
7035 
  """
7036 
 
7037 
  thrift_spec = (
7038 
    (0, TType.I32, 'success', None, None, ), # 0
7039 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7040 
  )
7041 
 
7042 
  def __init__(self, success=None, ex=None,):
7043 
    self.success = success
7044 
    self.ex = ex
7045 
 
7046 
  def read(self, iprot):
7047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7049 
      return
7050 
    iprot.readStructBegin()
7051 
    while True:
7052 
      (fname, ftype, fid) = iprot.readFieldBegin()
7053 
      if ftype == TType.STOP:
7054 
        break
7055 
      if fid == 0:
7056 
        if ftype == TType.I32:
7057 
          self.success = iprot.readI32();
7058 
        else:
7059 
          iprot.skip(ftype)
7060 
      elif fid == 1:
7061 
        if ftype == TType.STRUCT:
7062 
          self.ex = TransactionServiceException()
7063 
          self.ex.read(iprot)
7064 
        else:
7065 
          iprot.skip(ftype)
7066 
      else:
7067 
        iprot.skip(ftype)
7068 
      iprot.readFieldEnd()
7069 
    iprot.readStructEnd()
7070 
 
7071 
  def write(self, oprot):
7072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7074 
      return
7075 
    oprot.writeStructBegin('getOrderCount_result')
7076 
    if self.success is not None:
7077 
      oprot.writeFieldBegin('success', TType.I32, 0)
7078 
      oprot.writeI32(self.success)
7079 
      oprot.writeFieldEnd()
7080 
    if self.ex is not None:
7081 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7082 
      self.ex.write(oprot)
7083 
      oprot.writeFieldEnd()
7084 
    oprot.writeFieldStop()
7085 
    oprot.writeStructEnd()
7086 
 
7087 
  def validate(self):
7088 
    return
7089 
 
7090 
 
7091 
  def __repr__(self):
7092 
    L = ['%s=%r' % (key, value)
7093 
      for key, value in self.__dict__.iteritems()]
7094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7095 
 
7096 
  def __eq__(self, other):
7097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7098 
 
7099 
  def __ne__(self, other):
7100 
    return not (self == other)
7101 
 
999 varun.gupt 7102 
class getOrdersByBillingDate_args:
7103 
  """
7104 
  Attributes:
7105 
   - status
7106 
   - start_billing_date
7107 
   - end_billing_date
7108 
   - warehouse_id
7109 
  """
7110 
 
7111 
  thrift_spec = (
7112 
    None, # 0
7113 
    (1, TType.I32, 'status', None, None, ), # 1
7114 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
7115 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
7116 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7117 
  )
7118 
 
7119 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7120 
    self.status = status
7121 
    self.start_billing_date = start_billing_date
7122 
    self.end_billing_date = end_billing_date
7123 
    self.warehouse_id = warehouse_id
7124 
 
7125 
  def read(self, iprot):
7126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7128 
      return
7129 
    iprot.readStructBegin()
7130 
    while True:
7131 
      (fname, ftype, fid) = iprot.readFieldBegin()
7132 
      if ftype == TType.STOP:
7133 
        break
7134 
      if fid == 1:
7135 
        if ftype == TType.I32:
7136 
          self.status = iprot.readI32();
7137 
        else:
7138 
          iprot.skip(ftype)
7139 
      elif fid == 2:
7140 
        if ftype == TType.I64:
7141 
          self.start_billing_date = iprot.readI64();
7142 
        else:
7143 
          iprot.skip(ftype)
7144 
      elif fid == 3:
7145 
        if ftype == TType.I64:
7146 
          self.end_billing_date = iprot.readI64();
7147 
        else:
7148 
          iprot.skip(ftype)
7149 
      elif fid == 4:
7150 
        if ftype == TType.I64:
7151 
          self.warehouse_id = iprot.readI64();
7152 
        else:
7153 
          iprot.skip(ftype)
7154 
      else:
7155 
        iprot.skip(ftype)
7156 
      iprot.readFieldEnd()
7157 
    iprot.readStructEnd()
7158 
 
7159 
  def write(self, oprot):
7160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7162 
      return
7163 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7164 
    if self.status is not None:
999 varun.gupt 7165 
      oprot.writeFieldBegin('status', TType.I32, 1)
7166 
      oprot.writeI32(self.status)
7167 
      oprot.writeFieldEnd()
3431 rajveer 7168 
    if self.start_billing_date is not None:
999 varun.gupt 7169 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7170 
      oprot.writeI64(self.start_billing_date)
7171 
      oprot.writeFieldEnd()
3431 rajveer 7172 
    if self.end_billing_date is not None:
999 varun.gupt 7173 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7174 
      oprot.writeI64(self.end_billing_date)
7175 
      oprot.writeFieldEnd()
3431 rajveer 7176 
    if self.warehouse_id is not None:
999 varun.gupt 7177 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7178 
      oprot.writeI64(self.warehouse_id)
7179 
      oprot.writeFieldEnd()
7180 
    oprot.writeFieldStop()
7181 
    oprot.writeStructEnd()
7182 
 
3431 rajveer 7183 
  def validate(self):
7184 
    return
7185 
 
7186 
 
999 varun.gupt 7187 
  def __repr__(self):
7188 
    L = ['%s=%r' % (key, value)
7189 
      for key, value in self.__dict__.iteritems()]
7190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7191 
 
7192 
  def __eq__(self, other):
7193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7194 
 
7195 
  def __ne__(self, other):
7196 
    return not (self == other)
7197 
 
7198 
class getOrdersByBillingDate_result:
7199 
  """
7200 
  Attributes:
7201 
   - success
7202 
   - ex
7203 
  """
7204 
 
7205 
  thrift_spec = (
7206 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7207 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7208 
  )
7209 
 
7210 
  def __init__(self, success=None, ex=None,):
7211 
    self.success = success
7212 
    self.ex = ex
7213 
 
7214 
  def read(self, iprot):
7215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7217 
      return
7218 
    iprot.readStructBegin()
7219 
    while True:
7220 
      (fname, ftype, fid) = iprot.readFieldBegin()
7221 
      if ftype == TType.STOP:
7222 
        break
7223 
      if fid == 0:
7224 
        if ftype == TType.LIST:
7225 
          self.success = []
4133 chandransh 7226 
          (_etype59, _size56) = iprot.readListBegin()
7227 
          for _i60 in xrange(_size56):
7228 
            _elem61 = Order()
7229 
            _elem61.read(iprot)
7230 
            self.success.append(_elem61)
999 varun.gupt 7231 
          iprot.readListEnd()
7232 
        else:
7233 
          iprot.skip(ftype)
7234 
      elif fid == 1:
7235 
        if ftype == TType.STRUCT:
7236 
          self.ex = TransactionServiceException()
7237 
          self.ex.read(iprot)
7238 
        else:
7239 
          iprot.skip(ftype)
7240 
      else:
7241 
        iprot.skip(ftype)
7242 
      iprot.readFieldEnd()
7243 
    iprot.readStructEnd()
7244 
 
7245 
  def write(self, oprot):
7246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7248 
      return
7249 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 7250 
    if self.success is not None:
999 varun.gupt 7251 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7252 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7253 
      for iter62 in self.success:
7254 
        iter62.write(oprot)
999 varun.gupt 7255 
      oprot.writeListEnd()
7256 
      oprot.writeFieldEnd()
3431 rajveer 7257 
    if self.ex is not None:
999 varun.gupt 7258 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7259 
      self.ex.write(oprot)
7260 
      oprot.writeFieldEnd()
7261 
    oprot.writeFieldStop()
7262 
    oprot.writeStructEnd()
7263 
 
3431 rajveer 7264 
  def validate(self):
7265 
    return
7266 
 
7267 
 
999 varun.gupt 7268 
  def __repr__(self):
7269 
    L = ['%s=%r' % (key, value)
7270 
      for key, value in self.__dict__.iteritems()]
7271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7272 
 
7273 
  def __eq__(self, other):
7274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7275 
 
7276 
  def __ne__(self, other):
7277 
    return not (self == other)
7278 
 
3427 chandransh 7279 
class getOrdersByShippingDate_args:
7280 
  """
7281 
  Attributes:
7282 
   - fromShippingDate
7283 
   - toShippingDate
7284 
   - providerId
7285 
   - warehouseId
3451 chandransh 7286 
   - cod
3427 chandransh 7287 
  """
7288 
 
7289 
  thrift_spec = (
7290 
    None, # 0
7291 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
7292 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
7293 
    (3, TType.I64, 'providerId', None, None, ), # 3
7294 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 7295 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 7296 
  )
7297 
 
3451 chandransh 7298 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 7299 
    self.fromShippingDate = fromShippingDate
7300 
    self.toShippingDate = toShippingDate
7301 
    self.providerId = providerId
7302 
    self.warehouseId = warehouseId
3451 chandransh 7303 
    self.cod = cod
3427 chandransh 7304 
 
7305 
  def read(self, iprot):
7306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7308 
      return
7309 
    iprot.readStructBegin()
7310 
    while True:
7311 
      (fname, ftype, fid) = iprot.readFieldBegin()
7312 
      if ftype == TType.STOP:
7313 
        break
7314 
      if fid == 1:
7315 
        if ftype == TType.I64:
7316 
          self.fromShippingDate = iprot.readI64();
7317 
        else:
7318 
          iprot.skip(ftype)
7319 
      elif fid == 2:
7320 
        if ftype == TType.I64:
7321 
          self.toShippingDate = iprot.readI64();
7322 
        else:
7323 
          iprot.skip(ftype)
7324 
      elif fid == 3:
7325 
        if ftype == TType.I64:
7326 
          self.providerId = iprot.readI64();
7327 
        else:
7328 
          iprot.skip(ftype)
7329 
      elif fid == 4:
7330 
        if ftype == TType.I64:
7331 
          self.warehouseId = iprot.readI64();
7332 
        else:
7333 
          iprot.skip(ftype)
3451 chandransh 7334 
      elif fid == 5:
7335 
        if ftype == TType.BOOL:
7336 
          self.cod = iprot.readBool();
7337 
        else:
7338 
          iprot.skip(ftype)
3427 chandransh 7339 
      else:
7340 
        iprot.skip(ftype)
7341 
      iprot.readFieldEnd()
7342 
    iprot.readStructEnd()
7343 
 
7344 
  def write(self, oprot):
7345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7347 
      return
7348 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 7349 
    if self.fromShippingDate is not None:
3427 chandransh 7350 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
7351 
      oprot.writeI64(self.fromShippingDate)
7352 
      oprot.writeFieldEnd()
3431 rajveer 7353 
    if self.toShippingDate is not None:
3427 chandransh 7354 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
7355 
      oprot.writeI64(self.toShippingDate)
7356 
      oprot.writeFieldEnd()
3431 rajveer 7357 
    if self.providerId is not None:
3427 chandransh 7358 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
7359 
      oprot.writeI64(self.providerId)
7360 
      oprot.writeFieldEnd()
3431 rajveer 7361 
    if self.warehouseId is not None:
3427 chandransh 7362 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
7363 
      oprot.writeI64(self.warehouseId)
7364 
      oprot.writeFieldEnd()
3451 chandransh 7365 
    if self.cod is not None:
7366 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
7367 
      oprot.writeBool(self.cod)
7368 
      oprot.writeFieldEnd()
3427 chandransh 7369 
    oprot.writeFieldStop()
7370 
    oprot.writeStructEnd()
7371 
 
3431 rajveer 7372 
  def validate(self):
7373 
    return
7374 
 
7375 
 
3427 chandransh 7376 
  def __repr__(self):
7377 
    L = ['%s=%r' % (key, value)
7378 
      for key, value in self.__dict__.iteritems()]
7379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7380 
 
7381 
  def __eq__(self, other):
7382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7383 
 
7384 
  def __ne__(self, other):
7385 
    return not (self == other)
7386 
 
7387 
class getOrdersByShippingDate_result:
7388 
  """
7389 
  Attributes:
7390 
   - success
7391 
   - ex
7392 
  """
7393 
 
7394 
  thrift_spec = (
7395 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7396 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7397 
  )
7398 
 
7399 
  def __init__(self, success=None, ex=None,):
7400 
    self.success = success
7401 
    self.ex = ex
7402 
 
7403 
  def read(self, iprot):
7404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7406 
      return
7407 
    iprot.readStructBegin()
7408 
    while True:
7409 
      (fname, ftype, fid) = iprot.readFieldBegin()
7410 
      if ftype == TType.STOP:
7411 
        break
7412 
      if fid == 0:
7413 
        if ftype == TType.LIST:
7414 
          self.success = []
4133 chandransh 7415 
          (_etype66, _size63) = iprot.readListBegin()
7416 
          for _i67 in xrange(_size63):
7417 
            _elem68 = Order()
7418 
            _elem68.read(iprot)
7419 
            self.success.append(_elem68)
3427 chandransh 7420 
          iprot.readListEnd()
7421 
        else:
7422 
          iprot.skip(ftype)
7423 
      elif fid == 1:
7424 
        if ftype == TType.STRUCT:
7425 
          self.ex = TransactionServiceException()
7426 
          self.ex.read(iprot)
7427 
        else:
7428 
          iprot.skip(ftype)
7429 
      else:
7430 
        iprot.skip(ftype)
7431 
      iprot.readFieldEnd()
7432 
    iprot.readStructEnd()
7433 
 
7434 
  def write(self, oprot):
7435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7437 
      return
7438 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 7439 
    if self.success is not None:
3427 chandransh 7440 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7441 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7442 
      for iter69 in self.success:
7443 
        iter69.write(oprot)
3427 chandransh 7444 
      oprot.writeListEnd()
7445 
      oprot.writeFieldEnd()
3431 rajveer 7446 
    if self.ex is not None:
3427 chandransh 7447 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7448 
      self.ex.write(oprot)
7449 
      oprot.writeFieldEnd()
7450 
    oprot.writeFieldStop()
7451 
    oprot.writeStructEnd()
7452 
 
3431 rajveer 7453 
  def validate(self):
7454 
    return
7455 
 
7456 
 
3427 chandransh 7457 
  def __repr__(self):
7458 
    L = ['%s=%r' % (key, value)
7459 
      for key, value in self.__dict__.iteritems()]
7460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7461 
 
7462 
  def __eq__(self, other):
7463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7464 
 
7465 
  def __ne__(self, other):
7466 
    return not (self == other)
7467 
 
1382 varun.gupt 7468 
class getReturnableOrdersForCustomer_args:
7469 
  """
7470 
  Attributes:
7471 
   - customer_id
7472 
   - limit
7473 
  """
7474 
 
7475 
  thrift_spec = (
7476 
    None, # 0
7477 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7478 
    (2, TType.I64, 'limit', None, None, ), # 2
7479 
  )
7480 
 
7481 
  def __init__(self, customer_id=None, limit=None,):
7482 
    self.customer_id = customer_id
7483 
    self.limit = limit
7484 
 
7485 
  def read(self, iprot):
7486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7488 
      return
7489 
    iprot.readStructBegin()
7490 
    while True:
7491 
      (fname, ftype, fid) = iprot.readFieldBegin()
7492 
      if ftype == TType.STOP:
7493 
        break
7494 
      if fid == 1:
7495 
        if ftype == TType.I64:
7496 
          self.customer_id = iprot.readI64();
7497 
        else:
7498 
          iprot.skip(ftype)
7499 
      elif fid == 2:
7500 
        if ftype == TType.I64:
7501 
          self.limit = iprot.readI64();
7502 
        else:
7503 
          iprot.skip(ftype)
7504 
      else:
7505 
        iprot.skip(ftype)
7506 
      iprot.readFieldEnd()
7507 
    iprot.readStructEnd()
7508 
 
7509 
  def write(self, oprot):
7510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7512 
      return
7513 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 7514 
    if self.customer_id is not None:
1382 varun.gupt 7515 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7516 
      oprot.writeI64(self.customer_id)
7517 
      oprot.writeFieldEnd()
3431 rajveer 7518 
    if self.limit is not None:
1382 varun.gupt 7519 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7520 
      oprot.writeI64(self.limit)
7521 
      oprot.writeFieldEnd()
7522 
    oprot.writeFieldStop()
7523 
    oprot.writeStructEnd()
7524 
 
3431 rajveer 7525 
  def validate(self):
7526 
    return
7527 
 
7528 
 
1382 varun.gupt 7529 
  def __repr__(self):
7530 
    L = ['%s=%r' % (key, value)
7531 
      for key, value in self.__dict__.iteritems()]
7532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7533 
 
7534 
  def __eq__(self, other):
7535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7536 
 
7537 
  def __ne__(self, other):
7538 
    return not (self == other)
7539 
 
7540 
class getReturnableOrdersForCustomer_result:
7541 
  """
7542 
  Attributes:
7543 
   - success
7544 
   - ex
7545 
  """
7546 
 
7547 
  thrift_spec = (
7548 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7549 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7550 
  )
7551 
 
7552 
  def __init__(self, success=None, ex=None,):
7553 
    self.success = success
7554 
    self.ex = ex
7555 
 
7556 
  def read(self, iprot):
7557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7559 
      return
7560 
    iprot.readStructBegin()
7561 
    while True:
7562 
      (fname, ftype, fid) = iprot.readFieldBegin()
7563 
      if ftype == TType.STOP:
7564 
        break
7565 
      if fid == 0:
7566 
        if ftype == TType.LIST:
7567 
          self.success = []
4133 chandransh 7568 
          (_etype73, _size70) = iprot.readListBegin()
7569 
          for _i74 in xrange(_size70):
7570 
            _elem75 = iprot.readI64();
7571 
            self.success.append(_elem75)
1382 varun.gupt 7572 
          iprot.readListEnd()
7573 
        else:
7574 
          iprot.skip(ftype)
7575 
      elif fid == 1:
7576 
        if ftype == TType.STRUCT:
7577 
          self.ex = TransactionServiceException()
7578 
          self.ex.read(iprot)
7579 
        else:
7580 
          iprot.skip(ftype)
7581 
      else:
7582 
        iprot.skip(ftype)
7583 
      iprot.readFieldEnd()
7584 
    iprot.readStructEnd()
7585 
 
7586 
  def write(self, oprot):
7587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7589 
      return
7590 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 7591 
    if self.success is not None:
1382 varun.gupt 7592 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7593 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7594 
      for iter76 in self.success:
7595 
        oprot.writeI64(iter76)
1382 varun.gupt 7596 
      oprot.writeListEnd()
7597 
      oprot.writeFieldEnd()
3431 rajveer 7598 
    if self.ex is not None:
1382 varun.gupt 7599 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7600 
      self.ex.write(oprot)
7601 
      oprot.writeFieldEnd()
7602 
    oprot.writeFieldStop()
7603 
    oprot.writeStructEnd()
7604 
 
3431 rajveer 7605 
  def validate(self):
7606 
    return
7607 
 
7608 
 
1382 varun.gupt 7609 
  def __repr__(self):
7610 
    L = ['%s=%r' % (key, value)
7611 
      for key, value in self.__dict__.iteritems()]
7612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7613 
 
7614 
  def __eq__(self, other):
7615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7616 
 
7617 
  def __ne__(self, other):
7618 
    return not (self == other)
7619 
 
7620 
class getCancellableOrdersForCustomer_args:
7621 
  """
7622 
  Attributes:
7623 
   - customer_id
7624 
   - limit
7625 
  """
7626 
 
7627 
  thrift_spec = (
7628 
    None, # 0
7629 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7630 
    (2, TType.I64, 'limit', None, None, ), # 2
7631 
  )
7632 
 
7633 
  def __init__(self, customer_id=None, limit=None,):
7634 
    self.customer_id = customer_id
7635 
    self.limit = limit
7636 
 
7637 
  def read(self, iprot):
7638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7640 
      return
7641 
    iprot.readStructBegin()
7642 
    while True:
7643 
      (fname, ftype, fid) = iprot.readFieldBegin()
7644 
      if ftype == TType.STOP:
7645 
        break
7646 
      if fid == 1:
7647 
        if ftype == TType.I64:
7648 
          self.customer_id = iprot.readI64();
7649 
        else:
7650 
          iprot.skip(ftype)
7651 
      elif fid == 2:
7652 
        if ftype == TType.I64:
7653 
          self.limit = iprot.readI64();
7654 
        else:
7655 
          iprot.skip(ftype)
7656 
      else:
7657 
        iprot.skip(ftype)
7658 
      iprot.readFieldEnd()
7659 
    iprot.readStructEnd()
7660 
 
7661 
  def write(self, oprot):
7662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7664 
      return
7665 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7666 
    if self.customer_id is not None:
1382 varun.gupt 7667 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7668 
      oprot.writeI64(self.customer_id)
7669 
      oprot.writeFieldEnd()
3431 rajveer 7670 
    if self.limit is not None:
1382 varun.gupt 7671 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7672 
      oprot.writeI64(self.limit)
7673 
      oprot.writeFieldEnd()
7674 
    oprot.writeFieldStop()
7675 
    oprot.writeStructEnd()
7676 
 
3431 rajveer 7677 
  def validate(self):
7678 
    return
7679 
 
7680 
 
1382 varun.gupt 7681 
  def __repr__(self):
7682 
    L = ['%s=%r' % (key, value)
7683 
      for key, value in self.__dict__.iteritems()]
7684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7685 
 
7686 
  def __eq__(self, other):
7687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7688 
 
7689 
  def __ne__(self, other):
7690 
    return not (self == other)
7691 
 
7692 
class getCancellableOrdersForCustomer_result:
7693 
  """
7694 
  Attributes:
7695 
   - success
7696 
   - ex
7697 
  """
7698 
 
7699 
  thrift_spec = (
7700 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7701 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7702 
  )
7703 
 
7704 
  def __init__(self, success=None, ex=None,):
7705 
    self.success = success
7706 
    self.ex = ex
7707 
 
7708 
  def read(self, iprot):
7709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7711 
      return
7712 
    iprot.readStructBegin()
7713 
    while True:
7714 
      (fname, ftype, fid) = iprot.readFieldBegin()
7715 
      if ftype == TType.STOP:
7716 
        break
7717 
      if fid == 0:
7718 
        if ftype == TType.LIST:
7719 
          self.success = []
4133 chandransh 7720 
          (_etype80, _size77) = iprot.readListBegin()
7721 
          for _i81 in xrange(_size77):
7722 
            _elem82 = iprot.readI64();
7723 
            self.success.append(_elem82)
1382 varun.gupt 7724 
          iprot.readListEnd()
7725 
        else:
7726 
          iprot.skip(ftype)
7727 
      elif fid == 1:
7728 
        if ftype == TType.STRUCT:
7729 
          self.ex = TransactionServiceException()
7730 
          self.ex.read(iprot)
7731 
        else:
7732 
          iprot.skip(ftype)
7733 
      else:
7734 
        iprot.skip(ftype)
7735 
      iprot.readFieldEnd()
7736 
    iprot.readStructEnd()
7737 
 
7738 
  def write(self, oprot):
7739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7741 
      return
7742 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 7743 
    if self.success is not None:
1382 varun.gupt 7744 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7745 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7746 
      for iter83 in self.success:
7747 
        oprot.writeI64(iter83)
1382 varun.gupt 7748 
      oprot.writeListEnd()
7749 
      oprot.writeFieldEnd()
3431 rajveer 7750 
    if self.ex is not None:
1382 varun.gupt 7751 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7752 
      self.ex.write(oprot)
7753 
      oprot.writeFieldEnd()
7754 
    oprot.writeFieldStop()
7755 
    oprot.writeStructEnd()
7756 
 
3431 rajveer 7757 
  def validate(self):
7758 
    return
7759 
 
7760 
 
1382 varun.gupt 7761 
  def __repr__(self):
7762 
    L = ['%s=%r' % (key, value)
7763 
      for key, value in self.__dict__.iteritems()]
7764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7765 
 
7766 
  def __eq__(self, other):
7767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7768 
 
7769 
  def __ne__(self, other):
7770 
    return not (self == other)
7771 
 
483 rajveer 7772 
class changeOrderStatus_args:
94 ashish 7773 
  """
7774 
  Attributes:
483 rajveer 7775 
   - orderId
7776 
   - status
7777 
   - description
94 ashish 7778 
  """
7779 
 
7780 
  thrift_spec = (
7781 
    None, # 0
483 rajveer 7782 
    (1, TType.I64, 'orderId', None, None, ), # 1
7783 
    (2, TType.I32, 'status', None, None, ), # 2
7784 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 7785 
  )
7786 
 
483 rajveer 7787 
  def __init__(self, orderId=None, status=None, description=None,):
7788 
    self.orderId = orderId
7789 
    self.status = status
7790 
    self.description = description
94 ashish 7791 
 
7792 
  def read(self, iprot):
7793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7795 
      return
7796 
    iprot.readStructBegin()
7797 
    while True:
7798 
      (fname, ftype, fid) = iprot.readFieldBegin()
7799 
      if ftype == TType.STOP:
7800 
        break
7801 
      if fid == 1:
7802 
        if ftype == TType.I64:
483 rajveer 7803 
          self.orderId = iprot.readI64();
94 ashish 7804 
        else:
7805 
          iprot.skip(ftype)
7806 
      elif fid == 2:
483 rajveer 7807 
        if ftype == TType.I32:
7808 
          self.status = iprot.readI32();
94 ashish 7809 
        else:
7810 
          iprot.skip(ftype)
483 rajveer 7811 
      elif fid == 3:
7812 
        if ftype == TType.STRING:
7813 
          self.description = iprot.readString();
7814 
        else:
7815 
          iprot.skip(ftype)
94 ashish 7816 
      else:
7817 
        iprot.skip(ftype)
7818 
      iprot.readFieldEnd()
7819 
    iprot.readStructEnd()
7820 
 
7821 
  def write(self, oprot):
7822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7824 
      return
483 rajveer 7825 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 7826 
    if self.orderId is not None:
483 rajveer 7827 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7828 
      oprot.writeI64(self.orderId)
94 ashish 7829 
      oprot.writeFieldEnd()
3431 rajveer 7830 
    if self.status is not None:
483 rajveer 7831 
      oprot.writeFieldBegin('status', TType.I32, 2)
7832 
      oprot.writeI32(self.status)
94 ashish 7833 
      oprot.writeFieldEnd()
3431 rajveer 7834 
    if self.description is not None:
483 rajveer 7835 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7836 
      oprot.writeString(self.description)
7837 
      oprot.writeFieldEnd()
94 ashish 7838 
    oprot.writeFieldStop()
7839 
    oprot.writeStructEnd()
7840 
 
3431 rajveer 7841 
  def validate(self):
7842 
    return
7843 
 
7844 
 
94 ashish 7845 
  def __repr__(self):
7846 
    L = ['%s=%r' % (key, value)
7847 
      for key, value in self.__dict__.iteritems()]
7848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7849 
 
7850 
  def __eq__(self, other):
7851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7852 
 
7853 
  def __ne__(self, other):
7854 
    return not (self == other)
7855 
 
483 rajveer 7856 
class changeOrderStatus_result:
94 ashish 7857 
  """
7858 
  Attributes:
7859 
   - success
7860 
   - ex
7861 
  """
7862 
 
7863 
  thrift_spec = (
7864 
    (0, TType.BOOL, 'success', None, None, ), # 0
7865 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7866 
  )
7867 
 
7868 
  def __init__(self, success=None, ex=None,):
7869 
    self.success = success
7870 
    self.ex = ex
7871 
 
7872 
  def read(self, iprot):
7873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7875 
      return
7876 
    iprot.readStructBegin()
7877 
    while True:
7878 
      (fname, ftype, fid) = iprot.readFieldBegin()
7879 
      if ftype == TType.STOP:
7880 
        break
7881 
      if fid == 0:
7882 
        if ftype == TType.BOOL:
7883 
          self.success = iprot.readBool();
7884 
        else:
7885 
          iprot.skip(ftype)
7886 
      elif fid == 1:
7887 
        if ftype == TType.STRUCT:
7888 
          self.ex = TransactionServiceException()
7889 
          self.ex.read(iprot)
7890 
        else:
7891 
          iprot.skip(ftype)
7892 
      else:
7893 
        iprot.skip(ftype)
7894 
      iprot.readFieldEnd()
7895 
    iprot.readStructEnd()
7896 
 
7897 
  def write(self, oprot):
7898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7900 
      return
483 rajveer 7901 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 7902 
    if self.success is not None:
94 ashish 7903 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7904 
      oprot.writeBool(self.success)
7905 
      oprot.writeFieldEnd()
3431 rajveer 7906 
    if self.ex is not None:
94 ashish 7907 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7908 
      self.ex.write(oprot)
7909 
      oprot.writeFieldEnd()
7910 
    oprot.writeFieldStop()
7911 
    oprot.writeStructEnd()
7912 
 
3431 rajveer 7913 
  def validate(self):
7914 
    return
7915 
 
7916 
 
94 ashish 7917 
  def __repr__(self):
7918 
    L = ['%s=%r' % (key, value)
7919 
      for key, value in self.__dict__.iteritems()]
7920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7921 
 
7922 
  def __eq__(self, other):
7923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7924 
 
7925 
  def __ne__(self, other):
7926 
    return not (self == other)
7927 
 
3064 chandransh 7928 
class getOrdersForTransaction_args:
494 rajveer 7929 
  """
7930 
  Attributes:
3064 chandransh 7931 
   - transactionId
7932 
   - customerId
494 rajveer 7933 
  """
7934 
 
7935 
  thrift_spec = (
7936 
    None, # 0
3064 chandransh 7937 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7938 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 7939 
  )
7940 
 
3064 chandransh 7941 
  def __init__(self, transactionId=None, customerId=None,):
7942 
    self.transactionId = transactionId
7943 
    self.customerId = customerId
494 rajveer 7944 
 
7945 
  def read(self, iprot):
7946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7948 
      return
7949 
    iprot.readStructBegin()
7950 
    while True:
7951 
      (fname, ftype, fid) = iprot.readFieldBegin()
7952 
      if ftype == TType.STOP:
7953 
        break
7954 
      if fid == 1:
7955 
        if ftype == TType.I64:
3064 chandransh 7956 
          self.transactionId = iprot.readI64();
494 rajveer 7957 
        else:
7958 
          iprot.skip(ftype)
7959 
      elif fid == 2:
3064 chandransh 7960 
        if ftype == TType.I64:
7961 
          self.customerId = iprot.readI64();
494 rajveer 7962 
        else:
7963 
          iprot.skip(ftype)
7964 
      else:
7965 
        iprot.skip(ftype)
7966 
      iprot.readFieldEnd()
7967 
    iprot.readStructEnd()
7968 
 
7969 
  def write(self, oprot):
7970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7972 
      return
3064 chandransh 7973 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 7974 
    if self.transactionId is not None:
3064 chandransh 7975 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7976 
      oprot.writeI64(self.transactionId)
494 rajveer 7977 
      oprot.writeFieldEnd()
3431 rajveer 7978 
    if self.customerId is not None:
3064 chandransh 7979 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
7980 
      oprot.writeI64(self.customerId)
494 rajveer 7981 
      oprot.writeFieldEnd()
7982 
    oprot.writeFieldStop()
7983 
    oprot.writeStructEnd()
7984 
 
3431 rajveer 7985 
  def validate(self):
7986 
    return
7987 
 
7988 
 
494 rajveer 7989 
  def __repr__(self):
7990 
    L = ['%s=%r' % (key, value)
7991 
      for key, value in self.__dict__.iteritems()]
7992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7993 
 
7994 
  def __eq__(self, other):
7995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7996 
 
7997 
  def __ne__(self, other):
7998 
    return not (self == other)
7999 
 
3064 chandransh 8000 
class getOrdersForTransaction_result:
494 rajveer 8001 
  """
8002 
  Attributes:
8003 
   - success
8004 
   - ex
8005 
  """
8006 
 
8007 
  thrift_spec = (
3064 chandransh 8008 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8009 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8010 
  )
8011 
 
8012 
  def __init__(self, success=None, ex=None,):
8013 
    self.success = success
8014 
    self.ex = ex
8015 
 
8016 
  def read(self, iprot):
8017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8019 
      return
8020 
    iprot.readStructBegin()
8021 
    while True:
8022 
      (fname, ftype, fid) = iprot.readFieldBegin()
8023 
      if ftype == TType.STOP:
8024 
        break
8025 
      if fid == 0:
3064 chandransh 8026 
        if ftype == TType.LIST:
8027 
          self.success = []
4133 chandransh 8028 
          (_etype87, _size84) = iprot.readListBegin()
8029 
          for _i88 in xrange(_size84):
8030 
            _elem89 = Order()
8031 
            _elem89.read(iprot)
8032 
            self.success.append(_elem89)
3064 chandransh 8033 
          iprot.readListEnd()
494 rajveer 8034 
        else:
8035 
          iprot.skip(ftype)
8036 
      elif fid == 1:
8037 
        if ftype == TType.STRUCT:
8038 
          self.ex = TransactionServiceException()
8039 
          self.ex.read(iprot)
8040 
        else:
8041 
          iprot.skip(ftype)
8042 
      else:
8043 
        iprot.skip(ftype)
8044 
      iprot.readFieldEnd()
8045 
    iprot.readStructEnd()
8046 
 
8047 
  def write(self, oprot):
8048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8050 
      return
3064 chandransh 8051 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 8052 
    if self.success is not None:
3064 chandransh 8053 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8054 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8055 
      for iter90 in self.success:
8056 
        iter90.write(oprot)
3064 chandransh 8057 
      oprot.writeListEnd()
494 rajveer 8058 
      oprot.writeFieldEnd()
3431 rajveer 8059 
    if self.ex is not None:
494 rajveer 8060 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8061 
      self.ex.write(oprot)
8062 
      oprot.writeFieldEnd()
8063 
    oprot.writeFieldStop()
8064 
    oprot.writeStructEnd()
8065 
 
3431 rajveer 8066 
  def validate(self):
8067 
    return
8068 
 
8069 
 
494 rajveer 8070 
  def __repr__(self):
8071 
    L = ['%s=%r' % (key, value)
8072 
      for key, value in self.__dict__.iteritems()]
8073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8074 
 
8075 
  def __eq__(self, other):
8076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8077 
 
8078 
  def __ne__(self, other):
8079 
    return not (self == other)
8080 
 
3064 chandransh 8081 
class getOrdersForCustomer_args:
1149 chandransh 8082 
  """
8083 
  Attributes:
3064 chandransh 8084 
   - customerId
8085 
   - from_date
8086 
   - to_date
8087 
   - statuses
1149 chandransh 8088 
  """
8089 
 
8090 
  thrift_spec = (
8091 
    None, # 0
3064 chandransh 8092 
    (1, TType.I64, 'customerId', None, None, ), # 1
8093 
    (2, TType.I64, 'from_date', None, None, ), # 2
8094 
    (3, TType.I64, 'to_date', None, None, ), # 3
8095 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 8096 
  )
8097 
 
3064 chandransh 8098 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
8099 
    self.customerId = customerId
8100 
    self.from_date = from_date
8101 
    self.to_date = to_date
8102 
    self.statuses = statuses
1149 chandransh 8103 
 
8104 
  def read(self, iprot):
8105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8107 
      return
8108 
    iprot.readStructBegin()
8109 
    while True:
8110 
      (fname, ftype, fid) = iprot.readFieldBegin()
8111 
      if ftype == TType.STOP:
8112 
        break
8113 
      if fid == 1:
8114 
        if ftype == TType.I64:
3064 chandransh 8115 
          self.customerId = iprot.readI64();
1149 chandransh 8116 
        else:
8117 
          iprot.skip(ftype)
8118 
      elif fid == 2:
8119 
        if ftype == TType.I64:
3064 chandransh 8120 
          self.from_date = iprot.readI64();
1149 chandransh 8121 
        else:
8122 
          iprot.skip(ftype)
2783 chandransh 8123 
      elif fid == 3:
8124 
        if ftype == TType.I64:
3064 chandransh 8125 
          self.to_date = iprot.readI64();
2783 chandransh 8126 
        else:
8127 
          iprot.skip(ftype)
8128 
      elif fid == 4:
3064 chandransh 8129 
        if ftype == TType.LIST:
8130 
          self.statuses = []
4133 chandransh 8131 
          (_etype94, _size91) = iprot.readListBegin()
8132 
          for _i95 in xrange(_size91):
8133 
            _elem96 = iprot.readI32();
8134 
            self.statuses.append(_elem96)
3064 chandransh 8135 
          iprot.readListEnd()
2783 chandransh 8136 
        else:
8137 
          iprot.skip(ftype)
1149 chandransh 8138 
      else:
8139 
        iprot.skip(ftype)
8140 
      iprot.readFieldEnd()
8141 
    iprot.readStructEnd()
8142 
 
8143 
  def write(self, oprot):
8144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8146 
      return
3064 chandransh 8147 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 8148 
    if self.customerId is not None:
3064 chandransh 8149 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8150 
      oprot.writeI64(self.customerId)
1149 chandransh 8151 
      oprot.writeFieldEnd()
3431 rajveer 8152 
    if self.from_date is not None:
3064 chandransh 8153 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8154 
      oprot.writeI64(self.from_date)
1149 chandransh 8155 
      oprot.writeFieldEnd()
3431 rajveer 8156 
    if self.to_date is not None:
3064 chandransh 8157 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8158 
      oprot.writeI64(self.to_date)
2783 chandransh 8159 
      oprot.writeFieldEnd()
3431 rajveer 8160 
    if self.statuses is not None:
3064 chandransh 8161 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
8162 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 8163 
      for iter97 in self.statuses:
8164 
        oprot.writeI32(iter97)
3064 chandransh 8165 
      oprot.writeListEnd()
2783 chandransh 8166 
      oprot.writeFieldEnd()
1149 chandransh 8167 
    oprot.writeFieldStop()
8168 
    oprot.writeStructEnd()
8169 
 
3431 rajveer 8170 
  def validate(self):
8171 
    return
8172 
 
8173 
 
1149 chandransh 8174 
  def __repr__(self):
8175 
    L = ['%s=%r' % (key, value)
8176 
      for key, value in self.__dict__.iteritems()]
8177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8178 
 
8179 
  def __eq__(self, other):
8180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8181 
 
8182 
  def __ne__(self, other):
8183 
    return not (self == other)
8184 
 
3064 chandransh 8185 
class getOrdersForCustomer_result:
1149 chandransh 8186 
  """
8187 
  Attributes:
8188 
   - success
8189 
   - ex
8190 
  """
8191 
 
8192 
  thrift_spec = (
3064 chandransh 8193 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8194 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8195 
  )
8196 
 
8197 
  def __init__(self, success=None, ex=None,):
8198 
    self.success = success
8199 
    self.ex = ex
8200 
 
8201 
  def read(self, iprot):
8202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8204 
      return
8205 
    iprot.readStructBegin()
8206 
    while True:
8207 
      (fname, ftype, fid) = iprot.readFieldBegin()
8208 
      if ftype == TType.STOP:
8209 
        break
8210 
      if fid == 0:
3064 chandransh 8211 
        if ftype == TType.LIST:
8212 
          self.success = []
4133 chandransh 8213 
          (_etype101, _size98) = iprot.readListBegin()
8214 
          for _i102 in xrange(_size98):
8215 
            _elem103 = Order()
8216 
            _elem103.read(iprot)
8217 
            self.success.append(_elem103)
3064 chandransh 8218 
          iprot.readListEnd()
1149 chandransh 8219 
        else:
8220 
          iprot.skip(ftype)
8221 
      elif fid == 1:
8222 
        if ftype == TType.STRUCT:
8223 
          self.ex = TransactionServiceException()
8224 
          self.ex.read(iprot)
8225 
        else:
8226 
          iprot.skip(ftype)
8227 
      else:
8228 
        iprot.skip(ftype)
8229 
      iprot.readFieldEnd()
8230 
    iprot.readStructEnd()
8231 
 
8232 
  def write(self, oprot):
8233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8235 
      return
3064 chandransh 8236 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 8237 
    if self.success is not None:
3064 chandransh 8238 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8239 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8240 
      for iter104 in self.success:
8241 
        iter104.write(oprot)
3064 chandransh 8242 
      oprot.writeListEnd()
1149 chandransh 8243 
      oprot.writeFieldEnd()
3431 rajveer 8244 
    if self.ex is not None:
1149 chandransh 8245 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8246 
      self.ex.write(oprot)
8247 
      oprot.writeFieldEnd()
8248 
    oprot.writeFieldStop()
8249 
    oprot.writeStructEnd()
8250 
 
3431 rajveer 8251 
  def validate(self):
8252 
    return
8253 
 
8254 
 
1149 chandransh 8255 
  def __repr__(self):
8256 
    L = ['%s=%r' % (key, value)
8257 
      for key, value in self.__dict__.iteritems()]
8258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8259 
 
8260 
  def __eq__(self, other):
8261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8262 
 
8263 
  def __ne__(self, other):
8264 
    return not (self == other)
8265 
 
3064 chandransh 8266 
class createOrder_args:
921 rajveer 8267 
  """
8268 
  Attributes:
3064 chandransh 8269 
   - order
921 rajveer 8270 
  """
8271 
 
8272 
  thrift_spec = (
8273 
    None, # 0
3064 chandransh 8274 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 8275 
  )
8276 
 
3064 chandransh 8277 
  def __init__(self, order=None,):
8278 
    self.order = order
921 rajveer 8279 
 
8280 
  def read(self, iprot):
8281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8283 
      return
8284 
    iprot.readStructBegin()
8285 
    while True:
8286 
      (fname, ftype, fid) = iprot.readFieldBegin()
8287 
      if ftype == TType.STOP:
8288 
        break
8289 
      if fid == 1:
3064 chandransh 8290 
        if ftype == TType.STRUCT:
8291 
          self.order = Order()
8292 
          self.order.read(iprot)
921 rajveer 8293 
        else:
8294 
          iprot.skip(ftype)
8295 
      else:
8296 
        iprot.skip(ftype)
8297 
      iprot.readFieldEnd()
8298 
    iprot.readStructEnd()
8299 
 
8300 
  def write(self, oprot):
8301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8303 
      return
3064 chandransh 8304 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 8305 
    if self.order is not None:
3064 chandransh 8306 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
8307 
      self.order.write(oprot)
921 rajveer 8308 
      oprot.writeFieldEnd()
8309 
    oprot.writeFieldStop()
8310 
    oprot.writeStructEnd()
8311 
 
3431 rajveer 8312 
  def validate(self):
8313 
    return
8314 
 
8315 
 
921 rajveer 8316 
  def __repr__(self):
8317 
    L = ['%s=%r' % (key, value)
8318 
      for key, value in self.__dict__.iteritems()]
8319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8320 
 
8321 
  def __eq__(self, other):
8322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8323 
 
8324 
  def __ne__(self, other):
8325 
    return not (self == other)
8326 
 
3064 chandransh 8327 
class createOrder_result:
921 rajveer 8328 
  """
8329 
  Attributes:
8330 
   - success
8331 
   - ex
8332 
  """
8333 
 
8334 
  thrift_spec = (
3064 chandransh 8335 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 8336 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8337 
  )
8338 
 
8339 
  def __init__(self, success=None, ex=None,):
8340 
    self.success = success
8341 
    self.ex = ex
8342 
 
8343 
  def read(self, iprot):
8344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8346 
      return
8347 
    iprot.readStructBegin()
8348 
    while True:
8349 
      (fname, ftype, fid) = iprot.readFieldBegin()
8350 
      if ftype == TType.STOP:
8351 
        break
8352 
      if fid == 0:
3064 chandransh 8353 
        if ftype == TType.I64:
8354 
          self.success = iprot.readI64();
921 rajveer 8355 
        else:
8356 
          iprot.skip(ftype)
8357 
      elif fid == 1:
8358 
        if ftype == TType.STRUCT:
8359 
          self.ex = TransactionServiceException()
8360 
          self.ex.read(iprot)
8361 
        else:
8362 
          iprot.skip(ftype)
8363 
      else:
8364 
        iprot.skip(ftype)
8365 
      iprot.readFieldEnd()
8366 
    iprot.readStructEnd()
8367 
 
8368 
  def write(self, oprot):
8369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8371 
      return
3064 chandransh 8372 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 8373 
    if self.success is not None:
3064 chandransh 8374 
      oprot.writeFieldBegin('success', TType.I64, 0)
8375 
      oprot.writeI64(self.success)
921 rajveer 8376 
      oprot.writeFieldEnd()
3431 rajveer 8377 
    if self.ex is not None:
921 rajveer 8378 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8379 
      self.ex.write(oprot)
8380 
      oprot.writeFieldEnd()
8381 
    oprot.writeFieldStop()
8382 
    oprot.writeStructEnd()
8383 
 
3431 rajveer 8384 
  def validate(self):
8385 
    return
8386 
 
8387 
 
921 rajveer 8388 
  def __repr__(self):
8389 
    L = ['%s=%r' % (key, value)
8390 
      for key, value in self.__dict__.iteritems()]
8391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8392 
 
8393 
  def __eq__(self, other):
8394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8395 
 
8396 
  def __ne__(self, other):
8397 
    return not (self == other)
8398 
 
3064 chandransh 8399 
class getOrder_args:
921 rajveer 8400 
  """
8401 
  Attributes:
3064 chandransh 8402 
   - id
921 rajveer 8403 
  """
8404 
 
8405 
  thrift_spec = (
8406 
    None, # 0
3064 chandransh 8407 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 8408 
  )
8409 
 
3064 chandransh 8410 
  def __init__(self, id=None,):
8411 
    self.id = id
921 rajveer 8412 
 
8413 
  def read(self, iprot):
8414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8416 
      return
8417 
    iprot.readStructBegin()
8418 
    while True:
8419 
      (fname, ftype, fid) = iprot.readFieldBegin()
8420 
      if ftype == TType.STOP:
8421 
        break
8422 
      if fid == 1:
8423 
        if ftype == TType.I64:
3064 chandransh 8424 
          self.id = iprot.readI64();
921 rajveer 8425 
        else:
8426 
          iprot.skip(ftype)
8427 
      else:
8428 
        iprot.skip(ftype)
8429 
      iprot.readFieldEnd()
8430 
    iprot.readStructEnd()
8431 
 
8432 
  def write(self, oprot):
8433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8435 
      return
3064 chandransh 8436 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 8437 
    if self.id is not None:
3064 chandransh 8438 
      oprot.writeFieldBegin('id', TType.I64, 1)
8439 
      oprot.writeI64(self.id)
921 rajveer 8440 
      oprot.writeFieldEnd()
8441 
    oprot.writeFieldStop()
8442 
    oprot.writeStructEnd()
8443 
 
3431 rajveer 8444 
  def validate(self):
8445 
    return
8446 
 
8447 
 
921 rajveer 8448 
  def __repr__(self):
8449 
    L = ['%s=%r' % (key, value)
8450 
      for key, value in self.__dict__.iteritems()]
8451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8452 
 
8453 
  def __eq__(self, other):
8454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8455 
 
8456 
  def __ne__(self, other):
8457 
    return not (self == other)
8458 
 
3064 chandransh 8459 
class getOrder_result:
921 rajveer 8460 
  """
8461 
  Attributes:
8462 
   - success
8463 
   - ex
8464 
  """
8465 
 
8466 
  thrift_spec = (
3064 chandransh 8467 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 8468 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8469 
  )
8470 
 
8471 
  def __init__(self, success=None, ex=None,):
8472 
    self.success = success
8473 
    self.ex = ex
8474 
 
8475 
  def read(self, iprot):
8476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8478 
      return
8479 
    iprot.readStructBegin()
8480 
    while True:
8481 
      (fname, ftype, fid) = iprot.readFieldBegin()
8482 
      if ftype == TType.STOP:
8483 
        break
8484 
      if fid == 0:
3064 chandransh 8485 
        if ftype == TType.STRUCT:
8486 
          self.success = Order()
8487 
          self.success.read(iprot)
921 rajveer 8488 
        else:
8489 
          iprot.skip(ftype)
8490 
      elif fid == 1:
8491 
        if ftype == TType.STRUCT:
8492 
          self.ex = TransactionServiceException()
8493 
          self.ex.read(iprot)
8494 
        else:
8495 
          iprot.skip(ftype)
8496 
      else:
8497 
        iprot.skip(ftype)
8498 
      iprot.readFieldEnd()
8499 
    iprot.readStructEnd()
8500 
 
8501 
  def write(self, oprot):
8502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8504 
      return
3064 chandransh 8505 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 8506 
    if self.success is not None:
3064 chandransh 8507 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8508 
      self.success.write(oprot)
921 rajveer 8509 
      oprot.writeFieldEnd()
3431 rajveer 8510 
    if self.ex is not None:
921 rajveer 8511 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8512 
      self.ex.write(oprot)
8513 
      oprot.writeFieldEnd()
8514 
    oprot.writeFieldStop()
8515 
    oprot.writeStructEnd()
8516 
 
3431 rajveer 8517 
  def validate(self):
8518 
    return
8519 
 
8520 
 
921 rajveer 8521 
  def __repr__(self):
8522 
    L = ['%s=%r' % (key, value)
8523 
      for key, value in self.__dict__.iteritems()]
8524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8525 
 
8526 
  def __eq__(self, other):
8527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8528 
 
8529 
  def __ne__(self, other):
8530 
    return not (self == other)
8531 
 
3064 chandransh 8532 
class getLineItemsForOrder_args:
94 ashish 8533 
  """
8534 
  Attributes:
3064 chandransh 8535 
   - orderId
94 ashish 8536 
  """
8537 
 
8538 
  thrift_spec = (
8539 
    None, # 0
3064 chandransh 8540 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 8541 
  )
8542 
 
3064 chandransh 8543 
  def __init__(self, orderId=None,):
8544 
    self.orderId = orderId
94 ashish 8545 
 
8546 
  def read(self, iprot):
8547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8549 
      return
8550 
    iprot.readStructBegin()
8551 
    while True:
8552 
      (fname, ftype, fid) = iprot.readFieldBegin()
8553 
      if ftype == TType.STOP:
8554 
        break
8555 
      if fid == 1:
8556 
        if ftype == TType.I64:
3064 chandransh 8557 
          self.orderId = iprot.readI64();
94 ashish 8558 
        else:
8559 
          iprot.skip(ftype)
8560 
      else:
8561 
        iprot.skip(ftype)
8562 
      iprot.readFieldEnd()
8563 
    iprot.readStructEnd()
8564 
 
8565 
  def write(self, oprot):
8566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8568 
      return
3064 chandransh 8569 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 8570 
    if self.orderId is not None:
3064 chandransh 8571 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8572 
      oprot.writeI64(self.orderId)
94 ashish 8573 
      oprot.writeFieldEnd()
8574 
    oprot.writeFieldStop()
8575 
    oprot.writeStructEnd()
8576 
 
3431 rajveer 8577 
  def validate(self):
8578 
    return
8579 
 
8580 
 
94 ashish 8581 
  def __repr__(self):
8582 
    L = ['%s=%r' % (key, value)
8583 
      for key, value in self.__dict__.iteritems()]
8584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8585 
 
8586 
  def __eq__(self, other):
8587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8588 
 
8589 
  def __ne__(self, other):
8590 
    return not (self == other)
8591 
 
3064 chandransh 8592 
class getLineItemsForOrder_result:
94 ashish 8593 
  """
8594 
  Attributes:
8595 
   - success
8596 
   - ex
8597 
  """
8598 
 
8599 
  thrift_spec = (
3064 chandransh 8600 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 8601 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8602 
  )
8603 
 
8604 
  def __init__(self, success=None, ex=None,):
8605 
    self.success = success
8606 
    self.ex = ex
8607 
 
8608 
  def read(self, iprot):
8609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8611 
      return
8612 
    iprot.readStructBegin()
8613 
    while True:
8614 
      (fname, ftype, fid) = iprot.readFieldBegin()
8615 
      if ftype == TType.STOP:
8616 
        break
8617 
      if fid == 0:
483 rajveer 8618 
        if ftype == TType.LIST:
8619 
          self.success = []
4133 chandransh 8620 
          (_etype108, _size105) = iprot.readListBegin()
8621 
          for _i109 in xrange(_size105):
8622 
            _elem110 = LineItem()
8623 
            _elem110.read(iprot)
8624 
            self.success.append(_elem110)
483 rajveer 8625 
          iprot.readListEnd()
94 ashish 8626 
        else:
8627 
          iprot.skip(ftype)
8628 
      elif fid == 1:
8629 
        if ftype == TType.STRUCT:
8630 
          self.ex = TransactionServiceException()
8631 
          self.ex.read(iprot)
8632 
        else:
8633 
          iprot.skip(ftype)
8634 
      else:
8635 
        iprot.skip(ftype)
8636 
      iprot.readFieldEnd()
8637 
    iprot.readStructEnd()
8638 
 
8639 
  def write(self, oprot):
8640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8642 
      return
3064 chandransh 8643 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8644 
    if self.success is not None:
483 rajveer 8645 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8646 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8647 
      for iter111 in self.success:
8648 
        iter111.write(oprot)
483 rajveer 8649 
      oprot.writeListEnd()
94 ashish 8650 
      oprot.writeFieldEnd()
3431 rajveer 8651 
    if self.ex is not None:
94 ashish 8652 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8653 
      self.ex.write(oprot)
8654 
      oprot.writeFieldEnd()
8655 
    oprot.writeFieldStop()
8656 
    oprot.writeStructEnd()
8657 
 
3431 rajveer 8658 
  def validate(self):
8659 
    return
8660 
 
8661 
 
94 ashish 8662 
  def __repr__(self):
8663 
    L = ['%s=%r' % (key, value)
8664 
      for key, value in self.__dict__.iteritems()]
8665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8666 
 
8667 
  def __eq__(self, other):
8668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8669 
 
8670 
  def __ne__(self, other):
8671 
    return not (self == other)
8672 
 
3064 chandransh 8673 
class getOrderForCustomer_args:
94 ashish 8674 
  """
8675 
  Attributes:
3064 chandransh 8676 
   - orderId
483 rajveer 8677 
   - customerId
94 ashish 8678 
  """
8679 
 
8680 
  thrift_spec = (
8681 
    None, # 0
3064 chandransh 8682 
    (1, TType.I64, 'orderId', None, None, ), # 1
8683 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8684 
  )
8685 
 
3064 chandransh 8686 
  def __init__(self, orderId=None, customerId=None,):
8687 
    self.orderId = orderId
483 rajveer 8688 
    self.customerId = customerId
94 ashish 8689 
 
8690 
  def read(self, iprot):
8691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8693 
      return
8694 
    iprot.readStructBegin()
8695 
    while True:
8696 
      (fname, ftype, fid) = iprot.readFieldBegin()
8697 
      if ftype == TType.STOP:
8698 
        break
8699 
      if fid == 1:
8700 
        if ftype == TType.I64:
3064 chandransh 8701 
          self.orderId = iprot.readI64();
94 ashish 8702 
        else:
8703 
          iprot.skip(ftype)
8704 
      elif fid == 2:
8705 
        if ftype == TType.I64:
3064 chandransh 8706 
          self.customerId = iprot.readI64();
94 ashish 8707 
        else:
8708 
          iprot.skip(ftype)
8709 
      else:
8710 
        iprot.skip(ftype)
8711 
      iprot.readFieldEnd()
8712 
    iprot.readStructEnd()
8713 
 
8714 
  def write(self, oprot):
8715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8717 
      return
3064 chandransh 8718 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 8719 
    if self.orderId is not None:
3064 chandransh 8720 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8721 
      oprot.writeI64(self.orderId)
8722 
      oprot.writeFieldEnd()
3431 rajveer 8723 
    if self.customerId is not None:
3064 chandransh 8724 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 8725 
      oprot.writeI64(self.customerId)
94 ashish 8726 
      oprot.writeFieldEnd()
8727 
    oprot.writeFieldStop()
8728 
    oprot.writeStructEnd()
8729 
 
3431 rajveer 8730 
  def validate(self):
8731 
    return
8732 
 
8733 
 
94 ashish 8734 
  def __repr__(self):
8735 
    L = ['%s=%r' % (key, value)
8736 
      for key, value in self.__dict__.iteritems()]
8737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8738 
 
8739 
  def __eq__(self, other):
8740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8741 
 
8742 
  def __ne__(self, other):
8743 
    return not (self == other)
8744 
 
3064 chandransh 8745 
class getOrderForCustomer_result:
94 ashish 8746 
  """
8747 
  Attributes:
8748 
   - success
8749 
   - ex
8750 
  """
8751 
 
8752 
  thrift_spec = (
3064 chandransh 8753 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 8754 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8755 
  )
8756 
 
8757 
  def __init__(self, success=None, ex=None,):
8758 
    self.success = success
8759 
    self.ex = ex
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.STRUCT:
8772 
          self.success = Order()
8773 
          self.success.read(iprot)
94 ashish 8774 
        else:
8775 
          iprot.skip(ftype)
8776 
      elif fid == 1:
8777 
        if ftype == TType.STRUCT:
8778 
          self.ex = TransactionServiceException()
8779 
          self.ex.read(iprot)
8780 
        else:
8781 
          iprot.skip(ftype)
8782 
      else:
8783 
        iprot.skip(ftype)
8784 
      iprot.readFieldEnd()
8785 
    iprot.readStructEnd()
8786 
 
8787 
  def write(self, oprot):
8788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8790 
      return
3064 chandransh 8791 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 8792 
    if self.success is not None:
3064 chandransh 8793 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8794 
      self.success.write(oprot)
94 ashish 8795 
      oprot.writeFieldEnd()
3431 rajveer 8796 
    if self.ex is not None:
94 ashish 8797 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8798 
      self.ex.write(oprot)
8799 
      oprot.writeFieldEnd()
8800 
    oprot.writeFieldStop()
8801 
    oprot.writeStructEnd()
8802 
 
3431 rajveer 8803 
  def validate(self):
8804 
    return
8805 
 
8806 
 
94 ashish 8807 
  def __repr__(self):
8808 
    L = ['%s=%r' % (key, value)
8809 
      for key, value in self.__dict__.iteritems()]
8810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8811 
 
8812 
  def __eq__(self, other):
8813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8814 
 
8815 
  def __ne__(self, other):
8816 
    return not (self == other)
8817 
 
3064 chandransh 8818 
class getAlerts_args:
94 ashish 8819 
  """
8820 
  Attributes:
4394 rajveer 8821 
   - type
4444 rajveer 8822 
   - warehouseId
4394 rajveer 8823 
   - status
8824 
   - timestamp
94 ashish 8825 
  """
8826 
 
8827 
  thrift_spec = (
8828 
    None, # 0
4394 rajveer 8829 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8830 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8831 
    (3, TType.I64, 'status', None, None, ), # 3
8832 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 8833 
  )
8834 
 
4444 rajveer 8835 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 8836 
    self.type = type
4444 rajveer 8837 
    self.warehouseId = warehouseId
4394 rajveer 8838 
    self.status = status
8839 
    self.timestamp = timestamp
94 ashish 8840 
 
8841 
  def read(self, iprot):
8842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8844 
      return
8845 
    iprot.readStructBegin()
8846 
    while True:
8847 
      (fname, ftype, fid) = iprot.readFieldBegin()
8848 
      if ftype == TType.STOP:
8849 
        break
8850 
      if fid == 1:
3064 chandransh 8851 
        if ftype == TType.I64:
4394 rajveer 8852 
          self.type = iprot.readI64();
94 ashish 8853 
        else:
8854 
          iprot.skip(ftype)
3064 chandransh 8855 
      elif fid == 2:
4394 rajveer 8856 
        if ftype == TType.I64:
4444 rajveer 8857 
          self.warehouseId = iprot.readI64();
3064 chandransh 8858 
        else:
8859 
          iprot.skip(ftype)
4394 rajveer 8860 
      elif fid == 3:
8861 
        if ftype == TType.I64:
4444 rajveer 8862 
          self.status = iprot.readI64();
8863 
        else:
8864 
          iprot.skip(ftype)
8865 
      elif fid == 4:
8866 
        if ftype == TType.I64:
4394 rajveer 8867 
          self.timestamp = iprot.readI64();
8868 
        else:
8869 
          iprot.skip(ftype)
94 ashish 8870 
      else:
8871 
        iprot.skip(ftype)
8872 
      iprot.readFieldEnd()
8873 
    iprot.readStructEnd()
8874 
 
8875 
  def write(self, oprot):
8876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8878 
      return
3064 chandransh 8879 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 8880 
    if self.type is not None:
8881 
      oprot.writeFieldBegin('type', TType.I64, 1)
8882 
      oprot.writeI64(self.type)
94 ashish 8883 
      oprot.writeFieldEnd()
4444 rajveer 8884 
    if self.warehouseId is not None:
8885 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8886 
      oprot.writeI64(self.warehouseId)
8887 
      oprot.writeFieldEnd()
4394 rajveer 8888 
    if self.status is not None:
4444 rajveer 8889 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 8890 
      oprot.writeI64(self.status)
3064 chandransh 8891 
      oprot.writeFieldEnd()
4394 rajveer 8892 
    if self.timestamp is not None:
4444 rajveer 8893 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 8894 
      oprot.writeI64(self.timestamp)
8895 
      oprot.writeFieldEnd()
94 ashish 8896 
    oprot.writeFieldStop()
8897 
    oprot.writeStructEnd()
8898 
 
3431 rajveer 8899 
  def validate(self):
8900 
    return
8901 
 
8902 
 
94 ashish 8903 
  def __repr__(self):
8904 
    L = ['%s=%r' % (key, value)
8905 
      for key, value in self.__dict__.iteritems()]
8906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8907 
 
8908 
  def __eq__(self, other):
8909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8910 
 
8911 
  def __ne__(self, other):
8912 
    return not (self == other)
8913 
 
3064 chandransh 8914 
class getAlerts_result:
94 ashish 8915 
  """
8916 
  Attributes:
8917 
   - success
8918 
  """
8919 
 
8920 
  thrift_spec = (
3064 chandransh 8921 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 8922 
  )
8923 
 
3064 chandransh 8924 
  def __init__(self, success=None,):
94 ashish 8925 
    self.success = success
8926 
 
8927 
  def read(self, iprot):
8928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8930 
      return
8931 
    iprot.readStructBegin()
8932 
    while True:
8933 
      (fname, ftype, fid) = iprot.readFieldBegin()
8934 
      if ftype == TType.STOP:
8935 
        break
8936 
      if fid == 0:
3064 chandransh 8937 
        if ftype == TType.LIST:
8938 
          self.success = []
4133 chandransh 8939 
          (_etype115, _size112) = iprot.readListBegin()
8940 
          for _i116 in xrange(_size112):
8941 
            _elem117 = Alert()
8942 
            _elem117.read(iprot)
8943 
            self.success.append(_elem117)
3064 chandransh 8944 
          iprot.readListEnd()
94 ashish 8945 
        else:
8946 
          iprot.skip(ftype)
8947 
      else:
8948 
        iprot.skip(ftype)
8949 
      iprot.readFieldEnd()
8950 
    iprot.readStructEnd()
8951 
 
8952 
  def write(self, oprot):
8953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8955 
      return
3064 chandransh 8956 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 8957 
    if self.success is not None:
3064 chandransh 8958 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8959 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8960 
      for iter118 in self.success:
8961 
        iter118.write(oprot)
3064 chandransh 8962 
      oprot.writeListEnd()
94 ashish 8963 
      oprot.writeFieldEnd()
8964 
    oprot.writeFieldStop()
8965 
    oprot.writeStructEnd()
8966 
 
3431 rajveer 8967 
  def validate(self):
8968 
    return
8969 
 
8970 
 
94 ashish 8971 
  def __repr__(self):
8972 
    L = ['%s=%r' % (key, value)
8973 
      for key, value in self.__dict__.iteritems()]
8974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8975 
 
8976 
  def __eq__(self, other):
8977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8978 
 
8979 
  def __ne__(self, other):
8980 
    return not (self == other)
8981 
 
4394 rajveer 8982 
class addAlert_args:
94 ashish 8983 
  """
8984 
  Attributes:
3064 chandransh 8985 
   - type
4444 rajveer 8986 
   - warehouseId
4394 rajveer 8987 
   - description
94 ashish 8988 
  """
8989 
 
8990 
  thrift_spec = (
8991 
    None, # 0
4394 rajveer 8992 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8993 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8994 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8995 
  )
8996 
 
4444 rajveer 8997 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 8998 
    self.type = type
4444 rajveer 8999 
    self.warehouseId = warehouseId
4394 rajveer 9000 
    self.description = description
94 ashish 9001 
 
9002 
  def read(self, iprot):
9003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9005 
      return
9006 
    iprot.readStructBegin()
9007 
    while True:
9008 
      (fname, ftype, fid) = iprot.readFieldBegin()
9009 
      if ftype == TType.STOP:
9010 
        break
9011 
      if fid == 1:
9012 
        if ftype == TType.I64:
4394 rajveer 9013 
          self.type = iprot.readI64();
94 ashish 9014 
        else:
9015 
          iprot.skip(ftype)
3064 chandransh 9016 
      elif fid == 2:
4444 rajveer 9017 
        if ftype == TType.I64:
9018 
          self.warehouseId = iprot.readI64();
9019 
        else:
9020 
          iprot.skip(ftype)
9021 
      elif fid == 3:
3064 chandransh 9022 
        if ftype == TType.STRING:
4394 rajveer 9023 
          self.description = iprot.readString();
3064 chandransh 9024 
        else:
9025 
          iprot.skip(ftype)
94 ashish 9026 
      else:
9027 
        iprot.skip(ftype)
9028 
      iprot.readFieldEnd()
9029 
    iprot.readStructEnd()
9030 
 
9031 
  def write(self, oprot):
9032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9034 
      return
4394 rajveer 9035 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 9036 
    if self.type is not None:
4394 rajveer 9037 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 9038 
      oprot.writeI64(self.type)
9039 
      oprot.writeFieldEnd()
4444 rajveer 9040 
    if self.warehouseId is not None:
9041 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9042 
      oprot.writeI64(self.warehouseId)
9043 
      oprot.writeFieldEnd()
4394 rajveer 9044 
    if self.description is not None:
4444 rajveer 9045 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 9046 
      oprot.writeString(self.description)
3064 chandransh 9047 
      oprot.writeFieldEnd()
94 ashish 9048 
    oprot.writeFieldStop()
9049 
    oprot.writeStructEnd()
9050 
 
3431 rajveer 9051 
  def validate(self):
9052 
    return
9053 
 
9054 
 
94 ashish 9055 
  def __repr__(self):
9056 
    L = ['%s=%r' % (key, value)
9057 
      for key, value in self.__dict__.iteritems()]
9058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9059 
 
9060 
  def __eq__(self, other):
9061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9062 
 
9063 
  def __ne__(self, other):
9064 
    return not (self == other)
9065 
 
4394 rajveer 9066 
class addAlert_result:
3064 chandransh 9067 
 
9068 
  thrift_spec = (
9069 
  )
9070 
 
9071 
  def read(self, iprot):
9072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9074 
      return
9075 
    iprot.readStructBegin()
9076 
    while True:
9077 
      (fname, ftype, fid) = iprot.readFieldBegin()
9078 
      if ftype == TType.STOP:
9079 
        break
9080 
      else:
9081 
        iprot.skip(ftype)
9082 
      iprot.readFieldEnd()
9083 
    iprot.readStructEnd()
9084 
 
9085 
  def write(self, oprot):
9086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9088 
      return
4394 rajveer 9089 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 9090 
    oprot.writeFieldStop()
9091 
    oprot.writeStructEnd()
9092 
 
3431 rajveer 9093 
  def validate(self):
9094 
    return
9095 
 
9096 
 
3064 chandransh 9097 
  def __repr__(self):
9098 
    L = ['%s=%r' % (key, value)
9099 
      for key, value in self.__dict__.iteritems()]
9100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9101 
 
9102 
  def __eq__(self, other):
9103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9104 
 
9105 
  def __ne__(self, other):
9106 
    return not (self == other)
9107 
 
4444 rajveer 9108 
class markAlertsAsSeen_args:
9109 
  """
9110 
  Attributes:
9111 
   - warehouseId
9112 
  """
9113 
 
9114 
  thrift_spec = (
9115 
    None, # 0
9116 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9117 
  )
9118 
 
9119 
  def __init__(self, warehouseId=None,):
9120 
    self.warehouseId = warehouseId
9121 
 
9122 
  def read(self, iprot):
9123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9125 
      return
9126 
    iprot.readStructBegin()
9127 
    while True:
9128 
      (fname, ftype, fid) = iprot.readFieldBegin()
9129 
      if ftype == TType.STOP:
9130 
        break
9131 
      if fid == 1:
9132 
        if ftype == TType.I64:
9133 
          self.warehouseId = iprot.readI64();
9134 
        else:
9135 
          iprot.skip(ftype)
9136 
      else:
9137 
        iprot.skip(ftype)
9138 
      iprot.readFieldEnd()
9139 
    iprot.readStructEnd()
9140 
 
9141 
  def write(self, oprot):
9142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9144 
      return
9145 
    oprot.writeStructBegin('markAlertsAsSeen_args')
9146 
    if self.warehouseId is not None:
9147 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9148 
      oprot.writeI64(self.warehouseId)
9149 
      oprot.writeFieldEnd()
9150 
    oprot.writeFieldStop()
9151 
    oprot.writeStructEnd()
9152 
 
9153 
  def validate(self):
9154 
    return
9155 
 
9156 
 
9157 
  def __repr__(self):
9158 
    L = ['%s=%r' % (key, value)
9159 
      for key, value in self.__dict__.iteritems()]
9160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9161 
 
9162 
  def __eq__(self, other):
9163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9164 
 
9165 
  def __ne__(self, other):
9166 
    return not (self == other)
9167 
 
9168 
class markAlertsAsSeen_result:
9169 
 
9170 
  thrift_spec = (
9171 
  )
9172 
 
9173 
  def read(self, iprot):
9174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9176 
      return
9177 
    iprot.readStructBegin()
9178 
    while True:
9179 
      (fname, ftype, fid) = iprot.readFieldBegin()
9180 
      if ftype == TType.STOP:
9181 
        break
9182 
      else:
9183 
        iprot.skip(ftype)
9184 
      iprot.readFieldEnd()
9185 
    iprot.readStructEnd()
9186 
 
9187 
  def write(self, oprot):
9188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9190 
      return
9191 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9192 
    oprot.writeFieldStop()
9193 
    oprot.writeStructEnd()
9194 
 
9195 
  def validate(self):
9196 
    return
9197 
 
9198 
 
9199 
  def __repr__(self):
9200 
    L = ['%s=%r' % (key, value)
9201 
      for key, value in self.__dict__.iteritems()]
9202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9203 
 
9204 
  def __eq__(self, other):
9205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9206 
 
9207 
  def __ne__(self, other):
9208 
    return not (self == other)
9209 
 
3064 chandransh 9210 
class getValidOrderCount_args:
9211 
 
9212 
  thrift_spec = (
9213 
  )
9214 
 
9215 
  def read(self, iprot):
9216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9218 
      return
9219 
    iprot.readStructBegin()
9220 
    while True:
9221 
      (fname, ftype, fid) = iprot.readFieldBegin()
9222 
      if ftype == TType.STOP:
9223 
        break
9224 
      else:
9225 
        iprot.skip(ftype)
9226 
      iprot.readFieldEnd()
9227 
    iprot.readStructEnd()
9228 
 
9229 
  def write(self, oprot):
9230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9232 
      return
9233 
    oprot.writeStructBegin('getValidOrderCount_args')
9234 
    oprot.writeFieldStop()
9235 
    oprot.writeStructEnd()
9236 
 
3431 rajveer 9237 
  def validate(self):
9238 
    return
9239 
 
9240 
 
3064 chandransh 9241 
  def __repr__(self):
9242 
    L = ['%s=%r' % (key, value)
9243 
      for key, value in self.__dict__.iteritems()]
9244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9245 
 
9246 
  def __eq__(self, other):
9247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9248 
 
9249 
  def __ne__(self, other):
9250 
    return not (self == other)
9251 
 
9252 
class getValidOrderCount_result:
94 ashish 9253 
  """
9254 
  Attributes:
9255 
   - success
9256 
  """
9257 
 
9258 
  thrift_spec = (
3064 chandransh 9259 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9260 
  )
9261 
 
3064 chandransh 9262 
  def __init__(self, success=None,):
94 ashish 9263 
    self.success = success
9264 
 
9265 
  def read(self, iprot):
9266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9268 
      return
9269 
    iprot.readStructBegin()
9270 
    while True:
9271 
      (fname, ftype, fid) = iprot.readFieldBegin()
9272 
      if ftype == TType.STOP:
9273 
        break
9274 
      if fid == 0:
3064 chandransh 9275 
        if ftype == TType.I64:
9276 
          self.success = iprot.readI64();
94 ashish 9277 
        else:
9278 
          iprot.skip(ftype)
9279 
      else:
9280 
        iprot.skip(ftype)
9281 
      iprot.readFieldEnd()
9282 
    iprot.readStructEnd()
9283 
 
9284 
  def write(self, oprot):
9285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9287 
      return
3064 chandransh 9288 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 9289 
    if self.success is not None:
3064 chandransh 9290 
      oprot.writeFieldBegin('success', TType.I64, 0)
9291 
      oprot.writeI64(self.success)
94 ashish 9292 
      oprot.writeFieldEnd()
9293 
    oprot.writeFieldStop()
9294 
    oprot.writeStructEnd()
9295 
 
3431 rajveer 9296 
  def validate(self):
9297 
    return
9298 
 
9299 
 
94 ashish 9300 
  def __repr__(self):
9301 
    L = ['%s=%r' % (key, value)
9302 
      for key, value in self.__dict__.iteritems()]
9303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9304 
 
9305 
  def __eq__(self, other):
9306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9307 
 
9308 
  def __ne__(self, other):
9309 
    return not (self == other)
9310 
 
3064 chandransh 9311 
class getNoOfCustomersWithSuccessfulTransaction_args:
9312 
 
9313 
  thrift_spec = (
9314 
  )
9315 
 
9316 
  def read(self, iprot):
9317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9319 
      return
9320 
    iprot.readStructBegin()
9321 
    while True:
9322 
      (fname, ftype, fid) = iprot.readFieldBegin()
9323 
      if ftype == TType.STOP:
9324 
        break
9325 
      else:
9326 
        iprot.skip(ftype)
9327 
      iprot.readFieldEnd()
9328 
    iprot.readStructEnd()
9329 
 
9330 
  def write(self, oprot):
9331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9333 
      return
9334 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
9335 
    oprot.writeFieldStop()
9336 
    oprot.writeStructEnd()
9337 
 
3431 rajveer 9338 
  def validate(self):
9339 
    return
9340 
 
9341 
 
3064 chandransh 9342 
  def __repr__(self):
9343 
    L = ['%s=%r' % (key, value)
9344 
      for key, value in self.__dict__.iteritems()]
9345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9346 
 
9347 
  def __eq__(self, other):
9348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9349 
 
9350 
  def __ne__(self, other):
9351 
    return not (self == other)
9352 
 
9353 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 9354 
  """
9355 
  Attributes:
3064 chandransh 9356 
   - success
94 ashish 9357 
  """
9358 
 
9359 
  thrift_spec = (
3064 chandransh 9360 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9361 
  )
9362 
 
3064 chandransh 9363 
  def __init__(self, success=None,):
9364 
    self.success = success
94 ashish 9365 
 
9366 
  def read(self, iprot):
9367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9369 
      return
9370 
    iprot.readStructBegin()
9371 
    while True:
9372 
      (fname, ftype, fid) = iprot.readFieldBegin()
9373 
      if ftype == TType.STOP:
9374 
        break
3064 chandransh 9375 
      if fid == 0:
94 ashish 9376 
        if ftype == TType.I64:
3064 chandransh 9377 
          self.success = iprot.readI64();
94 ashish 9378 
        else:
9379 
          iprot.skip(ftype)
9380 
      else:
9381 
        iprot.skip(ftype)
9382 
      iprot.readFieldEnd()
9383 
    iprot.readStructEnd()
9384 
 
9385 
  def write(self, oprot):
9386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9388 
      return
3064 chandransh 9389 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 9390 
    if self.success is not None:
3064 chandransh 9391 
      oprot.writeFieldBegin('success', TType.I64, 0)
9392 
      oprot.writeI64(self.success)
94 ashish 9393 
      oprot.writeFieldEnd()
9394 
    oprot.writeFieldStop()
9395 
    oprot.writeStructEnd()
9396 
 
3431 rajveer 9397 
  def validate(self):
9398 
    return
9399 
 
9400 
 
94 ashish 9401 
  def __repr__(self):
9402 
    L = ['%s=%r' % (key, value)
9403 
      for key, value in self.__dict__.iteritems()]
9404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9405 
 
9406 
  def __eq__(self, other):
9407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9408 
 
9409 
  def __ne__(self, other):
9410 
    return not (self == other)
9411 
 
3064 chandransh 9412 
class getValidOrdersAmountRange_args:
9413 
 
9414 
  thrift_spec = (
9415 
  )
9416 
 
9417 
  def read(self, iprot):
9418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9420 
      return
9421 
    iprot.readStructBegin()
9422 
    while True:
9423 
      (fname, ftype, fid) = iprot.readFieldBegin()
9424 
      if ftype == TType.STOP:
9425 
        break
9426 
      else:
9427 
        iprot.skip(ftype)
9428 
      iprot.readFieldEnd()
9429 
    iprot.readStructEnd()
9430 
 
9431 
  def write(self, oprot):
9432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9434 
      return
9435 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
9436 
    oprot.writeFieldStop()
9437 
    oprot.writeStructEnd()
9438 
 
3431 rajveer 9439 
  def validate(self):
9440 
    return
9441 
 
9442 
 
3064 chandransh 9443 
  def __repr__(self):
9444 
    L = ['%s=%r' % (key, value)
9445 
      for key, value in self.__dict__.iteritems()]
9446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9447 
 
9448 
  def __eq__(self, other):
9449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9450 
 
9451 
  def __ne__(self, other):
9452 
    return not (self == other)
9453 
 
9454 
class getValidOrdersAmountRange_result:
94 ashish 9455 
  """
9456 
  Attributes:
9457 
   - success
9458 
  """
9459 
 
9460 
  thrift_spec = (
3064 chandransh 9461 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 9462 
  )
9463 
 
3064 chandransh 9464 
  def __init__(self, success=None,):
94 ashish 9465 
    self.success = success
9466 
 
9467 
  def read(self, iprot):
9468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9470 
      return
9471 
    iprot.readStructBegin()
9472 
    while True:
9473 
      (fname, ftype, fid) = iprot.readFieldBegin()
9474 
      if ftype == TType.STOP:
9475 
        break
9476 
      if fid == 0:
483 rajveer 9477 
        if ftype == TType.LIST:
9478 
          self.success = []
4133 chandransh 9479 
          (_etype122, _size119) = iprot.readListBegin()
9480 
          for _i123 in xrange(_size119):
9481 
            _elem124 = iprot.readDouble();
9482 
            self.success.append(_elem124)
483 rajveer 9483 
          iprot.readListEnd()
94 ashish 9484 
        else:
9485 
          iprot.skip(ftype)
9486 
      else:
9487 
        iprot.skip(ftype)
9488 
      iprot.readFieldEnd()
9489 
    iprot.readStructEnd()
9490 
 
9491 
  def write(self, oprot):
9492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9494 
      return
3064 chandransh 9495 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 9496 
    if self.success is not None:
483 rajveer 9497 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 9498 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 9499 
      for iter125 in self.success:
9500 
        oprot.writeDouble(iter125)
483 rajveer 9501 
      oprot.writeListEnd()
94 ashish 9502 
      oprot.writeFieldEnd()
9503 
    oprot.writeFieldStop()
9504 
    oprot.writeStructEnd()
9505 
 
3431 rajveer 9506 
  def validate(self):
9507 
    return
9508 
 
9509 
 
94 ashish 9510 
  def __repr__(self):
9511 
    L = ['%s=%r' % (key, value)
9512 
      for key, value in self.__dict__.iteritems()]
9513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9514 
 
9515 
  def __eq__(self, other):
9516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9517 
 
9518 
  def __ne__(self, other):
9519 
    return not (self == other)
9520 
 
3064 chandransh 9521 
class getValidOrders_args:
1528 ankur.sing 9522 
  """
9523 
  Attributes:
3064 chandransh 9524 
   - limit
1528 ankur.sing 9525 
  """
9526 
 
9527 
  thrift_spec = (
9528 
    None, # 0
3064 chandransh 9529 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 9530 
  )
9531 
 
3064 chandransh 9532 
  def __init__(self, limit=None,):
9533 
    self.limit = limit
1528 ankur.sing 9534 
 
9535 
  def read(self, iprot):
9536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9538 
      return
9539 
    iprot.readStructBegin()
9540 
    while True:
9541 
      (fname, ftype, fid) = iprot.readFieldBegin()
9542 
      if ftype == TType.STOP:
9543 
        break
9544 
      if fid == 1:
9545 
        if ftype == TType.I64:
3064 chandransh 9546 
          self.limit = iprot.readI64();
1528 ankur.sing 9547 
        else:
9548 
          iprot.skip(ftype)
9549 
      else:
9550 
        iprot.skip(ftype)
9551 
      iprot.readFieldEnd()
9552 
    iprot.readStructEnd()
9553 
 
9554 
  def write(self, oprot):
9555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9557 
      return
3064 chandransh 9558 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 9559 
    if self.limit is not None:
3064 chandransh 9560 
      oprot.writeFieldBegin('limit', TType.I64, 1)
9561 
      oprot.writeI64(self.limit)
1528 ankur.sing 9562 
      oprot.writeFieldEnd()
9563 
    oprot.writeFieldStop()
9564 
    oprot.writeStructEnd()
9565 
 
3431 rajveer 9566 
  def validate(self):
9567 
    return
9568 
 
9569 
 
1528 ankur.sing 9570 
  def __repr__(self):
9571 
    L = ['%s=%r' % (key, value)
9572 
      for key, value in self.__dict__.iteritems()]
9573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9574 
 
9575 
  def __eq__(self, other):
9576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9577 
 
9578 
  def __ne__(self, other):
9579 
    return not (self == other)
9580 
 
3064 chandransh 9581 
class getValidOrders_result:
1528 ankur.sing 9582 
  """
9583 
  Attributes:
9584 
   - success
9585 
  """
9586 
 
9587 
  thrift_spec = (
3064 chandransh 9588 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 9589 
  )
9590 
 
3064 chandransh 9591 
  def __init__(self, success=None,):
1528 ankur.sing 9592 
    self.success = success
9593 
 
9594 
  def read(self, iprot):
9595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9597 
      return
9598 
    iprot.readStructBegin()
9599 
    while True:
9600 
      (fname, ftype, fid) = iprot.readFieldBegin()
9601 
      if ftype == TType.STOP:
9602 
        break
9603 
      if fid == 0:
3064 chandransh 9604 
        if ftype == TType.LIST:
9605 
          self.success = []
4133 chandransh 9606 
          (_etype129, _size126) = iprot.readListBegin()
9607 
          for _i130 in xrange(_size126):
9608 
            _elem131 = Order()
9609 
            _elem131.read(iprot)
9610 
            self.success.append(_elem131)
3064 chandransh 9611 
          iprot.readListEnd()
1528 ankur.sing 9612 
        else:
9613 
          iprot.skip(ftype)
9614 
      else:
9615 
        iprot.skip(ftype)
9616 
      iprot.readFieldEnd()
9617 
    iprot.readStructEnd()
9618 
 
9619 
  def write(self, oprot):
9620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9622 
      return
3064 chandransh 9623 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9624 
    if self.success is not None:
3064 chandransh 9625 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9626 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9627 
      for iter132 in self.success:
9628 
        iter132.write(oprot)
3064 chandransh 9629 
      oprot.writeListEnd()
1528 ankur.sing 9630 
      oprot.writeFieldEnd()
9631 
    oprot.writeFieldStop()
9632 
    oprot.writeStructEnd()
9633 
 
3431 rajveer 9634 
  def validate(self):
9635 
    return
9636 
 
9637 
 
1528 ankur.sing 9638 
  def __repr__(self):
9639 
    L = ['%s=%r' % (key, value)
9640 
      for key, value in self.__dict__.iteritems()]
9641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9642 
 
9643 
  def __eq__(self, other):
9644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9645 
 
9646 
  def __ne__(self, other):
9647 
    return not (self == other)
9648 
 
1220 chandransh 9649 
class batchOrders_args:
9650 
  """
9651 
  Attributes:
9652 
   - warehouseId
9653 
  """
9654 
 
9655 
  thrift_spec = (
9656 
    None, # 0
9657 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9658 
  )
9659 
 
9660 
  def __init__(self, warehouseId=None,):
9661 
    self.warehouseId = warehouseId
9662 
 
9663 
  def read(self, iprot):
9664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9666 
      return
9667 
    iprot.readStructBegin()
9668 
    while True:
9669 
      (fname, ftype, fid) = iprot.readFieldBegin()
9670 
      if ftype == TType.STOP:
9671 
        break
9672 
      if fid == 1:
9673 
        if ftype == TType.I64:
9674 
          self.warehouseId = iprot.readI64();
9675 
        else:
9676 
          iprot.skip(ftype)
9677 
      else:
9678 
        iprot.skip(ftype)
9679 
      iprot.readFieldEnd()
9680 
    iprot.readStructEnd()
9681 
 
9682 
  def write(self, oprot):
9683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9685 
      return
9686 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9687 
    if self.warehouseId is not None:
1220 chandransh 9688 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9689 
      oprot.writeI64(self.warehouseId)
9690 
      oprot.writeFieldEnd()
9691 
    oprot.writeFieldStop()
9692 
    oprot.writeStructEnd()
9693 
 
3431 rajveer 9694 
  def validate(self):
9695 
    return
9696 
 
9697 
 
1220 chandransh 9698 
  def __repr__(self):
9699 
    L = ['%s=%r' % (key, value)
9700 
      for key, value in self.__dict__.iteritems()]
9701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9702 
 
9703 
  def __eq__(self, other):
9704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9705 
 
9706 
  def __ne__(self, other):
9707 
    return not (self == other)
9708 
 
9709 
class batchOrders_result:
9710 
  """
9711 
  Attributes:
9712 
   - success
9713 
   - ex
9714 
  """
9715 
 
9716 
  thrift_spec = (
9717 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9718 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9719 
  )
9720 
 
9721 
  def __init__(self, success=None, ex=None,):
9722 
    self.success = success
9723 
    self.ex = ex
9724 
 
9725 
  def read(self, iprot):
9726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9728 
      return
9729 
    iprot.readStructBegin()
9730 
    while True:
9731 
      (fname, ftype, fid) = iprot.readFieldBegin()
9732 
      if ftype == TType.STOP:
9733 
        break
9734 
      if fid == 0:
9735 
        if ftype == TType.LIST:
9736 
          self.success = []
4133 chandransh 9737 
          (_etype136, _size133) = iprot.readListBegin()
9738 
          for _i137 in xrange(_size133):
9739 
            _elem138 = Order()
9740 
            _elem138.read(iprot)
9741 
            self.success.append(_elem138)
1220 chandransh 9742 
          iprot.readListEnd()
9743 
        else:
9744 
          iprot.skip(ftype)
9745 
      elif fid == 1:
9746 
        if ftype == TType.STRUCT:
9747 
          self.ex = TransactionServiceException()
9748 
          self.ex.read(iprot)
9749 
        else:
9750 
          iprot.skip(ftype)
9751 
      else:
9752 
        iprot.skip(ftype)
9753 
      iprot.readFieldEnd()
9754 
    iprot.readStructEnd()
9755 
 
9756 
  def write(self, oprot):
9757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9759 
      return
9760 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 9761 
    if self.success is not None:
1220 chandransh 9762 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9763 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9764 
      for iter139 in self.success:
9765 
        iter139.write(oprot)
1220 chandransh 9766 
      oprot.writeListEnd()
9767 
      oprot.writeFieldEnd()
3431 rajveer 9768 
    if self.ex is not None:
1220 chandransh 9769 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9770 
      self.ex.write(oprot)
9771 
      oprot.writeFieldEnd()
9772 
    oprot.writeFieldStop()
9773 
    oprot.writeStructEnd()
9774 
 
3431 rajveer 9775 
  def validate(self):
9776 
    return
9777 
 
9778 
 
1220 chandransh 9779 
  def __repr__(self):
9780 
    L = ['%s=%r' % (key, value)
9781 
      for key, value in self.__dict__.iteritems()]
9782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9783 
 
9784 
  def __eq__(self, other):
9785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9786 
 
9787 
  def __ne__(self, other):
9788 
    return not (self == other)
9789 
 
1208 chandransh 9790 
class markOrderAsOutOfStock_args:
9791 
  """
9792 
  Attributes:
9793 
   - orderId
9794 
  """
9795 
 
9796 
  thrift_spec = (
9797 
    None, # 0
9798 
    (1, TType.I64, 'orderId', None, None, ), # 1
9799 
  )
9800 
 
9801 
  def __init__(self, orderId=None,):
9802 
    self.orderId = orderId
9803 
 
9804 
  def read(self, iprot):
9805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9807 
      return
9808 
    iprot.readStructBegin()
9809 
    while True:
9810 
      (fname, ftype, fid) = iprot.readFieldBegin()
9811 
      if ftype == TType.STOP:
9812 
        break
9813 
      if fid == 1:
9814 
        if ftype == TType.I64:
9815 
          self.orderId = iprot.readI64();
9816 
        else:
9817 
          iprot.skip(ftype)
9818 
      else:
9819 
        iprot.skip(ftype)
9820 
      iprot.readFieldEnd()
9821 
    iprot.readStructEnd()
9822 
 
9823 
  def write(self, oprot):
9824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9826 
      return
9827 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 9828 
    if self.orderId is not None:
1208 chandransh 9829 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9830 
      oprot.writeI64(self.orderId)
9831 
      oprot.writeFieldEnd()
9832 
    oprot.writeFieldStop()
9833 
    oprot.writeStructEnd()
9834 
 
3431 rajveer 9835 
  def validate(self):
9836 
    return
9837 
 
9838 
 
1208 chandransh 9839 
  def __repr__(self):
9840 
    L = ['%s=%r' % (key, value)
9841 
      for key, value in self.__dict__.iteritems()]
9842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9843 
 
9844 
  def __eq__(self, other):
9845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9846 
 
9847 
  def __ne__(self, other):
9848 
    return not (self == other)
9849 
 
9850 
class markOrderAsOutOfStock_result:
9851 
  """
9852 
  Attributes:
9853 
   - success
9854 
   - ex
9855 
  """
9856 
 
9857 
  thrift_spec = (
9858 
    (0, TType.BOOL, 'success', None, None, ), # 0
9859 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9860 
  )
9861 
 
9862 
  def __init__(self, success=None, ex=None,):
9863 
    self.success = success
9864 
    self.ex = ex
9865 
 
9866 
  def read(self, iprot):
9867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9869 
      return
9870 
    iprot.readStructBegin()
9871 
    while True:
9872 
      (fname, ftype, fid) = iprot.readFieldBegin()
9873 
      if ftype == TType.STOP:
9874 
        break
9875 
      if fid == 0:
9876 
        if ftype == TType.BOOL:
9877 
          self.success = iprot.readBool();
9878 
        else:
9879 
          iprot.skip(ftype)
9880 
      elif fid == 1:
9881 
        if ftype == TType.STRUCT:
9882 
          self.ex = TransactionServiceException()
9883 
          self.ex.read(iprot)
9884 
        else:
9885 
          iprot.skip(ftype)
9886 
      else:
9887 
        iprot.skip(ftype)
9888 
      iprot.readFieldEnd()
9889 
    iprot.readStructEnd()
9890 
 
9891 
  def write(self, oprot):
9892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9894 
      return
9895 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 9896 
    if self.success is not None:
1208 chandransh 9897 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9898 
      oprot.writeBool(self.success)
9899 
      oprot.writeFieldEnd()
3431 rajveer 9900 
    if self.ex is not None:
1208 chandransh 9901 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9902 
      self.ex.write(oprot)
9903 
      oprot.writeFieldEnd()
9904 
    oprot.writeFieldStop()
9905 
    oprot.writeStructEnd()
9906 
 
3431 rajveer 9907 
  def validate(self):
9908 
    return
9909 
 
9910 
 
1208 chandransh 9911 
  def __repr__(self):
9912 
    L = ['%s=%r' % (key, value)
9913 
      for key, value in self.__dict__.iteritems()]
9914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9915 
 
9916 
  def __eq__(self, other):
9917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9918 
 
9919 
  def __ne__(self, other):
9920 
    return not (self == other)
9921 
 
3064 chandransh 9922 
class verifyOrder_args:
759 chandransh 9923 
  """
9924 
  Attributes:
3064 chandransh 9925 
   - orderId
759 chandransh 9926 
  """
9927 
 
9928 
  thrift_spec = (
9929 
    None, # 0
3064 chandransh 9930 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 9931 
  )
9932 
 
3064 chandransh 9933 
  def __init__(self, orderId=None,):
9934 
    self.orderId = orderId
759 chandransh 9935 
 
9936 
  def read(self, iprot):
9937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9939 
      return
9940 
    iprot.readStructBegin()
9941 
    while True:
9942 
      (fname, ftype, fid) = iprot.readFieldBegin()
9943 
      if ftype == TType.STOP:
9944 
        break
9945 
      if fid == 1:
9946 
        if ftype == TType.I64:
3064 chandransh 9947 
          self.orderId = iprot.readI64();
759 chandransh 9948 
        else:
9949 
          iprot.skip(ftype)
9950 
      else:
9951 
        iprot.skip(ftype)
9952 
      iprot.readFieldEnd()
9953 
    iprot.readStructEnd()
9954 
 
9955 
  def write(self, oprot):
9956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9958 
      return
3064 chandransh 9959 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 9960 
    if self.orderId is not None:
3064 chandransh 9961 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9962 
      oprot.writeI64(self.orderId)
759 chandransh 9963 
      oprot.writeFieldEnd()
9964 
    oprot.writeFieldStop()
9965 
    oprot.writeStructEnd()
9966 
 
3431 rajveer 9967 
  def validate(self):
9968 
    return
9969 
 
9970 
 
759 chandransh 9971 
  def __repr__(self):
9972 
    L = ['%s=%r' % (key, value)
9973 
      for key, value in self.__dict__.iteritems()]
9974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9975 
 
9976 
  def __eq__(self, other):
9977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9978 
 
9979 
  def __ne__(self, other):
9980 
    return not (self == other)
9981 
 
3064 chandransh 9982 
class verifyOrder_result:
759 chandransh 9983 
  """
9984 
  Attributes:
9985 
   - success
9986 
   - ex
9987 
  """
9988 
 
9989 
  thrift_spec = (
9990 
    (0, TType.BOOL, 'success', None, None, ), # 0
9991 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9992 
  )
9993 
 
9994 
  def __init__(self, success=None, ex=None,):
9995 
    self.success = success
9996 
    self.ex = ex
9997 
 
9998 
  def read(self, iprot):
9999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10001 
      return
10002 
    iprot.readStructBegin()
10003 
    while True:
10004 
      (fname, ftype, fid) = iprot.readFieldBegin()
10005 
      if ftype == TType.STOP:
10006 
        break
10007 
      if fid == 0:
10008 
        if ftype == TType.BOOL:
10009 
          self.success = iprot.readBool();
10010 
        else:
10011 
          iprot.skip(ftype)
10012 
      elif fid == 1:
10013 
        if ftype == TType.STRUCT:
10014 
          self.ex = TransactionServiceException()
10015 
          self.ex.read(iprot)
10016 
        else:
10017 
          iprot.skip(ftype)
10018 
      else:
10019 
        iprot.skip(ftype)
10020 
      iprot.readFieldEnd()
10021 
    iprot.readStructEnd()
10022 
 
10023 
  def write(self, oprot):
10024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10026 
      return
3064 chandransh 10027 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 10028 
    if self.success is not None:
759 chandransh 10029 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10030 
      oprot.writeBool(self.success)
10031 
      oprot.writeFieldEnd()
3431 rajveer 10032 
    if self.ex is not None:
759 chandransh 10033 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10034 
      self.ex.write(oprot)
10035 
      oprot.writeFieldEnd()
10036 
    oprot.writeFieldStop()
10037 
    oprot.writeStructEnd()
10038 
 
3431 rajveer 10039 
  def validate(self):
10040 
    return
10041 
 
10042 
 
759 chandransh 10043 
  def __repr__(self):
10044 
    L = ['%s=%r' % (key, value)
10045 
      for key, value in self.__dict__.iteritems()]
10046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10047 
 
10048 
  def __eq__(self, other):
10049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10050 
 
10051 
  def __ne__(self, other):
10052 
    return not (self == other)
10053 
 
3064 chandransh 10054 
class acceptOrder_args:
1113 chandransh 10055 
  """
10056 
  Attributes:
3064 chandransh 10057 
   - orderId
1113 chandransh 10058 
  """
10059 
 
10060 
  thrift_spec = (
10061 
    None, # 0
3064 chandransh 10062 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 10063 
  )
10064 
 
3064 chandransh 10065 
  def __init__(self, orderId=None,):
10066 
    self.orderId = orderId
1113 chandransh 10067 
 
10068 
  def read(self, iprot):
10069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10071 
      return
10072 
    iprot.readStructBegin()
10073 
    while True:
10074 
      (fname, ftype, fid) = iprot.readFieldBegin()
10075 
      if ftype == TType.STOP:
10076 
        break
10077 
      if fid == 1:
10078 
        if ftype == TType.I64:
3064 chandransh 10079 
          self.orderId = iprot.readI64();
1113 chandransh 10080 
        else:
10081 
          iprot.skip(ftype)
10082 
      else:
10083 
        iprot.skip(ftype)
10084 
      iprot.readFieldEnd()
10085 
    iprot.readStructEnd()
10086 
 
10087 
  def write(self, oprot):
10088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10090 
      return
3064 chandransh 10091 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 10092 
    if self.orderId is not None:
3064 chandransh 10093 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10094 
      oprot.writeI64(self.orderId)
1113 chandransh 10095 
      oprot.writeFieldEnd()
10096 
    oprot.writeFieldStop()
10097 
    oprot.writeStructEnd()
10098 
 
3431 rajveer 10099 
  def validate(self):
10100 
    return
10101 
 
10102 
 
1113 chandransh 10103 
  def __repr__(self):
10104 
    L = ['%s=%r' % (key, value)
10105 
      for key, value in self.__dict__.iteritems()]
10106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10107 
 
10108 
  def __eq__(self, other):
10109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10110 
 
10111 
  def __ne__(self, other):
10112 
    return not (self == other)
10113 
 
3064 chandransh 10114 
class acceptOrder_result:
1113 chandransh 10115 
  """
10116 
  Attributes:
10117 
   - success
10118 
   - ex
10119 
  """
10120 
 
10121 
  thrift_spec = (
3064 chandransh 10122 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 10123 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10124 
  )
10125 
 
10126 
  def __init__(self, success=None, ex=None,):
10127 
    self.success = success
10128 
    self.ex = ex
10129 
 
10130 
  def read(self, iprot):
10131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10133 
      return
10134 
    iprot.readStructBegin()
10135 
    while True:
10136 
      (fname, ftype, fid) = iprot.readFieldBegin()
10137 
      if ftype == TType.STOP:
10138 
        break
10139 
      if fid == 0:
3064 chandransh 10140 
        if ftype == TType.BOOL:
10141 
          self.success = iprot.readBool();
1113 chandransh 10142 
        else:
10143 
          iprot.skip(ftype)
10144 
      elif fid == 1:
10145 
        if ftype == TType.STRUCT:
10146 
          self.ex = TransactionServiceException()
10147 
          self.ex.read(iprot)
10148 
        else:
10149 
          iprot.skip(ftype)
10150 
      else:
10151 
        iprot.skip(ftype)
10152 
      iprot.readFieldEnd()
10153 
    iprot.readStructEnd()
10154 
 
10155 
  def write(self, oprot):
10156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10158 
      return
3064 chandransh 10159 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 10160 
    if self.success is not None:
3064 chandransh 10161 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10162 
      oprot.writeBool(self.success)
1113 chandransh 10163 
      oprot.writeFieldEnd()
3431 rajveer 10164 
    if self.ex is not None:
1113 chandransh 10165 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10166 
      self.ex.write(oprot)
10167 
      oprot.writeFieldEnd()
10168 
    oprot.writeFieldStop()
10169 
    oprot.writeStructEnd()
10170 
 
3431 rajveer 10171 
  def validate(self):
10172 
    return
10173 
 
10174 
 
1113 chandransh 10175 
  def __repr__(self):
10176 
    L = ['%s=%r' % (key, value)
10177 
      for key, value in self.__dict__.iteritems()]
10178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10179 
 
10180 
  def __eq__(self, other):
10181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10182 
 
10183 
  def __ne__(self, other):
10184 
    return not (self == other)
10185 
 
3064 chandransh 10186 
class addBillingDetails_args:
1135 chandransh 10187 
  """
10188 
  Attributes:
3064 chandransh 10189 
   - orderId
10190 
   - invoice_number
4658 mandeep.dh 10191 
   - serialNumber
4283 anupam.sin 10192 
   - itemNumber
3064 chandransh 10193 
   - billed_by
4264 rajveer 10194 
   - jacketNumber
4283 anupam.sin 10195 
   - billingType
10196 
   - vendorId
1135 chandransh 10197 
  """
10198 
 
10199 
  thrift_spec = (
10200 
    None, # 0
3064 chandransh 10201 
    (1, TType.I64, 'orderId', None, None, ), # 1
10202 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 10203 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 10204 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10205 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10206 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10207 
    (7, TType.I64, 'billingType', None, None, ), # 7
10208 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 10209 
  )
10210 
 
4658 mandeep.dh 10211 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 10212 
    self.orderId = orderId
10213 
    self.invoice_number = invoice_number
4658 mandeep.dh 10214 
    self.serialNumber = serialNumber
4283 anupam.sin 10215 
    self.itemNumber = itemNumber
3064 chandransh 10216 
    self.billed_by = billed_by
4264 rajveer 10217 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10218 
    self.billingType = billingType
10219 
    self.vendorId = vendorId
1135 chandransh 10220 
 
10221 
  def read(self, iprot):
10222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10224 
      return
10225 
    iprot.readStructBegin()
10226 
    while True:
10227 
      (fname, ftype, fid) = iprot.readFieldBegin()
10228 
      if ftype == TType.STOP:
10229 
        break
10230 
      if fid == 1:
10231 
        if ftype == TType.I64:
3064 chandransh 10232 
          self.orderId = iprot.readI64();
1135 chandransh 10233 
        else:
10234 
          iprot.skip(ftype)
10235 
      elif fid == 2:
3064 chandransh 10236 
        if ftype == TType.STRING:
10237 
          self.invoice_number = iprot.readString();
1135 chandransh 10238 
        else:
10239 
          iprot.skip(ftype)
3064 chandransh 10240 
      elif fid == 3:
4658 mandeep.dh 10241 
        if ftype == TType.STRING:
10242 
          self.serialNumber = iprot.readString();
3064 chandransh 10243 
        else:
10244 
          iprot.skip(ftype)
10245 
      elif fid == 4:
10246 
        if ftype == TType.STRING:
10247 
          self.itemNumber = iprot.readString();
10248 
        else:
10249 
          iprot.skip(ftype)
10250 
      elif fid == 5:
10251 
        if ftype == TType.STRING:
4283 anupam.sin 10252 
          self.billed_by = iprot.readString();
3064 chandransh 10253 
        else:
10254 
          iprot.skip(ftype)
10255 
      elif fid == 6:
10256 
        if ftype == TType.I64:
4283 anupam.sin 10257 
          self.jacketNumber = iprot.readI64();
10258 
        else:
10259 
          iprot.skip(ftype)
10260 
      elif fid == 7:
10261 
        if ftype == TType.I64:
3064 chandransh 10262 
          self.billingType = iprot.readI64();
10263 
        else:
10264 
          iprot.skip(ftype)
4283 anupam.sin 10265 
      elif fid == 8:
10266 
        if ftype == TType.I64:
10267 
          self.vendorId = iprot.readI64();
10268 
        else:
10269 
          iprot.skip(ftype)
1246 chandransh 10270 
      else:
10271 
        iprot.skip(ftype)
10272 
      iprot.readFieldEnd()
10273 
    iprot.readStructEnd()
10274 
 
10275 
  def write(self, oprot):
10276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10278 
      return
4283 anupam.sin 10279 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 10280 
    if self.orderId is not None:
3064 chandransh 10281 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10282 
      oprot.writeI64(self.orderId)
1246 chandransh 10283 
      oprot.writeFieldEnd()
4283 anupam.sin 10284 
    if self.invoice_number is not None:
10285 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
10286 
      oprot.writeString(self.invoice_number)
1246 chandransh 10287 
      oprot.writeFieldEnd()
4658 mandeep.dh 10288 
    if self.serialNumber is not None:
10289 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
10290 
      oprot.writeString(self.serialNumber)
3064 chandransh 10291 
      oprot.writeFieldEnd()
3431 rajveer 10292 
    if self.itemNumber is not None:
3064 chandransh 10293 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
10294 
      oprot.writeString(self.itemNumber)
10295 
      oprot.writeFieldEnd()
4283 anupam.sin 10296 
    if self.billed_by is not None:
10297 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
10298 
      oprot.writeString(self.billed_by)
3064 chandransh 10299 
      oprot.writeFieldEnd()
4283 anupam.sin 10300 
    if self.jacketNumber is not None:
10301 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
10302 
      oprot.writeI64(self.jacketNumber)
10303 
      oprot.writeFieldEnd()
3431 rajveer 10304 
    if self.billingType is not None:
4283 anupam.sin 10305 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 10306 
      oprot.writeI64(self.billingType)
10307 
      oprot.writeFieldEnd()
4283 anupam.sin 10308 
    if self.vendorId is not None:
10309 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
10310 
      oprot.writeI64(self.vendorId)
10311 
      oprot.writeFieldEnd()
1246 chandransh 10312 
    oprot.writeFieldStop()
10313 
    oprot.writeStructEnd()
10314 
 
3431 rajveer 10315 
  def validate(self):
10316 
    return
10317 
 
10318 
 
1246 chandransh 10319 
  def __repr__(self):
10320 
    L = ['%s=%r' % (key, value)
10321 
      for key, value in self.__dict__.iteritems()]
10322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10323 
 
10324 
  def __eq__(self, other):
10325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10326 
 
10327 
  def __ne__(self, other):
10328 
    return not (self == other)
10329 
 
4283 anupam.sin 10330 
class addBillingDetails_result:
1246 chandransh 10331 
  """
10332 
  Attributes:
3064 chandransh 10333 
   - success
1246 chandransh 10334 
   - ex
10335 
  """
10336 
 
10337 
  thrift_spec = (
3064 chandransh 10338 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 10339 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10340 
  )
10341 
 
3064 chandransh 10342 
  def __init__(self, success=None, ex=None,):
10343 
    self.success = success
1246 chandransh 10344 
    self.ex = ex
10345 
 
10346 
  def read(self, iprot):
10347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10349 
      return
10350 
    iprot.readStructBegin()
10351 
    while True:
10352 
      (fname, ftype, fid) = iprot.readFieldBegin()
10353 
      if ftype == TType.STOP:
10354 
        break
3064 chandransh 10355 
      if fid == 0:
10356 
        if ftype == TType.BOOL:
10357 
          self.success = iprot.readBool();
10358 
        else:
10359 
          iprot.skip(ftype)
10360 
      elif fid == 1:
1246 chandransh 10361 
        if ftype == TType.STRUCT:
10362 
          self.ex = TransactionServiceException()
10363 
          self.ex.read(iprot)
10364 
        else:
10365 
          iprot.skip(ftype)
10366 
      else:
10367 
        iprot.skip(ftype)
10368 
      iprot.readFieldEnd()
10369 
    iprot.readStructEnd()
10370 
 
10371 
  def write(self, oprot):
10372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10374 
      return
4283 anupam.sin 10375 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 10376 
    if self.success is not None:
3064 chandransh 10377 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10378 
      oprot.writeBool(self.success)
10379 
      oprot.writeFieldEnd()
3431 rajveer 10380 
    if self.ex is not None:
1246 chandransh 10381 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10382 
      self.ex.write(oprot)
10383 
      oprot.writeFieldEnd()
10384 
    oprot.writeFieldStop()
10385 
    oprot.writeStructEnd()
10386 
 
3431 rajveer 10387 
  def validate(self):
10388 
    return
10389 
 
10390 
 
1246 chandransh 10391 
  def __repr__(self):
10392 
    L = ['%s=%r' % (key, value)
10393 
      for key, value in self.__dict__.iteritems()]
10394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10395 
 
10396 
  def __eq__(self, other):
10397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10398 
 
10399 
  def __ne__(self, other):
10400 
    return not (self == other)
10401 
 
4579 rajveer 10402 
class addInvoiceNumber_args:
10403 
  """
10404 
  Attributes:
10405 
   - orderId
10406 
   - invoiceNumber
10407 
  """
10408 
 
10409 
  thrift_spec = (
10410 
    None, # 0
10411 
    (1, TType.I64, 'orderId', None, None, ), # 1
10412 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
10413 
  )
10414 
 
10415 
  def __init__(self, orderId=None, invoiceNumber=None,):
10416 
    self.orderId = orderId
10417 
    self.invoiceNumber = invoiceNumber
10418 
 
10419 
  def read(self, iprot):
10420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10422 
      return
10423 
    iprot.readStructBegin()
10424 
    while True:
10425 
      (fname, ftype, fid) = iprot.readFieldBegin()
10426 
      if ftype == TType.STOP:
10427 
        break
10428 
      if fid == 1:
10429 
        if ftype == TType.I64:
10430 
          self.orderId = iprot.readI64();
10431 
        else:
10432 
          iprot.skip(ftype)
10433 
      elif fid == 2:
10434 
        if ftype == TType.STRING:
10435 
          self.invoiceNumber = iprot.readString();
10436 
        else:
10437 
          iprot.skip(ftype)
10438 
      else:
10439 
        iprot.skip(ftype)
10440 
      iprot.readFieldEnd()
10441 
    iprot.readStructEnd()
10442 
 
10443 
  def write(self, oprot):
10444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10446 
      return
10447 
    oprot.writeStructBegin('addInvoiceNumber_args')
10448 
    if self.orderId is not None:
10449 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10450 
      oprot.writeI64(self.orderId)
10451 
      oprot.writeFieldEnd()
10452 
    if self.invoiceNumber is not None:
10453 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
10454 
      oprot.writeString(self.invoiceNumber)
10455 
      oprot.writeFieldEnd()
10456 
    oprot.writeFieldStop()
10457 
    oprot.writeStructEnd()
10458 
 
10459 
  def validate(self):
10460 
    return
10461 
 
10462 
 
10463 
  def __repr__(self):
10464 
    L = ['%s=%r' % (key, value)
10465 
      for key, value in self.__dict__.iteritems()]
10466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10467 
 
10468 
  def __eq__(self, other):
10469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10470 
 
10471 
  def __ne__(self, other):
10472 
    return not (self == other)
10473 
 
10474 
class addInvoiceNumber_result:
10475 
  """
10476 
  Attributes:
10477 
   - ex
10478 
  """
10479 
 
10480 
  thrift_spec = (
10481 
    None, # 0
10482 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10483 
  )
10484 
 
10485 
  def __init__(self, ex=None,):
10486 
    self.ex = ex
10487 
 
10488 
  def read(self, iprot):
10489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10491 
      return
10492 
    iprot.readStructBegin()
10493 
    while True:
10494 
      (fname, ftype, fid) = iprot.readFieldBegin()
10495 
      if ftype == TType.STOP:
10496 
        break
10497 
      if fid == 1:
10498 
        if ftype == TType.STRUCT:
10499 
          self.ex = TransactionServiceException()
10500 
          self.ex.read(iprot)
10501 
        else:
10502 
          iprot.skip(ftype)
10503 
      else:
10504 
        iprot.skip(ftype)
10505 
      iprot.readFieldEnd()
10506 
    iprot.readStructEnd()
10507 
 
10508 
  def write(self, oprot):
10509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10511 
      return
10512 
    oprot.writeStructBegin('addInvoiceNumber_result')
10513 
    if self.ex is not None:
10514 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10515 
      self.ex.write(oprot)
10516 
      oprot.writeFieldEnd()
10517 
    oprot.writeFieldStop()
10518 
    oprot.writeStructEnd()
10519 
 
10520 
  def validate(self):
10521 
    return
10522 
 
10523 
 
10524 
  def __repr__(self):
10525 
    L = ['%s=%r' % (key, value)
10526 
      for key, value in self.__dict__.iteritems()]
10527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10528 
 
10529 
  def __eq__(self, other):
10530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10531 
 
10532 
  def __ne__(self, other):
10533 
    return not (self == other)
10534 
 
3064 chandransh 10535 
class markOrdersAsManifested_args:
1408 ankur.sing 10536 
  """
10537 
  Attributes:
3064 chandransh 10538 
   - warehouseId
1408 ankur.sing 10539 
   - providerId
3064 chandransh 10540 
   - cod
1408 ankur.sing 10541 
  """
10542 
 
10543 
  thrift_spec = (
10544 
    None, # 0
3064 chandransh 10545 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10546 
    (2, TType.I64, 'providerId', None, None, ), # 2
10547 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 10548 
  )
10549 
 
3064 chandransh 10550 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10551 
    self.warehouseId = warehouseId
1408 ankur.sing 10552 
    self.providerId = providerId
3064 chandransh 10553 
    self.cod = cod
1408 ankur.sing 10554 
 
10555 
  def read(self, iprot):
10556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10558 
      return
10559 
    iprot.readStructBegin()
10560 
    while True:
10561 
      (fname, ftype, fid) = iprot.readFieldBegin()
10562 
      if ftype == TType.STOP:
10563 
        break
10564 
      if fid == 1:
10565 
        if ftype == TType.I64:
3064 chandransh 10566 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 10567 
        else:
10568 
          iprot.skip(ftype)
10569 
      elif fid == 2:
10570 
        if ftype == TType.I64:
3064 chandransh 10571 
          self.providerId = iprot.readI64();
1408 ankur.sing 10572 
        else:
10573 
          iprot.skip(ftype)
3064 chandransh 10574 
      elif fid == 3:
10575 
        if ftype == TType.BOOL:
10576 
          self.cod = iprot.readBool();
10577 
        else:
10578 
          iprot.skip(ftype)
1408 ankur.sing 10579 
      else:
10580 
        iprot.skip(ftype)
10581 
      iprot.readFieldEnd()
10582 
    iprot.readStructEnd()
10583 
 
10584 
  def write(self, oprot):
10585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10587 
      return
3064 chandransh 10588 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 10589 
    if self.warehouseId is not None:
3064 chandransh 10590 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10591 
      oprot.writeI64(self.warehouseId)
10592 
      oprot.writeFieldEnd()
3431 rajveer 10593 
    if self.providerId is not None:
3064 chandransh 10594 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 10595 
      oprot.writeI64(self.providerId)
10596 
      oprot.writeFieldEnd()
3431 rajveer 10597 
    if self.cod is not None:
3064 chandransh 10598 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10599 
      oprot.writeBool(self.cod)
1408 ankur.sing 10600 
      oprot.writeFieldEnd()
10601 
    oprot.writeFieldStop()
10602 
    oprot.writeStructEnd()
10603 
 
3431 rajveer 10604 
  def validate(self):
10605 
    return
10606 
 
10607 
 
1408 ankur.sing 10608 
  def __repr__(self):
10609 
    L = ['%s=%r' % (key, value)
10610 
      for key, value in self.__dict__.iteritems()]
10611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10612 
 
10613 
  def __eq__(self, other):
10614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10615 
 
10616 
  def __ne__(self, other):
10617 
    return not (self == other)
10618 
 
3064 chandransh 10619 
class markOrdersAsManifested_result:
1408 ankur.sing 10620 
  """
10621 
  Attributes:
10622 
   - success
3064 chandransh 10623 
   - ex
1408 ankur.sing 10624 
  """
10625 
 
10626 
  thrift_spec = (
3064 chandransh 10627 
    (0, TType.BOOL, 'success', None, None, ), # 0
10628 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10629 
  )
10630 
 
3064 chandransh 10631 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10632 
    self.success = success
3064 chandransh 10633 
    self.ex = ex
1408 ankur.sing 10634 
 
10635 
  def read(self, iprot):
10636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10638 
      return
10639 
    iprot.readStructBegin()
10640 
    while True:
10641 
      (fname, ftype, fid) = iprot.readFieldBegin()
10642 
      if ftype == TType.STOP:
10643 
        break
10644 
      if fid == 0:
3064 chandransh 10645 
        if ftype == TType.BOOL:
10646 
          self.success = iprot.readBool();
1408 ankur.sing 10647 
        else:
10648 
          iprot.skip(ftype)
3064 chandransh 10649 
      elif fid == 1:
10650 
        if ftype == TType.STRUCT:
10651 
          self.ex = TransactionServiceException()
10652 
          self.ex.read(iprot)
10653 
        else:
10654 
          iprot.skip(ftype)
1408 ankur.sing 10655 
      else:
10656 
        iprot.skip(ftype)
10657 
      iprot.readFieldEnd()
10658 
    iprot.readStructEnd()
10659 
 
10660 
  def write(self, oprot):
10661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10663 
      return
3064 chandransh 10664 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10665 
    if self.success is not None:
3064 chandransh 10666 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10667 
      oprot.writeBool(self.success)
1408 ankur.sing 10668 
      oprot.writeFieldEnd()
3431 rajveer 10669 
    if self.ex is not None:
3064 chandransh 10670 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10671 
      self.ex.write(oprot)
10672 
      oprot.writeFieldEnd()
1408 ankur.sing 10673 
    oprot.writeFieldStop()
10674 
    oprot.writeStructEnd()
10675 
 
3431 rajveer 10676 
  def validate(self):
10677 
    return
10678 
 
10679 
 
1408 ankur.sing 10680 
  def __repr__(self):
10681 
    L = ['%s=%r' % (key, value)
10682 
      for key, value in self.__dict__.iteritems()]
10683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10684 
 
10685 
  def __eq__(self, other):
10686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10687 
 
10688 
  def __ne__(self, other):
10689 
    return not (self == other)
10690 
 
4410 rajveer 10691 
class markOrdersAsShippedFromWarehouse_args:
10692 
  """
10693 
  Attributes:
10694 
   - warehouseId
10695 
   - providerId
10696 
   - cod
10697 
  """
10698 
 
10699 
  thrift_spec = (
10700 
    None, # 0
10701 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10702 
    (2, TType.I64, 'providerId', None, None, ), # 2
10703 
    (3, TType.BOOL, 'cod', None, None, ), # 3
10704 
  )
10705 
 
10706 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10707 
    self.warehouseId = warehouseId
10708 
    self.providerId = providerId
10709 
    self.cod = cod
10710 
 
10711 
  def read(self, iprot):
10712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10714 
      return
10715 
    iprot.readStructBegin()
10716 
    while True:
10717 
      (fname, ftype, fid) = iprot.readFieldBegin()
10718 
      if ftype == TType.STOP:
10719 
        break
10720 
      if fid == 1:
10721 
        if ftype == TType.I64:
10722 
          self.warehouseId = iprot.readI64();
10723 
        else:
10724 
          iprot.skip(ftype)
10725 
      elif fid == 2:
10726 
        if ftype == TType.I64:
10727 
          self.providerId = iprot.readI64();
10728 
        else:
10729 
          iprot.skip(ftype)
10730 
      elif fid == 3:
10731 
        if ftype == TType.BOOL:
10732 
          self.cod = iprot.readBool();
10733 
        else:
10734 
          iprot.skip(ftype)
10735 
      else:
10736 
        iprot.skip(ftype)
10737 
      iprot.readFieldEnd()
10738 
    iprot.readStructEnd()
10739 
 
10740 
  def write(self, oprot):
10741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10743 
      return
10744 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
10745 
    if self.warehouseId is not None:
10746 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10747 
      oprot.writeI64(self.warehouseId)
10748 
      oprot.writeFieldEnd()
10749 
    if self.providerId is not None:
10750 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
10751 
      oprot.writeI64(self.providerId)
10752 
      oprot.writeFieldEnd()
10753 
    if self.cod is not None:
10754 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10755 
      oprot.writeBool(self.cod)
10756 
      oprot.writeFieldEnd()
10757 
    oprot.writeFieldStop()
10758 
    oprot.writeStructEnd()
10759 
 
10760 
  def validate(self):
10761 
    return
10762 
 
10763 
 
10764 
  def __repr__(self):
10765 
    L = ['%s=%r' % (key, value)
10766 
      for key, value in self.__dict__.iteritems()]
10767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10768 
 
10769 
  def __eq__(self, other):
10770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10771 
 
10772 
  def __ne__(self, other):
10773 
    return not (self == other)
10774 
 
10775 
class markOrdersAsShippedFromWarehouse_result:
10776 
  """
10777 
  Attributes:
10778 
   - success
10779 
   - ex
10780 
  """
10781 
 
10782 
  thrift_spec = (
10783 
    (0, TType.BOOL, 'success', None, None, ), # 0
10784 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10785 
  )
10786 
 
10787 
  def __init__(self, success=None, ex=None,):
10788 
    self.success = success
10789 
    self.ex = ex
10790 
 
10791 
  def read(self, iprot):
10792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10794 
      return
10795 
    iprot.readStructBegin()
10796 
    while True:
10797 
      (fname, ftype, fid) = iprot.readFieldBegin()
10798 
      if ftype == TType.STOP:
10799 
        break
10800 
      if fid == 0:
10801 
        if ftype == TType.BOOL:
10802 
          self.success = iprot.readBool();
10803 
        else:
10804 
          iprot.skip(ftype)
10805 
      elif fid == 1:
10806 
        if ftype == TType.STRUCT:
10807 
          self.ex = TransactionServiceException()
10808 
          self.ex.read(iprot)
10809 
        else:
10810 
          iprot.skip(ftype)
10811 
      else:
10812 
        iprot.skip(ftype)
10813 
      iprot.readFieldEnd()
10814 
    iprot.readStructEnd()
10815 
 
10816 
  def write(self, oprot):
10817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10819 
      return
10820 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
10821 
    if self.success is not None:
10822 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10823 
      oprot.writeBool(self.success)
10824 
      oprot.writeFieldEnd()
10825 
    if self.ex is not None:
10826 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10827 
      self.ex.write(oprot)
10828 
      oprot.writeFieldEnd()
10829 
    oprot.writeFieldStop()
10830 
    oprot.writeStructEnd()
10831 
 
10832 
  def validate(self):
10833 
    return
10834 
 
10835 
 
10836 
  def __repr__(self):
10837 
    L = ['%s=%r' % (key, value)
10838 
      for key, value in self.__dict__.iteritems()]
10839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10840 
 
10841 
  def __eq__(self, other):
10842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10843 
 
10844 
  def __ne__(self, other):
10845 
    return not (self == other)
10846 
 
3064 chandransh 10847 
class markOrdersAsPickedUp_args:
304 ashish 10848 
  """
10849 
  Attributes:
3064 chandransh 10850 
   - providerId
10851 
   - pickupDetails
304 ashish 10852 
  """
94 ashish 10853 
 
304 ashish 10854 
  thrift_spec = (
10855 
    None, # 0
3064 chandransh 10856 
    (1, TType.I64, 'providerId', None, None, ), # 1
10857 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10858 
  )
10859 
 
3064 chandransh 10860 
  def __init__(self, providerId=None, pickupDetails=None,):
10861 
    self.providerId = providerId
10862 
    self.pickupDetails = pickupDetails
304 ashish 10863 
 
10864 
  def read(self, iprot):
10865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10867 
      return
10868 
    iprot.readStructBegin()
10869 
    while True:
10870 
      (fname, ftype, fid) = iprot.readFieldBegin()
10871 
      if ftype == TType.STOP:
10872 
        break
10873 
      if fid == 1:
10874 
        if ftype == TType.I64:
3064 chandransh 10875 
          self.providerId = iprot.readI64();
304 ashish 10876 
        else:
10877 
          iprot.skip(ftype)
10878 
      elif fid == 2:
3064 chandransh 10879 
        if ftype == TType.MAP:
10880 
          self.pickupDetails = {}
4133 chandransh 10881 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
10882 
          for _i144 in xrange(_size140):
10883 
            _key145 = iprot.readString();
10884 
            _val146 = iprot.readString();
10885 
            self.pickupDetails[_key145] = _val146
3064 chandransh 10886 
          iprot.readMapEnd()
304 ashish 10887 
        else:
10888 
          iprot.skip(ftype)
10889 
      else:
10890 
        iprot.skip(ftype)
10891 
      iprot.readFieldEnd()
10892 
    iprot.readStructEnd()
10893 
 
10894 
  def write(self, oprot):
10895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10897 
      return
3064 chandransh 10898 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 10899 
    if self.providerId is not None:
3064 chandransh 10900 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10901 
      oprot.writeI64(self.providerId)
304 ashish 10902 
      oprot.writeFieldEnd()
3431 rajveer 10903 
    if self.pickupDetails is not None:
3064 chandransh 10904 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10905 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10906 
      for kiter147,viter148 in self.pickupDetails.items():
10907 
        oprot.writeString(kiter147)
10908 
        oprot.writeString(viter148)
3064 chandransh 10909 
      oprot.writeMapEnd()
304 ashish 10910 
      oprot.writeFieldEnd()
10911 
    oprot.writeFieldStop()
10912 
    oprot.writeStructEnd()
10913 
 
3431 rajveer 10914 
  def validate(self):
10915 
    return
10916 
 
10917 
 
304 ashish 10918 
  def __repr__(self):
10919 
    L = ['%s=%r' % (key, value)
10920 
      for key, value in self.__dict__.iteritems()]
10921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10922 
 
10923 
  def __eq__(self, other):
10924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10925 
 
10926 
  def __ne__(self, other):
10927 
    return not (self == other)
10928 
 
3064 chandransh 10929 
class markOrdersAsPickedUp_result:
304 ashish 10930 
  """
10931 
  Attributes:
10932 
   - success
3064 chandransh 10933 
   - ex
304 ashish 10934 
  """
10935 
 
10936 
  thrift_spec = (
3064 chandransh 10937 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10938 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10939 
  )
10940 
 
3064 chandransh 10941 
  def __init__(self, success=None, ex=None,):
304 ashish 10942 
    self.success = success
3064 chandransh 10943 
    self.ex = ex
304 ashish 10944 
 
10945 
  def read(self, iprot):
10946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10948 
      return
10949 
    iprot.readStructBegin()
10950 
    while True:
10951 
      (fname, ftype, fid) = iprot.readFieldBegin()
10952 
      if ftype == TType.STOP:
10953 
        break
10954 
      if fid == 0:
10955 
        if ftype == TType.LIST:
10956 
          self.success = []
4133 chandransh 10957 
          (_etype152, _size149) = iprot.readListBegin()
10958 
          for _i153 in xrange(_size149):
10959 
            _elem154 = Order()
10960 
            _elem154.read(iprot)
10961 
            self.success.append(_elem154)
304 ashish 10962 
          iprot.readListEnd()
10963 
        else:
10964 
          iprot.skip(ftype)
3064 chandransh 10965 
      elif fid == 1:
10966 
        if ftype == TType.STRUCT:
10967 
          self.ex = TransactionServiceException()
10968 
          self.ex.read(iprot)
10969 
        else:
10970 
          iprot.skip(ftype)
304 ashish 10971 
      else:
10972 
        iprot.skip(ftype)
10973 
      iprot.readFieldEnd()
10974 
    iprot.readStructEnd()
10975 
 
10976 
  def write(self, oprot):
10977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10979 
      return
3064 chandransh 10980 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 10981 
    if self.success is not None:
304 ashish 10982 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10983 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10984 
      for iter155 in self.success:
10985 
        iter155.write(oprot)
304 ashish 10986 
      oprot.writeListEnd()
10987 
      oprot.writeFieldEnd()
3431 rajveer 10988 
    if self.ex is not None:
3064 chandransh 10989 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10990 
      self.ex.write(oprot)
10991 
      oprot.writeFieldEnd()
304 ashish 10992 
    oprot.writeFieldStop()
10993 
    oprot.writeStructEnd()
10994 
 
3431 rajveer 10995 
  def validate(self):
10996 
    return
10997 
 
10998 
 
304 ashish 10999 
  def __repr__(self):
11000 
    L = ['%s=%r' % (key, value)
11001 
      for key, value in self.__dict__.iteritems()]
11002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11003 
 
11004 
  def __eq__(self, other):
11005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11006 
 
11007 
  def __ne__(self, other):
11008 
    return not (self == other)
11009 
 
3064 chandransh 11010 
class markOrdersAsDelivered_args:
304 ashish 11011 
  """
11012 
  Attributes:
3064 chandransh 11013 
   - providerId
11014 
   - deliveredOrders
304 ashish 11015 
  """
11016 
 
11017 
  thrift_spec = (
11018 
    None, # 0
3064 chandransh 11019 
    (1, TType.I64, 'providerId', None, None, ), # 1
11020 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11021 
  )
11022 
 
3064 chandransh 11023 
  def __init__(self, providerId=None, deliveredOrders=None,):
11024 
    self.providerId = providerId
11025 
    self.deliveredOrders = deliveredOrders
304 ashish 11026 
 
11027 
  def read(self, iprot):
11028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11030 
      return
11031 
    iprot.readStructBegin()
11032 
    while True:
11033 
      (fname, ftype, fid) = iprot.readFieldBegin()
11034 
      if ftype == TType.STOP:
11035 
        break
11036 
      if fid == 1:
11037 
        if ftype == TType.I64:
3064 chandransh 11038 
          self.providerId = iprot.readI64();
304 ashish 11039 
        else:
11040 
          iprot.skip(ftype)
11041 
      elif fid == 2:
3064 chandransh 11042 
        if ftype == TType.MAP:
11043 
          self.deliveredOrders = {}
4133 chandransh 11044 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
11045 
          for _i160 in xrange(_size156):
11046 
            _key161 = iprot.readString();
11047 
            _val162 = iprot.readString();
11048 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 11049 
          iprot.readMapEnd()
304 ashish 11050 
        else:
11051 
          iprot.skip(ftype)
11052 
      else:
11053 
        iprot.skip(ftype)
11054 
      iprot.readFieldEnd()
11055 
    iprot.readStructEnd()
11056 
 
11057 
  def write(self, oprot):
11058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11060 
      return
3064 chandransh 11061 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 11062 
    if self.providerId is not None:
3064 chandransh 11063 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11064 
      oprot.writeI64(self.providerId)
304 ashish 11065 
      oprot.writeFieldEnd()
3431 rajveer 11066 
    if self.deliveredOrders is not None:
3064 chandransh 11067 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
11068 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 11069 
      for kiter163,viter164 in self.deliveredOrders.items():
11070 
        oprot.writeString(kiter163)
11071 
        oprot.writeString(viter164)
3064 chandransh 11072 
      oprot.writeMapEnd()
304 ashish 11073 
      oprot.writeFieldEnd()
11074 
    oprot.writeFieldStop()
11075 
    oprot.writeStructEnd()
11076 
 
3431 rajveer 11077 
  def validate(self):
11078 
    return
11079 
 
11080 
 
304 ashish 11081 
  def __repr__(self):
11082 
    L = ['%s=%r' % (key, value)
11083 
      for key, value in self.__dict__.iteritems()]
11084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11085 
 
11086 
  def __eq__(self, other):
11087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11088 
 
11089 
  def __ne__(self, other):
11090 
    return not (self == other)
11091 
 
3064 chandransh 11092 
class markOrdersAsDelivered_result:
11093 
  """
11094 
  Attributes:
11095 
   - ex
11096 
  """
304 ashish 11097 
 
11098 
  thrift_spec = (
3064 chandransh 11099 
    None, # 0
11100 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11101 
  )
11102 
 
3064 chandransh 11103 
  def __init__(self, ex=None,):
11104 
    self.ex = ex
304 ashish 11105 
 
1596 ankur.sing 11106 
  def read(self, iprot):
11107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11109 
      return
11110 
    iprot.readStructBegin()
11111 
    while True:
11112 
      (fname, ftype, fid) = iprot.readFieldBegin()
11113 
      if ftype == TType.STOP:
11114 
        break
3064 chandransh 11115 
      if fid == 1:
11116 
        if ftype == TType.STRUCT:
11117 
          self.ex = TransactionServiceException()
11118 
          self.ex.read(iprot)
11119 
        else:
11120 
          iprot.skip(ftype)
1596 ankur.sing 11121 
      else:
11122 
        iprot.skip(ftype)
11123 
      iprot.readFieldEnd()
11124 
    iprot.readStructEnd()
11125 
 
11126 
  def write(self, oprot):
11127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11129 
      return
3064 chandransh 11130 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 11131 
    if self.ex is not None:
3064 chandransh 11132 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11133 
      self.ex.write(oprot)
11134 
      oprot.writeFieldEnd()
1596 ankur.sing 11135 
    oprot.writeFieldStop()
11136 
    oprot.writeStructEnd()
11137 
 
3431 rajveer 11138 
  def validate(self):
11139 
    return
11140 
 
11141 
 
1596 ankur.sing 11142 
  def __repr__(self):
11143 
    L = ['%s=%r' % (key, value)
11144 
      for key, value in self.__dict__.iteritems()]
11145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11146 
 
11147 
  def __eq__(self, other):
11148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11149 
 
11150 
  def __ne__(self, other):
11151 
    return not (self == other)
11152 
 
3064 chandransh 11153 
class markOrdersAsFailed_args:
1596 ankur.sing 11154 
  """
11155 
  Attributes:
3064 chandransh 11156 
   - providerId
11157 
   - returnedOrders
1596 ankur.sing 11158 
  """
11159 
 
11160 
  thrift_spec = (
3064 chandransh 11161 
    None, # 0
11162 
    (1, TType.I64, 'providerId', None, None, ), # 1
11163 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 11164 
  )
11165 
 
3064 chandransh 11166 
  def __init__(self, providerId=None, returnedOrders=None,):
11167 
    self.providerId = providerId
11168 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11169 
 
11170 
  def read(self, iprot):
11171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11173 
      return
11174 
    iprot.readStructBegin()
11175 
    while True:
11176 
      (fname, ftype, fid) = iprot.readFieldBegin()
11177 
      if ftype == TType.STOP:
11178 
        break
3064 chandransh 11179 
      if fid == 1:
1596 ankur.sing 11180 
        if ftype == TType.I64:
3064 chandransh 11181 
          self.providerId = iprot.readI64();
1596 ankur.sing 11182 
        else:
11183 
          iprot.skip(ftype)
3064 chandransh 11184 
      elif fid == 2:
11185 
        if ftype == TType.MAP:
11186 
          self.returnedOrders = {}
4133 chandransh 11187 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
11188 
          for _i169 in xrange(_size165):
11189 
            _key170 = iprot.readString();
11190 
            _val171 = iprot.readString();
11191 
            self.returnedOrders[_key170] = _val171
3064 chandransh 11192 
          iprot.readMapEnd()
11193 
        else:
11194 
          iprot.skip(ftype)
1596 ankur.sing 11195 
      else:
11196 
        iprot.skip(ftype)
11197 
      iprot.readFieldEnd()
11198 
    iprot.readStructEnd()
11199 
 
11200 
  def write(self, oprot):
11201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11203 
      return
3064 chandransh 11204 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 11205 
    if self.providerId is not None:
3064 chandransh 11206 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11207 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11208 
      oprot.writeFieldEnd()
3431 rajveer 11209 
    if self.returnedOrders is not None:
3064 chandransh 11210 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11211 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 11212 
      for kiter172,viter173 in self.returnedOrders.items():
11213 
        oprot.writeString(kiter172)
11214 
        oprot.writeString(viter173)
3064 chandransh 11215 
      oprot.writeMapEnd()
11216 
      oprot.writeFieldEnd()
1596 ankur.sing 11217 
    oprot.writeFieldStop()
11218 
    oprot.writeStructEnd()
11219 
 
3431 rajveer 11220 
  def validate(self):
11221 
    return
11222 
 
11223 
 
1596 ankur.sing 11224 
  def __repr__(self):
11225 
    L = ['%s=%r' % (key, value)
11226 
      for key, value in self.__dict__.iteritems()]
11227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11228 
 
11229 
  def __eq__(self, other):
11230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11231 
 
11232 
  def __ne__(self, other):
11233 
    return not (self == other)
11234 
 
3064 chandransh 11235 
class markOrdersAsFailed_result:
11236 
  """
11237 
  Attributes:
11238 
   - ex
11239 
  """
1596 ankur.sing 11240 
 
1627 ankur.sing 11241 
  thrift_spec = (
3064 chandransh 11242 
    None, # 0
11243 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11244 
  )
11245 
 
3064 chandransh 11246 
  def __init__(self, ex=None,):
11247 
    self.ex = ex
11248 
 
1627 ankur.sing 11249 
  def read(self, iprot):
11250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11252 
      return
11253 
    iprot.readStructBegin()
11254 
    while True:
11255 
      (fname, ftype, fid) = iprot.readFieldBegin()
11256 
      if ftype == TType.STOP:
11257 
        break
3064 chandransh 11258 
      if fid == 1:
11259 
        if ftype == TType.STRUCT:
11260 
          self.ex = TransactionServiceException()
11261 
          self.ex.read(iprot)
11262 
        else:
11263 
          iprot.skip(ftype)
1627 ankur.sing 11264 
      else:
11265 
        iprot.skip(ftype)
11266 
      iprot.readFieldEnd()
11267 
    iprot.readStructEnd()
11268 
 
11269 
  def write(self, oprot):
11270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11272 
      return
3064 chandransh 11273 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 11274 
    if self.ex is not None:
3064 chandransh 11275 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11276 
      self.ex.write(oprot)
11277 
      oprot.writeFieldEnd()
1627 ankur.sing 11278 
    oprot.writeFieldStop()
11279 
    oprot.writeStructEnd()
11280 
 
3431 rajveer 11281 
  def validate(self):
11282 
    return
11283 
 
11284 
 
1627 ankur.sing 11285 
  def __repr__(self):
11286 
    L = ['%s=%r' % (key, value)
11287 
      for key, value in self.__dict__.iteritems()]
11288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11289 
 
11290 
  def __eq__(self, other):
11291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11292 
 
11293 
  def __ne__(self, other):
11294 
    return not (self == other)
11295 
 
3064 chandransh 11296 
class updateNonDeliveryReason_args:
1627 ankur.sing 11297 
  """
11298 
  Attributes:
3064 chandransh 11299 
   - providerId
11300 
   - undeliveredOrders
1627 ankur.sing 11301 
  """
11302 
 
11303 
  thrift_spec = (
3064 chandransh 11304 
    None, # 0
11305 
    (1, TType.I64, 'providerId', None, None, ), # 1
11306 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 11307 
  )
11308 
 
3064 chandransh 11309 
  def __init__(self, providerId=None, undeliveredOrders=None,):
11310 
    self.providerId = providerId
11311 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 11312 
 
11313 
  def read(self, iprot):
11314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11316 
      return
11317 
    iprot.readStructBegin()
11318 
    while True:
11319 
      (fname, ftype, fid) = iprot.readFieldBegin()
11320 
      if ftype == TType.STOP:
11321 
        break
3064 chandransh 11322 
      if fid == 1:
1627 ankur.sing 11323 
        if ftype == TType.I64:
3064 chandransh 11324 
          self.providerId = iprot.readI64();
1627 ankur.sing 11325 
        else:
11326 
          iprot.skip(ftype)
3064 chandransh 11327 
      elif fid == 2:
11328 
        if ftype == TType.MAP:
11329 
          self.undeliveredOrders = {}
4133 chandransh 11330 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
11331 
          for _i178 in xrange(_size174):
11332 
            _key179 = iprot.readString();
11333 
            _val180 = iprot.readString();
11334 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 11335 
          iprot.readMapEnd()
11336 
        else:
11337 
          iprot.skip(ftype)
1627 ankur.sing 11338 
      else:
11339 
        iprot.skip(ftype)
11340 
      iprot.readFieldEnd()
11341 
    iprot.readStructEnd()
11342 
 
11343 
  def write(self, oprot):
11344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11346 
      return
3064 chandransh 11347 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 11348 
    if self.providerId is not None:
3064 chandransh 11349 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11350 
      oprot.writeI64(self.providerId)
1627 ankur.sing 11351 
      oprot.writeFieldEnd()
3431 rajveer 11352 
    if self.undeliveredOrders is not None:
3064 chandransh 11353 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
11354 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 11355 
      for kiter181,viter182 in self.undeliveredOrders.items():
11356 
        oprot.writeString(kiter181)
11357 
        oprot.writeString(viter182)
3064 chandransh 11358 
      oprot.writeMapEnd()
11359 
      oprot.writeFieldEnd()
1627 ankur.sing 11360 
    oprot.writeFieldStop()
11361 
    oprot.writeStructEnd()
11362 
 
3431 rajveer 11363 
  def validate(self):
11364 
    return
11365 
 
11366 
 
1627 ankur.sing 11367 
  def __repr__(self):
11368 
    L = ['%s=%r' % (key, value)
11369 
      for key, value in self.__dict__.iteritems()]
11370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11371 
 
11372 
  def __eq__(self, other):
11373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11374 
 
11375 
  def __ne__(self, other):
11376 
    return not (self == other)
11377 
 
3064 chandransh 11378 
class updateNonDeliveryReason_result:
1627 ankur.sing 11379 
  """
11380 
  Attributes:
4581 phani.kuma 11381 
   - success
3064 chandransh 11382 
   - ex
1627 ankur.sing 11383 
  """
11384 
 
11385 
  thrift_spec = (
4581 phani.kuma 11386 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 11387 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11388 
  )
11389 
 
4581 phani.kuma 11390 
  def __init__(self, success=None, ex=None,):
11391 
    self.success = success
3064 chandransh 11392 
    self.ex = ex
1627 ankur.sing 11393 
 
11394 
  def read(self, iprot):
11395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11397 
      return
11398 
    iprot.readStructBegin()
11399 
    while True:
11400 
      (fname, ftype, fid) = iprot.readFieldBegin()
11401 
      if ftype == TType.STOP:
11402 
        break
4581 phani.kuma 11403 
      if fid == 0:
11404 
        if ftype == TType.LIST:
11405 
          self.success = []
11406 
          (_etype186, _size183) = iprot.readListBegin()
11407 
          for _i187 in xrange(_size183):
11408 
            _elem188 = Order()
11409 
            _elem188.read(iprot)
11410 
            self.success.append(_elem188)
11411 
          iprot.readListEnd()
11412 
        else:
11413 
          iprot.skip(ftype)
11414 
      elif fid == 1:
3064 chandransh 11415 
        if ftype == TType.STRUCT:
11416 
          self.ex = TransactionServiceException()
11417 
          self.ex.read(iprot)
1627 ankur.sing 11418 
        else:
11419 
          iprot.skip(ftype)
11420 
      else:
11421 
        iprot.skip(ftype)
11422 
      iprot.readFieldEnd()
11423 
    iprot.readStructEnd()
11424 
 
11425 
  def write(self, oprot):
11426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11428 
      return
3064 chandransh 11429 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 11430 
    if self.success is not None:
11431 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11432 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11433 
      for iter189 in self.success:
11434 
        iter189.write(oprot)
11435 
      oprot.writeListEnd()
11436 
      oprot.writeFieldEnd()
3431 rajveer 11437 
    if self.ex is not None:
3064 chandransh 11438 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11439 
      self.ex.write(oprot)
1627 ankur.sing 11440 
      oprot.writeFieldEnd()
11441 
    oprot.writeFieldStop()
11442 
    oprot.writeStructEnd()
11443 
 
3431 rajveer 11444 
  def validate(self):
11445 
    return
11446 
 
11447 
 
1627 ankur.sing 11448 
  def __repr__(self):
11449 
    L = ['%s=%r' % (key, value)
11450 
      for key, value in self.__dict__.iteritems()]
11451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11452 
 
11453 
  def __eq__(self, other):
11454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11455 
 
11456 
  def __ne__(self, other):
11457 
    return not (self == other)
11458 
 
3064 chandransh 11459 
class getUndeliveredOrders_args:
1886 ankur.sing 11460 
  """
11461 
  Attributes:
3064 chandransh 11462 
   - providerId
11463 
   - warehouseId
1886 ankur.sing 11464 
  """
1627 ankur.sing 11465 
 
1886 ankur.sing 11466 
  thrift_spec = (
11467 
    None, # 0
3064 chandransh 11468 
    (1, TType.I64, 'providerId', None, None, ), # 1
11469 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 11470 
  )
11471 
 
3064 chandransh 11472 
  def __init__(self, providerId=None, warehouseId=None,):
11473 
    self.providerId = providerId
11474 
    self.warehouseId = warehouseId
1886 ankur.sing 11475 
 
11476 
  def read(self, iprot):
11477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11479 
      return
11480 
    iprot.readStructBegin()
11481 
    while True:
11482 
      (fname, ftype, fid) = iprot.readFieldBegin()
11483 
      if ftype == TType.STOP:
11484 
        break
11485 
      if fid == 1:
11486 
        if ftype == TType.I64:
3064 chandransh 11487 
          self.providerId = iprot.readI64();
1886 ankur.sing 11488 
        else:
11489 
          iprot.skip(ftype)
3064 chandransh 11490 
      elif fid == 2:
11491 
        if ftype == TType.I64:
11492 
          self.warehouseId = iprot.readI64();
11493 
        else:
11494 
          iprot.skip(ftype)
1886 ankur.sing 11495 
      else:
11496 
        iprot.skip(ftype)
11497 
      iprot.readFieldEnd()
11498 
    iprot.readStructEnd()
11499 
 
11500 
  def write(self, oprot):
11501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11503 
      return
3064 chandransh 11504 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 11505 
    if self.providerId is not None:
3064 chandransh 11506 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11507 
      oprot.writeI64(self.providerId)
1886 ankur.sing 11508 
      oprot.writeFieldEnd()
3431 rajveer 11509 
    if self.warehouseId is not None:
3064 chandransh 11510 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11511 
      oprot.writeI64(self.warehouseId)
11512 
      oprot.writeFieldEnd()
1886 ankur.sing 11513 
    oprot.writeFieldStop()
11514 
    oprot.writeStructEnd()
11515 
 
3431 rajveer 11516 
  def validate(self):
11517 
    return
11518 
 
11519 
 
1886 ankur.sing 11520 
  def __repr__(self):
11521 
    L = ['%s=%r' % (key, value)
11522 
      for key, value in self.__dict__.iteritems()]
11523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11524 
 
11525 
  def __eq__(self, other):
11526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11527 
 
11528 
  def __ne__(self, other):
11529 
    return not (self == other)
11530 
 
3064 chandransh 11531 
class getUndeliveredOrders_result:
1886 ankur.sing 11532 
  """
11533 
  Attributes:
11534 
   - success
11535 
  """
11536 
 
11537 
  thrift_spec = (
11538 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11539 
  )
11540 
 
11541 
  def __init__(self, success=None,):
11542 
    self.success = success
11543 
 
11544 
  def read(self, iprot):
11545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11547 
      return
11548 
    iprot.readStructBegin()
11549 
    while True:
11550 
      (fname, ftype, fid) = iprot.readFieldBegin()
11551 
      if ftype == TType.STOP:
11552 
        break
11553 
      if fid == 0:
11554 
        if ftype == TType.LIST:
11555 
          self.success = []
4581 phani.kuma 11556 
          (_etype193, _size190) = iprot.readListBegin()
11557 
          for _i194 in xrange(_size190):
11558 
            _elem195 = Order()
11559 
            _elem195.read(iprot)
11560 
            self.success.append(_elem195)
1886 ankur.sing 11561 
          iprot.readListEnd()
11562 
        else:
11563 
          iprot.skip(ftype)
11564 
      else:
11565 
        iprot.skip(ftype)
11566 
      iprot.readFieldEnd()
11567 
    iprot.readStructEnd()
11568 
 
11569 
  def write(self, oprot):
11570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11572 
      return
3064 chandransh 11573 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 11574 
    if self.success is not None:
1886 ankur.sing 11575 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11576 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 11577 
      for iter196 in self.success:
11578 
        iter196.write(oprot)
1886 ankur.sing 11579 
      oprot.writeListEnd()
11580 
      oprot.writeFieldEnd()
11581 
    oprot.writeFieldStop()
11582 
    oprot.writeStructEnd()
11583 
 
3431 rajveer 11584 
  def validate(self):
11585 
    return
11586 
 
11587 
 
1886 ankur.sing 11588 
  def __repr__(self):
11589 
    L = ['%s=%r' % (key, value)
11590 
      for key, value in self.__dict__.iteritems()]
11591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11592 
 
11593 
  def __eq__(self, other):
11594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11595 
 
11596 
  def __ne__(self, other):
11597 
    return not (self == other)
11598 
 
2536 chandransh 11599 
class toggleDOAFlag_args:
11600 
  """
11601 
  Attributes:
11602 
   - orderId
11603 
  """
1886 ankur.sing 11604 
 
2536 chandransh 11605 
  thrift_spec = (
11606 
    None, # 0
11607 
    (1, TType.I64, 'orderId', None, None, ), # 1
11608 
  )
11609 
 
11610 
  def __init__(self, orderId=None,):
11611 
    self.orderId = orderId
11612 
 
11613 
  def read(self, iprot):
11614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11616 
      return
11617 
    iprot.readStructBegin()
11618 
    while True:
11619 
      (fname, ftype, fid) = iprot.readFieldBegin()
11620 
      if ftype == TType.STOP:
11621 
        break
11622 
      if fid == 1:
11623 
        if ftype == TType.I64:
11624 
          self.orderId = iprot.readI64();
11625 
        else:
11626 
          iprot.skip(ftype)
11627 
      else:
11628 
        iprot.skip(ftype)
11629 
      iprot.readFieldEnd()
11630 
    iprot.readStructEnd()
11631 
 
11632 
  def write(self, oprot):
11633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11635 
      return
11636 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 11637 
    if self.orderId is not None:
2536 chandransh 11638 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11639 
      oprot.writeI64(self.orderId)
11640 
      oprot.writeFieldEnd()
11641 
    oprot.writeFieldStop()
11642 
    oprot.writeStructEnd()
11643 
 
3431 rajveer 11644 
  def validate(self):
11645 
    return
11646 
 
11647 
 
2536 chandransh 11648 
  def __repr__(self):
11649 
    L = ['%s=%r' % (key, value)
11650 
      for key, value in self.__dict__.iteritems()]
11651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11652 
 
11653 
  def __eq__(self, other):
11654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11655 
 
11656 
  def __ne__(self, other):
11657 
    return not (self == other)
11658 
 
11659 
class toggleDOAFlag_result:
11660 
  """
11661 
  Attributes:
11662 
   - success
11663 
   - ex
11664 
  """
11665 
 
11666 
  thrift_spec = (
11667 
    (0, TType.BOOL, 'success', None, None, ), # 0
11668 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11669 
  )
11670 
 
11671 
  def __init__(self, success=None, ex=None,):
11672 
    self.success = success
11673 
    self.ex = ex
11674 
 
11675 
  def read(self, iprot):
11676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11678 
      return
11679 
    iprot.readStructBegin()
11680 
    while True:
11681 
      (fname, ftype, fid) = iprot.readFieldBegin()
11682 
      if ftype == TType.STOP:
11683 
        break
11684 
      if fid == 0:
11685 
        if ftype == TType.BOOL:
11686 
          self.success = iprot.readBool();
11687 
        else:
11688 
          iprot.skip(ftype)
11689 
      elif fid == 1:
11690 
        if ftype == TType.STRUCT:
11691 
          self.ex = TransactionServiceException()
11692 
          self.ex.read(iprot)
11693 
        else:
11694 
          iprot.skip(ftype)
11695 
      else:
11696 
        iprot.skip(ftype)
11697 
      iprot.readFieldEnd()
11698 
    iprot.readStructEnd()
11699 
 
11700 
  def write(self, oprot):
11701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11703 
      return
11704 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 11705 
    if self.success is not None:
2536 chandransh 11706 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11707 
      oprot.writeBool(self.success)
11708 
      oprot.writeFieldEnd()
3431 rajveer 11709 
    if self.ex is not None:
2536 chandransh 11710 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11711 
      self.ex.write(oprot)
11712 
      oprot.writeFieldEnd()
11713 
    oprot.writeFieldStop()
11714 
    oprot.writeStructEnd()
11715 
 
3431 rajveer 11716 
  def validate(self):
11717 
    return
11718 
 
11719 
 
2536 chandransh 11720 
  def __repr__(self):
11721 
    L = ['%s=%r' % (key, value)
11722 
      for key, value in self.__dict__.iteritems()]
11723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11724 
 
11725 
  def __eq__(self, other):
11726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11727 
 
11728 
  def __ne__(self, other):
11729 
    return not (self == other)
11730 
 
4454 rajveer 11731 
class markOrderDoaRequestReceived_args:
11732 
  """
11733 
  Attributes:
11734 
   - orderId
11735 
  """
11736 
 
11737 
  thrift_spec = (
11738 
    None, # 0
11739 
    (1, TType.I64, 'orderId', None, None, ), # 1
11740 
  )
11741 
 
11742 
  def __init__(self, orderId=None,):
11743 
    self.orderId = orderId
11744 
 
11745 
  def read(self, iprot):
11746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11748 
      return
11749 
    iprot.readStructBegin()
11750 
    while True:
11751 
      (fname, ftype, fid) = iprot.readFieldBegin()
11752 
      if ftype == TType.STOP:
11753 
        break
11754 
      if fid == 1:
11755 
        if ftype == TType.I64:
11756 
          self.orderId = iprot.readI64();
11757 
        else:
11758 
          iprot.skip(ftype)
11759 
      else:
11760 
        iprot.skip(ftype)
11761 
      iprot.readFieldEnd()
11762 
    iprot.readStructEnd()
11763 
 
11764 
  def write(self, oprot):
11765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11767 
      return
11768 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
11769 
    if self.orderId is not None:
11770 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11771 
      oprot.writeI64(self.orderId)
11772 
      oprot.writeFieldEnd()
11773 
    oprot.writeFieldStop()
11774 
    oprot.writeStructEnd()
11775 
 
11776 
  def validate(self):
11777 
    return
11778 
 
11779 
 
11780 
  def __repr__(self):
11781 
    L = ['%s=%r' % (key, value)
11782 
      for key, value in self.__dict__.iteritems()]
11783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11784 
 
11785 
  def __eq__(self, other):
11786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11787 
 
11788 
  def __ne__(self, other):
11789 
    return not (self == other)
11790 
 
11791 
class markOrderDoaRequestReceived_result:
11792 
  """
11793 
  Attributes:
11794 
   - success
11795 
   - ex
11796 
  """
11797 
 
11798 
  thrift_spec = (
11799 
    (0, TType.BOOL, 'success', None, None, ), # 0
11800 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11801 
  )
11802 
 
11803 
  def __init__(self, success=None, ex=None,):
11804 
    self.success = success
11805 
    self.ex = ex
11806 
 
11807 
  def read(self, iprot):
11808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11810 
      return
11811 
    iprot.readStructBegin()
11812 
    while True:
11813 
      (fname, ftype, fid) = iprot.readFieldBegin()
11814 
      if ftype == TType.STOP:
11815 
        break
11816 
      if fid == 0:
11817 
        if ftype == TType.BOOL:
11818 
          self.success = iprot.readBool();
11819 
        else:
11820 
          iprot.skip(ftype)
11821 
      elif fid == 1:
11822 
        if ftype == TType.STRUCT:
11823 
          self.ex = TransactionServiceException()
11824 
          self.ex.read(iprot)
11825 
        else:
11826 
          iprot.skip(ftype)
11827 
      else:
11828 
        iprot.skip(ftype)
11829 
      iprot.readFieldEnd()
11830 
    iprot.readStructEnd()
11831 
 
11832 
  def write(self, oprot):
11833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11835 
      return
11836 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
11837 
    if self.success is not None:
11838 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11839 
      oprot.writeBool(self.success)
11840 
      oprot.writeFieldEnd()
11841 
    if self.ex is not None:
11842 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11843 
      self.ex.write(oprot)
11844 
      oprot.writeFieldEnd()
11845 
    oprot.writeFieldStop()
11846 
    oprot.writeStructEnd()
11847 
 
11848 
  def validate(self):
11849 
    return
11850 
 
11851 
 
11852 
  def __repr__(self):
11853 
    L = ['%s=%r' % (key, value)
11854 
      for key, value in self.__dict__.iteritems()]
11855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11856 
 
11857 
  def __eq__(self, other):
11858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11859 
 
11860 
  def __ne__(self, other):
11861 
    return not (self == other)
11862 
 
11863 
class markOrderDoaRequestAuthorized_args:
11864 
  """
11865 
  Attributes:
11866 
   - orderId
11867 
   - isAuthorized
11868 
  """
11869 
 
11870 
  thrift_spec = (
11871 
    None, # 0
11872 
    (1, TType.I64, 'orderId', None, None, ), # 1
11873 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11874 
  )
11875 
 
11876 
  def __init__(self, orderId=None, isAuthorized=None,):
11877 
    self.orderId = orderId
11878 
    self.isAuthorized = isAuthorized
11879 
 
11880 
  def read(self, iprot):
11881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11883 
      return
11884 
    iprot.readStructBegin()
11885 
    while True:
11886 
      (fname, ftype, fid) = iprot.readFieldBegin()
11887 
      if ftype == TType.STOP:
11888 
        break
11889 
      if fid == 1:
11890 
        if ftype == TType.I64:
11891 
          self.orderId = iprot.readI64();
11892 
        else:
11893 
          iprot.skip(ftype)
11894 
      elif fid == 2:
11895 
        if ftype == TType.BOOL:
11896 
          self.isAuthorized = iprot.readBool();
11897 
        else:
11898 
          iprot.skip(ftype)
11899 
      else:
11900 
        iprot.skip(ftype)
11901 
      iprot.readFieldEnd()
11902 
    iprot.readStructEnd()
11903 
 
11904 
  def write(self, oprot):
11905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11907 
      return
11908 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
11909 
    if self.orderId is not None:
11910 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11911 
      oprot.writeI64(self.orderId)
11912 
      oprot.writeFieldEnd()
11913 
    if self.isAuthorized is not None:
11914 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11915 
      oprot.writeBool(self.isAuthorized)
11916 
      oprot.writeFieldEnd()
11917 
    oprot.writeFieldStop()
11918 
    oprot.writeStructEnd()
11919 
 
11920 
  def validate(self):
11921 
    return
11922 
 
11923 
 
11924 
  def __repr__(self):
11925 
    L = ['%s=%r' % (key, value)
11926 
      for key, value in self.__dict__.iteritems()]
11927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11928 
 
11929 
  def __eq__(self, other):
11930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11931 
 
11932 
  def __ne__(self, other):
11933 
    return not (self == other)
11934 
 
11935 
class markOrderDoaRequestAuthorized_result:
11936 
  """
11937 
  Attributes:
11938 
   - success
11939 
   - ex
11940 
  """
11941 
 
11942 
  thrift_spec = (
11943 
    (0, TType.BOOL, 'success', None, None, ), # 0
11944 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11945 
  )
11946 
 
11947 
  def __init__(self, success=None, ex=None,):
11948 
    self.success = success
11949 
    self.ex = ex
11950 
 
11951 
  def read(self, iprot):
11952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11954 
      return
11955 
    iprot.readStructBegin()
11956 
    while True:
11957 
      (fname, ftype, fid) = iprot.readFieldBegin()
11958 
      if ftype == TType.STOP:
11959 
        break
11960 
      if fid == 0:
11961 
        if ftype == TType.BOOL:
11962 
          self.success = iprot.readBool();
11963 
        else:
11964 
          iprot.skip(ftype)
11965 
      elif fid == 1:
11966 
        if ftype == TType.STRUCT:
11967 
          self.ex = TransactionServiceException()
11968 
          self.ex.read(iprot)
11969 
        else:
11970 
          iprot.skip(ftype)
11971 
      else:
11972 
        iprot.skip(ftype)
11973 
      iprot.readFieldEnd()
11974 
    iprot.readStructEnd()
11975 
 
11976 
  def write(self, oprot):
11977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11979 
      return
11980 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
11981 
    if self.success is not None:
11982 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11983 
      oprot.writeBool(self.success)
11984 
      oprot.writeFieldEnd()
11985 
    if self.ex is not None:
11986 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11987 
      self.ex.write(oprot)
11988 
      oprot.writeFieldEnd()
11989 
    oprot.writeFieldStop()
11990 
    oprot.writeStructEnd()
11991 
 
11992 
  def validate(self):
11993 
    return
11994 
 
11995 
 
11996 
  def __repr__(self):
11997 
    L = ['%s=%r' % (key, value)
11998 
      for key, value in self.__dict__.iteritems()]
11999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12000 
 
12001 
  def __eq__(self, other):
12002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12003 
 
12004 
  def __ne__(self, other):
12005 
    return not (self == other)
12006 
 
4488 rajveer 12007 
class markOrderReturnRequestReceived_args:
12008 
  """
12009 
  Attributes:
12010 
   - orderId
12011 
  """
12012 
 
12013 
  thrift_spec = (
12014 
    None, # 0
12015 
    (1, TType.I64, 'orderId', None, None, ), # 1
12016 
  )
12017 
 
12018 
  def __init__(self, orderId=None,):
12019 
    self.orderId = orderId
12020 
 
12021 
  def read(self, iprot):
12022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12024 
      return
12025 
    iprot.readStructBegin()
12026 
    while True:
12027 
      (fname, ftype, fid) = iprot.readFieldBegin()
12028 
      if ftype == TType.STOP:
12029 
        break
12030 
      if fid == 1:
12031 
        if ftype == TType.I64:
12032 
          self.orderId = iprot.readI64();
12033 
        else:
12034 
          iprot.skip(ftype)
12035 
      else:
12036 
        iprot.skip(ftype)
12037 
      iprot.readFieldEnd()
12038 
    iprot.readStructEnd()
12039 
 
12040 
  def write(self, oprot):
12041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12043 
      return
12044 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
12045 
    if self.orderId is not None:
12046 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12047 
      oprot.writeI64(self.orderId)
12048 
      oprot.writeFieldEnd()
12049 
    oprot.writeFieldStop()
12050 
    oprot.writeStructEnd()
12051 
 
12052 
  def validate(self):
12053 
    return
12054 
 
12055 
 
12056 
  def __repr__(self):
12057 
    L = ['%s=%r' % (key, value)
12058 
      for key, value in self.__dict__.iteritems()]
12059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12060 
 
12061 
  def __eq__(self, other):
12062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12063 
 
12064 
  def __ne__(self, other):
12065 
    return not (self == other)
12066 
 
12067 
class markOrderReturnRequestReceived_result:
12068 
  """
12069 
  Attributes:
12070 
   - success
12071 
   - ex
12072 
  """
12073 
 
12074 
  thrift_spec = (
12075 
    (0, TType.BOOL, 'success', None, None, ), # 0
12076 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12077 
  )
12078 
 
12079 
  def __init__(self, success=None, ex=None,):
12080 
    self.success = success
12081 
    self.ex = ex
12082 
 
12083 
  def read(self, iprot):
12084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12086 
      return
12087 
    iprot.readStructBegin()
12088 
    while True:
12089 
      (fname, ftype, fid) = iprot.readFieldBegin()
12090 
      if ftype == TType.STOP:
12091 
        break
12092 
      if fid == 0:
12093 
        if ftype == TType.BOOL:
12094 
          self.success = iprot.readBool();
12095 
        else:
12096 
          iprot.skip(ftype)
12097 
      elif fid == 1:
12098 
        if ftype == TType.STRUCT:
12099 
          self.ex = TransactionServiceException()
12100 
          self.ex.read(iprot)
12101 
        else:
12102 
          iprot.skip(ftype)
12103 
      else:
12104 
        iprot.skip(ftype)
12105 
      iprot.readFieldEnd()
12106 
    iprot.readStructEnd()
12107 
 
12108 
  def write(self, oprot):
12109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12111 
      return
12112 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
12113 
    if self.success is not None:
12114 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12115 
      oprot.writeBool(self.success)
12116 
      oprot.writeFieldEnd()
12117 
    if self.ex is not None:
12118 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12119 
      self.ex.write(oprot)
12120 
      oprot.writeFieldEnd()
12121 
    oprot.writeFieldStop()
12122 
    oprot.writeStructEnd()
12123 
 
12124 
  def validate(self):
12125 
    return
12126 
 
12127 
 
12128 
  def __repr__(self):
12129 
    L = ['%s=%r' % (key, value)
12130 
      for key, value in self.__dict__.iteritems()]
12131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12132 
 
12133 
  def __eq__(self, other):
12134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12135 
 
12136 
  def __ne__(self, other):
12137 
    return not (self == other)
12138 
 
12139 
class markOrderReturnRequestAuthorized_args:
12140 
  """
12141 
  Attributes:
12142 
   - orderId
12143 
   - isAuthorized
12144 
  """
12145 
 
12146 
  thrift_spec = (
12147 
    None, # 0
12148 
    (1, TType.I64, 'orderId', None, None, ), # 1
12149 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12150 
  )
12151 
 
12152 
  def __init__(self, orderId=None, isAuthorized=None,):
12153 
    self.orderId = orderId
12154 
    self.isAuthorized = isAuthorized
12155 
 
12156 
  def read(self, iprot):
12157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12159 
      return
12160 
    iprot.readStructBegin()
12161 
    while True:
12162 
      (fname, ftype, fid) = iprot.readFieldBegin()
12163 
      if ftype == TType.STOP:
12164 
        break
12165 
      if fid == 1:
12166 
        if ftype == TType.I64:
12167 
          self.orderId = iprot.readI64();
12168 
        else:
12169 
          iprot.skip(ftype)
12170 
      elif fid == 2:
12171 
        if ftype == TType.BOOL:
12172 
          self.isAuthorized = iprot.readBool();
12173 
        else:
12174 
          iprot.skip(ftype)
12175 
      else:
12176 
        iprot.skip(ftype)
12177 
      iprot.readFieldEnd()
12178 
    iprot.readStructEnd()
12179 
 
12180 
  def write(self, oprot):
12181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12183 
      return
12184 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
12185 
    if self.orderId is not None:
12186 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12187 
      oprot.writeI64(self.orderId)
12188 
      oprot.writeFieldEnd()
12189 
    if self.isAuthorized is not None:
12190 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12191 
      oprot.writeBool(self.isAuthorized)
12192 
      oprot.writeFieldEnd()
12193 
    oprot.writeFieldStop()
12194 
    oprot.writeStructEnd()
12195 
 
12196 
  def validate(self):
12197 
    return
12198 
 
12199 
 
12200 
  def __repr__(self):
12201 
    L = ['%s=%r' % (key, value)
12202 
      for key, value in self.__dict__.iteritems()]
12203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12204 
 
12205 
  def __eq__(self, other):
12206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12207 
 
12208 
  def __ne__(self, other):
12209 
    return not (self == other)
12210 
 
12211 
class markOrderReturnRequestAuthorized_result:
12212 
  """
12213 
  Attributes:
12214 
   - success
12215 
   - ex
12216 
  """
12217 
 
12218 
  thrift_spec = (
12219 
    (0, TType.BOOL, 'success', None, None, ), # 0
12220 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12221 
  )
12222 
 
12223 
  def __init__(self, success=None, ex=None,):
12224 
    self.success = success
12225 
    self.ex = ex
12226 
 
12227 
  def read(self, iprot):
12228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12230 
      return
12231 
    iprot.readStructBegin()
12232 
    while True:
12233 
      (fname, ftype, fid) = iprot.readFieldBegin()
12234 
      if ftype == TType.STOP:
12235 
        break
12236 
      if fid == 0:
12237 
        if ftype == TType.BOOL:
12238 
          self.success = iprot.readBool();
12239 
        else:
12240 
          iprot.skip(ftype)
12241 
      elif fid == 1:
12242 
        if ftype == TType.STRUCT:
12243 
          self.ex = TransactionServiceException()
12244 
          self.ex.read(iprot)
12245 
        else:
12246 
          iprot.skip(ftype)
12247 
      else:
12248 
        iprot.skip(ftype)
12249 
      iprot.readFieldEnd()
12250 
    iprot.readStructEnd()
12251 
 
12252 
  def write(self, oprot):
12253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12255 
      return
12256 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
12257 
    if self.success is not None:
12258 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12259 
      oprot.writeBool(self.success)
12260 
      oprot.writeFieldEnd()
12261 
    if self.ex is not None:
12262 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12263 
      self.ex.write(oprot)
12264 
      oprot.writeFieldEnd()
12265 
    oprot.writeFieldStop()
12266 
    oprot.writeStructEnd()
12267 
 
12268 
  def validate(self):
12269 
    return
12270 
 
12271 
 
12272 
  def __repr__(self):
12273 
    L = ['%s=%r' % (key, value)
12274 
      for key, value in self.__dict__.iteritems()]
12275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12276 
 
12277 
  def __eq__(self, other):
12278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12279 
 
12280 
  def __ne__(self, other):
12281 
    return not (self == other)
12282 
 
2536 chandransh 12283 
class requestPickupNumber_args:
12284 
  """
12285 
  Attributes:
12286 
   - orderId
4579 rajveer 12287 
   - providerId
2536 chandransh 12288 
  """
12289 
 
12290 
  thrift_spec = (
12291 
    None, # 0
12292 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 12293 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 12294 
  )
12295 
 
4579 rajveer 12296 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 12297 
    self.orderId = orderId
4579 rajveer 12298 
    self.providerId = providerId
2536 chandransh 12299 
 
12300 
  def read(self, iprot):
12301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12303 
      return
12304 
    iprot.readStructBegin()
12305 
    while True:
12306 
      (fname, ftype, fid) = iprot.readFieldBegin()
12307 
      if ftype == TType.STOP:
12308 
        break
12309 
      if fid == 1:
12310 
        if ftype == TType.I64:
12311 
          self.orderId = iprot.readI64();
12312 
        else:
12313 
          iprot.skip(ftype)
4579 rajveer 12314 
      elif fid == 2:
12315 
        if ftype == TType.I64:
12316 
          self.providerId = iprot.readI64();
12317 
        else:
12318 
          iprot.skip(ftype)
2536 chandransh 12319 
      else:
12320 
        iprot.skip(ftype)
12321 
      iprot.readFieldEnd()
12322 
    iprot.readStructEnd()
12323 
 
12324 
  def write(self, oprot):
12325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12327 
      return
12328 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 12329 
    if self.orderId is not None:
2536 chandransh 12330 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12331 
      oprot.writeI64(self.orderId)
12332 
      oprot.writeFieldEnd()
4579 rajveer 12333 
    if self.providerId is not None:
12334 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
12335 
      oprot.writeI64(self.providerId)
12336 
      oprot.writeFieldEnd()
2536 chandransh 12337 
    oprot.writeFieldStop()
12338 
    oprot.writeStructEnd()
12339 
 
3431 rajveer 12340 
  def validate(self):
12341 
    return
12342 
 
12343 
 
2536 chandransh 12344 
  def __repr__(self):
12345 
    L = ['%s=%r' % (key, value)
12346 
      for key, value in self.__dict__.iteritems()]
12347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12348 
 
12349 
  def __eq__(self, other):
12350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12351 
 
12352 
  def __ne__(self, other):
12353 
    return not (self == other)
12354 
 
12355 
class requestPickupNumber_result:
12356 
  """
12357 
  Attributes:
12358 
   - success
12359 
   - ex
12360 
  """
12361 
 
12362 
  thrift_spec = (
12363 
    (0, TType.BOOL, 'success', None, None, ), # 0
12364 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12365 
  )
12366 
 
12367 
  def __init__(self, success=None, ex=None,):
12368 
    self.success = success
12369 
    self.ex = ex
12370 
 
12371 
  def read(self, iprot):
12372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12374 
      return
12375 
    iprot.readStructBegin()
12376 
    while True:
12377 
      (fname, ftype, fid) = iprot.readFieldBegin()
12378 
      if ftype == TType.STOP:
12379 
        break
12380 
      if fid == 0:
12381 
        if ftype == TType.BOOL:
12382 
          self.success = iprot.readBool();
12383 
        else:
12384 
          iprot.skip(ftype)
12385 
      elif fid == 1:
12386 
        if ftype == TType.STRUCT:
12387 
          self.ex = TransactionServiceException()
12388 
          self.ex.read(iprot)
12389 
        else:
12390 
          iprot.skip(ftype)
12391 
      else:
12392 
        iprot.skip(ftype)
12393 
      iprot.readFieldEnd()
12394 
    iprot.readStructEnd()
12395 
 
12396 
  def write(self, oprot):
12397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12399 
      return
12400 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 12401 
    if self.success is not None:
2536 chandransh 12402 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12403 
      oprot.writeBool(self.success)
12404 
      oprot.writeFieldEnd()
3431 rajveer 12405 
    if self.ex is not None:
2536 chandransh 12406 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12407 
      self.ex.write(oprot)
12408 
      oprot.writeFieldEnd()
12409 
    oprot.writeFieldStop()
12410 
    oprot.writeStructEnd()
12411 
 
3431 rajveer 12412 
  def validate(self):
12413 
    return
12414 
 
12415 
 
2536 chandransh 12416 
  def __repr__(self):
12417 
    L = ['%s=%r' % (key, value)
12418 
      for key, value in self.__dict__.iteritems()]
12419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12420 
 
12421 
  def __eq__(self, other):
12422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12423 
 
12424 
  def __ne__(self, other):
12425 
    return not (self == other)
12426 
 
12427 
class authorizePickup_args:
12428 
  """
12429 
  Attributes:
12430 
   - orderId
12431 
   - pickupNumber
4602 rajveer 12432 
   - providerId
2536 chandransh 12433 
  """
12434 
 
12435 
  thrift_spec = (
12436 
    None, # 0
12437 
    (1, TType.I64, 'orderId', None, None, ), # 1
12438 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 12439 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 12440 
  )
12441 
 
4602 rajveer 12442 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 12443 
    self.orderId = orderId
12444 
    self.pickupNumber = pickupNumber
4602 rajveer 12445 
    self.providerId = providerId
2536 chandransh 12446 
 
12447 
  def read(self, iprot):
12448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12450 
      return
12451 
    iprot.readStructBegin()
12452 
    while True:
12453 
      (fname, ftype, fid) = iprot.readFieldBegin()
12454 
      if ftype == TType.STOP:
12455 
        break
12456 
      if fid == 1:
12457 
        if ftype == TType.I64:
12458 
          self.orderId = iprot.readI64();
12459 
        else:
12460 
          iprot.skip(ftype)
12461 
      elif fid == 2:
12462 
        if ftype == TType.STRING:
12463 
          self.pickupNumber = iprot.readString();
12464 
        else:
12465 
          iprot.skip(ftype)
4602 rajveer 12466 
      elif fid == 3:
12467 
        if ftype == TType.I64:
12468 
          self.providerId = iprot.readI64();
12469 
        else:
12470 
          iprot.skip(ftype)
2536 chandransh 12471 
      else:
12472 
        iprot.skip(ftype)
12473 
      iprot.readFieldEnd()
12474 
    iprot.readStructEnd()
12475 
 
12476 
  def write(self, oprot):
12477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12479 
      return
12480 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 12481 
    if self.orderId is not None:
2536 chandransh 12482 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12483 
      oprot.writeI64(self.orderId)
12484 
      oprot.writeFieldEnd()
3431 rajveer 12485 
    if self.pickupNumber is not None:
2536 chandransh 12486 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
12487 
      oprot.writeString(self.pickupNumber)
12488 
      oprot.writeFieldEnd()
4602 rajveer 12489 
    if self.providerId is not None:
12490 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
12491 
      oprot.writeI64(self.providerId)
12492 
      oprot.writeFieldEnd()
2536 chandransh 12493 
    oprot.writeFieldStop()
12494 
    oprot.writeStructEnd()
12495 
 
3431 rajveer 12496 
  def validate(self):
12497 
    return
12498 
 
12499 
 
2536 chandransh 12500 
  def __repr__(self):
12501 
    L = ['%s=%r' % (key, value)
12502 
      for key, value in self.__dict__.iteritems()]
12503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12504 
 
12505 
  def __eq__(self, other):
12506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12507 
 
12508 
  def __ne__(self, other):
12509 
    return not (self == other)
12510 
 
12511 
class authorizePickup_result:
12512 
  """
12513 
  Attributes:
12514 
   - success
12515 
   - ex
12516 
  """
12517 
 
12518 
  thrift_spec = (
12519 
    (0, TType.BOOL, 'success', None, None, ), # 0
12520 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12521 
  )
12522 
 
12523 
  def __init__(self, success=None, ex=None,):
12524 
    self.success = success
12525 
    self.ex = ex
12526 
 
12527 
  def read(self, iprot):
12528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12530 
      return
12531 
    iprot.readStructBegin()
12532 
    while True:
12533 
      (fname, ftype, fid) = iprot.readFieldBegin()
12534 
      if ftype == TType.STOP:
12535 
        break
12536 
      if fid == 0:
12537 
        if ftype == TType.BOOL:
12538 
          self.success = iprot.readBool();
12539 
        else:
12540 
          iprot.skip(ftype)
12541 
      elif fid == 1:
12542 
        if ftype == TType.STRUCT:
12543 
          self.ex = TransactionServiceException()
12544 
          self.ex.read(iprot)
12545 
        else:
12546 
          iprot.skip(ftype)
12547 
      else:
12548 
        iprot.skip(ftype)
12549 
      iprot.readFieldEnd()
12550 
    iprot.readStructEnd()
12551 
 
12552 
  def write(self, oprot):
12553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12555 
      return
12556 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 12557 
    if self.success is not None:
2536 chandransh 12558 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12559 
      oprot.writeBool(self.success)
12560 
      oprot.writeFieldEnd()
3431 rajveer 12561 
    if self.ex is not None:
2536 chandransh 12562 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12563 
      self.ex.write(oprot)
12564 
      oprot.writeFieldEnd()
12565 
    oprot.writeFieldStop()
12566 
    oprot.writeStructEnd()
12567 
 
3431 rajveer 12568 
  def validate(self):
12569 
    return
12570 
 
12571 
 
2536 chandransh 12572 
  def __repr__(self):
12573 
    L = ['%s=%r' % (key, value)
12574 
      for key, value in self.__dict__.iteritems()]
12575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12576 
 
12577 
  def __eq__(self, other):
12578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12579 
 
12580 
  def __ne__(self, other):
12581 
    return not (self == other)
12582 
 
2764 chandransh 12583 
class markDoasAsPickedUp_args:
12584 
  """
12585 
  Attributes:
12586 
   - providerId
12587 
   - pickupDetails
12588 
  """
12589 
 
12590 
  thrift_spec = (
12591 
    None, # 0
12592 
    (1, TType.I64, 'providerId', None, None, ), # 1
12593 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
12594 
  )
12595 
 
12596 
  def __init__(self, providerId=None, pickupDetails=None,):
12597 
    self.providerId = providerId
12598 
    self.pickupDetails = pickupDetails
12599 
 
12600 
  def read(self, iprot):
12601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12603 
      return
12604 
    iprot.readStructBegin()
12605 
    while True:
12606 
      (fname, ftype, fid) = iprot.readFieldBegin()
12607 
      if ftype == TType.STOP:
12608 
        break
12609 
      if fid == 1:
12610 
        if ftype == TType.I64:
12611 
          self.providerId = iprot.readI64();
12612 
        else:
12613 
          iprot.skip(ftype)
12614 
      elif fid == 2:
12615 
        if ftype == TType.MAP:
12616 
          self.pickupDetails = {}
4581 phani.kuma 12617 
          (_ktype198, _vtype199, _size197 ) = iprot.readMapBegin()
12618 
          for _i201 in xrange(_size197):
12619 
            _key202 = iprot.readString();
12620 
            _val203 = iprot.readString();
12621 
            self.pickupDetails[_key202] = _val203
2764 chandransh 12622 
          iprot.readMapEnd()
12623 
        else:
12624 
          iprot.skip(ftype)
12625 
      else:
12626 
        iprot.skip(ftype)
12627 
      iprot.readFieldEnd()
12628 
    iprot.readStructEnd()
12629 
 
12630 
  def write(self, oprot):
12631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12633 
      return
12634 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 12635 
    if self.providerId is not None:
2764 chandransh 12636 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12637 
      oprot.writeI64(self.providerId)
12638 
      oprot.writeFieldEnd()
3431 rajveer 12639 
    if self.pickupDetails is not None:
2764 chandransh 12640 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12641 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4581 phani.kuma 12642 
      for kiter204,viter205 in self.pickupDetails.items():
12643 
        oprot.writeString(kiter204)
12644 
        oprot.writeString(viter205)
2764 chandransh 12645 
      oprot.writeMapEnd()
12646 
      oprot.writeFieldEnd()
12647 
    oprot.writeFieldStop()
12648 
    oprot.writeStructEnd()
12649 
 
3431 rajveer 12650 
  def validate(self):
12651 
    return
12652 
 
12653 
 
2764 chandransh 12654 
  def __repr__(self):
12655 
    L = ['%s=%r' % (key, value)
12656 
      for key, value in self.__dict__.iteritems()]
12657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12658 
 
12659 
  def __eq__(self, other):
12660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12661 
 
12662 
  def __ne__(self, other):
12663 
    return not (self == other)
12664 
 
12665 
class markDoasAsPickedUp_result:
12666 
  """
12667 
  Attributes:
12668 
   - success
12669 
  """
12670 
 
12671 
  thrift_spec = (
12672 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12673 
  )
12674 
 
12675 
  def __init__(self, success=None,):
12676 
    self.success = success
12677 
 
12678 
  def read(self, iprot):
12679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12681 
      return
12682 
    iprot.readStructBegin()
12683 
    while True:
12684 
      (fname, ftype, fid) = iprot.readFieldBegin()
12685 
      if ftype == TType.STOP:
12686 
        break
12687 
      if fid == 0:
12688 
        if ftype == TType.LIST:
12689 
          self.success = []
4581 phani.kuma 12690 
          (_etype209, _size206) = iprot.readListBegin()
12691 
          for _i210 in xrange(_size206):
12692 
            _elem211 = Order()
12693 
            _elem211.read(iprot)
12694 
            self.success.append(_elem211)
2764 chandransh 12695 
          iprot.readListEnd()
12696 
        else:
12697 
          iprot.skip(ftype)
12698 
      else:
12699 
        iprot.skip(ftype)
12700 
      iprot.readFieldEnd()
12701 
    iprot.readStructEnd()
12702 
 
12703 
  def write(self, oprot):
12704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12706 
      return
12707 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 12708 
    if self.success is not None:
2764 chandransh 12709 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12710 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 12711 
      for iter212 in self.success:
12712 
        iter212.write(oprot)
2764 chandransh 12713 
      oprot.writeListEnd()
12714 
      oprot.writeFieldEnd()
12715 
    oprot.writeFieldStop()
12716 
    oprot.writeStructEnd()
12717 
 
3431 rajveer 12718 
  def validate(self):
12719 
    return
12720 
 
12721 
 
2764 chandransh 12722 
  def __repr__(self):
12723 
    L = ['%s=%r' % (key, value)
12724 
      for key, value in self.__dict__.iteritems()]
12725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12726 
 
12727 
  def __eq__(self, other):
12728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12729 
 
12730 
  def __ne__(self, other):
12731 
    return not (self == other)
12732 
 
2616 chandransh 12733 
class receiveReturn_args:
2591 chandransh 12734 
  """
12735 
  Attributes:
12736 
   - orderId
4479 rajveer 12737 
   - receiveCondition
2591 chandransh 12738 
  """
2536 chandransh 12739 
 
2591 chandransh 12740 
  thrift_spec = (
12741 
    None, # 0
12742 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 12743 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 12744 
  )
12745 
 
4479 rajveer 12746 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 12747 
    self.orderId = orderId
4479 rajveer 12748 
    self.receiveCondition = receiveCondition
2591 chandransh 12749 
 
12750 
  def read(self, iprot):
12751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12753 
      return
12754 
    iprot.readStructBegin()
12755 
    while True:
12756 
      (fname, ftype, fid) = iprot.readFieldBegin()
12757 
      if ftype == TType.STOP:
12758 
        break
12759 
      if fid == 1:
12760 
        if ftype == TType.I64:
12761 
          self.orderId = iprot.readI64();
12762 
        else:
12763 
          iprot.skip(ftype)
4479 rajveer 12764 
      elif fid == 2:
12765 
        if ftype == TType.I64:
12766 
          self.receiveCondition = iprot.readI64();
12767 
        else:
12768 
          iprot.skip(ftype)
2591 chandransh 12769 
      else:
12770 
        iprot.skip(ftype)
12771 
      iprot.readFieldEnd()
12772 
    iprot.readStructEnd()
12773 
 
12774 
  def write(self, oprot):
12775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12777 
      return
2616 chandransh 12778 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 12779 
    if self.orderId is not None:
2591 chandransh 12780 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12781 
      oprot.writeI64(self.orderId)
12782 
      oprot.writeFieldEnd()
4479 rajveer 12783 
    if self.receiveCondition is not None:
12784 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
12785 
      oprot.writeI64(self.receiveCondition)
12786 
      oprot.writeFieldEnd()
2591 chandransh 12787 
    oprot.writeFieldStop()
12788 
    oprot.writeStructEnd()
12789 
 
3431 rajveer 12790 
  def validate(self):
12791 
    return
12792 
 
12793 
 
2591 chandransh 12794 
  def __repr__(self):
12795 
    L = ['%s=%r' % (key, value)
12796 
      for key, value in self.__dict__.iteritems()]
12797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12798 
 
12799 
  def __eq__(self, other):
12800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12801 
 
12802 
  def __ne__(self, other):
12803 
    return not (self == other)
12804 
 
2616 chandransh 12805 
class receiveReturn_result:
2591 chandransh 12806 
  """
12807 
  Attributes:
12808 
   - success
12809 
   - ex
12810 
  """
12811 
 
12812 
  thrift_spec = (
12813 
    (0, TType.BOOL, 'success', None, None, ), # 0
12814 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12815 
  )
12816 
 
12817 
  def __init__(self, success=None, ex=None,):
12818 
    self.success = success
12819 
    self.ex = ex
12820 
 
12821 
  def read(self, iprot):
12822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12824 
      return
12825 
    iprot.readStructBegin()
12826 
    while True:
12827 
      (fname, ftype, fid) = iprot.readFieldBegin()
12828 
      if ftype == TType.STOP:
12829 
        break
12830 
      if fid == 0:
12831 
        if ftype == TType.BOOL:
12832 
          self.success = iprot.readBool();
12833 
        else:
12834 
          iprot.skip(ftype)
12835 
      elif fid == 1:
12836 
        if ftype == TType.STRUCT:
12837 
          self.ex = TransactionServiceException()
12838 
          self.ex.read(iprot)
12839 
        else:
12840 
          iprot.skip(ftype)
12841 
      else:
12842 
        iprot.skip(ftype)
12843 
      iprot.readFieldEnd()
12844 
    iprot.readStructEnd()
12845 
 
12846 
  def write(self, oprot):
12847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12849 
      return
2616 chandransh 12850 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 12851 
    if self.success is not None:
2591 chandransh 12852 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12853 
      oprot.writeBool(self.success)
12854 
      oprot.writeFieldEnd()
3431 rajveer 12855 
    if self.ex is not None:
2591 chandransh 12856 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12857 
      self.ex.write(oprot)
12858 
      oprot.writeFieldEnd()
12859 
    oprot.writeFieldStop()
12860 
    oprot.writeStructEnd()
12861 
 
3431 rajveer 12862 
  def validate(self):
12863 
    return
12864 
 
12865 
 
2591 chandransh 12866 
  def __repr__(self):
12867 
    L = ['%s=%r' % (key, value)
12868 
      for key, value in self.__dict__.iteritems()]
12869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12870 
 
12871 
  def __eq__(self, other):
12872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12873 
 
12874 
  def __ne__(self, other):
12875 
    return not (self == other)
12876 
 
12877 
class validateDoa_args:
12878 
  """
12879 
  Attributes:
12880 
   - orderId
12881 
   - isValid
12882 
  """
12883 
 
12884 
  thrift_spec = (
12885 
    None, # 0
12886 
    (1, TType.I64, 'orderId', None, None, ), # 1
12887 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
12888 
  )
12889 
 
12890 
  def __init__(self, orderId=None, isValid=None,):
12891 
    self.orderId = orderId
12892 
    self.isValid = isValid
12893 
 
12894 
  def read(self, iprot):
12895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12897 
      return
12898 
    iprot.readStructBegin()
12899 
    while True:
12900 
      (fname, ftype, fid) = iprot.readFieldBegin()
12901 
      if ftype == TType.STOP:
12902 
        break
12903 
      if fid == 1:
12904 
        if ftype == TType.I64:
12905 
          self.orderId = iprot.readI64();
12906 
        else:
12907 
          iprot.skip(ftype)
12908 
      elif fid == 2:
12909 
        if ftype == TType.BOOL:
12910 
          self.isValid = iprot.readBool();
12911 
        else:
12912 
          iprot.skip(ftype)
12913 
      else:
12914 
        iprot.skip(ftype)
12915 
      iprot.readFieldEnd()
12916 
    iprot.readStructEnd()
12917 
 
12918 
  def write(self, oprot):
12919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12921 
      return
12922 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 12923 
    if self.orderId is not None:
2591 chandransh 12924 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12925 
      oprot.writeI64(self.orderId)
12926 
      oprot.writeFieldEnd()
3431 rajveer 12927 
    if self.isValid is not None:
2591 chandransh 12928 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
12929 
      oprot.writeBool(self.isValid)
12930 
      oprot.writeFieldEnd()
12931 
    oprot.writeFieldStop()
12932 
    oprot.writeStructEnd()
12933 
 
3431 rajveer 12934 
  def validate(self):
12935 
    return
12936 
 
12937 
 
2591 chandransh 12938 
  def __repr__(self):
12939 
    L = ['%s=%r' % (key, value)
12940 
      for key, value in self.__dict__.iteritems()]
12941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12942 
 
12943 
  def __eq__(self, other):
12944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12945 
 
12946 
  def __ne__(self, other):
12947 
    return not (self == other)
12948 
 
12949 
class validateDoa_result:
12950 
  """
12951 
  Attributes:
12952 
   - success
12953 
   - ex
12954 
  """
12955 
 
12956 
  thrift_spec = (
12957 
    (0, TType.BOOL, 'success', None, None, ), # 0
12958 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12959 
  )
12960 
 
12961 
  def __init__(self, success=None, ex=None,):
12962 
    self.success = success
12963 
    self.ex = ex
12964 
 
12965 
  def read(self, iprot):
12966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12968 
      return
12969 
    iprot.readStructBegin()
12970 
    while True:
12971 
      (fname, ftype, fid) = iprot.readFieldBegin()
12972 
      if ftype == TType.STOP:
12973 
        break
12974 
      if fid == 0:
12975 
        if ftype == TType.BOOL:
12976 
          self.success = iprot.readBool();
12977 
        else:
12978 
          iprot.skip(ftype)
12979 
      elif fid == 1:
12980 
        if ftype == TType.STRUCT:
12981 
          self.ex = TransactionServiceException()
12982 
          self.ex.read(iprot)
12983 
        else:
12984 
          iprot.skip(ftype)
12985 
      else:
12986 
        iprot.skip(ftype)
12987 
      iprot.readFieldEnd()
12988 
    iprot.readStructEnd()
12989 
 
12990 
  def write(self, oprot):
12991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12993 
      return
12994 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 12995 
    if self.success is not None:
2591 chandransh 12996 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12997 
      oprot.writeBool(self.success)
12998 
      oprot.writeFieldEnd()
3431 rajveer 12999 
    if self.ex is not None:
2591 chandransh 13000 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13001 
      self.ex.write(oprot)
13002 
      oprot.writeFieldEnd()
13003 
    oprot.writeFieldStop()
13004 
    oprot.writeStructEnd()
13005 
 
3431 rajveer 13006 
  def validate(self):
13007 
    return
13008 
 
13009 
 
2591 chandransh 13010 
  def __repr__(self):
13011 
    L = ['%s=%r' % (key, value)
13012 
      for key, value in self.__dict__.iteritems()]
13013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13014 
 
13015 
  def __eq__(self, other):
13016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13017 
 
13018 
  def __ne__(self, other):
13019 
    return not (self == other)
13020 
 
4495 rajveer 13021 
class validateReturnProduct_args:
13022 
  """
13023 
  Attributes:
13024 
   - orderId
13025 
   - isUsable
13026 
  """
13027 
 
13028 
  thrift_spec = (
13029 
    None, # 0
13030 
    (1, TType.I64, 'orderId', None, None, ), # 1
13031 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
13032 
  )
13033 
 
13034 
  def __init__(self, orderId=None, isUsable=None,):
13035 
    self.orderId = orderId
13036 
    self.isUsable = isUsable
13037 
 
13038 
  def read(self, iprot):
13039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13041 
      return
13042 
    iprot.readStructBegin()
13043 
    while True:
13044 
      (fname, ftype, fid) = iprot.readFieldBegin()
13045 
      if ftype == TType.STOP:
13046 
        break
13047 
      if fid == 1:
13048 
        if ftype == TType.I64:
13049 
          self.orderId = iprot.readI64();
13050 
        else:
13051 
          iprot.skip(ftype)
13052 
      elif fid == 2:
13053 
        if ftype == TType.BOOL:
13054 
          self.isUsable = iprot.readBool();
13055 
        else:
13056 
          iprot.skip(ftype)
13057 
      else:
13058 
        iprot.skip(ftype)
13059 
      iprot.readFieldEnd()
13060 
    iprot.readStructEnd()
13061 
 
13062 
  def write(self, oprot):
13063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13065 
      return
13066 
    oprot.writeStructBegin('validateReturnProduct_args')
13067 
    if self.orderId is not None:
13068 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13069 
      oprot.writeI64(self.orderId)
13070 
      oprot.writeFieldEnd()
13071 
    if self.isUsable is not None:
13072 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
13073 
      oprot.writeBool(self.isUsable)
13074 
      oprot.writeFieldEnd()
13075 
    oprot.writeFieldStop()
13076 
    oprot.writeStructEnd()
13077 
 
13078 
  def validate(self):
13079 
    return
13080 
 
13081 
 
13082 
  def __repr__(self):
13083 
    L = ['%s=%r' % (key, value)
13084 
      for key, value in self.__dict__.iteritems()]
13085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13086 
 
13087 
  def __eq__(self, other):
13088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13089 
 
13090 
  def __ne__(self, other):
13091 
    return not (self == other)
13092 
 
13093 
class validateReturnProduct_result:
13094 
  """
13095 
  Attributes:
13096 
   - success
13097 
   - ex
13098 
  """
13099 
 
13100 
  thrift_spec = (
13101 
    (0, TType.BOOL, 'success', None, None, ), # 0
13102 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13103 
  )
13104 
 
13105 
  def __init__(self, success=None, ex=None,):
13106 
    self.success = success
13107 
    self.ex = ex
13108 
 
13109 
  def read(self, iprot):
13110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13112 
      return
13113 
    iprot.readStructBegin()
13114 
    while True:
13115 
      (fname, ftype, fid) = iprot.readFieldBegin()
13116 
      if ftype == TType.STOP:
13117 
        break
13118 
      if fid == 0:
13119 
        if ftype == TType.BOOL:
13120 
          self.success = iprot.readBool();
13121 
        else:
13122 
          iprot.skip(ftype)
13123 
      elif fid == 1:
13124 
        if ftype == TType.STRUCT:
13125 
          self.ex = TransactionServiceException()
13126 
          self.ex.read(iprot)
13127 
        else:
13128 
          iprot.skip(ftype)
13129 
      else:
13130 
        iprot.skip(ftype)
13131 
      iprot.readFieldEnd()
13132 
    iprot.readStructEnd()
13133 
 
13134 
  def write(self, oprot):
13135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13137 
      return
13138 
    oprot.writeStructBegin('validateReturnProduct_result')
13139 
    if self.success is not None:
13140 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13141 
      oprot.writeBool(self.success)
13142 
      oprot.writeFieldEnd()
13143 
    if self.ex is not None:
13144 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13145 
      self.ex.write(oprot)
13146 
      oprot.writeFieldEnd()
13147 
    oprot.writeFieldStop()
13148 
    oprot.writeStructEnd()
13149 
 
13150 
  def validate(self):
13151 
    return
13152 
 
13153 
 
13154 
  def __repr__(self):
13155 
    L = ['%s=%r' % (key, value)
13156 
      for key, value in self.__dict__.iteritems()]
13157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13158 
 
13159 
  def __eq__(self, other):
13160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13161 
 
13162 
  def __ne__(self, other):
13163 
    return not (self == other)
13164 
 
2616 chandransh 13165 
class reshipOrder_args:
13166 
  """
13167 
  Attributes:
13168 
   - orderId
13169 
  """
2591 chandransh 13170 
 
2616 chandransh 13171 
  thrift_spec = (
13172 
    None, # 0
13173 
    (1, TType.I64, 'orderId', None, None, ), # 1
13174 
  )
13175 
 
13176 
  def __init__(self, orderId=None,):
13177 
    self.orderId = orderId
13178 
 
13179 
  def read(self, iprot):
13180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13182 
      return
13183 
    iprot.readStructBegin()
13184 
    while True:
13185 
      (fname, ftype, fid) = iprot.readFieldBegin()
13186 
      if ftype == TType.STOP:
13187 
        break
13188 
      if fid == 1:
13189 
        if ftype == TType.I64:
13190 
          self.orderId = iprot.readI64();
13191 
        else:
13192 
          iprot.skip(ftype)
13193 
      else:
13194 
        iprot.skip(ftype)
13195 
      iprot.readFieldEnd()
13196 
    iprot.readStructEnd()
13197 
 
13198 
  def write(self, oprot):
13199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13201 
      return
13202 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 13203 
    if self.orderId is not None:
2616 chandransh 13204 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13205 
      oprot.writeI64(self.orderId)
13206 
      oprot.writeFieldEnd()
13207 
    oprot.writeFieldStop()
13208 
    oprot.writeStructEnd()
13209 
 
3431 rajveer 13210 
  def validate(self):
13211 
    return
13212 
 
13213 
 
2616 chandransh 13214 
  def __repr__(self):
13215 
    L = ['%s=%r' % (key, value)
13216 
      for key, value in self.__dict__.iteritems()]
13217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13218 
 
13219 
  def __eq__(self, other):
13220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13221 
 
13222 
  def __ne__(self, other):
13223 
    return not (self == other)
13224 
 
13225 
class reshipOrder_result:
13226 
  """
13227 
  Attributes:
13228 
   - success
13229 
   - ex
13230 
  """
13231 
 
13232 
  thrift_spec = (
13233 
    (0, TType.I64, 'success', None, None, ), # 0
13234 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13235 
  )
13236 
 
13237 
  def __init__(self, success=None, ex=None,):
13238 
    self.success = success
13239 
    self.ex = ex
13240 
 
13241 
  def read(self, iprot):
13242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13244 
      return
13245 
    iprot.readStructBegin()
13246 
    while True:
13247 
      (fname, ftype, fid) = iprot.readFieldBegin()
13248 
      if ftype == TType.STOP:
13249 
        break
13250 
      if fid == 0:
13251 
        if ftype == TType.I64:
13252 
          self.success = iprot.readI64();
13253 
        else:
13254 
          iprot.skip(ftype)
13255 
      elif fid == 1:
13256 
        if ftype == TType.STRUCT:
13257 
          self.ex = TransactionServiceException()
13258 
          self.ex.read(iprot)
13259 
        else:
13260 
          iprot.skip(ftype)
13261 
      else:
13262 
        iprot.skip(ftype)
13263 
      iprot.readFieldEnd()
13264 
    iprot.readStructEnd()
13265 
 
13266 
  def write(self, oprot):
13267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13269 
      return
13270 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 13271 
    if self.success is not None:
2616 chandransh 13272 
      oprot.writeFieldBegin('success', TType.I64, 0)
13273 
      oprot.writeI64(self.success)
13274 
      oprot.writeFieldEnd()
3431 rajveer 13275 
    if self.ex is not None:
2616 chandransh 13276 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13277 
      self.ex.write(oprot)
13278 
      oprot.writeFieldEnd()
13279 
    oprot.writeFieldStop()
13280 
    oprot.writeStructEnd()
13281 
 
3431 rajveer 13282 
  def validate(self):
13283 
    return
13284 
 
13285 
 
2616 chandransh 13286 
  def __repr__(self):
13287 
    L = ['%s=%r' % (key, value)
13288 
      for key, value in self.__dict__.iteritems()]
13289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13290 
 
13291 
  def __eq__(self, other):
13292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13293 
 
13294 
  def __ne__(self, other):
13295 
    return not (self == other)
13296 
 
13297 
class refundOrder_args:
13298 
  """
13299 
  Attributes:
13300 
   - orderId
3226 chandransh 13301 
   - refundedBy
13302 
   - reason
2616 chandransh 13303 
  """
13304 
 
13305 
  thrift_spec = (
13306 
    None, # 0
13307 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 13308 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13309 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 13310 
  )
13311 
 
3226 chandransh 13312 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 13313 
    self.orderId = orderId
3226 chandransh 13314 
    self.refundedBy = refundedBy
13315 
    self.reason = reason
2616 chandransh 13316 
 
13317 
  def read(self, iprot):
13318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13320 
      return
13321 
    iprot.readStructBegin()
13322 
    while True:
13323 
      (fname, ftype, fid) = iprot.readFieldBegin()
13324 
      if ftype == TType.STOP:
13325 
        break
13326 
      if fid == 1:
13327 
        if ftype == TType.I64:
13328 
          self.orderId = iprot.readI64();
13329 
        else:
13330 
          iprot.skip(ftype)
3226 chandransh 13331 
      elif fid == 2:
13332 
        if ftype == TType.STRING:
13333 
          self.refundedBy = iprot.readString();
13334 
        else:
13335 
          iprot.skip(ftype)
13336 
      elif fid == 3:
13337 
        if ftype == TType.STRING:
13338 
          self.reason = iprot.readString();
13339 
        else:
13340 
          iprot.skip(ftype)
2616 chandransh 13341 
      else:
13342 
        iprot.skip(ftype)
13343 
      iprot.readFieldEnd()
13344 
    iprot.readStructEnd()
13345 
 
13346 
  def write(self, oprot):
13347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13349 
      return
13350 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 13351 
    if self.orderId is not None:
2616 chandransh 13352 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13353 
      oprot.writeI64(self.orderId)
13354 
      oprot.writeFieldEnd()
3431 rajveer 13355 
    if self.refundedBy is not None:
3226 chandransh 13356 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13357 
      oprot.writeString(self.refundedBy)
13358 
      oprot.writeFieldEnd()
3431 rajveer 13359 
    if self.reason is not None:
3226 chandransh 13360 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13361 
      oprot.writeString(self.reason)
13362 
      oprot.writeFieldEnd()
2616 chandransh 13363 
    oprot.writeFieldStop()
13364 
    oprot.writeStructEnd()
13365 
 
3431 rajveer 13366 
  def validate(self):
13367 
    return
13368 
 
13369 
 
2616 chandransh 13370 
  def __repr__(self):
13371 
    L = ['%s=%r' % (key, value)
13372 
      for key, value in self.__dict__.iteritems()]
13373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13374 
 
13375 
  def __eq__(self, other):
13376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13377 
 
13378 
  def __ne__(self, other):
13379 
    return not (self == other)
13380 
 
13381 
class refundOrder_result:
13382 
  """
13383 
  Attributes:
13384 
   - success
13385 
   - ex
13386 
  """
13387 
 
13388 
  thrift_spec = (
13389 
    (0, TType.BOOL, 'success', None, None, ), # 0
13390 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13391 
  )
13392 
 
13393 
  def __init__(self, success=None, ex=None,):
13394 
    self.success = success
13395 
    self.ex = ex
13396 
 
13397 
  def read(self, iprot):
13398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13400 
      return
13401 
    iprot.readStructBegin()
13402 
    while True:
13403 
      (fname, ftype, fid) = iprot.readFieldBegin()
13404 
      if ftype == TType.STOP:
13405 
        break
13406 
      if fid == 0:
13407 
        if ftype == TType.BOOL:
13408 
          self.success = iprot.readBool();
13409 
        else:
13410 
          iprot.skip(ftype)
13411 
      elif fid == 1:
13412 
        if ftype == TType.STRUCT:
13413 
          self.ex = TransactionServiceException()
13414 
          self.ex.read(iprot)
13415 
        else:
13416 
          iprot.skip(ftype)
13417 
      else:
13418 
        iprot.skip(ftype)
13419 
      iprot.readFieldEnd()
13420 
    iprot.readStructEnd()
13421 
 
13422 
  def write(self, oprot):
13423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13425 
      return
13426 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 13427 
    if self.success is not None:
2616 chandransh 13428 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13429 
      oprot.writeBool(self.success)
13430 
      oprot.writeFieldEnd()
3431 rajveer 13431 
    if self.ex is not None:
2616 chandransh 13432 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13433 
      self.ex.write(oprot)
13434 
      oprot.writeFieldEnd()
13435 
    oprot.writeFieldStop()
13436 
    oprot.writeStructEnd()
13437 
 
3431 rajveer 13438 
  def validate(self):
13439 
    return
13440 
 
13441 
 
2616 chandransh 13442 
  def __repr__(self):
13443 
    L = ['%s=%r' % (key, value)
13444 
      for key, value in self.__dict__.iteritems()]
13445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13446 
 
13447 
  def __eq__(self, other):
13448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13449 
 
13450 
  def __ne__(self, other):
13451 
    return not (self == other)
13452 
 
2690 chandransh 13453 
class getReturnOrders_args:
13454 
  """
13455 
  Attributes:
13456 
   - warehouseId
13457 
   - fromDate
13458 
   - toDate
13459 
  """
2616 chandransh 13460 
 
2690 chandransh 13461 
  thrift_spec = (
13462 
    None, # 0
13463 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13464 
    (2, TType.I64, 'fromDate', None, None, ), # 2
13465 
    (3, TType.I64, 'toDate', None, None, ), # 3
13466 
  )
13467 
 
13468 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
13469 
    self.warehouseId = warehouseId
13470 
    self.fromDate = fromDate
13471 
    self.toDate = toDate
13472 
 
13473 
  def read(self, iprot):
13474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13476 
      return
13477 
    iprot.readStructBegin()
13478 
    while True:
13479 
      (fname, ftype, fid) = iprot.readFieldBegin()
13480 
      if ftype == TType.STOP:
13481 
        break
13482 
      if fid == 1:
13483 
        if ftype == TType.I64:
13484 
          self.warehouseId = iprot.readI64();
13485 
        else:
13486 
          iprot.skip(ftype)
13487 
      elif fid == 2:
13488 
        if ftype == TType.I64:
13489 
          self.fromDate = iprot.readI64();
13490 
        else:
13491 
          iprot.skip(ftype)
13492 
      elif fid == 3:
13493 
        if ftype == TType.I64:
13494 
          self.toDate = iprot.readI64();
13495 
        else:
13496 
          iprot.skip(ftype)
13497 
      else:
13498 
        iprot.skip(ftype)
13499 
      iprot.readFieldEnd()
13500 
    iprot.readStructEnd()
13501 
 
13502 
  def write(self, oprot):
13503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13505 
      return
13506 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 13507 
    if self.warehouseId is not None:
2690 chandransh 13508 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13509 
      oprot.writeI64(self.warehouseId)
13510 
      oprot.writeFieldEnd()
3431 rajveer 13511 
    if self.fromDate is not None:
2690 chandransh 13512 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
13513 
      oprot.writeI64(self.fromDate)
13514 
      oprot.writeFieldEnd()
3431 rajveer 13515 
    if self.toDate is not None:
2690 chandransh 13516 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
13517 
      oprot.writeI64(self.toDate)
13518 
      oprot.writeFieldEnd()
13519 
    oprot.writeFieldStop()
13520 
    oprot.writeStructEnd()
13521 
 
3431 rajveer 13522 
  def validate(self):
13523 
    return
13524 
 
13525 
 
2690 chandransh 13526 
  def __repr__(self):
13527 
    L = ['%s=%r' % (key, value)
13528 
      for key, value in self.__dict__.iteritems()]
13529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13530 
 
13531 
  def __eq__(self, other):
13532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13533 
 
13534 
  def __ne__(self, other):
13535 
    return not (self == other)
13536 
 
13537 
class getReturnOrders_result:
13538 
  """
13539 
  Attributes:
13540 
   - success
13541 
  """
13542 
 
13543 
  thrift_spec = (
13544 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
13545 
  )
13546 
 
13547 
  def __init__(self, success=None,):
13548 
    self.success = success
13549 
 
13550 
  def read(self, iprot):
13551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13553 
      return
13554 
    iprot.readStructBegin()
13555 
    while True:
13556 
      (fname, ftype, fid) = iprot.readFieldBegin()
13557 
      if ftype == TType.STOP:
13558 
        break
13559 
      if fid == 0:
13560 
        if ftype == TType.LIST:
13561 
          self.success = []
4581 phani.kuma 13562 
          (_etype216, _size213) = iprot.readListBegin()
13563 
          for _i217 in xrange(_size213):
13564 
            _elem218 = ReturnOrder()
13565 
            _elem218.read(iprot)
13566 
            self.success.append(_elem218)
2690 chandransh 13567 
          iprot.readListEnd()
13568 
        else:
13569 
          iprot.skip(ftype)
13570 
      else:
13571 
        iprot.skip(ftype)
13572 
      iprot.readFieldEnd()
13573 
    iprot.readStructEnd()
13574 
 
13575 
  def write(self, oprot):
13576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13578 
      return
13579 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 13580 
    if self.success is not None:
2690 chandransh 13581 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13582 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 13583 
      for iter219 in self.success:
13584 
        iter219.write(oprot)
2690 chandransh 13585 
      oprot.writeListEnd()
13586 
      oprot.writeFieldEnd()
13587 
    oprot.writeFieldStop()
13588 
    oprot.writeStructEnd()
13589 
 
3431 rajveer 13590 
  def validate(self):
13591 
    return
13592 
 
13593 
 
2690 chandransh 13594 
  def __repr__(self):
13595 
    L = ['%s=%r' % (key, value)
13596 
      for key, value in self.__dict__.iteritems()]
13597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13598 
 
13599 
  def __eq__(self, other):
13600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13601 
 
13602 
  def __ne__(self, other):
13603 
    return not (self == other)
13604 
 
2700 chandransh 13605 
class getReturnOrder_args:
13606 
  """
13607 
  Attributes:
13608 
   - id
13609 
  """
13610 
 
13611 
  thrift_spec = (
13612 
    None, # 0
13613 
    (1, TType.I64, 'id', None, None, ), # 1
13614 
  )
13615 
 
13616 
  def __init__(self, id=None,):
13617 
    self.id = id
13618 
 
13619 
  def read(self, iprot):
13620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13622 
      return
13623 
    iprot.readStructBegin()
13624 
    while True:
13625 
      (fname, ftype, fid) = iprot.readFieldBegin()
13626 
      if ftype == TType.STOP:
13627 
        break
13628 
      if fid == 1:
13629 
        if ftype == TType.I64:
13630 
          self.id = iprot.readI64();
13631 
        else:
13632 
          iprot.skip(ftype)
13633 
      else:
13634 
        iprot.skip(ftype)
13635 
      iprot.readFieldEnd()
13636 
    iprot.readStructEnd()
13637 
 
13638 
  def write(self, oprot):
13639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13641 
      return
13642 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 13643 
    if self.id is not None:
2700 chandransh 13644 
      oprot.writeFieldBegin('id', TType.I64, 1)
13645 
      oprot.writeI64(self.id)
13646 
      oprot.writeFieldEnd()
13647 
    oprot.writeFieldStop()
13648 
    oprot.writeStructEnd()
13649 
 
3431 rajveer 13650 
  def validate(self):
13651 
    return
13652 
 
13653 
 
2700 chandransh 13654 
  def __repr__(self):
13655 
    L = ['%s=%r' % (key, value)
13656 
      for key, value in self.__dict__.iteritems()]
13657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13658 
 
13659 
  def __eq__(self, other):
13660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13661 
 
13662 
  def __ne__(self, other):
13663 
    return not (self == other)
13664 
 
13665 
class getReturnOrder_result:
13666 
  """
13667 
  Attributes:
13668 
   - success
13669 
   - ex
13670 
  """
13671 
 
13672 
  thrift_spec = (
13673 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
13674 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13675 
  )
13676 
 
13677 
  def __init__(self, success=None, ex=None,):
13678 
    self.success = success
13679 
    self.ex = ex
13680 
 
13681 
  def read(self, iprot):
13682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13684 
      return
13685 
    iprot.readStructBegin()
13686 
    while True:
13687 
      (fname, ftype, fid) = iprot.readFieldBegin()
13688 
      if ftype == TType.STOP:
13689 
        break
13690 
      if fid == 0:
13691 
        if ftype == TType.STRUCT:
13692 
          self.success = ReturnOrder()
13693 
          self.success.read(iprot)
13694 
        else:
13695 
          iprot.skip(ftype)
13696 
      elif fid == 1:
13697 
        if ftype == TType.STRUCT:
13698 
          self.ex = TransactionServiceException()
13699 
          self.ex.read(iprot)
13700 
        else:
13701 
          iprot.skip(ftype)
13702 
      else:
13703 
        iprot.skip(ftype)
13704 
      iprot.readFieldEnd()
13705 
    iprot.readStructEnd()
13706 
 
13707 
  def write(self, oprot):
13708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13710 
      return
13711 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 13712 
    if self.success is not None:
2700 chandransh 13713 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13714 
      self.success.write(oprot)
13715 
      oprot.writeFieldEnd()
3431 rajveer 13716 
    if self.ex is not None:
2700 chandransh 13717 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13718 
      self.ex.write(oprot)
13719 
      oprot.writeFieldEnd()
13720 
    oprot.writeFieldStop()
13721 
    oprot.writeStructEnd()
13722 
 
3431 rajveer 13723 
  def validate(self):
13724 
    return
13725 
 
13726 
 
2700 chandransh 13727 
  def __repr__(self):
13728 
    L = ['%s=%r' % (key, value)
13729 
      for key, value in self.__dict__.iteritems()]
13730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13731 
 
13732 
  def __eq__(self, other):
13733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13734 
 
13735 
  def __ne__(self, other):
13736 
    return not (self == other)
13737 
 
2690 chandransh 13738 
class processReturn_args:
13739 
  """
13740 
  Attributes:
13741 
   - returnOrderId
13742 
  """
13743 
 
13744 
  thrift_spec = (
13745 
    None, # 0
13746 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
13747 
  )
13748 
 
13749 
  def __init__(self, returnOrderId=None,):
13750 
    self.returnOrderId = returnOrderId
13751 
 
13752 
  def read(self, iprot):
13753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13755 
      return
13756 
    iprot.readStructBegin()
13757 
    while True:
13758 
      (fname, ftype, fid) = iprot.readFieldBegin()
13759 
      if ftype == TType.STOP:
13760 
        break
13761 
      if fid == 1:
13762 
        if ftype == TType.I64:
13763 
          self.returnOrderId = iprot.readI64();
13764 
        else:
13765 
          iprot.skip(ftype)
13766 
      else:
13767 
        iprot.skip(ftype)
13768 
      iprot.readFieldEnd()
13769 
    iprot.readStructEnd()
13770 
 
13771 
  def write(self, oprot):
13772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13774 
      return
13775 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 13776 
    if self.returnOrderId is not None:
2690 chandransh 13777 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
13778 
      oprot.writeI64(self.returnOrderId)
13779 
      oprot.writeFieldEnd()
13780 
    oprot.writeFieldStop()
13781 
    oprot.writeStructEnd()
13782 
 
3431 rajveer 13783 
  def validate(self):
13784 
    return
13785 
 
13786 
 
2690 chandransh 13787 
  def __repr__(self):
13788 
    L = ['%s=%r' % (key, value)
13789 
      for key, value in self.__dict__.iteritems()]
13790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13791 
 
13792 
  def __eq__(self, other):
13793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13794 
 
13795 
  def __ne__(self, other):
13796 
    return not (self == other)
13797 
 
13798 
class processReturn_result:
13799 
  """
13800 
  Attributes:
13801 
   - ex
13802 
  """
13803 
 
13804 
  thrift_spec = (
13805 
    None, # 0
13806 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13807 
  )
13808 
 
13809 
  def __init__(self, ex=None,):
13810 
    self.ex = ex
13811 
 
13812 
  def read(self, iprot):
13813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13815 
      return
13816 
    iprot.readStructBegin()
13817 
    while True:
13818 
      (fname, ftype, fid) = iprot.readFieldBegin()
13819 
      if ftype == TType.STOP:
13820 
        break
13821 
      if fid == 1:
13822 
        if ftype == TType.STRUCT:
13823 
          self.ex = TransactionServiceException()
13824 
          self.ex.read(iprot)
13825 
        else:
13826 
          iprot.skip(ftype)
13827 
      else:
13828 
        iprot.skip(ftype)
13829 
      iprot.readFieldEnd()
13830 
    iprot.readStructEnd()
13831 
 
13832 
  def write(self, oprot):
13833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13835 
      return
13836 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 13837 
    if self.ex is not None:
2690 chandransh 13838 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13839 
      self.ex.write(oprot)
13840 
      oprot.writeFieldEnd()
13841 
    oprot.writeFieldStop()
13842 
    oprot.writeStructEnd()
13843 
 
3431 rajveer 13844 
  def validate(self):
13845 
    return
13846 
 
13847 
 
2690 chandransh 13848 
  def __repr__(self):
13849 
    L = ['%s=%r' % (key, value)
13850 
      for key, value in self.__dict__.iteritems()]
13851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13852 
 
13853 
  def __eq__(self, other):
13854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13855 
 
13856 
  def __ne__(self, other):
13857 
    return not (self == other)
13858 
 
2819 chandransh 13859 
class createPurchaseOrder_args:
13860 
  """
13861 
  Attributes:
13862 
   - warehouseId
13863 
  """
2690 chandransh 13864 
 
2819 chandransh 13865 
  thrift_spec = (
13866 
    None, # 0
13867 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13868 
  )
13869 
 
13870 
  def __init__(self, warehouseId=None,):
13871 
    self.warehouseId = warehouseId
13872 
 
13873 
  def read(self, iprot):
13874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13876 
      return
13877 
    iprot.readStructBegin()
13878 
    while True:
13879 
      (fname, ftype, fid) = iprot.readFieldBegin()
13880 
      if ftype == TType.STOP:
13881 
        break
13882 
      if fid == 1:
13883 
        if ftype == TType.I64:
13884 
          self.warehouseId = iprot.readI64();
13885 
        else:
13886 
          iprot.skip(ftype)
13887 
      else:
13888 
        iprot.skip(ftype)
13889 
      iprot.readFieldEnd()
13890 
    iprot.readStructEnd()
13891 
 
13892 
  def write(self, oprot):
13893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13895 
      return
13896 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 13897 
    if self.warehouseId is not None:
2819 chandransh 13898 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13899 
      oprot.writeI64(self.warehouseId)
13900 
      oprot.writeFieldEnd()
13901 
    oprot.writeFieldStop()
13902 
    oprot.writeStructEnd()
13903 
 
3431 rajveer 13904 
  def validate(self):
13905 
    return
13906 
 
13907 
 
2819 chandransh 13908 
  def __repr__(self):
13909 
    L = ['%s=%r' % (key, value)
13910 
      for key, value in self.__dict__.iteritems()]
13911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13912 
 
13913 
  def __eq__(self, other):
13914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13915 
 
13916 
  def __ne__(self, other):
13917 
    return not (self == other)
13918 
 
13919 
class createPurchaseOrder_result:
13920 
  """
13921 
  Attributes:
13922 
   - success
13923 
   - ex
13924 
  """
13925 
 
13926 
  thrift_spec = (
4586 mandeep.dh 13927 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
2819 chandransh 13928 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13929 
  )
13930 
 
13931 
  def __init__(self, success=None, ex=None,):
13932 
    self.success = success
13933 
    self.ex = ex
13934 
 
13935 
  def read(self, iprot):
13936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13938 
      return
13939 
    iprot.readStructBegin()
13940 
    while True:
13941 
      (fname, ftype, fid) = iprot.readFieldBegin()
13942 
      if ftype == TType.STOP:
13943 
        break
13944 
      if fid == 0:
4586 mandeep.dh 13945 
        if ftype == TType.LIST:
13946 
          self.success = []
13947 
          (_etype223, _size220) = iprot.readListBegin()
13948 
          for _i224 in xrange(_size220):
13949 
            _elem225 = iprot.readI64();
13950 
            self.success.append(_elem225)
13951 
          iprot.readListEnd()
2819 chandransh 13952 
        else:
13953 
          iprot.skip(ftype)
13954 
      elif fid == 1:
13955 
        if ftype == TType.STRUCT:
13956 
          self.ex = TransactionServiceException()
13957 
          self.ex.read(iprot)
13958 
        else:
13959 
          iprot.skip(ftype)
13960 
      else:
13961 
        iprot.skip(ftype)
13962 
      iprot.readFieldEnd()
13963 
    iprot.readStructEnd()
13964 
 
13965 
  def write(self, oprot):
13966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13968 
      return
13969 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 13970 
    if self.success is not None:
4586 mandeep.dh 13971 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13972 
      oprot.writeListBegin(TType.I64, len(self.success))
13973 
      for iter226 in self.success:
13974 
        oprot.writeI64(iter226)
13975 
      oprot.writeListEnd()
2819 chandransh 13976 
      oprot.writeFieldEnd()
3431 rajveer 13977 
    if self.ex is not None:
2819 chandransh 13978 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13979 
      self.ex.write(oprot)
13980 
      oprot.writeFieldEnd()
13981 
    oprot.writeFieldStop()
13982 
    oprot.writeStructEnd()
13983 
 
3431 rajveer 13984 
  def validate(self):
13985 
    return
13986 
 
13987 
 
2819 chandransh 13988 
  def __repr__(self):
13989 
    L = ['%s=%r' % (key, value)
13990 
      for key, value in self.__dict__.iteritems()]
13991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13992 
 
13993 
  def __eq__(self, other):
13994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13995 
 
13996 
  def __ne__(self, other):
13997 
    return not (self == other)
3451 chandransh 13998 
 
13999 
class updateWeight_args:
14000 
  """
14001 
  Attributes:
14002 
   - orderId
14003 
   - weight
14004 
  """
14005 
 
14006 
  thrift_spec = (
14007 
    None, # 0
14008 
    (1, TType.I64, 'orderId', None, None, ), # 1
14009 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
14010 
  )
14011 
 
14012 
  def __init__(self, orderId=None, weight=None,):
14013 
    self.orderId = orderId
14014 
    self.weight = weight
14015 
 
14016 
  def read(self, iprot):
14017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14019 
      return
14020 
    iprot.readStructBegin()
14021 
    while True:
14022 
      (fname, ftype, fid) = iprot.readFieldBegin()
14023 
      if ftype == TType.STOP:
14024 
        break
14025 
      if fid == 1:
14026 
        if ftype == TType.I64:
14027 
          self.orderId = iprot.readI64();
14028 
        else:
14029 
          iprot.skip(ftype)
14030 
      elif fid == 2:
14031 
        if ftype == TType.DOUBLE:
14032 
          self.weight = iprot.readDouble();
14033 
        else:
14034 
          iprot.skip(ftype)
14035 
      else:
14036 
        iprot.skip(ftype)
14037 
      iprot.readFieldEnd()
14038 
    iprot.readStructEnd()
14039 
 
14040 
  def write(self, oprot):
14041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14043 
      return
14044 
    oprot.writeStructBegin('updateWeight_args')
14045 
    if self.orderId is not None:
14046 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14047 
      oprot.writeI64(self.orderId)
14048 
      oprot.writeFieldEnd()
14049 
    if self.weight is not None:
14050 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
14051 
      oprot.writeDouble(self.weight)
14052 
      oprot.writeFieldEnd()
14053 
    oprot.writeFieldStop()
14054 
    oprot.writeStructEnd()
14055 
 
14056 
  def validate(self):
14057 
    return
14058 
 
14059 
 
14060 
  def __repr__(self):
14061 
    L = ['%s=%r' % (key, value)
14062 
      for key, value in self.__dict__.iteritems()]
14063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14064 
 
14065 
  def __eq__(self, other):
14066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14067 
 
14068 
  def __ne__(self, other):
14069 
    return not (self == other)
14070 
 
14071 
class updateWeight_result:
14072 
  """
14073 
  Attributes:
14074 
   - success
14075 
   - ex
14076 
  """
14077 
 
14078 
  thrift_spec = (
14079 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14080 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14081 
  )
14082 
 
14083 
  def __init__(self, success=None, ex=None,):
14084 
    self.success = success
14085 
    self.ex = ex
14086 
 
14087 
  def read(self, iprot):
14088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14090 
      return
14091 
    iprot.readStructBegin()
14092 
    while True:
14093 
      (fname, ftype, fid) = iprot.readFieldBegin()
14094 
      if ftype == TType.STOP:
14095 
        break
14096 
      if fid == 0:
14097 
        if ftype == TType.STRUCT:
14098 
          self.success = Order()
14099 
          self.success.read(iprot)
14100 
        else:
14101 
          iprot.skip(ftype)
14102 
      elif fid == 1:
14103 
        if ftype == TType.STRUCT:
14104 
          self.ex = TransactionServiceException()
14105 
          self.ex.read(iprot)
14106 
        else:
14107 
          iprot.skip(ftype)
14108 
      else:
14109 
        iprot.skip(ftype)
14110 
      iprot.readFieldEnd()
14111 
    iprot.readStructEnd()
14112 
 
14113 
  def write(self, oprot):
14114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14116 
      return
14117 
    oprot.writeStructBegin('updateWeight_result')
14118 
    if self.success is not None:
14119 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14120 
      self.success.write(oprot)
14121 
      oprot.writeFieldEnd()
14122 
    if self.ex is not None:
14123 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14124 
      self.ex.write(oprot)
14125 
      oprot.writeFieldEnd()
14126 
    oprot.writeFieldStop()
14127 
    oprot.writeStructEnd()
14128 
 
14129 
  def validate(self):
14130 
    return
14131 
 
14132 
 
14133 
  def __repr__(self):
14134 
    L = ['%s=%r' % (key, value)
14135 
      for key, value in self.__dict__.iteritems()]
14136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14137 
 
14138 
  def __eq__(self, other):
14139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14140 
 
14141 
  def __ne__(self, other):
14142 
    return not (self == other)
3469 chandransh 14143 
 
14144 
class changeItem_args:
14145 
  """
14146 
  Attributes:
14147 
   - orderId
14148 
   - itemId
14149 
  """
14150 
 
14151 
  thrift_spec = (
14152 
    None, # 0
14153 
    (1, TType.I64, 'orderId', None, None, ), # 1
14154 
    (2, TType.I64, 'itemId', None, None, ), # 2
14155 
  )
14156 
 
14157 
  def __init__(self, orderId=None, itemId=None,):
14158 
    self.orderId = orderId
14159 
    self.itemId = itemId
14160 
 
14161 
  def read(self, iprot):
14162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14164 
      return
14165 
    iprot.readStructBegin()
14166 
    while True:
14167 
      (fname, ftype, fid) = iprot.readFieldBegin()
14168 
      if ftype == TType.STOP:
14169 
        break
14170 
      if fid == 1:
14171 
        if ftype == TType.I64:
14172 
          self.orderId = iprot.readI64();
14173 
        else:
14174 
          iprot.skip(ftype)
14175 
      elif fid == 2:
14176 
        if ftype == TType.I64:
14177 
          self.itemId = iprot.readI64();
14178 
        else:
14179 
          iprot.skip(ftype)
14180 
      else:
14181 
        iprot.skip(ftype)
14182 
      iprot.readFieldEnd()
14183 
    iprot.readStructEnd()
14184 
 
14185 
  def write(self, oprot):
14186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14188 
      return
14189 
    oprot.writeStructBegin('changeItem_args')
14190 
    if self.orderId is not None:
14191 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14192 
      oprot.writeI64(self.orderId)
14193 
      oprot.writeFieldEnd()
14194 
    if self.itemId is not None:
14195 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14196 
      oprot.writeI64(self.itemId)
14197 
      oprot.writeFieldEnd()
14198 
    oprot.writeFieldStop()
14199 
    oprot.writeStructEnd()
14200 
 
14201 
  def validate(self):
14202 
    return
14203 
 
14204 
 
14205 
  def __repr__(self):
14206 
    L = ['%s=%r' % (key, value)
14207 
      for key, value in self.__dict__.iteritems()]
14208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14209 
 
14210 
  def __eq__(self, other):
14211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14212 
 
14213 
  def __ne__(self, other):
14214 
    return not (self == other)
14215 
 
14216 
class changeItem_result:
14217 
  """
14218 
  Attributes:
14219 
   - success
14220 
   - ex
14221 
  """
14222 
 
14223 
  thrift_spec = (
14224 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14225 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14226 
  )
14227 
 
14228 
  def __init__(self, success=None, ex=None,):
14229 
    self.success = success
14230 
    self.ex = ex
14231 
 
14232 
  def read(self, iprot):
14233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14235 
      return
14236 
    iprot.readStructBegin()
14237 
    while True:
14238 
      (fname, ftype, fid) = iprot.readFieldBegin()
14239 
      if ftype == TType.STOP:
14240 
        break
14241 
      if fid == 0:
14242 
        if ftype == TType.STRUCT:
14243 
          self.success = Order()
14244 
          self.success.read(iprot)
14245 
        else:
14246 
          iprot.skip(ftype)
14247 
      elif fid == 1:
14248 
        if ftype == TType.STRUCT:
14249 
          self.ex = TransactionServiceException()
14250 
          self.ex.read(iprot)
14251 
        else:
14252 
          iprot.skip(ftype)
14253 
      else:
14254 
        iprot.skip(ftype)
14255 
      iprot.readFieldEnd()
14256 
    iprot.readStructEnd()
14257 
 
14258 
  def write(self, oprot):
14259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14261 
      return
14262 
    oprot.writeStructBegin('changeItem_result')
14263 
    if self.success is not None:
14264 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14265 
      self.success.write(oprot)
14266 
      oprot.writeFieldEnd()
14267 
    if self.ex is not None:
14268 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14269 
      self.ex.write(oprot)
14270 
      oprot.writeFieldEnd()
14271 
    oprot.writeFieldStop()
14272 
    oprot.writeStructEnd()
14273 
 
14274 
  def validate(self):
14275 
    return
14276 
 
14277 
 
14278 
  def __repr__(self):
14279 
    L = ['%s=%r' % (key, value)
14280 
      for key, value in self.__dict__.iteritems()]
14281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14282 
 
14283 
  def __eq__(self, other):
14284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14285 
 
14286 
  def __ne__(self, other):
14287 
    return not (self == other)
14288 
 
14289 
class shiftToWarehouse_args:
14290 
  """
14291 
  Attributes:
14292 
   - orderId
14293 
   - warehouseId
14294 
  """
14295 
 
14296 
  thrift_spec = (
14297 
    None, # 0
14298 
    (1, TType.I64, 'orderId', None, None, ), # 1
14299 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
14300 
  )
14301 
 
14302 
  def __init__(self, orderId=None, warehouseId=None,):
14303 
    self.orderId = orderId
14304 
    self.warehouseId = warehouseId
14305 
 
14306 
  def read(self, iprot):
14307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14309 
      return
14310 
    iprot.readStructBegin()
14311 
    while True:
14312 
      (fname, ftype, fid) = iprot.readFieldBegin()
14313 
      if ftype == TType.STOP:
14314 
        break
14315 
      if fid == 1:
14316 
        if ftype == TType.I64:
14317 
          self.orderId = iprot.readI64();
14318 
        else:
14319 
          iprot.skip(ftype)
14320 
      elif fid == 2:
14321 
        if ftype == TType.I64:
14322 
          self.warehouseId = iprot.readI64();
14323 
        else:
14324 
          iprot.skip(ftype)
14325 
      else:
14326 
        iprot.skip(ftype)
14327 
      iprot.readFieldEnd()
14328 
    iprot.readStructEnd()
14329 
 
14330 
  def write(self, oprot):
14331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14333 
      return
14334 
    oprot.writeStructBegin('shiftToWarehouse_args')
14335 
    if self.orderId is not None:
14336 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14337 
      oprot.writeI64(self.orderId)
14338 
      oprot.writeFieldEnd()
14339 
    if self.warehouseId is not None:
14340 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14341 
      oprot.writeI64(self.warehouseId)
14342 
      oprot.writeFieldEnd()
14343 
    oprot.writeFieldStop()
14344 
    oprot.writeStructEnd()
14345 
 
14346 
  def validate(self):
14347 
    return
14348 
 
14349 
 
14350 
  def __repr__(self):
14351 
    L = ['%s=%r' % (key, value)
14352 
      for key, value in self.__dict__.iteritems()]
14353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14354 
 
14355 
  def __eq__(self, other):
14356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14357 
 
14358 
  def __ne__(self, other):
14359 
    return not (self == other)
14360 
 
14361 
class shiftToWarehouse_result:
14362 
  """
14363 
  Attributes:
14364 
   - success
14365 
   - ex
14366 
  """
14367 
 
14368 
  thrift_spec = (
14369 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14370 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14371 
  )
14372 
 
14373 
  def __init__(self, success=None, ex=None,):
14374 
    self.success = success
14375 
    self.ex = ex
14376 
 
14377 
  def read(self, iprot):
14378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14380 
      return
14381 
    iprot.readStructBegin()
14382 
    while True:
14383 
      (fname, ftype, fid) = iprot.readFieldBegin()
14384 
      if ftype == TType.STOP:
14385 
        break
14386 
      if fid == 0:
14387 
        if ftype == TType.STRUCT:
14388 
          self.success = Order()
14389 
          self.success.read(iprot)
14390 
        else:
14391 
          iprot.skip(ftype)
14392 
      elif fid == 1:
14393 
        if ftype == TType.STRUCT:
14394 
          self.ex = TransactionServiceException()
14395 
          self.ex.read(iprot)
14396 
        else:
14397 
          iprot.skip(ftype)
14398 
      else:
14399 
        iprot.skip(ftype)
14400 
      iprot.readFieldEnd()
14401 
    iprot.readStructEnd()
14402 
 
14403 
  def write(self, oprot):
14404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14406 
      return
14407 
    oprot.writeStructBegin('shiftToWarehouse_result')
14408 
    if self.success is not None:
14409 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14410 
      self.success.write(oprot)
14411 
      oprot.writeFieldEnd()
14412 
    if self.ex is not None:
14413 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14414 
      self.ex.write(oprot)
14415 
      oprot.writeFieldEnd()
14416 
    oprot.writeFieldStop()
14417 
    oprot.writeStructEnd()
14418 
 
14419 
  def validate(self):
14420 
    return
14421 
 
14422 
 
14423 
  def __repr__(self):
14424 
    L = ['%s=%r' % (key, value)
14425 
      for key, value in self.__dict__.iteritems()]
14426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14427 
 
14428 
  def __eq__(self, other):
14429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14430 
 
14431 
  def __ne__(self, other):
14432 
    return not (self == other)
3553 chandransh 14433 
 
14434 
class addDelayReason_args:
14435 
  """
14436 
  Attributes:
14437 
   - orderId
14438 
   - delayReason
3986 chandransh 14439 
   - furtherDelay
4647 rajveer 14440 
   - delayReasonText
3553 chandransh 14441 
  """
14442 
 
14443 
  thrift_spec = (
14444 
    None, # 0
14445 
    (1, TType.I64, 'orderId', None, None, ), # 1
14446 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 14447 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 14448 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 14449 
  )
14450 
 
4647 rajveer 14451 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 14452 
    self.orderId = orderId
14453 
    self.delayReason = delayReason
3986 chandransh 14454 
    self.furtherDelay = furtherDelay
4647 rajveer 14455 
    self.delayReasonText = delayReasonText
3553 chandransh 14456 
 
14457 
  def read(self, iprot):
14458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14460 
      return
14461 
    iprot.readStructBegin()
14462 
    while True:
14463 
      (fname, ftype, fid) = iprot.readFieldBegin()
14464 
      if ftype == TType.STOP:
14465 
        break
14466 
      if fid == 1:
14467 
        if ftype == TType.I64:
14468 
          self.orderId = iprot.readI64();
14469 
        else:
14470 
          iprot.skip(ftype)
14471 
      elif fid == 2:
14472 
        if ftype == TType.I32:
14473 
          self.delayReason = iprot.readI32();
14474 
        else:
14475 
          iprot.skip(ftype)
3986 chandransh 14476 
      elif fid == 3:
14477 
        if ftype == TType.I64:
14478 
          self.furtherDelay = iprot.readI64();
14479 
        else:
14480 
          iprot.skip(ftype)
4647 rajveer 14481 
      elif fid == 4:
14482 
        if ftype == TType.STRING:
14483 
          self.delayReasonText = iprot.readString();
14484 
        else:
14485 
          iprot.skip(ftype)
3553 chandransh 14486 
      else:
14487 
        iprot.skip(ftype)
14488 
      iprot.readFieldEnd()
14489 
    iprot.readStructEnd()
14490 
 
14491 
  def write(self, oprot):
14492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14494 
      return
14495 
    oprot.writeStructBegin('addDelayReason_args')
14496 
    if self.orderId is not None:
14497 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14498 
      oprot.writeI64(self.orderId)
14499 
      oprot.writeFieldEnd()
14500 
    if self.delayReason is not None:
14501 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
14502 
      oprot.writeI32(self.delayReason)
14503 
      oprot.writeFieldEnd()
3986 chandransh 14504 
    if self.furtherDelay is not None:
14505 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
14506 
      oprot.writeI64(self.furtherDelay)
14507 
      oprot.writeFieldEnd()
4647 rajveer 14508 
    if self.delayReasonText is not None:
14509 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
14510 
      oprot.writeString(self.delayReasonText)
14511 
      oprot.writeFieldEnd()
3553 chandransh 14512 
    oprot.writeFieldStop()
14513 
    oprot.writeStructEnd()
14514 
 
14515 
  def validate(self):
14516 
    return
14517 
 
14518 
 
14519 
  def __repr__(self):
14520 
    L = ['%s=%r' % (key, value)
14521 
      for key, value in self.__dict__.iteritems()]
14522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14523 
 
14524 
  def __eq__(self, other):
14525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14526 
 
14527 
  def __ne__(self, other):
14528 
    return not (self == other)
14529 
 
14530 
class addDelayReason_result:
14531 
  """
14532 
  Attributes:
14533 
   - success
14534 
   - ex
14535 
  """
14536 
 
14537 
  thrift_spec = (
14538 
    (0, TType.BOOL, 'success', None, None, ), # 0
14539 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14540 
  )
14541 
 
14542 
  def __init__(self, success=None, ex=None,):
14543 
    self.success = success
14544 
    self.ex = ex
14545 
 
14546 
  def read(self, iprot):
14547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14549 
      return
14550 
    iprot.readStructBegin()
14551 
    while True:
14552 
      (fname, ftype, fid) = iprot.readFieldBegin()
14553 
      if ftype == TType.STOP:
14554 
        break
14555 
      if fid == 0:
14556 
        if ftype == TType.BOOL:
14557 
          self.success = iprot.readBool();
14558 
        else:
14559 
          iprot.skip(ftype)
14560 
      elif fid == 1:
14561 
        if ftype == TType.STRUCT:
14562 
          self.ex = TransactionServiceException()
14563 
          self.ex.read(iprot)
14564 
        else:
14565 
          iprot.skip(ftype)
14566 
      else:
14567 
        iprot.skip(ftype)
14568 
      iprot.readFieldEnd()
14569 
    iprot.readStructEnd()
14570 
 
14571 
  def write(self, oprot):
14572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14574 
      return
14575 
    oprot.writeStructBegin('addDelayReason_result')
14576 
    if self.success is not None:
14577 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14578 
      oprot.writeBool(self.success)
14579 
      oprot.writeFieldEnd()
14580 
    if self.ex is not None:
14581 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14582 
      self.ex.write(oprot)
14583 
      oprot.writeFieldEnd()
14584 
    oprot.writeFieldStop()
14585 
    oprot.writeStructEnd()
14586 
 
14587 
  def validate(self):
14588 
    return
14589 
 
14590 
 
14591 
  def __repr__(self):
14592 
    L = ['%s=%r' % (key, value)
14593 
      for key, value in self.__dict__.iteritems()]
14594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14595 
 
14596 
  def __eq__(self, other):
14597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14598 
 
14599 
  def __ne__(self, other):
14600 
    return not (self == other)
3956 chandransh 14601 
 
14602 
class reconcileCodCollection_args:
14603 
  """
14604 
  Attributes:
14605 
   - collectedAmountMap
14606 
   - xferBy
14607 
   - xferTxnId
14608 
   - xferDate
14609 
  """
14610 
 
14611 
  thrift_spec = (
14612 
    None, # 0
14613 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
14614 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
14615 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
14616 
    (4, TType.I64, 'xferDate', None, None, ), # 4
14617 
  )
14618 
 
14619 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
14620 
    self.collectedAmountMap = collectedAmountMap
14621 
    self.xferBy = xferBy
14622 
    self.xferTxnId = xferTxnId
14623 
    self.xferDate = xferDate
14624 
 
14625 
  def read(self, iprot):
14626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14628 
      return
14629 
    iprot.readStructBegin()
14630 
    while True:
14631 
      (fname, ftype, fid) = iprot.readFieldBegin()
14632 
      if ftype == TType.STOP:
14633 
        break
14634 
      if fid == 1:
14635 
        if ftype == TType.MAP:
14636 
          self.collectedAmountMap = {}
4586 mandeep.dh 14637 
          (_ktype228, _vtype229, _size227 ) = iprot.readMapBegin()
14638 
          for _i231 in xrange(_size227):
14639 
            _key232 = iprot.readString();
14640 
            _val233 = iprot.readDouble();
14641 
            self.collectedAmountMap[_key232] = _val233
3956 chandransh 14642 
          iprot.readMapEnd()
14643 
        else:
14644 
          iprot.skip(ftype)
14645 
      elif fid == 2:
14646 
        if ftype == TType.STRING:
14647 
          self.xferBy = iprot.readString();
14648 
        else:
14649 
          iprot.skip(ftype)
14650 
      elif fid == 3:
14651 
        if ftype == TType.STRING:
14652 
          self.xferTxnId = iprot.readString();
14653 
        else:
14654 
          iprot.skip(ftype)
14655 
      elif fid == 4:
14656 
        if ftype == TType.I64:
14657 
          self.xferDate = iprot.readI64();
14658 
        else:
14659 
          iprot.skip(ftype)
14660 
      else:
14661 
        iprot.skip(ftype)
14662 
      iprot.readFieldEnd()
14663 
    iprot.readStructEnd()
14664 
 
14665 
  def write(self, oprot):
14666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14668 
      return
14669 
    oprot.writeStructBegin('reconcileCodCollection_args')
14670 
    if self.collectedAmountMap is not None:
14671 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
14672 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4586 mandeep.dh 14673 
      for kiter234,viter235 in self.collectedAmountMap.items():
14674 
        oprot.writeString(kiter234)
14675 
        oprot.writeDouble(viter235)
3956 chandransh 14676 
      oprot.writeMapEnd()
14677 
      oprot.writeFieldEnd()
14678 
    if self.xferBy is not None:
14679 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
14680 
      oprot.writeString(self.xferBy)
14681 
      oprot.writeFieldEnd()
14682 
    if self.xferTxnId is not None:
14683 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
14684 
      oprot.writeString(self.xferTxnId)
14685 
      oprot.writeFieldEnd()
14686 
    if self.xferDate is not None:
14687 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
14688 
      oprot.writeI64(self.xferDate)
14689 
      oprot.writeFieldEnd()
14690 
    oprot.writeFieldStop()
14691 
    oprot.writeStructEnd()
14692 
 
14693 
  def validate(self):
14694 
    return
14695 
 
14696 
 
14697 
  def __repr__(self):
14698 
    L = ['%s=%r' % (key, value)
14699 
      for key, value in self.__dict__.iteritems()]
14700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14701 
 
14702 
  def __eq__(self, other):
14703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14704 
 
14705 
  def __ne__(self, other):
14706 
    return not (self == other)
14707 
 
14708 
class reconcileCodCollection_result:
14709 
  """
14710 
  Attributes:
14711 
   - success
14712 
   - ex
14713 
  """
14714 
 
14715 
  thrift_spec = (
14716 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
14717 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14718 
  )
14719 
 
14720 
  def __init__(self, success=None, ex=None,):
14721 
    self.success = success
14722 
    self.ex = ex
14723 
 
14724 
  def read(self, iprot):
14725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14727 
      return
14728 
    iprot.readStructBegin()
14729 
    while True:
14730 
      (fname, ftype, fid) = iprot.readFieldBegin()
14731 
      if ftype == TType.STOP:
14732 
        break
14733 
      if fid == 0:
14734 
        if ftype == TType.MAP:
14735 
          self.success = {}
4586 mandeep.dh 14736 
          (_ktype237, _vtype238, _size236 ) = iprot.readMapBegin()
14737 
          for _i240 in xrange(_size236):
14738 
            _key241 = iprot.readString();
14739 
            _val242 = iprot.readString();
14740 
            self.success[_key241] = _val242
3956 chandransh 14741 
          iprot.readMapEnd()
14742 
        else:
14743 
          iprot.skip(ftype)
14744 
      elif fid == 1:
14745 
        if ftype == TType.STRUCT:
14746 
          self.ex = TransactionServiceException()
14747 
          self.ex.read(iprot)
14748 
        else:
14749 
          iprot.skip(ftype)
14750 
      else:
14751 
        iprot.skip(ftype)
14752 
      iprot.readFieldEnd()
14753 
    iprot.readStructEnd()
14754 
 
14755 
  def write(self, oprot):
14756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14758 
      return
14759 
    oprot.writeStructBegin('reconcileCodCollection_result')
14760 
    if self.success is not None:
14761 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14762 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4586 mandeep.dh 14763 
      for kiter243,viter244 in self.success.items():
14764 
        oprot.writeString(kiter243)
14765 
        oprot.writeString(viter244)
3956 chandransh 14766 
      oprot.writeMapEnd()
14767 
      oprot.writeFieldEnd()
14768 
    if self.ex is not None:
14769 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14770 
      self.ex.write(oprot)
14771 
      oprot.writeFieldEnd()
14772 
    oprot.writeFieldStop()
14773 
    oprot.writeStructEnd()
14774 
 
14775 
  def validate(self):
14776 
    return
14777 
 
14778 
 
14779 
  def __repr__(self):
14780 
    L = ['%s=%r' % (key, value)
14781 
      for key, value in self.__dict__.iteritems()]
14782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14783 
 
14784 
  def __eq__(self, other):
14785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14786 
 
14787 
  def __ne__(self, other):
14788 
    return not (self == other)
4008 mandeep.dh 14789 
 
14790 
class getTransactionsRequiringExtraProcessing_args:
14791 
  """
14792 
  Attributes:
14793 
   - category
14794 
  """
14795 
 
14796 
  thrift_spec = (
14797 
    None, # 0
14798 
    (1, TType.I32, 'category', None, None, ), # 1
14799 
  )
14800 
 
14801 
  def __init__(self, category=None,):
14802 
    self.category = category
14803 
 
14804 
  def read(self, iprot):
14805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14807 
      return
14808 
    iprot.readStructBegin()
14809 
    while True:
14810 
      (fname, ftype, fid) = iprot.readFieldBegin()
14811 
      if ftype == TType.STOP:
14812 
        break
14813 
      if fid == 1:
14814 
        if ftype == TType.I32:
14815 
          self.category = iprot.readI32();
14816 
        else:
14817 
          iprot.skip(ftype)
14818 
      else:
14819 
        iprot.skip(ftype)
14820 
      iprot.readFieldEnd()
14821 
    iprot.readStructEnd()
14822 
 
14823 
  def write(self, oprot):
14824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14826 
      return
14827 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
14828 
    if self.category is not None:
14829 
      oprot.writeFieldBegin('category', TType.I32, 1)
14830 
      oprot.writeI32(self.category)
14831 
      oprot.writeFieldEnd()
14832 
    oprot.writeFieldStop()
14833 
    oprot.writeStructEnd()
14834 
 
14835 
  def validate(self):
14836 
    return
14837 
 
14838 
 
14839 
  def __repr__(self):
14840 
    L = ['%s=%r' % (key, value)
14841 
      for key, value in self.__dict__.iteritems()]
14842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14843 
 
14844 
  def __eq__(self, other):
14845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14846 
 
14847 
  def __ne__(self, other):
14848 
    return not (self == other)
14849 
 
14850 
class getTransactionsRequiringExtraProcessing_result:
14851 
  """
14852 
  Attributes:
14853 
   - success
14854 
  """
14855 
 
14856 
  thrift_spec = (
14857 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14858 
  )
14859 
 
14860 
  def __init__(self, success=None,):
14861 
    self.success = success
14862 
 
14863 
  def read(self, iprot):
14864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14866 
      return
14867 
    iprot.readStructBegin()
14868 
    while True:
14869 
      (fname, ftype, fid) = iprot.readFieldBegin()
14870 
      if ftype == TType.STOP:
14871 
        break
14872 
      if fid == 0:
14873 
        if ftype == TType.LIST:
14874 
          self.success = []
4586 mandeep.dh 14875 
          (_etype248, _size245) = iprot.readListBegin()
14876 
          for _i249 in xrange(_size245):
14877 
            _elem250 = iprot.readI64();
14878 
            self.success.append(_elem250)
4008 mandeep.dh 14879 
          iprot.readListEnd()
14880 
        else:
14881 
          iprot.skip(ftype)
14882 
      else:
14883 
        iprot.skip(ftype)
14884 
      iprot.readFieldEnd()
14885 
    iprot.readStructEnd()
14886 
 
14887 
  def write(self, oprot):
14888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14890 
      return
14891 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
14892 
    if self.success is not None:
14893 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14894 
      oprot.writeListBegin(TType.I64, len(self.success))
4586 mandeep.dh 14895 
      for iter251 in self.success:
14896 
        oprot.writeI64(iter251)
4008 mandeep.dh 14897 
      oprot.writeListEnd()
14898 
      oprot.writeFieldEnd()
14899 
    oprot.writeFieldStop()
14900 
    oprot.writeStructEnd()
14901 
 
14902 
  def validate(self):
14903 
    return
14904 
 
14905 
 
14906 
  def __repr__(self):
14907 
    L = ['%s=%r' % (key, value)
14908 
      for key, value in self.__dict__.iteritems()]
14909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14910 
 
14911 
  def __eq__(self, other):
14912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14913 
 
14914 
  def __ne__(self, other):
14915 
    return not (self == other)
14916 
 
14917 
class markTransactionAsProcessed_args:
14918 
  """
14919 
  Attributes:
14920 
   - transactionId
14921 
   - category
14922 
  """
14923 
 
14924 
  thrift_spec = (
14925 
    None, # 0
14926 
    (1, TType.I64, 'transactionId', None, None, ), # 1
14927 
    (2, TType.I32, 'category', None, None, ), # 2
14928 
  )
14929 
 
14930 
  def __init__(self, transactionId=None, category=None,):
14931 
    self.transactionId = transactionId
14932 
    self.category = category
14933 
 
14934 
  def read(self, iprot):
14935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14937 
      return
14938 
    iprot.readStructBegin()
14939 
    while True:
14940 
      (fname, ftype, fid) = iprot.readFieldBegin()
14941 
      if ftype == TType.STOP:
14942 
        break
14943 
      if fid == 1:
14944 
        if ftype == TType.I64:
14945 
          self.transactionId = iprot.readI64();
14946 
        else:
14947 
          iprot.skip(ftype)
14948 
      elif fid == 2:
14949 
        if ftype == TType.I32:
14950 
          self.category = iprot.readI32();
14951 
        else:
14952 
          iprot.skip(ftype)
14953 
      else:
14954 
        iprot.skip(ftype)
14955 
      iprot.readFieldEnd()
14956 
    iprot.readStructEnd()
14957 
 
14958 
  def write(self, oprot):
14959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14961 
      return
14962 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
14963 
    if self.transactionId is not None:
14964 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14965 
      oprot.writeI64(self.transactionId)
14966 
      oprot.writeFieldEnd()
14967 
    if self.category is not None:
14968 
      oprot.writeFieldBegin('category', TType.I32, 2)
14969 
      oprot.writeI32(self.category)
14970 
      oprot.writeFieldEnd()
14971 
    oprot.writeFieldStop()
14972 
    oprot.writeStructEnd()
14973 
 
14974 
  def validate(self):
14975 
    return
14976 
 
14977 
 
14978 
  def __repr__(self):
14979 
    L = ['%s=%r' % (key, value)
14980 
      for key, value in self.__dict__.iteritems()]
14981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14982 
 
14983 
  def __eq__(self, other):
14984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14985 
 
14986 
  def __ne__(self, other):
14987 
    return not (self == other)
14988 
 
14989 
class markTransactionAsProcessed_result:
14990 
 
14991 
  thrift_spec = (
14992 
  )
14993 
 
14994 
  def read(self, iprot):
14995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14997 
      return
14998 
    iprot.readStructBegin()
14999 
    while True:
15000 
      (fname, ftype, fid) = iprot.readFieldBegin()
15001 
      if ftype == TType.STOP:
15002 
        break
15003 
      else:
15004 
        iprot.skip(ftype)
15005 
      iprot.readFieldEnd()
15006 
    iprot.readStructEnd()
15007 
 
15008 
  def write(self, oprot):
15009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15011 
      return
15012 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
15013 
    oprot.writeFieldStop()
15014 
    oprot.writeStructEnd()
15015 
 
15016 
  def validate(self):
15017 
    return
15018 
 
15019 
 
15020 
  def __repr__(self):
15021 
    L = ['%s=%r' % (key, value)
15022 
      for key, value in self.__dict__.iteritems()]
15023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15024 
 
15025 
  def __eq__(self, other):
15026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15027 
 
15028 
  def __ne__(self, other):
15029 
    return not (self == other)
4018 chandransh 15030 
 
15031 
class getItemWiseRiskyOrdersCount_args:
15032 
 
15033 
  thrift_spec = (
15034 
  )
15035 
 
15036 
  def read(self, iprot):
15037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15039 
      return
15040 
    iprot.readStructBegin()
15041 
    while True:
15042 
      (fname, ftype, fid) = iprot.readFieldBegin()
15043 
      if ftype == TType.STOP:
15044 
        break
15045 
      else:
15046 
        iprot.skip(ftype)
15047 
      iprot.readFieldEnd()
15048 
    iprot.readStructEnd()
15049 
 
15050 
  def write(self, oprot):
15051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15053 
      return
15054 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
15055 
    oprot.writeFieldStop()
15056 
    oprot.writeStructEnd()
15057 
 
15058 
  def validate(self):
15059 
    return
15060 
 
15061 
 
15062 
  def __repr__(self):
15063 
    L = ['%s=%r' % (key, value)
15064 
      for key, value in self.__dict__.iteritems()]
15065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15066 
 
15067 
  def __eq__(self, other):
15068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15069 
 
15070 
  def __ne__(self, other):
15071 
    return not (self == other)
15072 
 
15073 
class getItemWiseRiskyOrdersCount_result:
15074 
  """
15075 
  Attributes:
15076 
   - success
15077 
  """
15078 
 
15079 
  thrift_spec = (
15080 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
15081 
  )
15082 
 
15083 
  def __init__(self, success=None,):
15084 
    self.success = success
15085 
 
15086 
  def read(self, iprot):
15087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15089 
      return
15090 
    iprot.readStructBegin()
15091 
    while True:
15092 
      (fname, ftype, fid) = iprot.readFieldBegin()
15093 
      if ftype == TType.STOP:
15094 
        break
15095 
      if fid == 0:
15096 
        if ftype == TType.MAP:
15097 
          self.success = {}
4586 mandeep.dh 15098 
          (_ktype253, _vtype254, _size252 ) = iprot.readMapBegin()
15099 
          for _i256 in xrange(_size252):
15100 
            _key257 = iprot.readI64();
15101 
            _val258 = iprot.readI64();
15102 
            self.success[_key257] = _val258
4018 chandransh 15103 
          iprot.readMapEnd()
15104 
        else:
15105 
          iprot.skip(ftype)
15106 
      else:
15107 
        iprot.skip(ftype)
15108 
      iprot.readFieldEnd()
15109 
    iprot.readStructEnd()
15110 
 
15111 
  def write(self, oprot):
15112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15114 
      return
15115 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
15116 
    if self.success is not None:
15117 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15118 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4586 mandeep.dh 15119 
      for kiter259,viter260 in self.success.items():
15120 
        oprot.writeI64(kiter259)
15121 
        oprot.writeI64(viter260)
4018 chandransh 15122 
      oprot.writeMapEnd()
15123 
      oprot.writeFieldEnd()
15124 
    oprot.writeFieldStop()
15125 
    oprot.writeStructEnd()
15126 
 
15127 
  def validate(self):
15128 
    return
15129 
 
15130 
 
15131 
  def __repr__(self):
15132 
    L = ['%s=%r' % (key, value)
15133 
      for key, value in self.__dict__.iteritems()]
15134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15135 
 
15136 
  def __eq__(self, other):
15137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15138 
 
15139 
  def __ne__(self, other):
15140 
    return not (self == other)
4247 rajveer 15141 
 
4295 varun.gupt 15142 
class getOrdersForItemIds_args:
15143 
  """
15144 
  Attributes:
15145 
   - itemIds
15146 
  """
15147 
 
15148 
  thrift_spec = (
15149 
    None, # 0
15150 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15151 
  )
15152 
 
15153 
  def __init__(self, itemIds=None,):
15154 
    self.itemIds = itemIds
15155 
 
15156 
  def read(self, iprot):
15157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15159 
      return
15160 
    iprot.readStructBegin()
15161 
    while True:
15162 
      (fname, ftype, fid) = iprot.readFieldBegin()
15163 
      if ftype == TType.STOP:
15164 
        break
15165 
      if fid == 1:
15166 
        if ftype == TType.LIST:
15167 
          self.itemIds = []
4586 mandeep.dh 15168 
          (_etype264, _size261) = iprot.readListBegin()
15169 
          for _i265 in xrange(_size261):
15170 
            _elem266 = iprot.readI64();
15171 
            self.itemIds.append(_elem266)
4295 varun.gupt 15172 
          iprot.readListEnd()
15173 
        else:
15174 
          iprot.skip(ftype)
15175 
      else:
15176 
        iprot.skip(ftype)
15177 
      iprot.readFieldEnd()
15178 
    iprot.readStructEnd()
15179 
 
15180 
  def write(self, oprot):
15181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15183 
      return
15184 
    oprot.writeStructBegin('getOrdersForItemIds_args')
15185 
    if self.itemIds is not None:
15186 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15187 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4586 mandeep.dh 15188 
      for iter267 in self.itemIds:
15189 
        oprot.writeI64(iter267)
4295 varun.gupt 15190 
      oprot.writeListEnd()
15191 
      oprot.writeFieldEnd()
15192 
    oprot.writeFieldStop()
15193 
    oprot.writeStructEnd()
15194 
 
15195 
  def validate(self):
15196 
    return
15197 
 
15198 
 
15199 
  def __repr__(self):
15200 
    L = ['%s=%r' % (key, value)
15201 
      for key, value in self.__dict__.iteritems()]
15202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15203 
 
15204 
  def __eq__(self, other):
15205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15206 
 
15207 
  def __ne__(self, other):
15208 
    return not (self == other)
15209 
 
15210 
class getOrdersForItemIds_result:
15211 
  """
15212 
  Attributes:
15213 
   - success
15214 
  """
15215 
 
15216 
  thrift_spec = (
15217 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15218 
  )
15219 
 
15220 
  def __init__(self, success=None,):
15221 
    self.success = success
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 == 0:
15233 
        if ftype == TType.LIST:
15234 
          self.success = []
4586 mandeep.dh 15235 
          (_etype271, _size268) = iprot.readListBegin()
15236 
          for _i272 in xrange(_size268):
15237 
            _elem273 = Order()
15238 
            _elem273.read(iprot)
15239 
            self.success.append(_elem273)
4295 varun.gupt 15240 
          iprot.readListEnd()
15241 
        else:
15242 
          iprot.skip(ftype)
15243 
      else:
15244 
        iprot.skip(ftype)
15245 
      iprot.readFieldEnd()
15246 
    iprot.readStructEnd()
15247 
 
15248 
  def write(self, oprot):
15249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15251 
      return
15252 
    oprot.writeStructBegin('getOrdersForItemIds_result')
15253 
    if self.success is not None:
15254 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15255 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 15256 
      for iter274 in self.success:
15257 
        iter274.write(oprot)
4295 varun.gupt 15258 
      oprot.writeListEnd()
15259 
      oprot.writeFieldEnd()
15260 
    oprot.writeFieldStop()
15261 
    oprot.writeStructEnd()
15262 
 
15263 
  def validate(self):
15264 
    return
15265 
 
15266 
 
15267 
  def __repr__(self):
15268 
    L = ['%s=%r' % (key, value)
15269 
      for key, value in self.__dict__.iteritems()]
15270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15271 
 
15272 
  def __eq__(self, other):
15273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15274 
 
15275 
  def __ne__(self, other):
15276 
    return not (self == other)
15277 
 
4247 rajveer 15278 
class markOrderCancellationRequestReceived_args:
15279 
  """
15280 
  Attributes:
15281 
   - orderId
15282 
  """
15283 
 
15284 
  thrift_spec = (
15285 
    None, # 0
15286 
    (1, TType.I64, 'orderId', None, None, ), # 1
15287 
  )
15288 
 
15289 
  def __init__(self, orderId=None,):
15290 
    self.orderId = orderId
15291 
 
15292 
  def read(self, iprot):
15293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15295 
      return
15296 
    iprot.readStructBegin()
15297 
    while True:
15298 
      (fname, ftype, fid) = iprot.readFieldBegin()
15299 
      if ftype == TType.STOP:
15300 
        break
15301 
      if fid == 1:
15302 
        if ftype == TType.I64:
15303 
          self.orderId = iprot.readI64();
15304 
        else:
15305 
          iprot.skip(ftype)
15306 
      else:
15307 
        iprot.skip(ftype)
15308 
      iprot.readFieldEnd()
15309 
    iprot.readStructEnd()
15310 
 
15311 
  def write(self, oprot):
15312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15314 
      return
15315 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
15316 
    if self.orderId is not None:
15317 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15318 
      oprot.writeI64(self.orderId)
15319 
      oprot.writeFieldEnd()
15320 
    oprot.writeFieldStop()
15321 
    oprot.writeStructEnd()
15322 
 
15323 
  def validate(self):
15324 
    return
15325 
 
15326 
 
15327 
  def __repr__(self):
15328 
    L = ['%s=%r' % (key, value)
15329 
      for key, value in self.__dict__.iteritems()]
15330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15331 
 
15332 
  def __eq__(self, other):
15333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15334 
 
15335 
  def __ne__(self, other):
15336 
    return not (self == other)
15337 
 
15338 
class markOrderCancellationRequestReceived_result:
15339 
  """
15340 
  Attributes:
15341 
   - ex
15342 
  """
15343 
 
15344 
  thrift_spec = (
15345 
    None, # 0
15346 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15347 
  )
15348 
 
15349 
  def __init__(self, ex=None,):
15350 
    self.ex = ex
15351 
 
15352 
  def read(self, iprot):
15353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15355 
      return
15356 
    iprot.readStructBegin()
15357 
    while True:
15358 
      (fname, ftype, fid) = iprot.readFieldBegin()
15359 
      if ftype == TType.STOP:
15360 
        break
15361 
      if fid == 1:
15362 
        if ftype == TType.STRUCT:
15363 
          self.ex = TransactionServiceException()
15364 
          self.ex.read(iprot)
15365 
        else:
15366 
          iprot.skip(ftype)
15367 
      else:
15368 
        iprot.skip(ftype)
15369 
      iprot.readFieldEnd()
15370 
    iprot.readStructEnd()
15371 
 
15372 
  def write(self, oprot):
15373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15375 
      return
15376 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
15377 
    if self.ex is not None:
15378 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15379 
      self.ex.write(oprot)
15380 
      oprot.writeFieldEnd()
15381 
    oprot.writeFieldStop()
15382 
    oprot.writeStructEnd()
15383 
 
15384 
  def validate(self):
15385 
    return
15386 
 
15387 
 
15388 
  def __repr__(self):
15389 
    L = ['%s=%r' % (key, value)
15390 
      for key, value in self.__dict__.iteritems()]
15391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15392 
 
15393 
  def __eq__(self, other):
15394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15395 
 
15396 
  def __ne__(self, other):
15397 
    return not (self == other)
15398 
 
15399 
class markOrderCancellationRequestConfirmed_args:
15400 
  """
15401 
  Attributes:
15402 
   - orderId
15403 
  """
15404 
 
15405 
  thrift_spec = (
15406 
    None, # 0
15407 
    (1, TType.I64, 'orderId', None, None, ), # 1
15408 
  )
15409 
 
15410 
  def __init__(self, orderId=None,):
15411 
    self.orderId = orderId
15412 
 
15413 
  def read(self, iprot):
15414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15416 
      return
15417 
    iprot.readStructBegin()
15418 
    while True:
15419 
      (fname, ftype, fid) = iprot.readFieldBegin()
15420 
      if ftype == TType.STOP:
15421 
        break
15422 
      if fid == 1:
15423 
        if ftype == TType.I64:
15424 
          self.orderId = iprot.readI64();
15425 
        else:
15426 
          iprot.skip(ftype)
15427 
      else:
15428 
        iprot.skip(ftype)
15429 
      iprot.readFieldEnd()
15430 
    iprot.readStructEnd()
15431 
 
15432 
  def write(self, oprot):
15433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15435 
      return
15436 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
15437 
    if self.orderId is not None:
15438 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15439 
      oprot.writeI64(self.orderId)
15440 
      oprot.writeFieldEnd()
15441 
    oprot.writeFieldStop()
15442 
    oprot.writeStructEnd()
15443 
 
15444 
  def validate(self):
15445 
    return
15446 
 
15447 
 
15448 
  def __repr__(self):
15449 
    L = ['%s=%r' % (key, value)
15450 
      for key, value in self.__dict__.iteritems()]
15451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15452 
 
15453 
  def __eq__(self, other):
15454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15455 
 
15456 
  def __ne__(self, other):
15457 
    return not (self == other)
15458 
 
15459 
class markOrderCancellationRequestConfirmed_result:
15460 
  """
15461 
  Attributes:
15462 
   - ex
15463 
  """
15464 
 
15465 
  thrift_spec = (
15466 
    None, # 0
15467 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15468 
  )
15469 
 
15470 
  def __init__(self, ex=None,):
15471 
    self.ex = ex
15472 
 
15473 
  def read(self, iprot):
15474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15476 
      return
15477 
    iprot.readStructBegin()
15478 
    while True:
15479 
      (fname, ftype, fid) = iprot.readFieldBegin()
15480 
      if ftype == TType.STOP:
15481 
        break
15482 
      if fid == 1:
15483 
        if ftype == TType.STRUCT:
15484 
          self.ex = TransactionServiceException()
15485 
          self.ex.read(iprot)
15486 
        else:
15487 
          iprot.skip(ftype)
15488 
      else:
15489 
        iprot.skip(ftype)
15490 
      iprot.readFieldEnd()
15491 
    iprot.readStructEnd()
15492 
 
15493 
  def write(self, oprot):
15494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15496 
      return
15497 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
15498 
    if self.ex is not None:
15499 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15500 
      self.ex.write(oprot)
15501 
      oprot.writeFieldEnd()
15502 
    oprot.writeFieldStop()
15503 
    oprot.writeStructEnd()
15504 
 
15505 
  def validate(self):
15506 
    return
15507 
 
15508 
 
15509 
  def __repr__(self):
15510 
    L = ['%s=%r' % (key, value)
15511 
      for key, value in self.__dict__.iteritems()]
15512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15513 
 
15514 
  def __eq__(self, other):
15515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15516 
 
15517 
  def __ne__(self, other):
15518 
    return not (self == other)
15519 
 
15520 
class markOrderCancellationRequestDenied_args:
15521 
  """
15522 
  Attributes:
15523 
   - orderId
15524 
  """
15525 
 
15526 
  thrift_spec = (
15527 
    None, # 0
15528 
    (1, TType.I64, 'orderId', None, None, ), # 1
15529 
  )
15530 
 
15531 
  def __init__(self, orderId=None,):
15532 
    self.orderId = orderId
15533 
 
15534 
  def read(self, iprot):
15535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15537 
      return
15538 
    iprot.readStructBegin()
15539 
    while True:
15540 
      (fname, ftype, fid) = iprot.readFieldBegin()
15541 
      if ftype == TType.STOP:
15542 
        break
15543 
      if fid == 1:
15544 
        if ftype == TType.I64:
15545 
          self.orderId = iprot.readI64();
15546 
        else:
15547 
          iprot.skip(ftype)
15548 
      else:
15549 
        iprot.skip(ftype)
15550 
      iprot.readFieldEnd()
15551 
    iprot.readStructEnd()
15552 
 
15553 
  def write(self, oprot):
15554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15556 
      return
15557 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
15558 
    if self.orderId is not None:
15559 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15560 
      oprot.writeI64(self.orderId)
15561 
      oprot.writeFieldEnd()
15562 
    oprot.writeFieldStop()
15563 
    oprot.writeStructEnd()
15564 
 
15565 
  def validate(self):
15566 
    return
15567 
 
15568 
 
15569 
  def __repr__(self):
15570 
    L = ['%s=%r' % (key, value)
15571 
      for key, value in self.__dict__.iteritems()]
15572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15573 
 
15574 
  def __eq__(self, other):
15575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15576 
 
15577 
  def __ne__(self, other):
15578 
    return not (self == other)
15579 
 
15580 
class markOrderCancellationRequestDenied_result:
15581 
  """
15582 
  Attributes:
15583 
   - ex
15584 
  """
15585 
 
15586 
  thrift_spec = (
15587 
    None, # 0
15588 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15589 
  )
15590 
 
15591 
  def __init__(self, ex=None,):
15592 
    self.ex = ex
15593 
 
15594 
  def read(self, iprot):
15595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15597 
      return
15598 
    iprot.readStructBegin()
15599 
    while True:
15600 
      (fname, ftype, fid) = iprot.readFieldBegin()
15601 
      if ftype == TType.STOP:
15602 
        break
15603 
      if fid == 1:
15604 
        if ftype == TType.STRUCT:
15605 
          self.ex = TransactionServiceException()
15606 
          self.ex.read(iprot)
15607 
        else:
15608 
          iprot.skip(ftype)
15609 
      else:
15610 
        iprot.skip(ftype)
15611 
      iprot.readFieldEnd()
15612 
    iprot.readStructEnd()
15613 
 
15614 
  def write(self, oprot):
15615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15617 
      return
15618 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
15619 
    if self.ex is not None:
15620 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15621 
      self.ex.write(oprot)
15622 
      oprot.writeFieldEnd()
15623 
    oprot.writeFieldStop()
15624 
    oprot.writeStructEnd()
15625 
 
15626 
  def validate(self):
15627 
    return
15628 
 
15629 
 
15630 
  def __repr__(self):
15631 
    L = ['%s=%r' % (key, value)
15632 
      for key, value in self.__dict__.iteritems()]
15633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15634 
 
15635 
  def __eq__(self, other):
15636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15637 
 
15638 
  def __ne__(self, other):
15639 
    return not (self == other)
15640 
 
4258 rajveer 15641 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 15642 
  """
15643 
  Attributes:
4258 rajveer 15644 
   - transactionId
4247 rajveer 15645 
  """
15646 
 
15647 
  thrift_spec = (
15648 
    None, # 0
4258 rajveer 15649 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 15650 
  )
15651 
 
4258 rajveer 15652 
  def __init__(self, transactionId=None,):
15653 
    self.transactionId = transactionId
4247 rajveer 15654 
 
15655 
  def read(self, iprot):
15656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15658 
      return
15659 
    iprot.readStructBegin()
15660 
    while True:
15661 
      (fname, ftype, fid) = iprot.readFieldBegin()
15662 
      if ftype == TType.STOP:
15663 
        break
15664 
      if fid == 1:
15665 
        if ftype == TType.I64:
4258 rajveer 15666 
          self.transactionId = iprot.readI64();
4247 rajveer 15667 
        else:
15668 
          iprot.skip(ftype)
15669 
      else:
15670 
        iprot.skip(ftype)
15671 
      iprot.readFieldEnd()
15672 
    iprot.readStructEnd()
15673 
 
15674 
  def write(self, oprot):
15675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15677 
      return
4258 rajveer 15678 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
15679 
    if self.transactionId is not None:
15680 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15681 
      oprot.writeI64(self.transactionId)
4247 rajveer 15682 
      oprot.writeFieldEnd()
15683 
    oprot.writeFieldStop()
15684 
    oprot.writeStructEnd()
15685 
 
15686 
  def validate(self):
15687 
    return
15688 
 
15689 
 
15690 
  def __repr__(self):
15691 
    L = ['%s=%r' % (key, value)
15692 
      for key, value in self.__dict__.iteritems()]
15693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15694 
 
15695 
  def __eq__(self, other):
15696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15697 
 
15698 
  def __ne__(self, other):
15699 
    return not (self == other)
15700 
 
4258 rajveer 15701 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 15702 
  """
15703 
  Attributes:
15704 
   - ex
15705 
  """
15706 
 
15707 
  thrift_spec = (
15708 
    None, # 0
15709 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15710 
  )
15711 
 
15712 
  def __init__(self, ex=None,):
15713 
    self.ex = ex
15714 
 
15715 
  def read(self, iprot):
15716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15718 
      return
15719 
    iprot.readStructBegin()
15720 
    while True:
15721 
      (fname, ftype, fid) = iprot.readFieldBegin()
15722 
      if ftype == TType.STOP:
15723 
        break
15724 
      if fid == 1:
15725 
        if ftype == TType.STRUCT:
15726 
          self.ex = TransactionServiceException()
15727 
          self.ex.read(iprot)
15728 
        else:
15729 
          iprot.skip(ftype)
15730 
      else:
15731 
        iprot.skip(ftype)
15732 
      iprot.readFieldEnd()
15733 
    iprot.readStructEnd()
15734 
 
15735 
  def write(self, oprot):
15736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15738 
      return
4258 rajveer 15739 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 15740 
    if self.ex is not None:
15741 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15742 
      self.ex.write(oprot)
15743 
      oprot.writeFieldEnd()
15744 
    oprot.writeFieldStop()
15745 
    oprot.writeStructEnd()
15746 
 
15747 
  def validate(self):
15748 
    return
15749 
 
15750 
 
15751 
  def __repr__(self):
15752 
    L = ['%s=%r' % (key, value)
15753 
      for key, value in self.__dict__.iteritems()]
15754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15755 
 
15756 
  def __eq__(self, other):
15757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15758 
 
15759 
  def __ne__(self, other):
15760 
    return not (self == other)
4259 anupam.sin 15761 
 
15762 
class refundTransaction_args:
15763 
  """
15764 
  Attributes:
15765 
   - transactionId
15766 
   - refundedBy
15767 
   - reason
15768 
  """
15769 
 
15770 
  thrift_spec = (
15771 
    None, # 0
15772 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15773 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15774 
    (3, TType.STRING, 'reason', None, None, ), # 3
15775 
  )
15776 
 
15777 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
15778 
    self.transactionId = transactionId
15779 
    self.refundedBy = refundedBy
15780 
    self.reason = reason
15781 
 
15782 
  def read(self, iprot):
15783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15785 
      return
15786 
    iprot.readStructBegin()
15787 
    while True:
15788 
      (fname, ftype, fid) = iprot.readFieldBegin()
15789 
      if ftype == TType.STOP:
15790 
        break
15791 
      if fid == 1:
15792 
        if ftype == TType.I64:
15793 
          self.transactionId = iprot.readI64();
15794 
        else:
15795 
          iprot.skip(ftype)
15796 
      elif fid == 2:
15797 
        if ftype == TType.STRING:
15798 
          self.refundedBy = iprot.readString();
15799 
        else:
15800 
          iprot.skip(ftype)
15801 
      elif fid == 3:
15802 
        if ftype == TType.STRING:
15803 
          self.reason = iprot.readString();
15804 
        else:
15805 
          iprot.skip(ftype)
15806 
      else:
15807 
        iprot.skip(ftype)
15808 
      iprot.readFieldEnd()
15809 
    iprot.readStructEnd()
15810 
 
15811 
  def write(self, oprot):
15812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15814 
      return
15815 
    oprot.writeStructBegin('refundTransaction_args')
15816 
    if self.transactionId is not None:
15817 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15818 
      oprot.writeI64(self.transactionId)
15819 
      oprot.writeFieldEnd()
15820 
    if self.refundedBy is not None:
15821 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15822 
      oprot.writeString(self.refundedBy)
15823 
      oprot.writeFieldEnd()
15824 
    if self.reason is not None:
15825 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15826 
      oprot.writeString(self.reason)
15827 
      oprot.writeFieldEnd()
15828 
    oprot.writeFieldStop()
15829 
    oprot.writeStructEnd()
15830 
 
15831 
  def validate(self):
15832 
    return
15833 
 
15834 
 
15835 
  def __repr__(self):
15836 
    L = ['%s=%r' % (key, value)
15837 
      for key, value in self.__dict__.iteritems()]
15838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15839 
 
15840 
  def __eq__(self, other):
15841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15842 
 
15843 
  def __ne__(self, other):
15844 
    return not (self == other)
15845 
 
15846 
class refundTransaction_result:
15847 
  """
15848 
  Attributes:
15849 
   - ex
15850 
  """
15851 
 
15852 
  thrift_spec = (
15853 
    None, # 0
15854 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15855 
  )
15856 
 
15857 
  def __init__(self, ex=None,):
15858 
    self.ex = ex
15859 
 
15860 
  def read(self, iprot):
15861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15863 
      return
15864 
    iprot.readStructBegin()
15865 
    while True:
15866 
      (fname, ftype, fid) = iprot.readFieldBegin()
15867 
      if ftype == TType.STOP:
15868 
        break
15869 
      if fid == 1:
15870 
        if ftype == TType.STRUCT:
15871 
          self.ex = TransactionServiceException()
15872 
          self.ex.read(iprot)
15873 
        else:
15874 
          iprot.skip(ftype)
15875 
      else:
15876 
        iprot.skip(ftype)
15877 
      iprot.readFieldEnd()
15878 
    iprot.readStructEnd()
15879 
 
15880 
  def write(self, oprot):
15881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15883 
      return
15884 
    oprot.writeStructBegin('refundTransaction_result')
15885 
    if self.ex is not None:
15886 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15887 
      self.ex.write(oprot)
15888 
      oprot.writeFieldEnd()
15889 
    oprot.writeFieldStop()
15890 
    oprot.writeStructEnd()
15891 
 
15892 
  def validate(self):
15893 
    return
15894 
 
15895 
 
15896 
  def __repr__(self):
15897 
    L = ['%s=%r' % (key, value)
15898 
      for key, value in self.__dict__.iteritems()]
15899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15900 
 
15901 
  def __eq__(self, other):
15902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15903 
 
15904 
  def __ne__(self, other):
15905 
    return not (self == other)
4285 rajveer 15906 
 
4324 mandeep.dh 15907 
class updateShipmentAddress_args:
15908 
  """
15909 
  Attributes:
15910 
   - orderId
15911 
   - addressId
15912 
  """
15913 
 
15914 
  thrift_spec = (
15915 
    None, # 0
15916 
    (1, TType.I64, 'orderId', None, None, ), # 1
15917 
    (2, TType.I64, 'addressId', None, None, ), # 2
15918 
  )
15919 
 
15920 
  def __init__(self, orderId=None, addressId=None,):
15921 
    self.orderId = orderId
15922 
    self.addressId = addressId
15923 
 
15924 
  def read(self, iprot):
15925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15927 
      return
15928 
    iprot.readStructBegin()
15929 
    while True:
15930 
      (fname, ftype, fid) = iprot.readFieldBegin()
15931 
      if ftype == TType.STOP:
15932 
        break
15933 
      if fid == 1:
15934 
        if ftype == TType.I64:
15935 
          self.orderId = iprot.readI64();
15936 
        else:
15937 
          iprot.skip(ftype)
15938 
      elif fid == 2:
15939 
        if ftype == TType.I64:
15940 
          self.addressId = iprot.readI64();
15941 
        else:
15942 
          iprot.skip(ftype)
15943 
      else:
15944 
        iprot.skip(ftype)
15945 
      iprot.readFieldEnd()
15946 
    iprot.readStructEnd()
15947 
 
15948 
  def write(self, oprot):
15949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15951 
      return
15952 
    oprot.writeStructBegin('updateShipmentAddress_args')
15953 
    if self.orderId is not None:
15954 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15955 
      oprot.writeI64(self.orderId)
15956 
      oprot.writeFieldEnd()
15957 
    if self.addressId is not None:
15958 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
15959 
      oprot.writeI64(self.addressId)
15960 
      oprot.writeFieldEnd()
15961 
    oprot.writeFieldStop()
15962 
    oprot.writeStructEnd()
15963 
 
15964 
  def validate(self):
15965 
    return
15966 
 
15967 
 
15968 
  def __repr__(self):
15969 
    L = ['%s=%r' % (key, value)
15970 
      for key, value in self.__dict__.iteritems()]
15971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15972 
 
15973 
  def __eq__(self, other):
15974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15975 
 
15976 
  def __ne__(self, other):
15977 
    return not (self == other)
15978 
 
15979 
class updateShipmentAddress_result:
15980 
  """
15981 
  Attributes:
15982 
   - ex
15983 
  """
15984 
 
15985 
  thrift_spec = (
15986 
    None, # 0
15987 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15988 
  )
15989 
 
15990 
  def __init__(self, ex=None,):
15991 
    self.ex = ex
15992 
 
15993 
  def read(self, iprot):
15994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15996 
      return
15997 
    iprot.readStructBegin()
15998 
    while True:
15999 
      (fname, ftype, fid) = iprot.readFieldBegin()
16000 
      if ftype == TType.STOP:
16001 
        break
16002 
      if fid == 1:
16003 
        if ftype == TType.STRUCT:
16004 
          self.ex = TransactionServiceException()
16005 
          self.ex.read(iprot)
16006 
        else:
16007 
          iprot.skip(ftype)
16008 
      else:
16009 
        iprot.skip(ftype)
16010 
      iprot.readFieldEnd()
16011 
    iprot.readStructEnd()
16012 
 
16013 
  def write(self, oprot):
16014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16016 
      return
16017 
    oprot.writeStructBegin('updateShipmentAddress_result')
16018 
    if self.ex is not None:
16019 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16020 
      self.ex.write(oprot)
16021 
      oprot.writeFieldEnd()
16022 
    oprot.writeFieldStop()
16023 
    oprot.writeStructEnd()
16024 
 
16025 
  def validate(self):
16026 
    return
16027 
 
16028 
 
16029 
  def __repr__(self):
16030 
    L = ['%s=%r' % (key, value)
16031 
      for key, value in self.__dict__.iteritems()]
16032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16033 
 
16034 
  def __eq__(self, other):
16035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16036 
 
16037 
  def __ne__(self, other):
16038 
    return not (self == other)
16039 
 
4285 rajveer 16040 
class acceptOrdersForItemId_args:
16041 
  """
16042 
  Attributes:
16043 
   - itemId
16044 
   - inventory
16045 
  """
16046 
 
16047 
  thrift_spec = (
16048 
    None, # 0
16049 
    (1, TType.I64, 'itemId', None, None, ), # 1
16050 
    (2, TType.I64, 'inventory', None, None, ), # 2
16051 
  )
16052 
 
16053 
  def __init__(self, itemId=None, inventory=None,):
16054 
    self.itemId = itemId
16055 
    self.inventory = inventory
16056 
 
16057 
  def read(self, iprot):
16058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16060 
      return
16061 
    iprot.readStructBegin()
16062 
    while True:
16063 
      (fname, ftype, fid) = iprot.readFieldBegin()
16064 
      if ftype == TType.STOP:
16065 
        break
16066 
      if fid == 1:
16067 
        if ftype == TType.I64:
16068 
          self.itemId = iprot.readI64();
16069 
        else:
16070 
          iprot.skip(ftype)
16071 
      elif fid == 2:
16072 
        if ftype == TType.I64:
16073 
          self.inventory = iprot.readI64();
16074 
        else:
16075 
          iprot.skip(ftype)
16076 
      else:
16077 
        iprot.skip(ftype)
16078 
      iprot.readFieldEnd()
16079 
    iprot.readStructEnd()
16080 
 
16081 
  def write(self, oprot):
16082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16084 
      return
16085 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
16086 
    if self.itemId is not None:
16087 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16088 
      oprot.writeI64(self.itemId)
16089 
      oprot.writeFieldEnd()
16090 
    if self.inventory is not None:
16091 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
16092 
      oprot.writeI64(self.inventory)
16093 
      oprot.writeFieldEnd()
16094 
    oprot.writeFieldStop()
16095 
    oprot.writeStructEnd()
16096 
 
16097 
  def validate(self):
16098 
    return
16099 
 
16100 
 
16101 
  def __repr__(self):
16102 
    L = ['%s=%r' % (key, value)
16103 
      for key, value in self.__dict__.iteritems()]
16104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16105 
 
16106 
  def __eq__(self, other):
16107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16108 
 
16109 
  def __ne__(self, other):
16110 
    return not (self == other)
16111 
 
16112 
class acceptOrdersForItemId_result:
16113 
  """
16114 
  Attributes:
16115 
   - success
16116 
   - ex
16117 
  """
16118 
 
16119 
  thrift_spec = (
16120 
    (0, TType.BOOL, 'success', None, None, ), # 0
16121 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16122 
  )
16123 
 
16124 
  def __init__(self, success=None, ex=None,):
16125 
    self.success = success
16126 
    self.ex = ex
16127 
 
16128 
  def read(self, iprot):
16129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16131 
      return
16132 
    iprot.readStructBegin()
16133 
    while True:
16134 
      (fname, ftype, fid) = iprot.readFieldBegin()
16135 
      if ftype == TType.STOP:
16136 
        break
16137 
      if fid == 0:
16138 
        if ftype == TType.BOOL:
16139 
          self.success = iprot.readBool();
16140 
        else:
16141 
          iprot.skip(ftype)
16142 
      elif fid == 1:
16143 
        if ftype == TType.STRUCT:
16144 
          self.ex = TransactionServiceException()
16145 
          self.ex.read(iprot)
16146 
        else:
16147 
          iprot.skip(ftype)
16148 
      else:
16149 
        iprot.skip(ftype)
16150 
      iprot.readFieldEnd()
16151 
    iprot.readStructEnd()
16152 
 
16153 
  def write(self, oprot):
16154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16156 
      return
16157 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
16158 
    if self.success is not None:
16159 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16160 
      oprot.writeBool(self.success)
16161 
      oprot.writeFieldEnd()
16162 
    if self.ex is not None:
16163 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16164 
      self.ex.write(oprot)
16165 
      oprot.writeFieldEnd()
16166 
    oprot.writeFieldStop()
16167 
    oprot.writeStructEnd()
16168 
 
16169 
  def validate(self):
16170 
    return
16171 
 
16172 
 
16173 
  def __repr__(self):
16174 
    L = ['%s=%r' % (key, value)
16175 
      for key, value in self.__dict__.iteritems()]
16176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16177 
 
16178 
  def __eq__(self, other):
16179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16180 
 
16181 
  def __ne__(self, other):
16182 
    return not (self == other)
4303 rajveer 16183 
 
16184 
class markOrdersAsPORaised_args:
16185 
  """
16186 
  Attributes:
16187 
   - vendorId
16188 
   - itemId
16189 
   - quantity
16190 
   - estimate
4369 rajveer 16191 
   - isReminder
4303 rajveer 16192 
  """
16193 
 
16194 
  thrift_spec = (
16195 
    None, # 0
16196 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16197 
    (2, TType.I64, 'itemId', None, None, ), # 2
16198 
    (3, TType.I64, 'quantity', None, None, ), # 3
16199 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16200 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16201 
  )
16202 
 
4369 rajveer 16203 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16204 
    self.vendorId = vendorId
16205 
    self.itemId = itemId
16206 
    self.quantity = quantity
16207 
    self.estimate = estimate
4369 rajveer 16208 
    self.isReminder = isReminder
4303 rajveer 16209 
 
16210 
  def read(self, iprot):
16211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16213 
      return
16214 
    iprot.readStructBegin()
16215 
    while True:
16216 
      (fname, ftype, fid) = iprot.readFieldBegin()
16217 
      if ftype == TType.STOP:
16218 
        break
16219 
      if fid == 1:
16220 
        if ftype == TType.I64:
16221 
          self.vendorId = iprot.readI64();
16222 
        else:
16223 
          iprot.skip(ftype)
16224 
      elif fid == 2:
16225 
        if ftype == TType.I64:
16226 
          self.itemId = iprot.readI64();
16227 
        else:
16228 
          iprot.skip(ftype)
16229 
      elif fid == 3:
16230 
        if ftype == TType.I64:
16231 
          self.quantity = iprot.readI64();
16232 
        else:
16233 
          iprot.skip(ftype)
16234 
      elif fid == 4:
16235 
        if ftype == TType.I64:
16236 
          self.estimate = iprot.readI64();
16237 
        else:
16238 
          iprot.skip(ftype)
4369 rajveer 16239 
      elif fid == 5:
16240 
        if ftype == TType.BOOL:
16241 
          self.isReminder = iprot.readBool();
16242 
        else:
16243 
          iprot.skip(ftype)
4303 rajveer 16244 
      else:
16245 
        iprot.skip(ftype)
16246 
      iprot.readFieldEnd()
16247 
    iprot.readStructEnd()
16248 
 
16249 
  def write(self, oprot):
16250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16252 
      return
16253 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
16254 
    if self.vendorId is not None:
16255 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16256 
      oprot.writeI64(self.vendorId)
16257 
      oprot.writeFieldEnd()
16258 
    if self.itemId is not None:
16259 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16260 
      oprot.writeI64(self.itemId)
16261 
      oprot.writeFieldEnd()
16262 
    if self.quantity is not None:
16263 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16264 
      oprot.writeI64(self.quantity)
16265 
      oprot.writeFieldEnd()
16266 
    if self.estimate is not None:
16267 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16268 
      oprot.writeI64(self.estimate)
16269 
      oprot.writeFieldEnd()
4369 rajveer 16270 
    if self.isReminder is not None:
16271 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16272 
      oprot.writeBool(self.isReminder)
16273 
      oprot.writeFieldEnd()
4303 rajveer 16274 
    oprot.writeFieldStop()
16275 
    oprot.writeStructEnd()
16276 
 
16277 
  def validate(self):
16278 
    return
16279 
 
16280 
 
16281 
  def __repr__(self):
16282 
    L = ['%s=%r' % (key, value)
16283 
      for key, value in self.__dict__.iteritems()]
16284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16285 
 
16286 
  def __eq__(self, other):
16287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16288 
 
16289 
  def __ne__(self, other):
16290 
    return not (self == other)
16291 
 
16292 
class markOrdersAsPORaised_result:
16293 
  """
16294 
  Attributes:
16295 
   - ex
16296 
  """
16297 
 
16298 
  thrift_spec = (
16299 
    None, # 0
16300 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16301 
  )
16302 
 
16303 
  def __init__(self, ex=None,):
16304 
    self.ex = ex
16305 
 
16306 
  def read(self, iprot):
16307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16309 
      return
16310 
    iprot.readStructBegin()
16311 
    while True:
16312 
      (fname, ftype, fid) = iprot.readFieldBegin()
16313 
      if ftype == TType.STOP:
16314 
        break
16315 
      if fid == 1:
16316 
        if ftype == TType.STRUCT:
16317 
          self.ex = TransactionServiceException()
16318 
          self.ex.read(iprot)
16319 
        else:
16320 
          iprot.skip(ftype)
16321 
      else:
16322 
        iprot.skip(ftype)
16323 
      iprot.readFieldEnd()
16324 
    iprot.readStructEnd()
16325 
 
16326 
  def write(self, oprot):
16327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16329 
      return
16330 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
16331 
    if self.ex is not None:
16332 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16333 
      self.ex.write(oprot)
16334 
      oprot.writeFieldEnd()
16335 
    oprot.writeFieldStop()
16336 
    oprot.writeStructEnd()
16337 
 
16338 
  def validate(self):
16339 
    return
16340 
 
16341 
 
16342 
  def __repr__(self):
16343 
    L = ['%s=%r' % (key, value)
16344 
      for key, value in self.__dict__.iteritems()]
16345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16346 
 
16347 
  def __eq__(self, other):
16348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16349 
 
16350 
  def __ne__(self, other):
16351 
    return not (self == other)
16352 
 
16353 
class markOrdersAsReversalInitiated_args:
16354 
  """
16355 
  Attributes:
16356 
   - vendorId
16357 
   - itemId
16358 
   - quantity
16359 
   - estimate
4369 rajveer 16360 
   - isReminder
4303 rajveer 16361 
  """
16362 
 
16363 
  thrift_spec = (
16364 
    None, # 0
16365 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16366 
    (2, TType.I64, 'itemId', None, None, ), # 2
16367 
    (3, TType.I64, 'quantity', None, None, ), # 3
16368 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16369 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16370 
  )
16371 
 
4369 rajveer 16372 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16373 
    self.vendorId = vendorId
16374 
    self.itemId = itemId
16375 
    self.quantity = quantity
16376 
    self.estimate = estimate
4369 rajveer 16377 
    self.isReminder = isReminder
4303 rajveer 16378 
 
16379 
  def read(self, iprot):
16380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16382 
      return
16383 
    iprot.readStructBegin()
16384 
    while True:
16385 
      (fname, ftype, fid) = iprot.readFieldBegin()
16386 
      if ftype == TType.STOP:
16387 
        break
16388 
      if fid == 1:
16389 
        if ftype == TType.I64:
16390 
          self.vendorId = iprot.readI64();
16391 
        else:
16392 
          iprot.skip(ftype)
16393 
      elif fid == 2:
16394 
        if ftype == TType.I64:
16395 
          self.itemId = iprot.readI64();
16396 
        else:
16397 
          iprot.skip(ftype)
16398 
      elif fid == 3:
16399 
        if ftype == TType.I64:
16400 
          self.quantity = iprot.readI64();
16401 
        else:
16402 
          iprot.skip(ftype)
16403 
      elif fid == 4:
16404 
        if ftype == TType.I64:
16405 
          self.estimate = iprot.readI64();
16406 
        else:
16407 
          iprot.skip(ftype)
4369 rajveer 16408 
      elif fid == 5:
16409 
        if ftype == TType.BOOL:
16410 
          self.isReminder = iprot.readBool();
16411 
        else:
16412 
          iprot.skip(ftype)
4303 rajveer 16413 
      else:
16414 
        iprot.skip(ftype)
16415 
      iprot.readFieldEnd()
16416 
    iprot.readStructEnd()
16417 
 
16418 
  def write(self, oprot):
16419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16421 
      return
16422 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
16423 
    if self.vendorId is not None:
16424 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16425 
      oprot.writeI64(self.vendorId)
16426 
      oprot.writeFieldEnd()
16427 
    if self.itemId is not None:
16428 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16429 
      oprot.writeI64(self.itemId)
16430 
      oprot.writeFieldEnd()
16431 
    if self.quantity is not None:
16432 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16433 
      oprot.writeI64(self.quantity)
16434 
      oprot.writeFieldEnd()
16435 
    if self.estimate is not None:
16436 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16437 
      oprot.writeI64(self.estimate)
16438 
      oprot.writeFieldEnd()
4369 rajveer 16439 
    if self.isReminder is not None:
16440 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16441 
      oprot.writeBool(self.isReminder)
16442 
      oprot.writeFieldEnd()
4303 rajveer 16443 
    oprot.writeFieldStop()
16444 
    oprot.writeStructEnd()
16445 
 
16446 
  def validate(self):
16447 
    return
16448 
 
16449 
 
16450 
  def __repr__(self):
16451 
    L = ['%s=%r' % (key, value)
16452 
      for key, value in self.__dict__.iteritems()]
16453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16454 
 
16455 
  def __eq__(self, other):
16456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16457 
 
16458 
  def __ne__(self, other):
16459 
    return not (self == other)
16460 
 
16461 
class markOrdersAsReversalInitiated_result:
16462 
  """
16463 
  Attributes:
16464 
   - ex
16465 
  """
16466 
 
16467 
  thrift_spec = (
16468 
    None, # 0
16469 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16470 
  )
16471 
 
16472 
  def __init__(self, ex=None,):
16473 
    self.ex = ex
16474 
 
16475 
  def read(self, iprot):
16476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16478 
      return
16479 
    iprot.readStructBegin()
16480 
    while True:
16481 
      (fname, ftype, fid) = iprot.readFieldBegin()
16482 
      if ftype == TType.STOP:
16483 
        break
16484 
      if fid == 1:
16485 
        if ftype == TType.STRUCT:
16486 
          self.ex = TransactionServiceException()
16487 
          self.ex.read(iprot)
16488 
        else:
16489 
          iprot.skip(ftype)
16490 
      else:
16491 
        iprot.skip(ftype)
16492 
      iprot.readFieldEnd()
16493 
    iprot.readStructEnd()
16494 
 
16495 
  def write(self, oprot):
16496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16498 
      return
16499 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
16500 
    if self.ex is not None:
16501 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16502 
      self.ex.write(oprot)
16503 
      oprot.writeFieldEnd()
16504 
    oprot.writeFieldStop()
16505 
    oprot.writeStructEnd()
16506 
 
16507 
  def validate(self):
16508 
    return
16509 
 
16510 
 
16511 
  def __repr__(self):
16512 
    L = ['%s=%r' % (key, value)
16513 
      for key, value in self.__dict__.iteritems()]
16514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16515 
 
16516 
  def __eq__(self, other):
16517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16518 
 
16519 
  def __ne__(self, other):
16520 
    return not (self == other)
16521 
 
16522 
class markOrdersAsNotAvailabke_args:
16523 
  """
16524 
  Attributes:
16525 
   - vendorId
16526 
   - itemId
16527 
   - quantity
16528 
   - estimate
4369 rajveer 16529 
   - isReminder
4303 rajveer 16530 
  """
16531 
 
16532 
  thrift_spec = (
16533 
    None, # 0
16534 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16535 
    (2, TType.I64, 'itemId', None, None, ), # 2
16536 
    (3, TType.I64, 'quantity', None, None, ), # 3
16537 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16538 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16539 
  )
16540 
 
4369 rajveer 16541 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16542 
    self.vendorId = vendorId
16543 
    self.itemId = itemId
16544 
    self.quantity = quantity
16545 
    self.estimate = estimate
4369 rajveer 16546 
    self.isReminder = isReminder
4303 rajveer 16547 
 
16548 
  def read(self, iprot):
16549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16551 
      return
16552 
    iprot.readStructBegin()
16553 
    while True:
16554 
      (fname, ftype, fid) = iprot.readFieldBegin()
16555 
      if ftype == TType.STOP:
16556 
        break
16557 
      if fid == 1:
16558 
        if ftype == TType.I64:
16559 
          self.vendorId = iprot.readI64();
16560 
        else:
16561 
          iprot.skip(ftype)
16562 
      elif fid == 2:
16563 
        if ftype == TType.I64:
16564 
          self.itemId = iprot.readI64();
16565 
        else:
16566 
          iprot.skip(ftype)
16567 
      elif fid == 3:
16568 
        if ftype == TType.I64:
16569 
          self.quantity = iprot.readI64();
16570 
        else:
16571 
          iprot.skip(ftype)
16572 
      elif fid == 4:
16573 
        if ftype == TType.I64:
16574 
          self.estimate = iprot.readI64();
16575 
        else:
16576 
          iprot.skip(ftype)
4369 rajveer 16577 
      elif fid == 5:
16578 
        if ftype == TType.BOOL:
16579 
          self.isReminder = iprot.readBool();
16580 
        else:
16581 
          iprot.skip(ftype)
4303 rajveer 16582 
      else:
16583 
        iprot.skip(ftype)
16584 
      iprot.readFieldEnd()
16585 
    iprot.readStructEnd()
16586 
 
16587 
  def write(self, oprot):
16588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16590 
      return
16591 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
16592 
    if self.vendorId is not None:
16593 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16594 
      oprot.writeI64(self.vendorId)
16595 
      oprot.writeFieldEnd()
16596 
    if self.itemId is not None:
16597 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16598 
      oprot.writeI64(self.itemId)
16599 
      oprot.writeFieldEnd()
16600 
    if self.quantity is not None:
16601 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16602 
      oprot.writeI64(self.quantity)
16603 
      oprot.writeFieldEnd()
16604 
    if self.estimate is not None:
16605 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16606 
      oprot.writeI64(self.estimate)
16607 
      oprot.writeFieldEnd()
4369 rajveer 16608 
    if self.isReminder is not None:
16609 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16610 
      oprot.writeBool(self.isReminder)
16611 
      oprot.writeFieldEnd()
4303 rajveer 16612 
    oprot.writeFieldStop()
16613 
    oprot.writeStructEnd()
16614 
 
16615 
  def validate(self):
16616 
    return
16617 
 
16618 
 
16619 
  def __repr__(self):
16620 
    L = ['%s=%r' % (key, value)
16621 
      for key, value in self.__dict__.iteritems()]
16622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16623 
 
16624 
  def __eq__(self, other):
16625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16626 
 
16627 
  def __ne__(self, other):
16628 
    return not (self == other)
16629 
 
16630 
class markOrdersAsNotAvailabke_result:
16631 
  """
16632 
  Attributes:
16633 
   - ex
16634 
  """
16635 
 
16636 
  thrift_spec = (
16637 
    None, # 0
16638 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16639 
  )
16640 
 
16641 
  def __init__(self, ex=None,):
16642 
    self.ex = ex
16643 
 
16644 
  def read(self, iprot):
16645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16647 
      return
16648 
    iprot.readStructBegin()
16649 
    while True:
16650 
      (fname, ftype, fid) = iprot.readFieldBegin()
16651 
      if ftype == TType.STOP:
16652 
        break
16653 
      if fid == 1:
16654 
        if ftype == TType.STRUCT:
16655 
          self.ex = TransactionServiceException()
16656 
          self.ex.read(iprot)
16657 
        else:
16658 
          iprot.skip(ftype)
16659 
      else:
16660 
        iprot.skip(ftype)
16661 
      iprot.readFieldEnd()
16662 
    iprot.readStructEnd()
16663 
 
16664 
  def write(self, oprot):
16665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16667 
      return
16668 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
16669 
    if self.ex is not None:
16670 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16671 
      self.ex.write(oprot)
16672 
      oprot.writeFieldEnd()
16673 
    oprot.writeFieldStop()
16674 
    oprot.writeStructEnd()
16675 
 
16676 
  def validate(self):
16677 
    return
16678 
 
16679 
 
16680 
  def __repr__(self):
16681 
    L = ['%s=%r' % (key, value)
16682 
      for key, value in self.__dict__.iteritems()]
16683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16684 
 
16685 
  def __eq__(self, other):
16686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16687 
 
16688 
  def __ne__(self, other):
16689 
    return not (self == other)
4369 rajveer 16690 
 
16691 
class markOrdersAsTimeout_args:
16692 
  """
16693 
  Attributes:
16694 
   - vendorId
16695 
  """
16696 
 
16697 
  thrift_spec = (
16698 
    None, # 0
16699 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16700 
  )
16701 
 
16702 
  def __init__(self, vendorId=None,):
16703 
    self.vendorId = vendorId
16704 
 
16705 
  def read(self, iprot):
16706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16708 
      return
16709 
    iprot.readStructBegin()
16710 
    while True:
16711 
      (fname, ftype, fid) = iprot.readFieldBegin()
16712 
      if ftype == TType.STOP:
16713 
        break
16714 
      if fid == 1:
16715 
        if ftype == TType.I64:
16716 
          self.vendorId = iprot.readI64();
16717 
        else:
16718 
          iprot.skip(ftype)
16719 
      else:
16720 
        iprot.skip(ftype)
16721 
      iprot.readFieldEnd()
16722 
    iprot.readStructEnd()
16723 
 
16724 
  def write(self, oprot):
16725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16727 
      return
16728 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
16729 
    if self.vendorId is not None:
16730 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16731 
      oprot.writeI64(self.vendorId)
16732 
      oprot.writeFieldEnd()
16733 
    oprot.writeFieldStop()
16734 
    oprot.writeStructEnd()
16735 
 
16736 
  def validate(self):
16737 
    return
16738 
 
16739 
 
16740 
  def __repr__(self):
16741 
    L = ['%s=%r' % (key, value)
16742 
      for key, value in self.__dict__.iteritems()]
16743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16744 
 
16745 
  def __eq__(self, other):
16746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16747 
 
16748 
  def __ne__(self, other):
16749 
    return not (self == other)
16750 
 
16751 
class markOrdersAsTimeout_result:
16752 
  """
16753 
  Attributes:
16754 
   - success
16755 
   - ex
16756 
  """
16757 
 
16758 
  thrift_spec = (
16759 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
16760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16761 
  )
16762 
 
16763 
  def __init__(self, success=None, ex=None,):
16764 
    self.success = success
16765 
    self.ex = ex
16766 
 
16767 
  def read(self, iprot):
16768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16770 
      return
16771 
    iprot.readStructBegin()
16772 
    while True:
16773 
      (fname, ftype, fid) = iprot.readFieldBegin()
16774 
      if ftype == TType.STOP:
16775 
        break
16776 
      if fid == 0:
16777 
        if ftype == TType.MAP:
16778 
          self.success = {}
4586 mandeep.dh 16779 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
16780 
          for _i279 in xrange(_size275):
16781 
            _key280 = iprot.readI32();
16782 
            _val281 = TimeoutSummary()
16783 
            _val281.read(iprot)
16784 
            self.success[_key280] = _val281
4369 rajveer 16785 
          iprot.readMapEnd()
16786 
        else:
16787 
          iprot.skip(ftype)
16788 
      elif fid == 1:
16789 
        if ftype == TType.STRUCT:
16790 
          self.ex = TransactionServiceException()
16791 
          self.ex.read(iprot)
16792 
        else:
16793 
          iprot.skip(ftype)
16794 
      else:
16795 
        iprot.skip(ftype)
16796 
      iprot.readFieldEnd()
16797 
    iprot.readStructEnd()
16798 
 
16799 
  def write(self, oprot):
16800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16802 
      return
16803 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
16804 
    if self.success is not None:
16805 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16806 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4586 mandeep.dh 16807 
      for kiter282,viter283 in self.success.items():
16808 
        oprot.writeI32(kiter282)
16809 
        viter283.write(oprot)
4369 rajveer 16810 
      oprot.writeMapEnd()
16811 
      oprot.writeFieldEnd()
16812 
    if self.ex is not None:
16813 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16814 
      self.ex.write(oprot)
16815 
      oprot.writeFieldEnd()
16816 
    oprot.writeFieldStop()
16817 
    oprot.writeStructEnd()
16818 
 
16819 
  def validate(self):
16820 
    return
16821 
 
16822 
 
16823 
  def __repr__(self):
16824 
    L = ['%s=%r' % (key, value)
16825 
      for key, value in self.__dict__.iteritems()]
16826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16827 
 
16828 
  def __eq__(self, other):
16829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16830 
 
16831 
  def __ne__(self, other):
16832 
    return not (self == other)
4386 anupam.sin 16833 
 
4662 rajveer 16834 
class markOrderAsLostInTransit_args:
16835 
  """
16836 
  Attributes:
16837 
   - orderId
16838 
  """
16839 
 
16840 
  thrift_spec = (
16841 
    None, # 0
16842 
    (1, TType.I64, 'orderId', None, None, ), # 1
16843 
  )
16844 
 
16845 
  def __init__(self, orderId=None,):
16846 
    self.orderId = orderId
16847 
 
16848 
  def read(self, iprot):
16849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16851 
      return
16852 
    iprot.readStructBegin()
16853 
    while True:
16854 
      (fname, ftype, fid) = iprot.readFieldBegin()
16855 
      if ftype == TType.STOP:
16856 
        break
16857 
      if fid == 1:
16858 
        if ftype == TType.I64:
16859 
          self.orderId = iprot.readI64();
16860 
        else:
16861 
          iprot.skip(ftype)
16862 
      else:
16863 
        iprot.skip(ftype)
16864 
      iprot.readFieldEnd()
16865 
    iprot.readStructEnd()
16866 
 
16867 
  def write(self, oprot):
16868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16870 
      return
16871 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
16872 
    if self.orderId is not None:
16873 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16874 
      oprot.writeI64(self.orderId)
16875 
      oprot.writeFieldEnd()
16876 
    oprot.writeFieldStop()
16877 
    oprot.writeStructEnd()
16878 
 
16879 
  def validate(self):
16880 
    return
16881 
 
16882 
 
16883 
  def __repr__(self):
16884 
    L = ['%s=%r' % (key, value)
16885 
      for key, value in self.__dict__.iteritems()]
16886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16887 
 
16888 
  def __eq__(self, other):
16889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16890 
 
16891 
  def __ne__(self, other):
16892 
    return not (self == other)
16893 
 
16894 
class markOrderAsLostInTransit_result:
16895 
  """
16896 
  Attributes:
16897 
   - success
16898 
   - ex
16899 
  """
16900 
 
16901 
  thrift_spec = (
16902 
    (0, TType.BOOL, 'success', None, None, ), # 0
16903 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16904 
  )
16905 
 
16906 
  def __init__(self, success=None, ex=None,):
16907 
    self.success = success
16908 
    self.ex = ex
16909 
 
16910 
  def read(self, iprot):
16911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16913 
      return
16914 
    iprot.readStructBegin()
16915 
    while True:
16916 
      (fname, ftype, fid) = iprot.readFieldBegin()
16917 
      if ftype == TType.STOP:
16918 
        break
16919 
      if fid == 0:
16920 
        if ftype == TType.BOOL:
16921 
          self.success = iprot.readBool();
16922 
        else:
16923 
          iprot.skip(ftype)
16924 
      elif fid == 1:
16925 
        if ftype == TType.STRUCT:
16926 
          self.ex = TransactionServiceException()
16927 
          self.ex.read(iprot)
16928 
        else:
16929 
          iprot.skip(ftype)
16930 
      else:
16931 
        iprot.skip(ftype)
16932 
      iprot.readFieldEnd()
16933 
    iprot.readStructEnd()
16934 
 
16935 
  def write(self, oprot):
16936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16938 
      return
16939 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
16940 
    if self.success is not None:
16941 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16942 
      oprot.writeBool(self.success)
16943 
      oprot.writeFieldEnd()
16944 
    if self.ex is not None:
16945 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16946 
      self.ex.write(oprot)
16947 
      oprot.writeFieldEnd()
16948 
    oprot.writeFieldStop()
16949 
    oprot.writeStructEnd()
16950 
 
16951 
  def validate(self):
16952 
    return
16953 
 
16954 
 
16955 
  def __repr__(self):
16956 
    L = ['%s=%r' % (key, value)
16957 
      for key, value in self.__dict__.iteritems()]
16958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16959 
 
16960 
  def __eq__(self, other):
16961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16962 
 
16963 
  def __ne__(self, other):
16964 
    return not (self == other)
16965 
 
4386 anupam.sin 16966 
class getOrderForAwb_args:
16967 
  """
16968 
  Attributes:
16969 
   - awb
16970 
  """
16971 
 
16972 
  thrift_spec = (
16973 
    None, # 0
16974 
    (1, TType.STRING, 'awb', None, None, ), # 1
16975 
  )
16976 
 
16977 
  def __init__(self, awb=None,):
16978 
    self.awb = awb
16979 
 
16980 
  def read(self, iprot):
16981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16983 
      return
16984 
    iprot.readStructBegin()
16985 
    while True:
16986 
      (fname, ftype, fid) = iprot.readFieldBegin()
16987 
      if ftype == TType.STOP:
16988 
        break
16989 
      if fid == 1:
16990 
        if ftype == TType.STRING:
16991 
          self.awb = iprot.readString();
16992 
        else:
16993 
          iprot.skip(ftype)
16994 
      else:
16995 
        iprot.skip(ftype)
16996 
      iprot.readFieldEnd()
16997 
    iprot.readStructEnd()
16998 
 
16999 
  def write(self, oprot):
17000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17002 
      return
17003 
    oprot.writeStructBegin('getOrderForAwb_args')
17004 
    if self.awb is not None:
17005 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
17006 
      oprot.writeString(self.awb)
17007 
      oprot.writeFieldEnd()
17008 
    oprot.writeFieldStop()
17009 
    oprot.writeStructEnd()
17010 
 
17011 
  def validate(self):
17012 
    return
17013 
 
17014 
 
17015 
  def __repr__(self):
17016 
    L = ['%s=%r' % (key, value)
17017 
      for key, value in self.__dict__.iteritems()]
17018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17019 
 
17020 
  def __eq__(self, other):
17021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17022 
 
17023 
  def __ne__(self, other):
17024 
    return not (self == other)
17025 
 
17026 
class getOrderForAwb_result:
17027 
  """
17028 
  Attributes:
17029 
   - success
17030 
   - ex
17031 
  """
17032 
 
17033 
  thrift_spec = (
17034 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17035 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17036 
  )
17037 
 
17038 
  def __init__(self, success=None, ex=None,):
17039 
    self.success = success
17040 
    self.ex = ex
17041 
 
17042 
  def read(self, iprot):
17043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17045 
      return
17046 
    iprot.readStructBegin()
17047 
    while True:
17048 
      (fname, ftype, fid) = iprot.readFieldBegin()
17049 
      if ftype == TType.STOP:
17050 
        break
17051 
      if fid == 0:
17052 
        if ftype == TType.STRUCT:
17053 
          self.success = Order()
17054 
          self.success.read(iprot)
17055 
        else:
17056 
          iprot.skip(ftype)
17057 
      elif fid == 1:
17058 
        if ftype == TType.STRUCT:
17059 
          self.ex = TransactionServiceException()
17060 
          self.ex.read(iprot)
17061 
        else:
17062 
          iprot.skip(ftype)
17063 
      else:
17064 
        iprot.skip(ftype)
17065 
      iprot.readFieldEnd()
17066 
    iprot.readStructEnd()
17067 
 
17068 
  def write(self, oprot):
17069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17071 
      return
17072 
    oprot.writeStructBegin('getOrderForAwb_result')
17073 
    if self.success is not None:
17074 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17075 
      self.success.write(oprot)
17076 
      oprot.writeFieldEnd()
17077 
    if self.ex is not None:
17078 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17079 
      self.ex.write(oprot)
17080 
      oprot.writeFieldEnd()
17081 
    oprot.writeFieldStop()
17082 
    oprot.writeStructEnd()
17083 
 
17084 
  def validate(self):
17085 
    return
17086 
 
17087 
 
17088 
  def __repr__(self):
17089 
    L = ['%s=%r' % (key, value)
17090 
      for key, value in self.__dict__.iteritems()]
17091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17092 
 
17093 
  def __eq__(self, other):
17094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17095 
 
17096 
  def __ne__(self, other):
17097 
    return not (self == other)
4506 phani.kuma 17098 
 
17099 
class getOrdersForProviderForStatus_args:
17100 
  """
17101 
  Attributes:
17102 
   - logistics_provider_id
17103 
   - order_status
17104 
  """
17105 
 
17106 
  thrift_spec = (
17107 
    None, # 0
17108 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
17109 
    (2, TType.I32, 'order_status', None, None, ), # 2
17110 
  )
17111 
 
17112 
  def __init__(self, logistics_provider_id=None, order_status=None,):
17113 
    self.logistics_provider_id = logistics_provider_id
17114 
    self.order_status = order_status
17115 
 
17116 
  def read(self, iprot):
17117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17119 
      return
17120 
    iprot.readStructBegin()
17121 
    while True:
17122 
      (fname, ftype, fid) = iprot.readFieldBegin()
17123 
      if ftype == TType.STOP:
17124 
        break
17125 
      if fid == 1:
17126 
        if ftype == TType.I64:
17127 
          self.logistics_provider_id = iprot.readI64();
17128 
        else:
17129 
          iprot.skip(ftype)
17130 
      elif fid == 2:
17131 
        if ftype == TType.I32:
17132 
          self.order_status = iprot.readI32();
17133 
        else:
17134 
          iprot.skip(ftype)
17135 
      else:
17136 
        iprot.skip(ftype)
17137 
      iprot.readFieldEnd()
17138 
    iprot.readStructEnd()
17139 
 
17140 
  def write(self, oprot):
17141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17143 
      return
17144 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
17145 
    if self.logistics_provider_id is not None:
17146 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
17147 
      oprot.writeI64(self.logistics_provider_id)
17148 
      oprot.writeFieldEnd()
17149 
    if self.order_status is not None:
17150 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
17151 
      oprot.writeI32(self.order_status)
17152 
      oprot.writeFieldEnd()
17153 
    oprot.writeFieldStop()
17154 
    oprot.writeStructEnd()
17155 
 
17156 
  def validate(self):
17157 
    return
17158 
 
17159 
 
17160 
  def __repr__(self):
17161 
    L = ['%s=%r' % (key, value)
17162 
      for key, value in self.__dict__.iteritems()]
17163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17164 
 
17165 
  def __eq__(self, other):
17166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17167 
 
17168 
  def __ne__(self, other):
17169 
    return not (self == other)
17170 
 
17171 
class getOrdersForProviderForStatus_result:
17172 
  """
17173 
  Attributes:
17174 
   - success
17175 
   - ex
17176 
  """
17177 
 
17178 
  thrift_spec = (
17179 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17180 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17181 
  )
17182 
 
17183 
  def __init__(self, success=None, ex=None,):
17184 
    self.success = success
17185 
    self.ex = ex
17186 
 
17187 
  def read(self, iprot):
17188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17190 
      return
17191 
    iprot.readStructBegin()
17192 
    while True:
17193 
      (fname, ftype, fid) = iprot.readFieldBegin()
17194 
      if ftype == TType.STOP:
17195 
        break
17196 
      if fid == 0:
17197 
        if ftype == TType.LIST:
17198 
          self.success = []
4586 mandeep.dh 17199 
          (_etype287, _size284) = iprot.readListBegin()
17200 
          for _i288 in xrange(_size284):
17201 
            _elem289 = Order()
17202 
            _elem289.read(iprot)
17203 
            self.success.append(_elem289)
4506 phani.kuma 17204 
          iprot.readListEnd()
17205 
        else:
17206 
          iprot.skip(ftype)
17207 
      elif fid == 1:
17208 
        if ftype == TType.STRUCT:
17209 
          self.ex = TransactionServiceException()
17210 
          self.ex.read(iprot)
17211 
        else:
17212 
          iprot.skip(ftype)
17213 
      else:
17214 
        iprot.skip(ftype)
17215 
      iprot.readFieldEnd()
17216 
    iprot.readStructEnd()
17217 
 
17218 
  def write(self, oprot):
17219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17221 
      return
17222 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
17223 
    if self.success is not None:
17224 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17225 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 17226 
      for iter290 in self.success:
17227 
        iter290.write(oprot)
4506 phani.kuma 17228 
      oprot.writeListEnd()
17229 
      oprot.writeFieldEnd()
17230 
    if self.ex is not None:
17231 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17232 
      self.ex.write(oprot)
17233 
      oprot.writeFieldEnd()
17234 
    oprot.writeFieldStop()
17235 
    oprot.writeStructEnd()
17236 
 
17237 
  def validate(self):
17238 
    return
17239 
 
17240 
 
17241 
  def __repr__(self):
17242 
    L = ['%s=%r' % (key, value)
17243 
      for key, value in self.__dict__.iteritems()]
17244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17245 
 
17246 
  def __eq__(self, other):
17247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17248 
 
17249 
  def __ne__(self, other):
17250 
    return not (self == other)
4600 varun.gupt 17251 
 
17252 
class getBilledOrdersForVendor_args:
17253 
  """
17254 
  Attributes:
17255 
   - vendorId
17256 
   - billingDateFrom
17257 
   - billingDateTo
17258 
  """
17259 
 
17260 
  thrift_spec = (
17261 
    None, # 0
17262 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17263 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
17264 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
17265 
  )
17266 
 
17267 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
17268 
    self.vendorId = vendorId
17269 
    self.billingDateFrom = billingDateFrom
17270 
    self.billingDateTo = billingDateTo
17271 
 
17272 
  def read(self, iprot):
17273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17275 
      return
17276 
    iprot.readStructBegin()
17277 
    while True:
17278 
      (fname, ftype, fid) = iprot.readFieldBegin()
17279 
      if ftype == TType.STOP:
17280 
        break
17281 
      if fid == 1:
17282 
        if ftype == TType.I64:
17283 
          self.vendorId = iprot.readI64();
17284 
        else:
17285 
          iprot.skip(ftype)
17286 
      elif fid == 2:
17287 
        if ftype == TType.I64:
17288 
          self.billingDateFrom = iprot.readI64();
17289 
        else:
17290 
          iprot.skip(ftype)
17291 
      elif fid == 3:
17292 
        if ftype == TType.I64:
17293 
          self.billingDateTo = iprot.readI64();
17294 
        else:
17295 
          iprot.skip(ftype)
17296 
      else:
17297 
        iprot.skip(ftype)
17298 
      iprot.readFieldEnd()
17299 
    iprot.readStructEnd()
17300 
 
17301 
  def write(self, oprot):
17302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17304 
      return
17305 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
17306 
    if self.vendorId is not None:
17307 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17308 
      oprot.writeI64(self.vendorId)
17309 
      oprot.writeFieldEnd()
17310 
    if self.billingDateFrom is not None:
17311 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
17312 
      oprot.writeI64(self.billingDateFrom)
17313 
      oprot.writeFieldEnd()
17314 
    if self.billingDateTo is not None:
17315 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
17316 
      oprot.writeI64(self.billingDateTo)
17317 
      oprot.writeFieldEnd()
17318 
    oprot.writeFieldStop()
17319 
    oprot.writeStructEnd()
17320 
 
17321 
  def validate(self):
17322 
    return
17323 
 
17324 
 
17325 
  def __repr__(self):
17326 
    L = ['%s=%r' % (key, value)
17327 
      for key, value in self.__dict__.iteritems()]
17328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17329 
 
17330 
  def __eq__(self, other):
17331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17332 
 
17333 
  def __ne__(self, other):
17334 
    return not (self == other)
17335 
 
17336 
class getBilledOrdersForVendor_result:
17337 
  """
17338 
  Attributes:
17339 
   - success
17340 
   - ex
17341 
  """
17342 
 
17343 
  thrift_spec = (
17344 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17345 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17346 
  )
17347 
 
17348 
  def __init__(self, success=None, ex=None,):
17349 
    self.success = success
17350 
    self.ex = ex
17351 
 
17352 
  def read(self, iprot):
17353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17355 
      return
17356 
    iprot.readStructBegin()
17357 
    while True:
17358 
      (fname, ftype, fid) = iprot.readFieldBegin()
17359 
      if ftype == TType.STOP:
17360 
        break
17361 
      if fid == 0:
17362 
        if ftype == TType.LIST:
17363 
          self.success = []
17364 
          (_etype294, _size291) = iprot.readListBegin()
17365 
          for _i295 in xrange(_size291):
17366 
            _elem296 = Order()
17367 
            _elem296.read(iprot)
17368 
            self.success.append(_elem296)
17369 
          iprot.readListEnd()
17370 
        else:
17371 
          iprot.skip(ftype)
17372 
      elif fid == 1:
17373 
        if ftype == TType.STRUCT:
17374 
          self.ex = TransactionServiceException()
17375 
          self.ex.read(iprot)
17376 
        else:
17377 
          iprot.skip(ftype)
17378 
      else:
17379 
        iprot.skip(ftype)
17380 
      iprot.readFieldEnd()
17381 
    iprot.readStructEnd()
17382 
 
17383 
  def write(self, oprot):
17384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17386 
      return
17387 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
17388 
    if self.success is not None:
17389 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17390 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17391 
      for iter297 in self.success:
17392 
        iter297.write(oprot)
17393 
      oprot.writeListEnd()
17394 
      oprot.writeFieldEnd()
17395 
    if self.ex is not None:
17396 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17397 
      self.ex.write(oprot)
17398 
      oprot.writeFieldEnd()
17399 
    oprot.writeFieldStop()
17400 
    oprot.writeStructEnd()
17401 
 
17402 
  def validate(self):
17403 
    return
17404 
 
17405 
 
17406 
  def __repr__(self):
17407 
    L = ['%s=%r' % (key, value)
17408 
      for key, value in self.__dict__.iteritems()]
17409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17410 
 
17411 
  def __eq__(self, other):
17412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17413 
 
17414 
  def __ne__(self, other):
17415 
    return not (self == other)
17416 
 
4607 rajveer 17417 
class getSlippedSippingDateOrders_args:
17418 
 
17419 
  thrift_spec = (
17420 
  )
17421 
 
17422 
  def read(self, iprot):
17423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17425 
      return
17426 
    iprot.readStructBegin()
17427 
    while True:
17428 
      (fname, ftype, fid) = iprot.readFieldBegin()
17429 
      if ftype == TType.STOP:
17430 
        break
17431 
      else:
17432 
        iprot.skip(ftype)
17433 
      iprot.readFieldEnd()
17434 
    iprot.readStructEnd()
17435 
 
17436 
  def write(self, oprot):
17437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17439 
      return
17440 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
17441 
    oprot.writeFieldStop()
17442 
    oprot.writeStructEnd()
17443 
 
17444 
  def validate(self):
17445 
    return
17446 
 
17447 
 
17448 
  def __repr__(self):
17449 
    L = ['%s=%r' % (key, value)
17450 
      for key, value in self.__dict__.iteritems()]
17451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17452 
 
17453 
  def __eq__(self, other):
17454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17455 
 
17456 
  def __ne__(self, other):
17457 
    return not (self == other)
17458 
 
17459 
class getSlippedSippingDateOrders_result:
17460 
  """
17461 
  Attributes:
17462 
   - success
17463 
   - ex
17464 
  """
17465 
 
17466 
  thrift_spec = (
17467 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17468 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17469 
  )
17470 
 
17471 
  def __init__(self, success=None, ex=None,):
17472 
    self.success = success
17473 
    self.ex = ex
17474 
 
17475 
  def read(self, iprot):
17476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17478 
      return
17479 
    iprot.readStructBegin()
17480 
    while True:
17481 
      (fname, ftype, fid) = iprot.readFieldBegin()
17482 
      if ftype == TType.STOP:
17483 
        break
17484 
      if fid == 0:
17485 
        if ftype == TType.LIST:
17486 
          self.success = []
17487 
          (_etype301, _size298) = iprot.readListBegin()
17488 
          for _i302 in xrange(_size298):
17489 
            _elem303 = Order()
17490 
            _elem303.read(iprot)
17491 
            self.success.append(_elem303)
17492 
          iprot.readListEnd()
17493 
        else:
17494 
          iprot.skip(ftype)
17495 
      elif fid == 1:
17496 
        if ftype == TType.STRUCT:
17497 
          self.ex = TransactionServiceException()
17498 
          self.ex.read(iprot)
17499 
        else:
17500 
          iprot.skip(ftype)
17501 
      else:
17502 
        iprot.skip(ftype)
17503 
      iprot.readFieldEnd()
17504 
    iprot.readStructEnd()
17505 
 
17506 
  def write(self, oprot):
17507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17509 
      return
17510 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
17511 
    if self.success is not None:
17512 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17513 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17514 
      for iter304 in self.success:
17515 
        iter304.write(oprot)
17516 
      oprot.writeListEnd()
17517 
      oprot.writeFieldEnd()
17518 
    if self.ex is not None:
17519 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17520 
      self.ex.write(oprot)
17521 
      oprot.writeFieldEnd()
17522 
    oprot.writeFieldStop()
17523 
    oprot.writeStructEnd()
17524 
 
17525 
  def validate(self):
17526 
    return
17527 
 
17528 
 
17529 
  def __repr__(self):
17530 
    L = ['%s=%r' % (key, value)
17531 
      for key, value in self.__dict__.iteritems()]
17532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17533 
 
17534 
  def __eq__(self, other):
17535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17536 
 
17537 
  def __ne__(self, other):
17538 
    return not (self == other)
17539 
 
4709 rajveer 17540 
class getCancelledOrders_args:
17541 
  """
17542 
  Attributes:
17543 
   - cancelDateFrom
17544 
   - cancelDateTo
17545 
  """
17546 
 
17547 
  thrift_spec = (
17548 
    None, # 0
17549 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
17550 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
17551 
  )
17552 
 
17553 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
17554 
    self.cancelDateFrom = cancelDateFrom
17555 
    self.cancelDateTo = cancelDateTo
17556 
 
17557 
  def read(self, iprot):
17558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17560 
      return
17561 
    iprot.readStructBegin()
17562 
    while True:
17563 
      (fname, ftype, fid) = iprot.readFieldBegin()
17564 
      if ftype == TType.STOP:
17565 
        break
17566 
      if fid == 1:
17567 
        if ftype == TType.I64:
17568 
          self.cancelDateFrom = iprot.readI64();
17569 
        else:
17570 
          iprot.skip(ftype)
17571 
      elif fid == 2:
17572 
        if ftype == TType.I64:
17573 
          self.cancelDateTo = iprot.readI64();
17574 
        else:
17575 
          iprot.skip(ftype)
17576 
      else:
17577 
        iprot.skip(ftype)
17578 
      iprot.readFieldEnd()
17579 
    iprot.readStructEnd()
17580 
 
17581 
  def write(self, oprot):
17582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17584 
      return
17585 
    oprot.writeStructBegin('getCancelledOrders_args')
17586 
    if self.cancelDateFrom is not None:
17587 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
17588 
      oprot.writeI64(self.cancelDateFrom)
17589 
      oprot.writeFieldEnd()
17590 
    if self.cancelDateTo is not None:
17591 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
17592 
      oprot.writeI64(self.cancelDateTo)
17593 
      oprot.writeFieldEnd()
17594 
    oprot.writeFieldStop()
17595 
    oprot.writeStructEnd()
17596 
 
17597 
  def validate(self):
17598 
    return
17599 
 
17600 
 
17601 
  def __repr__(self):
17602 
    L = ['%s=%r' % (key, value)
17603 
      for key, value in self.__dict__.iteritems()]
17604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17605 
 
17606 
  def __eq__(self, other):
17607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17608 
 
17609 
  def __ne__(self, other):
17610 
    return not (self == other)
17611 
 
17612 
class getCancelledOrders_result:
17613 
  """
17614 
  Attributes:
17615 
   - success
17616 
   - ex
17617 
  """
17618 
 
17619 
  thrift_spec = (
17620 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17621 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17622 
  )
17623 
 
17624 
  def __init__(self, success=None, ex=None,):
17625 
    self.success = success
17626 
    self.ex = ex
17627 
 
17628 
  def read(self, iprot):
17629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17631 
      return
17632 
    iprot.readStructBegin()
17633 
    while True:
17634 
      (fname, ftype, fid) = iprot.readFieldBegin()
17635 
      if ftype == TType.STOP:
17636 
        break
17637 
      if fid == 0:
17638 
        if ftype == TType.LIST:
17639 
          self.success = []
17640 
          (_etype308, _size305) = iprot.readListBegin()
17641 
          for _i309 in xrange(_size305):
17642 
            _elem310 = Order()
17643 
            _elem310.read(iprot)
17644 
            self.success.append(_elem310)
17645 
          iprot.readListEnd()
17646 
        else:
17647 
          iprot.skip(ftype)
17648 
      elif fid == 1:
17649 
        if ftype == TType.STRUCT:
17650 
          self.ex = TransactionServiceException()
17651 
          self.ex.read(iprot)
17652 
        else:
17653 
          iprot.skip(ftype)
17654 
      else:
17655 
        iprot.skip(ftype)
17656 
      iprot.readFieldEnd()
17657 
    iprot.readStructEnd()
17658 
 
17659 
  def write(self, oprot):
17660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17662 
      return
17663 
    oprot.writeStructBegin('getCancelledOrders_result')
17664 
    if self.success is not None:
17665 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17666 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17667 
      for iter311 in self.success:
17668 
        iter311.write(oprot)
17669 
      oprot.writeListEnd()
17670 
      oprot.writeFieldEnd()
17671 
    if self.ex is not None:
17672 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17673 
      self.ex.write(oprot)
17674 
      oprot.writeFieldEnd()
17675 
    oprot.writeFieldStop()
17676 
    oprot.writeStructEnd()
17677 
 
17678 
  def validate(self):
17679 
    return
17680 
 
17681 
 
17682 
  def __repr__(self):
17683 
    L = ['%s=%r' % (key, value)
17684 
      for key, value in self.__dict__.iteritems()]
17685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17686 
 
17687 
  def __eq__(self, other):
17688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17689 
 
17690 
  def __ne__(self, other):
17691 
    return not (self == other)
17692 
 
4600 varun.gupt 17693 
class saveBluedartSettlements_args:
17694 
  """
17695 
  Attributes:
17696 
   - mapAWBAndAmount
17697 
  """
17698 
 
17699 
  thrift_spec = (
17700 
    None, # 0
17701 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
17702 
  )
17703 
 
17704 
  def __init__(self, mapAWBAndAmount=None,):
17705 
    self.mapAWBAndAmount = mapAWBAndAmount
17706 
 
17707 
  def read(self, iprot):
17708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17710 
      return
17711 
    iprot.readStructBegin()
17712 
    while True:
17713 
      (fname, ftype, fid) = iprot.readFieldBegin()
17714 
      if ftype == TType.STOP:
17715 
        break
17716 
      if fid == 1:
17717 
        if ftype == TType.MAP:
17718 
          self.mapAWBAndAmount = {}
4709 rajveer 17719 
          (_ktype313, _vtype314, _size312 ) = iprot.readMapBegin()
17720 
          for _i316 in xrange(_size312):
17721 
            _key317 = iprot.readI64();
17722 
            _val318 = iprot.readDouble();
17723 
            self.mapAWBAndAmount[_key317] = _val318
4600 varun.gupt 17724 
          iprot.readMapEnd()
17725 
        else:
17726 
          iprot.skip(ftype)
17727 
      else:
17728 
        iprot.skip(ftype)
17729 
      iprot.readFieldEnd()
17730 
    iprot.readStructEnd()
17731 
 
17732 
  def write(self, oprot):
17733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17735 
      return
17736 
    oprot.writeStructBegin('saveBluedartSettlements_args')
17737 
    if self.mapAWBAndAmount is not None:
17738 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
17739 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
4709 rajveer 17740 
      for kiter319,viter320 in self.mapAWBAndAmount.items():
17741 
        oprot.writeI64(kiter319)
17742 
        oprot.writeDouble(viter320)
4600 varun.gupt 17743 
      oprot.writeMapEnd()
17744 
      oprot.writeFieldEnd()
17745 
    oprot.writeFieldStop()
17746 
    oprot.writeStructEnd()
17747 
 
17748 
  def validate(self):
17749 
    return
17750 
 
17751 
 
17752 
  def __repr__(self):
17753 
    L = ['%s=%r' % (key, value)
17754 
      for key, value in self.__dict__.iteritems()]
17755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17756 
 
17757 
  def __eq__(self, other):
17758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17759 
 
17760 
  def __ne__(self, other):
17761 
    return not (self == other)
17762 
 
17763 
class saveBluedartSettlements_result:
17764 
  """
17765 
  Attributes:
17766 
   - ex
17767 
  """
17768 
 
17769 
  thrift_spec = (
17770 
    None, # 0
17771 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17772 
  )
17773 
 
17774 
  def __init__(self, ex=None,):
17775 
    self.ex = ex
17776 
 
17777 
  def read(self, iprot):
17778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17780 
      return
17781 
    iprot.readStructBegin()
17782 
    while True:
17783 
      (fname, ftype, fid) = iprot.readFieldBegin()
17784 
      if ftype == TType.STOP:
17785 
        break
17786 
      if fid == 1:
17787 
        if ftype == TType.STRUCT:
17788 
          self.ex = TransactionServiceException()
17789 
          self.ex.read(iprot)
17790 
        else:
17791 
          iprot.skip(ftype)
17792 
      else:
17793 
        iprot.skip(ftype)
17794 
      iprot.readFieldEnd()
17795 
    iprot.readStructEnd()
17796 
 
17797 
  def write(self, oprot):
17798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17800 
      return
17801 
    oprot.writeStructBegin('saveBluedartSettlements_result')
17802 
    if self.ex is not None:
17803 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17804 
      self.ex.write(oprot)
17805 
      oprot.writeFieldEnd()
17806 
    oprot.writeFieldStop()
17807 
    oprot.writeStructEnd()
17808 
 
17809 
  def validate(self):
17810 
    return
17811 
 
17812 
 
17813 
  def __repr__(self):
17814 
    L = ['%s=%r' % (key, value)
17815 
      for key, value in self.__dict__.iteritems()]
17816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17817 
 
17818 
  def __eq__(self, other):
17819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17820 
 
17821 
  def __ne__(self, other):
17822 
    return not (self == other)
17823 
 
17824 
class savePaymentSettlements_args:
17825 
  """
17826 
  Attributes:
17827 
   - settlementDate
17828 
   - paymentGatewayId
17829 
   - paymentId
17830 
   - serviceTax
17831 
   - otherCharges
17832 
   - netCollection
17833 
  """
17834 
 
17835 
  thrift_spec = (
17836 
    None, # 0
17837 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
17838 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
17839 
    (3, TType.I64, 'paymentId', None, None, ), # 3
17840 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
17841 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
17842 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
17843 
  )
17844 
 
17845 
  def __init__(self, settlementDate=None, paymentGatewayId=None, paymentId=None, serviceTax=None, otherCharges=None, netCollection=None,):
17846 
    self.settlementDate = settlementDate
17847 
    self.paymentGatewayId = paymentGatewayId
17848 
    self.paymentId = paymentId
17849 
    self.serviceTax = serviceTax
17850 
    self.otherCharges = otherCharges
17851 
    self.netCollection = netCollection
17852 
 
17853 
  def read(self, iprot):
17854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17856 
      return
17857 
    iprot.readStructBegin()
17858 
    while True:
17859 
      (fname, ftype, fid) = iprot.readFieldBegin()
17860 
      if ftype == TType.STOP:
17861 
        break
17862 
      if fid == 1:
17863 
        if ftype == TType.I64:
17864 
          self.settlementDate = iprot.readI64();
17865 
        else:
17866 
          iprot.skip(ftype)
17867 
      elif fid == 2:
17868 
        if ftype == TType.I64:
17869 
          self.paymentGatewayId = iprot.readI64();
17870 
        else:
17871 
          iprot.skip(ftype)
17872 
      elif fid == 3:
17873 
        if ftype == TType.I64:
17874 
          self.paymentId = iprot.readI64();
17875 
        else:
17876 
          iprot.skip(ftype)
17877 
      elif fid == 4:
17878 
        if ftype == TType.DOUBLE:
17879 
          self.serviceTax = iprot.readDouble();
17880 
        else:
17881 
          iprot.skip(ftype)
17882 
      elif fid == 5:
17883 
        if ftype == TType.DOUBLE:
17884 
          self.otherCharges = iprot.readDouble();
17885 
        else:
17886 
          iprot.skip(ftype)
17887 
      elif fid == 6:
17888 
        if ftype == TType.DOUBLE:
17889 
          self.netCollection = iprot.readDouble();
17890 
        else:
17891 
          iprot.skip(ftype)
17892 
      else:
17893 
        iprot.skip(ftype)
17894 
      iprot.readFieldEnd()
17895 
    iprot.readStructEnd()
17896 
 
17897 
  def write(self, oprot):
17898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17900 
      return
17901 
    oprot.writeStructBegin('savePaymentSettlements_args')
17902 
    if self.settlementDate is not None:
17903 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
17904 
      oprot.writeI64(self.settlementDate)
17905 
      oprot.writeFieldEnd()
17906 
    if self.paymentGatewayId is not None:
17907 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
17908 
      oprot.writeI64(self.paymentGatewayId)
17909 
      oprot.writeFieldEnd()
17910 
    if self.paymentId is not None:
17911 
      oprot.writeFieldBegin('paymentId', TType.I64, 3)
17912 
      oprot.writeI64(self.paymentId)
17913 
      oprot.writeFieldEnd()
17914 
    if self.serviceTax is not None:
17915 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
17916 
      oprot.writeDouble(self.serviceTax)
17917 
      oprot.writeFieldEnd()
17918 
    if self.otherCharges is not None:
17919 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
17920 
      oprot.writeDouble(self.otherCharges)
17921 
      oprot.writeFieldEnd()
17922 
    if self.netCollection is not None:
17923 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
17924 
      oprot.writeDouble(self.netCollection)
17925 
      oprot.writeFieldEnd()
17926 
    oprot.writeFieldStop()
17927 
    oprot.writeStructEnd()
17928 
 
17929 
  def validate(self):
17930 
    return
17931 
 
17932 
 
17933 
  def __repr__(self):
17934 
    L = ['%s=%r' % (key, value)
17935 
      for key, value in self.__dict__.iteritems()]
17936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17937 
 
17938 
  def __eq__(self, other):
17939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17940 
 
17941 
  def __ne__(self, other):
17942 
    return not (self == other)
17943 
 
17944 
class savePaymentSettlements_result:
17945 
  """
17946 
  Attributes:
17947 
   - ex
17948 
  """
17949 
 
17950 
  thrift_spec = (
17951 
    None, # 0
17952 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17953 
  )
17954 
 
17955 
  def __init__(self, ex=None,):
17956 
    self.ex = ex
17957 
 
17958 
  def read(self, iprot):
17959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17961 
      return
17962 
    iprot.readStructBegin()
17963 
    while True:
17964 
      (fname, ftype, fid) = iprot.readFieldBegin()
17965 
      if ftype == TType.STOP:
17966 
        break
17967 
      if fid == 1:
17968 
        if ftype == TType.STRUCT:
17969 
          self.ex = TransactionServiceException()
17970 
          self.ex.read(iprot)
17971 
        else:
17972 
          iprot.skip(ftype)
17973 
      else:
17974 
        iprot.skip(ftype)
17975 
      iprot.readFieldEnd()
17976 
    iprot.readStructEnd()
17977 
 
17978 
  def write(self, oprot):
17979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17981 
      return
17982 
    oprot.writeStructBegin('savePaymentSettlements_result')
17983 
    if self.ex is not None:
17984 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17985 
      self.ex.write(oprot)
17986 
      oprot.writeFieldEnd()
17987 
    oprot.writeFieldStop()
17988 
    oprot.writeStructEnd()
17989 
 
17990 
  def validate(self):
17991 
    return
17992 
 
17993 
 
17994 
  def __repr__(self):
17995 
    L = ['%s=%r' % (key, value)
17996 
      for key, value in self.__dict__.iteritems()]
17997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17998 
 
17999 
  def __eq__(self, other):
18000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18001 
 
18002 
  def __ne__(self, other):
18003 
    return not (self == other)
18004 
 
18005 
class saveEBSSettlementSummary_args:
18006 
  """
18007 
  Attributes:
18008 
   - settlementId
18009 
   - settlementDate
18010 
   - transactionDateFrom
18011 
   - transactionDateTo
18012 
   - amount
18013 
  """
18014 
 
18015 
  thrift_spec = (
18016 
    None, # 0
18017 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18018 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
18019 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
18020 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
18021 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
18022 
  )
18023 
 
18024 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
18025 
    self.settlementId = settlementId
18026 
    self.settlementDate = settlementDate
18027 
    self.transactionDateFrom = transactionDateFrom
18028 
    self.transactionDateTo = transactionDateTo
18029 
    self.amount = amount
18030 
 
18031 
  def read(self, iprot):
18032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18034 
      return
18035 
    iprot.readStructBegin()
18036 
    while True:
18037 
      (fname, ftype, fid) = iprot.readFieldBegin()
18038 
      if ftype == TType.STOP:
18039 
        break
18040 
      if fid == 1:
18041 
        if ftype == TType.I64:
18042 
          self.settlementId = iprot.readI64();
18043 
        else:
18044 
          iprot.skip(ftype)
18045 
      elif fid == 2:
18046 
        if ftype == TType.I64:
18047 
          self.settlementDate = iprot.readI64();
18048 
        else:
18049 
          iprot.skip(ftype)
18050 
      elif fid == 3:
18051 
        if ftype == TType.I64:
18052 
          self.transactionDateFrom = iprot.readI64();
18053 
        else:
18054 
          iprot.skip(ftype)
18055 
      elif fid == 4:
18056 
        if ftype == TType.I64:
18057 
          self.transactionDateTo = iprot.readI64();
18058 
        else:
18059 
          iprot.skip(ftype)
18060 
      elif fid == 5:
18061 
        if ftype == TType.DOUBLE:
18062 
          self.amount = iprot.readDouble();
18063 
        else:
18064 
          iprot.skip(ftype)
18065 
      else:
18066 
        iprot.skip(ftype)
18067 
      iprot.readFieldEnd()
18068 
    iprot.readStructEnd()
18069 
 
18070 
  def write(self, oprot):
18071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18073 
      return
18074 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
18075 
    if self.settlementId is not None:
18076 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18077 
      oprot.writeI64(self.settlementId)
18078 
      oprot.writeFieldEnd()
18079 
    if self.settlementDate is not None:
18080 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
18081 
      oprot.writeI64(self.settlementDate)
18082 
      oprot.writeFieldEnd()
18083 
    if self.transactionDateFrom is not None:
18084 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
18085 
      oprot.writeI64(self.transactionDateFrom)
18086 
      oprot.writeFieldEnd()
18087 
    if self.transactionDateTo is not None:
18088 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
18089 
      oprot.writeI64(self.transactionDateTo)
18090 
      oprot.writeFieldEnd()
18091 
    if self.amount is not None:
18092 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
18093 
      oprot.writeDouble(self.amount)
18094 
      oprot.writeFieldEnd()
18095 
    oprot.writeFieldStop()
18096 
    oprot.writeStructEnd()
18097 
 
18098 
  def validate(self):
18099 
    return
18100 
 
18101 
 
18102 
  def __repr__(self):
18103 
    L = ['%s=%r' % (key, value)
18104 
      for key, value in self.__dict__.iteritems()]
18105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18106 
 
18107 
  def __eq__(self, other):
18108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18109 
 
18110 
  def __ne__(self, other):
18111 
    return not (self == other)
18112 
 
18113 
class saveEBSSettlementSummary_result:
18114 
  """
18115 
  Attributes:
18116 
   - ex
18117 
  """
18118 
 
18119 
  thrift_spec = (
18120 
    None, # 0
18121 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18122 
  )
18123 
 
18124 
  def __init__(self, ex=None,):
18125 
    self.ex = ex
18126 
 
18127 
  def read(self, iprot):
18128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18130 
      return
18131 
    iprot.readStructBegin()
18132 
    while True:
18133 
      (fname, ftype, fid) = iprot.readFieldBegin()
18134 
      if ftype == TType.STOP:
18135 
        break
18136 
      if fid == 1:
18137 
        if ftype == TType.STRUCT:
18138 
          self.ex = TransactionServiceException()
18139 
          self.ex.read(iprot)
18140 
        else:
18141 
          iprot.skip(ftype)
18142 
      else:
18143 
        iprot.skip(ftype)
18144 
      iprot.readFieldEnd()
18145 
    iprot.readStructEnd()
18146 
 
18147 
  def write(self, oprot):
18148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18150 
      return
18151 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
18152 
    if self.ex is not None:
18153 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18154 
      self.ex.write(oprot)
18155 
      oprot.writeFieldEnd()
18156 
    oprot.writeFieldStop()
18157 
    oprot.writeStructEnd()
18158 
 
18159 
  def validate(self):
18160 
    return
18161 
 
18162 
 
18163 
  def __repr__(self):
18164 
    L = ['%s=%r' % (key, value)
18165 
      for key, value in self.__dict__.iteritems()]
18166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18167 
 
18168 
  def __eq__(self, other):
18169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18170 
 
18171 
  def __ne__(self, other):
18172 
    return not (self == other)
18173 
 
18174 
class getSettlementForPaymentId_args:
18175 
  """
18176 
  Attributes:
18177 
   - paymentId
18178 
  """
18179 
 
18180 
  thrift_spec = (
18181 
    None, # 0
18182 
    (1, TType.I64, 'paymentId', None, None, ), # 1
18183 
  )
18184 
 
18185 
  def __init__(self, paymentId=None,):
18186 
    self.paymentId = paymentId
18187 
 
18188 
  def read(self, iprot):
18189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18191 
      return
18192 
    iprot.readStructBegin()
18193 
    while True:
18194 
      (fname, ftype, fid) = iprot.readFieldBegin()
18195 
      if ftype == TType.STOP:
18196 
        break
18197 
      if fid == 1:
18198 
        if ftype == TType.I64:
18199 
          self.paymentId = iprot.readI64();
18200 
        else:
18201 
          iprot.skip(ftype)
18202 
      else:
18203 
        iprot.skip(ftype)
18204 
      iprot.readFieldEnd()
18205 
    iprot.readStructEnd()
18206 
 
18207 
  def write(self, oprot):
18208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18210 
      return
18211 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
18212 
    if self.paymentId is not None:
18213 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
18214 
      oprot.writeI64(self.paymentId)
18215 
      oprot.writeFieldEnd()
18216 
    oprot.writeFieldStop()
18217 
    oprot.writeStructEnd()
18218 
 
18219 
  def validate(self):
18220 
    return
18221 
 
18222 
 
18223 
  def __repr__(self):
18224 
    L = ['%s=%r' % (key, value)
18225 
      for key, value in self.__dict__.iteritems()]
18226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18227 
 
18228 
  def __eq__(self, other):
18229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18230 
 
18231 
  def __ne__(self, other):
18232 
    return not (self == other)
18233 
 
18234 
class getSettlementForPaymentId_result:
18235 
  """
18236 
  Attributes:
18237 
   - success
18238 
   - ex
18239 
  """
18240 
 
18241 
  thrift_spec = (
18242 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
18243 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18244 
  )
18245 
 
18246 
  def __init__(self, success=None, ex=None,):
18247 
    self.success = success
18248 
    self.ex = ex
18249 
 
18250 
  def read(self, iprot):
18251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18253 
      return
18254 
    iprot.readStructBegin()
18255 
    while True:
18256 
      (fname, ftype, fid) = iprot.readFieldBegin()
18257 
      if ftype == TType.STOP:
18258 
        break
18259 
      if fid == 0:
18260 
        if ftype == TType.STRUCT:
18261 
          self.success = PaymentSettlement()
18262 
          self.success.read(iprot)
18263 
        else:
18264 
          iprot.skip(ftype)
18265 
      elif fid == 1:
18266 
        if ftype == TType.STRUCT:
18267 
          self.ex = TransactionServiceException()
18268 
          self.ex.read(iprot)
18269 
        else:
18270 
          iprot.skip(ftype)
18271 
      else:
18272 
        iprot.skip(ftype)
18273 
      iprot.readFieldEnd()
18274 
    iprot.readStructEnd()
18275 
 
18276 
  def write(self, oprot):
18277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18279 
      return
18280 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
18281 
    if self.success is not None:
18282 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18283 
      self.success.write(oprot)
18284 
      oprot.writeFieldEnd()
18285 
    if self.ex is not None:
18286 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18287 
      self.ex.write(oprot)
18288 
      oprot.writeFieldEnd()
18289 
    oprot.writeFieldStop()
18290 
    oprot.writeStructEnd()
18291 
 
18292 
  def validate(self):
18293 
    return
18294 
 
18295 
 
18296 
  def __repr__(self):
18297 
    L = ['%s=%r' % (key, value)
18298 
      for key, value in self.__dict__.iteritems()]
18299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18300 
 
18301 
  def __eq__(self, other):
18302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18303 
 
18304 
  def __ne__(self, other):
18305 
    return not (self == other)
18306 
 
18307 
class getEBSSettlementSummaries_args:
18308 
 
18309 
  thrift_spec = (
18310 
  )
18311 
 
18312 
  def read(self, iprot):
18313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18315 
      return
18316 
    iprot.readStructBegin()
18317 
    while True:
18318 
      (fname, ftype, fid) = iprot.readFieldBegin()
18319 
      if ftype == TType.STOP:
18320 
        break
18321 
      else:
18322 
        iprot.skip(ftype)
18323 
      iprot.readFieldEnd()
18324 
    iprot.readStructEnd()
18325 
 
18326 
  def write(self, oprot):
18327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18329 
      return
18330 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
18331 
    oprot.writeFieldStop()
18332 
    oprot.writeStructEnd()
18333 
 
18334 
  def validate(self):
18335 
    return
18336 
 
18337 
 
18338 
  def __repr__(self):
18339 
    L = ['%s=%r' % (key, value)
18340 
      for key, value in self.__dict__.iteritems()]
18341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18342 
 
18343 
  def __eq__(self, other):
18344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18345 
 
18346 
  def __ne__(self, other):
18347 
    return not (self == other)
18348 
 
18349 
class getEBSSettlementSummaries_result:
18350 
  """
18351 
  Attributes:
18352 
   - success
18353 
   - ex
18354 
  """
18355 
 
18356 
  thrift_spec = (
18357 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
18358 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18359 
  )
18360 
 
18361 
  def __init__(self, success=None, ex=None,):
18362 
    self.success = success
18363 
    self.ex = ex
18364 
 
18365 
  def read(self, iprot):
18366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18368 
      return
18369 
    iprot.readStructBegin()
18370 
    while True:
18371 
      (fname, ftype, fid) = iprot.readFieldBegin()
18372 
      if ftype == TType.STOP:
18373 
        break
18374 
      if fid == 0:
18375 
        if ftype == TType.MAP:
18376 
          self.success = {}
4709 rajveer 18377 
          (_ktype322, _vtype323, _size321 ) = iprot.readMapBegin()
18378 
          for _i325 in xrange(_size321):
18379 
            _key326 = iprot.readI64();
18380 
            _val327 = iprot.readString();
18381 
            self.success[_key326] = _val327
4600 varun.gupt 18382 
          iprot.readMapEnd()
18383 
        else:
18384 
          iprot.skip(ftype)
18385 
      elif fid == 1:
18386 
        if ftype == TType.STRUCT:
18387 
          self.ex = TransactionServiceException()
18388 
          self.ex.read(iprot)
18389 
        else:
18390 
          iprot.skip(ftype)
18391 
      else:
18392 
        iprot.skip(ftype)
18393 
      iprot.readFieldEnd()
18394 
    iprot.readStructEnd()
18395 
 
18396 
  def write(self, oprot):
18397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18399 
      return
18400 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
18401 
    if self.success is not None:
18402 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18403 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
4709 rajveer 18404 
      for kiter328,viter329 in self.success.items():
18405 
        oprot.writeI64(kiter328)
18406 
        oprot.writeString(viter329)
4600 varun.gupt 18407 
      oprot.writeMapEnd()
18408 
      oprot.writeFieldEnd()
18409 
    if self.ex is not None:
18410 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18411 
      self.ex.write(oprot)
18412 
      oprot.writeFieldEnd()
18413 
    oprot.writeFieldStop()
18414 
    oprot.writeStructEnd()
18415 
 
18416 
  def validate(self):
18417 
    return
18418 
 
18419 
 
18420 
  def __repr__(self):
18421 
    L = ['%s=%r' % (key, value)
18422 
      for key, value in self.__dict__.iteritems()]
18423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18424 
 
18425 
  def __eq__(self, other):
18426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18427 
 
18428 
  def __ne__(self, other):
18429 
    return not (self == other)
18430 
 
18431 
class markEBSSettlementUploaded_args:
18432 
  """
18433 
  Attributes:
18434 
   - settlementId
18435 
  """
18436 
 
18437 
  thrift_spec = (
18438 
    None, # 0
18439 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18440 
  )
18441 
 
18442 
  def __init__(self, settlementId=None,):
18443 
    self.settlementId = settlementId
18444 
 
18445 
  def read(self, iprot):
18446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18448 
      return
18449 
    iprot.readStructBegin()
18450 
    while True:
18451 
      (fname, ftype, fid) = iprot.readFieldBegin()
18452 
      if ftype == TType.STOP:
18453 
        break
18454 
      if fid == 1:
18455 
        if ftype == TType.I64:
18456 
          self.settlementId = iprot.readI64();
18457 
        else:
18458 
          iprot.skip(ftype)
18459 
      else:
18460 
        iprot.skip(ftype)
18461 
      iprot.readFieldEnd()
18462 
    iprot.readStructEnd()
18463 
 
18464 
  def write(self, oprot):
18465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18467 
      return
18468 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
18469 
    if self.settlementId is not None:
18470 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18471 
      oprot.writeI64(self.settlementId)
18472 
      oprot.writeFieldEnd()
18473 
    oprot.writeFieldStop()
18474 
    oprot.writeStructEnd()
18475 
 
18476 
  def validate(self):
18477 
    return
18478 
 
18479 
 
18480 
  def __repr__(self):
18481 
    L = ['%s=%r' % (key, value)
18482 
      for key, value in self.__dict__.iteritems()]
18483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18484 
 
18485 
  def __eq__(self, other):
18486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18487 
 
18488 
  def __ne__(self, other):
18489 
    return not (self == other)
18490 
 
18491 
class markEBSSettlementUploaded_result:
18492 
  """
18493 
  Attributes:
18494 
   - ex
18495 
  """
18496 
 
18497 
  thrift_spec = (
18498 
    None, # 0
18499 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18500 
  )
18501 
 
18502 
  def __init__(self, ex=None,):
18503 
    self.ex = ex
18504 
 
18505 
  def read(self, iprot):
18506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18508 
      return
18509 
    iprot.readStructBegin()
18510 
    while True:
18511 
      (fname, ftype, fid) = iprot.readFieldBegin()
18512 
      if ftype == TType.STOP:
18513 
        break
18514 
      if fid == 1:
18515 
        if ftype == TType.STRUCT:
18516 
          self.ex = TransactionServiceException()
18517 
          self.ex.read(iprot)
18518 
        else:
18519 
          iprot.skip(ftype)
18520 
      else:
18521 
        iprot.skip(ftype)
18522 
      iprot.readFieldEnd()
18523 
    iprot.readStructEnd()
18524 
 
18525 
  def write(self, oprot):
18526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18528 
      return
18529 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
18530 
    if self.ex is not None:
18531 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18532 
      self.ex.write(oprot)
18533 
      oprot.writeFieldEnd()
18534 
    oprot.writeFieldStop()
18535 
    oprot.writeStructEnd()
18536 
 
18537 
  def validate(self):
18538 
    return
18539 
 
18540 
 
18541 
  def __repr__(self):
18542 
    L = ['%s=%r' % (key, value)
18543 
      for key, value in self.__dict__.iteritems()]
18544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18545 
 
18546 
  def __eq__(self, other):
18547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18548 
 
18549 
  def __ne__(self, other):
18550 
    return not (self == other)
18551 
 
18552 
class getEBSSettlementDate_args:
18553 
  """
18554 
  Attributes:
18555 
   - settlementId
18556 
  """
18557 
 
18558 
  thrift_spec = (
18559 
    None, # 0
18560 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18561 
  )
18562 
 
18563 
  def __init__(self, settlementId=None,):
18564 
    self.settlementId = settlementId
18565 
 
18566 
  def read(self, iprot):
18567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18569 
      return
18570 
    iprot.readStructBegin()
18571 
    while True:
18572 
      (fname, ftype, fid) = iprot.readFieldBegin()
18573 
      if ftype == TType.STOP:
18574 
        break
18575 
      if fid == 1:
18576 
        if ftype == TType.I64:
18577 
          self.settlementId = iprot.readI64();
18578 
        else:
18579 
          iprot.skip(ftype)
18580 
      else:
18581 
        iprot.skip(ftype)
18582 
      iprot.readFieldEnd()
18583 
    iprot.readStructEnd()
18584 
 
18585 
  def write(self, oprot):
18586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18588 
      return
18589 
    oprot.writeStructBegin('getEBSSettlementDate_args')
18590 
    if self.settlementId is not None:
18591 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18592 
      oprot.writeI64(self.settlementId)
18593 
      oprot.writeFieldEnd()
18594 
    oprot.writeFieldStop()
18595 
    oprot.writeStructEnd()
18596 
 
18597 
  def validate(self):
18598 
    return
18599 
 
18600 
 
18601 
  def __repr__(self):
18602 
    L = ['%s=%r' % (key, value)
18603 
      for key, value in self.__dict__.iteritems()]
18604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18605 
 
18606 
  def __eq__(self, other):
18607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18608 
 
18609 
  def __ne__(self, other):
18610 
    return not (self == other)
18611 
 
18612 
class getEBSSettlementDate_result:
18613 
  """
18614 
  Attributes:
18615 
   - success
18616 
   - ex
18617 
  """
18618 
 
18619 
  thrift_spec = (
18620 
    (0, TType.I64, 'success', None, None, ), # 0
18621 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18622 
  )
18623 
 
18624 
  def __init__(self, success=None, ex=None,):
18625 
    self.success = success
18626 
    self.ex = ex
18627 
 
18628 
  def read(self, iprot):
18629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18631 
      return
18632 
    iprot.readStructBegin()
18633 
    while True:
18634 
      (fname, ftype, fid) = iprot.readFieldBegin()
18635 
      if ftype == TType.STOP:
18636 
        break
18637 
      if fid == 0:
18638 
        if ftype == TType.I64:
18639 
          self.success = iprot.readI64();
18640 
        else:
18641 
          iprot.skip(ftype)
18642 
      elif fid == 1:
18643 
        if ftype == TType.STRUCT:
18644 
          self.ex = TransactionServiceException()
18645 
          self.ex.read(iprot)
18646 
        else:
18647 
          iprot.skip(ftype)
18648 
      else:
18649 
        iprot.skip(ftype)
18650 
      iprot.readFieldEnd()
18651 
    iprot.readStructEnd()
18652 
 
18653 
  def write(self, oprot):
18654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18656 
      return
18657 
    oprot.writeStructBegin('getEBSSettlementDate_result')
18658 
    if self.success is not None:
18659 
      oprot.writeFieldBegin('success', TType.I64, 0)
18660 
      oprot.writeI64(self.success)
18661 
      oprot.writeFieldEnd()
18662 
    if self.ex is not None:
18663 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18664 
      self.ex.write(oprot)
18665 
      oprot.writeFieldEnd()
18666 
    oprot.writeFieldStop()
18667 
    oprot.writeStructEnd()
18668 
 
18669 
  def validate(self):
18670 
    return
18671 
 
18672 
 
18673 
  def __repr__(self):
18674 
    L = ['%s=%r' % (key, value)
18675 
      for key, value in self.__dict__.iteritems()]
18676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18677 
 
18678 
  def __eq__(self, other):
18679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18680 
 
18681 
  def __ne__(self, other):
18682 
    return not (self == other)