Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
483 rajveer 74 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
483 rajveer 77 
     - status
78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
4444 rajveer 219 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 220 
    """
221 
    Parameters:
4394 rajveer 222 
     - type
4444 rajveer 223 
     - warehouseId
4394 rajveer 224 
     - status
225 
     - timestamp
3064 chandransh 226 
    """
227 
    pass
228 
 
4444 rajveer 229 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 230 
    """
231 
    Parameters:
232 
     - type
4444 rajveer 233 
     - warehouseId
4394 rajveer 234 
     - description
3064 chandransh 235 
    """
236 
    pass
237 
 
4444 rajveer 238 
  def markAlertsAsSeen(self, warehouseId):
239 
    """
240 
    Parameters:
241 
     - warehouseId
242 
    """
243 
    pass
244 
 
3064 chandransh 245 
  def getValidOrderCount(self, ):
246 
    """
247 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
248 
    """
249 
    pass
250 
 
251 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
252 
    """
253 
    Returns the number of distinct customers who have done successful transactions
254 
    """
255 
    pass
256 
 
257 
  def getValidOrdersAmountRange(self, ):
258 
    """
259 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
260 
    List contains two values, first minimum amount and second maximum amount.
261 
    """
262 
    pass
263 
 
264 
  def getValidOrders(self, limit):
265 
    """
266 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
267 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 268 
 
3064 chandransh 269 
    Parameters:
270 
     - limit
271 
    """
272 
    pass
273 
 
1220 chandransh 274 
  def batchOrders(self, warehouseId):
275 
    """
276 
    Create a batch of all the pending orders for the given warehouse.
277 
    The returned list is orderd by created_timestamp.
278 
    If there are no pending orders, an empty list is returned.
3431 rajveer 279 
 
1220 chandransh 280 
    Parameters:
281 
     - warehouseId
282 
    """
283 
    pass
284 
 
1208 chandransh 285 
  def markOrderAsOutOfStock(self, orderId):
286 
    """
287 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 288 
 
1208 chandransh 289 
    Parameters:
290 
     - orderId
291 
    """
292 
    pass
293 
 
3064 chandransh 294 
  def verifyOrder(self, orderId):
759 chandransh 295 
    """
3064 chandransh 296 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
297 
    timestamp. It is intended to be used for COD orders but can be harmlessly
298 
    used for all other orders as well.
299 
    Throws an exception if no such order exists.
3431 rajveer 300 
 
759 chandransh 301 
    Parameters:
3064 chandransh 302 
     - orderId
303 
    """
304 
    pass
305 
 
306 
  def acceptOrder(self, orderId):
307 
    """
308 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
309 
    given order is not a COD order, it also captures the payment if the same has
310 
    not been captured.
311 
    Throws an exception if no such order exists.
3431 rajveer 312 
 
3064 chandransh 313 
    Parameters:
314 
     - orderId
315 
    """
316 
    pass
317 
 
4283 anupam.sin 318 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 319 
    """
320 
    Add billing details such as the bill number and the biller to the Order.
321 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
322 
    the IMEI no. if a -1 is supplied.
323 
    Also, it generates an invoice number for the order, marks the order as
324 
    BILLED and sets the billing timestamp.
325 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 326 
 
3064 chandransh 327 
    Parameters:
328 
     - orderId
4283 anupam.sin 329 
     - invoice_number
3064 chandransh 330 
     - imeiNumber
331 
     - itemNumber
4283 anupam.sin 332 
     - billed_by
333 
     - jacketNumber
3064 chandransh 334 
     - billingType
4283 anupam.sin 335 
     - vendorId
3064 chandransh 336 
    """
337 
    pass
338 
 
339 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
340 
    """
341 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 342 
    given warehouse and were picked up by the given provider as MANIFESTED.
343 
 
344 
    Parameters:
345 
     - warehouseId
346 
     - providerId
347 
     - cod
348 
    """
349 
    pass
350 
 
351 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
352 
    """
353 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
3064 chandransh 354 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 355 
 
3064 chandransh 356 
    Parameters:
759 chandransh 357 
     - warehouseId
358 
     - providerId
3064 chandransh 359 
     - cod
759 chandransh 360 
    """
361 
    pass
362 
 
1113 chandransh 363 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
364 
    """
365 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
366 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
367 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 368 
 
1113 chandransh 369 
    Parameters:
370 
     - providerId
371 
     - pickupDetails
372 
    """
373 
    pass
374 
 
1132 chandransh 375 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
376 
    """
377 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
378 
    the name of the receiver.
379 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 380 
 
1132 chandransh 381 
    Parameters:
382 
     - providerId
383 
     - deliveredOrders
384 
    """
385 
    pass
386 
 
1135 chandransh 387 
  def markOrdersAsFailed(self, providerId, returnedOrders):
388 
    """
389 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
390 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 391 
 
1135 chandransh 392 
    Parameters:
393 
     - providerId
394 
     - returnedOrders
395 
    """
396 
    pass
397 
 
1246 chandransh 398 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
399 
    """
400 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 401 
 
1246 chandransh 402 
    Parameters:
403 
     - providerId
404 
     - undeliveredOrders
405 
    """
406 
    pass
407 
 
1408 ankur.sing 408 
  def getUndeliveredOrders(self, providerId, warehouseId):
409 
    """
410 
    Returns the list of orders whose delivery time has passed but have not been
411 
    delivered yet for the given provider and warehouse. To get a complete list of
412 
    undelivered orders, pass them as -1.
413 
    Returns an empty list if no such orders exist.
3431 rajveer 414 
 
1408 ankur.sing 415 
    Parameters:
416 
     - providerId
417 
     - warehouseId
418 
    """
419 
    pass
420 
 
2536 chandransh 421 
  def toggleDOAFlag(self, orderId):
422 
    """
423 
    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.
424 
    Returns the final flag status.
425 
    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 426 
 
2536 chandransh 427 
    Parameters:
428 
     - orderId
429 
    """
430 
    pass
1886 ankur.sing 431 
 
4454 rajveer 432 
  def markOrderDoaRequestReceived(self, orderId):
433 
    """
434 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
435 
 
436 
    Parameters:
437 
     - orderId
438 
    """
439 
    pass
440 
 
441 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
442 
    """
443 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
444 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
445 
 
446 
    Parameters:
447 
     - orderId
448 
     - isAuthorized
449 
    """
450 
    pass
451 
 
4488 rajveer 452 
  def markOrderReturnRequestReceived(self, orderId):
453 
    """
454 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
455 
 
456 
    Parameters:
457 
     - orderId
458 
    """
459 
    pass
460 
 
461 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
462 
    """
463 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
464 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
465 
 
466 
    Parameters:
467 
     - orderId
468 
     - isAuthorized
469 
    """
470 
    pass
471 
 
2536 chandransh 472 
  def requestPickupNumber(self, orderId):
473 
    """
474 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 475 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
476 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 477 
    For any other status, it returns false.
478 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 479 
 
2536 chandransh 480 
    Parameters:
481 
     - orderId
482 
    """
483 
    pass
484 
 
485 
  def authorizePickup(self, orderId, pickupNumber):
486 
    """
4452 rajveer 487 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 488 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
489 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
490 
    	3. Returns true
2591 chandransh 491 
    If the order is in any other status, it returns false.
2536 chandransh 492 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 493 
 
2536 chandransh 494 
    Parameters:
495 
     - orderId
496 
     - pickupNumber
497 
    """
498 
    pass
499 
 
2764 chandransh 500 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
501 
    """
502 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
503 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 504 
 
2764 chandransh 505 
    Parameters:
506 
     - providerId
507 
     - pickupDetails
508 
    """
509 
    pass
510 
 
4479 rajveer 511 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 512 
    """
4452 rajveer 513 
    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 514 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 515 
    If the order is in any other state, it returns false.
516 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 517 
 
2591 chandransh 518 
    Parameters:
519 
     - orderId
4479 rajveer 520 
     - receiveCondition
2591 chandransh 521 
    """
522 
    pass
2536 chandransh 523 
 
2591 chandransh 524 
  def validateDoa(self, orderId, isValid):
525 
    """
4452 rajveer 526 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 527 
    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 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
533 
     - isValid
534 
    """
535 
    pass
536 
 
4495 rajveer 537 
  def validateReturnProduct(self, orderId, isUsable):
538 
    """
539 
    Parameters:
540 
     - orderId
541 
     - isUsable
542 
    """
543 
    pass
544 
 
2616 chandransh 545 
  def reshipOrder(self, orderId):
546 
    """
4484 rajveer 547 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 548 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 549 
    	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 550 
 
551 
    If the order is in DOA_CERT_VALID state, it does the following:
552 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
553 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 554 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 555 
 
2616 chandransh 556 
    Returns the id of the newly created order.
3431 rajveer 557 
 
2616 chandransh 558 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 559 
 
2616 chandransh 560 
    Parameters:
561 
     - orderId
562 
    """
563 
    pass
2591 chandransh 564 
 
3226 chandransh 565 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 566 
    """
4484 rajveer 567 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 568 
    	1. Creates a refund request for batch processing.
569 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 570 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 571 
 
2616 chandransh 572 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
573 
    	1. Creates a refund request for batch processing.
3226 chandransh 574 
    	2. Cancels the reservation of the item in the warehouse.
575 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 576 
 
3226 chandransh 577 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
578 
    	1. Cancels the reservation of the item in the warehouse.
579 
    	2. Marks the current order as CANCELED.
580 
 
581 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
582 
 
2616 chandransh 583 
    Returns True if it is successful, False otherwise.
3431 rajveer 584 
 
2616 chandransh 585 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 586 
 
2616 chandransh 587 
    Parameters:
588 
     - orderId
3226 chandransh 589 
     - refundedBy
590 
     - reason
2616 chandransh 591 
    """
592 
    pass
593 
 
2690 chandransh 594 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
595 
    """
596 
    Get all return orders created between the from and to dates for the given warehouse.
597 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 598 
 
2690 chandransh 599 
    Parameters:
600 
     - warehouseId
601 
     - fromDate
602 
     - toDate
603 
    """
604 
    pass
2616 chandransh 605 
 
2700 chandransh 606 
  def getReturnOrder(self, id):
607 
    """
608 
    Returns the ReturnOrder corresponding to the given id.
609 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 610 
 
2700 chandransh 611 
    Parameters:
612 
     - id
613 
    """
614 
    pass
615 
 
2690 chandransh 616 
  def processReturn(self, returnOrderId):
617 
    """
618 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 619 
 
2690 chandransh 620 
    Parameters:
621 
     - returnOrderId
622 
    """
623 
    pass
624 
 
2819 chandransh 625 
  def createPurchaseOrder(self, warehouseId):
626 
    """
627 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 628 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 629 
 
2819 chandransh 630 
    Parameters:
631 
     - warehouseId
632 
    """
633 
    pass
2690 chandransh 634 
 
3451 chandransh 635 
  def updateWeight(self, orderId, weight):
636 
    """
637 
    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 638 
 
3451 chandransh 639 
    Parameters:
640 
     - orderId
641 
     - weight
642 
    """
643 
    pass
644 
 
3469 chandransh 645 
  def changeItem(self, orderId, itemId):
646 
    """
647 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
648 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 649 
 
3469 chandransh 650 
    Parameters:
651 
     - orderId
652 
     - itemId
653 
    """
654 
    pass
655 
 
656 
  def shiftToWarehouse(self, orderId, warehouseId):
657 
    """
658 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
659 
 
660 
    Parameters:
661 
     - orderId
662 
     - warehouseId
663 
    """
664 
    pass
665 
 
3986 chandransh 666 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 667 
    """
668 
    Adds the given delay reason to the given order.
3986 chandransh 669 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 670 
    Raises an exception if no order with the given id can be found.
3469 chandransh 671 
 
3553 chandransh 672 
    Parameters:
673 
     - orderId
674 
     - delayReason
3986 chandransh 675 
     - furtherDelay
3553 chandransh 676 
    """
677 
    pass
678 
 
3956 chandransh 679 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
680 
    """
681 
    Marks the COD orders with given AWB nos. as having been processed.
682 
    Updates the captured amount for the corresponding payment.
3553 chandransh 683 
 
3956 chandransh 684 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
685 
    1. There is no order corresponding to an AWB number.
686 
    2. The captured amount for a payment exceeds the total payment.
687 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
688 
 
689 
    Parameters:
690 
     - collectedAmountMap
691 
     - xferBy
692 
     - xferTxnId
693 
     - xferDate
694 
    """
695 
    pass
696 
 
4008 mandeep.dh 697 
  def getTransactionsRequiringExtraProcessing(self, category):
698 
    """
4065 mandeep.dh 699 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 700 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 701 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 702 
 
4008 mandeep.dh 703 
    Parameters:
704 
     - category
705 
    """
706 
    pass
707 
 
708 
  def markTransactionAsProcessed(self, transactionId, category):
709 
    """
710 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 711 
    It essentially deletes the transaction id record for a particular
712 
    processing type category (if present) from DB.
713 
    This is currently used by CRM application.
4008 mandeep.dh 714 
 
715 
    Parameters:
716 
     - transactionId
717 
     - category
718 
    """
719 
    pass
720 
 
4018 chandransh 721 
  def getItemWiseRiskyOrdersCount(self, ):
722 
    """
723 
    Returns a map containing the number of risky orders keyed by item id. A risky order
724 
    is defined as one whose shipping date is about to expire.
725 
    """
726 
    pass
4008 mandeep.dh 727 
 
4295 varun.gupt 728 
  def getOrdersForItemIds(self, itemIds):
729 
    """
730 
    Returns a list of all orders which have items with given id
731 
 
732 
    Parameters:
733 
     - itemIds
734 
    """
735 
    pass
736 
 
4247 rajveer 737 
  def markOrderCancellationRequestReceived(self, orderId):
738 
    """
739 
    Mark order as cancellation request received. If customer sends request of cancellation of
740 
    a particular order, this method will be called. It will just change status of the order
741 
    depending on its current status. It also records the previous status, so that we can move
742 
    back to that status if cancellation request is denied.
4018 chandransh 743 
 
4247 rajveer 744 
    Parameters:
745 
     - orderId
746 
    """
747 
    pass
748 
 
749 
  def markOrderCancellationRequestConfirmed(self, orderId):
750 
    """
751 
    If we decide to to cancel order, CRM will call this method to move the status of order to
752 
    cancellation request confirmed. After this OM will be able to cancel the order.
753 
 
754 
    Parameters:
755 
     - orderId
756 
    """
757 
    pass
758 
 
759 
  def markOrderCancellationRequestDenied(self, orderId):
760 
    """
761 
    If we decide to not to cancel order, we will move the order ro previous status.
762 
 
763 
    Parameters:
764 
     - orderId
765 
    """
766 
    pass
767 
 
4258 rajveer 768 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 769 
    """
4258 rajveer 770 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
771 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 772 
 
773 
    Parameters:
4258 rajveer 774 
     - transactionId
4247 rajveer 775 
    """
776 
    pass
777 
 
4259 anupam.sin 778 
  def refundTransaction(self, transactionId, refundedBy, reason):
779 
    """
780 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
781 
    need to be cancelled
4247 rajveer 782 
 
4259 anupam.sin 783 
    Parameters:
784 
     - transactionId
785 
     - refundedBy
786 
     - reason
787 
    """
788 
    pass
789 
 
4324 mandeep.dh 790 
  def updateShipmentAddress(self, orderId, addressId):
791 
    """
792 
    Updates shipment address of an order. Delivery and shipping date estimates
793 
    etc. are also updated here.
794 
 
795 
    Throws TransactionServiceException in case address change is not
796 
    possible due to certain reasons such as new pincode in address is
797 
    not serviceable etc.
798 
 
799 
    Parameters:
800 
     - orderId
801 
     - addressId
802 
    """
803 
    pass
804 
 
4285 rajveer 805 
  def acceptOrdersForItemId(self, itemId, inventory):
806 
    """
807 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
808 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 809 
 
4285 rajveer 810 
    Parameters:
811 
     - itemId
812 
     - inventory
813 
    """
814 
    pass
815 
 
4369 rajveer 816 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 817 
    """
818 
    Parameters:
819 
     - vendorId
820 
     - itemId
821 
     - quantity
822 
     - estimate
4369 rajveer 823 
     - isReminder
4303 rajveer 824 
    """
825 
    pass
4285 rajveer 826 
 
4369 rajveer 827 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 828 
    """
829 
    Parameters:
830 
     - vendorId
831 
     - itemId
832 
     - quantity
833 
     - estimate
4369 rajveer 834 
     - isReminder
4303 rajveer 835 
    """
836 
    pass
837 
 
4369 rajveer 838 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 839 
    """
840 
    Parameters:
841 
     - vendorId
842 
     - itemId
843 
     - quantity
844 
     - estimate
4369 rajveer 845 
     - isReminder
4303 rajveer 846 
    """
847 
    pass
848 
 
4369 rajveer 849 
  def markOrdersAsTimeout(self, vendorId):
850 
    """
851 
    Parameters:
852 
     - vendorId
853 
    """
854 
    pass
4303 rajveer 855 
 
4386 anupam.sin 856 
  def getOrderForAwb(self, awb):
857 
    """
858 
    Returns the order corresponding to an AWB number
4369 rajveer 859 
 
4386 anupam.sin 860 
    Parameters:
861 
     - awb
862 
    """
863 
    pass
864 
 
865 
 
3376 rajveer 866 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 867 
  def __init__(self, iprot, oprot=None):
3376 rajveer 868 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 869 
 
870 
  def createTransaction(self, transaction):
871 
    """
872 
    Parameters:
873 
     - transaction
874 
    """
875 
    self.send_createTransaction(transaction)
132 ashish 876 
    return self.recv_createTransaction()
94 ashish 877 
 
878 
  def send_createTransaction(self, transaction):
879 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
880 
    args = createTransaction_args()
881 
    args.transaction = transaction
882 
    args.write(self._oprot)
883 
    self._oprot.writeMessageEnd()
884 
    self._oprot.trans.flush()
885 
 
886 
  def recv_createTransaction(self, ):
887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
888 
    if mtype == TMessageType.EXCEPTION:
889 
      x = TApplicationException()
890 
      x.read(self._iprot)
891 
      self._iprot.readMessageEnd()
892 
      raise x
893 
    result = createTransaction_result()
894 
    result.read(self._iprot)
895 
    self._iprot.readMessageEnd()
3431 rajveer 896 
    if result.success is not None:
132 ashish 897 
      return result.success
3431 rajveer 898 
    if result.ex is not None:
94 ashish 899 
      raise result.ex
132 ashish 900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 901 
 
902 
  def getTransaction(self, id):
903 
    """
904 
    Parameters:
905 
     - id
906 
    """
907 
    self.send_getTransaction(id)
908 
    return self.recv_getTransaction()
909 
 
910 
  def send_getTransaction(self, id):
911 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
912 
    args = getTransaction_args()
913 
    args.id = id
914 
    args.write(self._oprot)
915 
    self._oprot.writeMessageEnd()
916 
    self._oprot.trans.flush()
917 
 
918 
  def recv_getTransaction(self, ):
919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
920 
    if mtype == TMessageType.EXCEPTION:
921 
      x = TApplicationException()
922 
      x.read(self._iprot)
923 
      self._iprot.readMessageEnd()
924 
      raise x
925 
    result = getTransaction_result()
926 
    result.read(self._iprot)
927 
    self._iprot.readMessageEnd()
3431 rajveer 928 
    if result.success is not None:
94 ashish 929 
      return result.success
3431 rajveer 930 
    if result.ex is not None:
94 ashish 931 
      raise result.ex
932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
933 
 
934 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
935 
    """
936 
    Parameters:
937 
     - customerId
938 
     - from_date
939 
     - to_date
940 
     - status
941 
    """
942 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
943 
    return self.recv_getTransactionsForCustomer()
944 
 
945 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
946 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
947 
    args = getTransactionsForCustomer_args()
948 
    args.customerId = customerId
949 
    args.from_date = from_date
950 
    args.to_date = to_date
951 
    args.status = status
952 
    args.write(self._oprot)
953 
    self._oprot.writeMessageEnd()
954 
    self._oprot.trans.flush()
955 
 
956 
  def recv_getTransactionsForCustomer(self, ):
957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
958 
    if mtype == TMessageType.EXCEPTION:
959 
      x = TApplicationException()
960 
      x.read(self._iprot)
961 
      self._iprot.readMessageEnd()
962 
      raise x
963 
    result = getTransactionsForCustomer_result()
964 
    result.read(self._iprot)
965 
    self._iprot.readMessageEnd()
3431 rajveer 966 
    if result.success is not None:
94 ashish 967 
      return result.success
3431 rajveer 968 
    if result.ex is not None:
94 ashish 969 
      raise result.ex
970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
971 
 
132 ashish 972 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
973 
    """
974 
    Parameters:
975 
     - shoppingCartId
976 
    """
977 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
978 
    return self.recv_getTransactionsForShoppingCartId()
979 
 
980 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
981 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
982 
    args = getTransactionsForShoppingCartId_args()
983 
    args.shoppingCartId = shoppingCartId
984 
    args.write(self._oprot)
985 
    self._oprot.writeMessageEnd()
986 
    self._oprot.trans.flush()
987 
 
988 
  def recv_getTransactionsForShoppingCartId(self, ):
989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
990 
    if mtype == TMessageType.EXCEPTION:
991 
      x = TApplicationException()
992 
      x.read(self._iprot)
993 
      self._iprot.readMessageEnd()
994 
      raise x
995 
    result = getTransactionsForShoppingCartId_result()
996 
    result.read(self._iprot)
997 
    self._iprot.readMessageEnd()
3431 rajveer 998 
    if result.success is not None:
132 ashish 999 
      return result.success
3431 rajveer 1000 
    if result.ex is not None:
132 ashish 1001 
      raise result.ex
1002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1003 
 
94 ashish 1004 
  def getTransactionStatus(self, transactionId):
1005 
    """
1006 
    Parameters:
1007 
     - transactionId
1008 
    """
1009 
    self.send_getTransactionStatus(transactionId)
1010 
    return self.recv_getTransactionStatus()
1011 
 
1012 
  def send_getTransactionStatus(self, transactionId):
1013 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1014 
    args = getTransactionStatus_args()
1015 
    args.transactionId = transactionId
1016 
    args.write(self._oprot)
1017 
    self._oprot.writeMessageEnd()
1018 
    self._oprot.trans.flush()
1019 
 
1020 
  def recv_getTransactionStatus(self, ):
1021 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1022 
    if mtype == TMessageType.EXCEPTION:
1023 
      x = TApplicationException()
1024 
      x.read(self._iprot)
1025 
      self._iprot.readMessageEnd()
1026 
      raise x
1027 
    result = getTransactionStatus_result()
1028 
    result.read(self._iprot)
1029 
    self._iprot.readMessageEnd()
3431 rajveer 1030 
    if result.success is not None:
94 ashish 1031 
      return result.success
3431 rajveer 1032 
    if result.ex is not None:
94 ashish 1033 
      raise result.ex
1034 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1035 
 
1036 
  def changeTransactionStatus(self, transactionId, status, description):
1037 
    """
1038 
    Parameters:
1039 
     - transactionId
1040 
     - status
1041 
     - description
1042 
    """
1043 
    self.send_changeTransactionStatus(transactionId, status, description)
1044 
    return self.recv_changeTransactionStatus()
1045 
 
1046 
  def send_changeTransactionStatus(self, transactionId, status, description):
1047 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1048 
    args = changeTransactionStatus_args()
1049 
    args.transactionId = transactionId
1050 
    args.status = status
1051 
    args.description = description
1052 
    args.write(self._oprot)
1053 
    self._oprot.writeMessageEnd()
1054 
    self._oprot.trans.flush()
1055 
 
1056 
  def recv_changeTransactionStatus(self, ):
1057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1058 
    if mtype == TMessageType.EXCEPTION:
1059 
      x = TApplicationException()
1060 
      x.read(self._iprot)
1061 
      self._iprot.readMessageEnd()
1062 
      raise x
1063 
    result = changeTransactionStatus_result()
1064 
    result.read(self._iprot)
1065 
    self._iprot.readMessageEnd()
3431 rajveer 1066 
    if result.success is not None:
94 ashish 1067 
      return result.success
3431 rajveer 1068 
    if result.ex is not None:
94 ashish 1069 
      raise result.ex
1070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1071 
 
1398 varun.gupt 1072 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1073 
    """
1074 
    Parameters:
1075 
     - transactionId
1076 
    """
1398 varun.gupt 1077 
    self.send_enqueueTransactionInfoEmail(transactionId)
1078 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1079 
 
1398 varun.gupt 1080 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1081 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1082 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1083 
    args.transactionId = transactionId
1084 
    args.write(self._oprot)
1085 
    self._oprot.writeMessageEnd()
1086 
    self._oprot.trans.flush()
1087 
 
1398 varun.gupt 1088 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1090 
    if mtype == TMessageType.EXCEPTION:
1091 
      x = TApplicationException()
1092 
      x.read(self._iprot)
1093 
      self._iprot.readMessageEnd()
1094 
      raise x
1398 varun.gupt 1095 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1096 
    result.read(self._iprot)
1097 
    self._iprot.readMessageEnd()
3431 rajveer 1098 
    if result.success is not None:
1382 varun.gupt 1099 
      return result.success
3431 rajveer 1100 
    if result.ex is not None:
1382 varun.gupt 1101 
      raise result.ex
1398 varun.gupt 1102 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1103 
 
483 rajveer 1104 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1105 
    """
1106 
    Parameters:
483 rajveer 1107 
     - status
1108 
     - from_date
1109 
     - to_date
1110 
     - warehouse_id
94 ashish 1111 
    """
483 rajveer 1112 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1113 
    return self.recv_getAllOrders()
94 ashish 1114 
 
483 rajveer 1115 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1116 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1117 
    args = getAllOrders_args()
1118 
    args.status = status
1119 
    args.from_date = from_date
1120 
    args.to_date = to_date
1121 
    args.warehouse_id = warehouse_id
94 ashish 1122 
    args.write(self._oprot)
1123 
    self._oprot.writeMessageEnd()
1124 
    self._oprot.trans.flush()
1125 
 
483 rajveer 1126 
  def recv_getAllOrders(self, ):
94 ashish 1127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1128 
    if mtype == TMessageType.EXCEPTION:
1129 
      x = TApplicationException()
1130 
      x.read(self._iprot)
1131 
      self._iprot.readMessageEnd()
1132 
      raise x
483 rajveer 1133 
    result = getAllOrders_result()
94 ashish 1134 
    result.read(self._iprot)
1135 
    self._iprot.readMessageEnd()
3431 rajveer 1136 
    if result.success is not None:
94 ashish 1137 
      return result.success
3431 rajveer 1138 
    if result.ex is not None:
94 ashish 1139 
      raise result.ex
483 rajveer 1140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1141 
 
4133 chandransh 1142 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1143 
    """
1144 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1145 
    Pass the status as null and the limit as 0 to ignore them.
1146 
 
1147 
    Parameters:
1148 
     - statuses
1149 
     - offset
1150 
     - limit
1151 
     - warehouse_id
1152 
    """
1153 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1154 
    return self.recv_getOrdersInBatch()
1155 
 
1156 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1157 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1158 
    args = getOrdersInBatch_args()
1159 
    args.statuses = statuses
1160 
    args.offset = offset
1161 
    args.limit = limit
1162 
    args.warehouse_id = warehouse_id
1163 
    args.write(self._oprot)
1164 
    self._oprot.writeMessageEnd()
1165 
    self._oprot.trans.flush()
1166 
 
1167 
  def recv_getOrdersInBatch(self, ):
1168 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1169 
    if mtype == TMessageType.EXCEPTION:
1170 
      x = TApplicationException()
1171 
      x.read(self._iprot)
1172 
      self._iprot.readMessageEnd()
1173 
      raise x
1174 
    result = getOrdersInBatch_result()
1175 
    result.read(self._iprot)
1176 
    self._iprot.readMessageEnd()
1177 
    if result.success is not None:
1178 
      return result.success
1179 
    if result.ex is not None:
1180 
      raise result.ex
1181 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1182 
 
1183 
  def getOrderCount(self, statuses, warehouseId):
1184 
    """
1185 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1186 
 
1187 
    Parameters:
1188 
     - statuses
1189 
     - warehouseId
1190 
    """
1191 
    self.send_getOrderCount(statuses, warehouseId)
1192 
    return self.recv_getOrderCount()
1193 
 
1194 
  def send_getOrderCount(self, statuses, warehouseId):
1195 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1196 
    args = getOrderCount_args()
1197 
    args.statuses = statuses
1198 
    args.warehouseId = warehouseId
1199 
    args.write(self._oprot)
1200 
    self._oprot.writeMessageEnd()
1201 
    self._oprot.trans.flush()
1202 
 
1203 
  def recv_getOrderCount(self, ):
1204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1205 
    if mtype == TMessageType.EXCEPTION:
1206 
      x = TApplicationException()
1207 
      x.read(self._iprot)
1208 
      self._iprot.readMessageEnd()
1209 
      raise x
1210 
    result = getOrderCount_result()
1211 
    result.read(self._iprot)
1212 
    self._iprot.readMessageEnd()
1213 
    if result.success is not None:
1214 
      return result.success
1215 
    if result.ex is not None:
1216 
      raise result.ex
1217 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1218 
 
999 varun.gupt 1219 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1220 
    """
1132 chandransh 1221 
    Returns orders within a range of their billing dates
3431 rajveer 1222 
 
999 varun.gupt 1223 
    Parameters:
1224 
     - status
1225 
     - start_billing_date
1226 
     - end_billing_date
1227 
     - warehouse_id
1228 
    """
1229 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1230 
    return self.recv_getOrdersByBillingDate()
1231 
 
1232 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1233 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1234 
    args = getOrdersByBillingDate_args()
1235 
    args.status = status
1236 
    args.start_billing_date = start_billing_date
1237 
    args.end_billing_date = end_billing_date
1238 
    args.warehouse_id = warehouse_id
1239 
    args.write(self._oprot)
1240 
    self._oprot.writeMessageEnd()
1241 
    self._oprot.trans.flush()
1242 
 
1243 
  def recv_getOrdersByBillingDate(self, ):
1244 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1245 
    if mtype == TMessageType.EXCEPTION:
1246 
      x = TApplicationException()
1247 
      x.read(self._iprot)
1248 
      self._iprot.readMessageEnd()
1249 
      raise x
1250 
    result = getOrdersByBillingDate_result()
1251 
    result.read(self._iprot)
1252 
    self._iprot.readMessageEnd()
3431 rajveer 1253 
    if result.success is not None:
999 varun.gupt 1254 
      return result.success
3431 rajveer 1255 
    if result.ex is not None:
999 varun.gupt 1256 
      raise result.ex
1257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1258 
 
3451 chandransh 1259 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1260 
    """
1261 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1262 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1263 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1264 
 
3427 chandransh 1265 
    Parameters:
1266 
     - fromShippingDate
1267 
     - toShippingDate
1268 
     - providerId
1269 
     - warehouseId
3451 chandransh 1270 
     - cod
3427 chandransh 1271 
    """
3451 chandransh 1272 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1273 
    return self.recv_getOrdersByShippingDate()
1274 
 
3451 chandransh 1275 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1276 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1277 
    args = getOrdersByShippingDate_args()
1278 
    args.fromShippingDate = fromShippingDate
1279 
    args.toShippingDate = toShippingDate
1280 
    args.providerId = providerId
1281 
    args.warehouseId = warehouseId
3451 chandransh 1282 
    args.cod = cod
3427 chandransh 1283 
    args.write(self._oprot)
1284 
    self._oprot.writeMessageEnd()
1285 
    self._oprot.trans.flush()
1286 
 
1287 
  def recv_getOrdersByShippingDate(self, ):
1288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1289 
    if mtype == TMessageType.EXCEPTION:
1290 
      x = TApplicationException()
1291 
      x.read(self._iprot)
1292 
      self._iprot.readMessageEnd()
1293 
      raise x
1294 
    result = getOrdersByShippingDate_result()
1295 
    result.read(self._iprot)
1296 
    self._iprot.readMessageEnd()
3431 rajveer 1297 
    if result.success is not None:
3427 chandransh 1298 
      return result.success
3431 rajveer 1299 
    if result.ex is not None:
3427 chandransh 1300 
      raise result.ex
1301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1302 
 
1382 varun.gupt 1303 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1304 
    """
1305 
    Returns order ids for orders which can be returned
3431 rajveer 1306 
 
1382 varun.gupt 1307 
    Parameters:
1308 
     - customer_id
1309 
     - limit
1310 
    """
1311 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1312 
    return self.recv_getReturnableOrdersForCustomer()
1313 
 
1314 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1315 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1316 
    args = getReturnableOrdersForCustomer_args()
1317 
    args.customer_id = customer_id
1318 
    args.limit = limit
1319 
    args.write(self._oprot)
1320 
    self._oprot.writeMessageEnd()
1321 
    self._oprot.trans.flush()
1322 
 
1323 
  def recv_getReturnableOrdersForCustomer(self, ):
1324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1325 
    if mtype == TMessageType.EXCEPTION:
1326 
      x = TApplicationException()
1327 
      x.read(self._iprot)
1328 
      self._iprot.readMessageEnd()
1329 
      raise x
1330 
    result = getReturnableOrdersForCustomer_result()
1331 
    result.read(self._iprot)
1332 
    self._iprot.readMessageEnd()
3431 rajveer 1333 
    if result.success is not None:
1382 varun.gupt 1334 
      return result.success
3431 rajveer 1335 
    if result.ex is not None:
1382 varun.gupt 1336 
      raise result.ex
1337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1338 
 
1339 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1340 
    """
1341 
    Returns order ids for orders which can be cancelled
3431 rajveer 1342 
 
1382 varun.gupt 1343 
    Parameters:
1344 
     - customer_id
1345 
     - limit
1346 
    """
1347 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1348 
    return self.recv_getCancellableOrdersForCustomer()
1349 
 
1350 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1351 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1352 
    args = getCancellableOrdersForCustomer_args()
1353 
    args.customer_id = customer_id
1354 
    args.limit = limit
1355 
    args.write(self._oprot)
1356 
    self._oprot.writeMessageEnd()
1357 
    self._oprot.trans.flush()
1358 
 
1359 
  def recv_getCancellableOrdersForCustomer(self, ):
1360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1361 
    if mtype == TMessageType.EXCEPTION:
1362 
      x = TApplicationException()
1363 
      x.read(self._iprot)
1364 
      self._iprot.readMessageEnd()
1365 
      raise x
1366 
    result = getCancellableOrdersForCustomer_result()
1367 
    result.read(self._iprot)
1368 
    self._iprot.readMessageEnd()
3431 rajveer 1369 
    if result.success is not None:
1382 varun.gupt 1370 
      return result.success
3431 rajveer 1371 
    if result.ex is not None:
1382 varun.gupt 1372 
      raise result.ex
1373 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1374 
 
483 rajveer 1375 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1376 
    """
1377 
    Parameters:
483 rajveer 1378 
     - orderId
1379 
     - status
1380 
     - description
94 ashish 1381 
    """
483 rajveer 1382 
    self.send_changeOrderStatus(orderId, status, description)
1383 
    return self.recv_changeOrderStatus()
94 ashish 1384 
 
483 rajveer 1385 
  def send_changeOrderStatus(self, orderId, status, description):
1386 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1387 
    args = changeOrderStatus_args()
1388 
    args.orderId = orderId
1389 
    args.status = status
1390 
    args.description = description
94 ashish 1391 
    args.write(self._oprot)
1392 
    self._oprot.writeMessageEnd()
1393 
    self._oprot.trans.flush()
1394 
 
483 rajveer 1395 
  def recv_changeOrderStatus(self, ):
94 ashish 1396 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1397 
    if mtype == TMessageType.EXCEPTION:
1398 
      x = TApplicationException()
1399 
      x.read(self._iprot)
1400 
      self._iprot.readMessageEnd()
1401 
      raise x
483 rajveer 1402 
    result = changeOrderStatus_result()
94 ashish 1403 
    result.read(self._iprot)
1404 
    self._iprot.readMessageEnd()
3431 rajveer 1405 
    if result.success is not None:
94 ashish 1406 
      return result.success
3431 rajveer 1407 
    if result.ex is not None:
94 ashish 1408 
      raise result.ex
483 rajveer 1409 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1410 
 
1528 ankur.sing 1411 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1412 
    """
1528 ankur.sing 1413 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1414 
    only user who owns the transaction can view its order details.
3431 rajveer 1415 
 
94 ashish 1416 
    Parameters:
1417 
     - transactionId
1528 ankur.sing 1418 
     - customerId
94 ashish 1419 
    """
1528 ankur.sing 1420 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1421 
    return self.recv_getOrdersForTransaction()
94 ashish 1422 
 
1528 ankur.sing 1423 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1424 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1425 
    args = getOrdersForTransaction_args()
94 ashish 1426 
    args.transactionId = transactionId
1528 ankur.sing 1427 
    args.customerId = customerId
94 ashish 1428 
    args.write(self._oprot)
1429 
    self._oprot.writeMessageEnd()
1430 
    self._oprot.trans.flush()
1431 
 
483 rajveer 1432 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1434 
    if mtype == TMessageType.EXCEPTION:
1435 
      x = TApplicationException()
1436 
      x.read(self._iprot)
1437 
      self._iprot.readMessageEnd()
1438 
      raise x
483 rajveer 1439 
    result = getOrdersForTransaction_result()
94 ashish 1440 
    result.read(self._iprot)
1441 
    self._iprot.readMessageEnd()
3431 rajveer 1442 
    if result.success is not None:
94 ashish 1443 
      return result.success
3431 rajveer 1444 
    if result.ex is not None:
94 ashish 1445 
      raise result.ex
483 rajveer 1446 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1447 
 
3014 chandransh 1448 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1449 
    """
3014 chandransh 1450 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1451 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1452 
 
94 ashish 1453 
    Parameters:
483 rajveer 1454 
     - customerId
1455 
     - from_date
1456 
     - to_date
3014 chandransh 1457 
     - statuses
94 ashish 1458 
    """
3014 chandransh 1459 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1460 
    return self.recv_getOrdersForCustomer()
94 ashish 1461 
 
3014 chandransh 1462 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1463 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1464 
    args = getOrdersForCustomer_args()
1465 
    args.customerId = customerId
1466 
    args.from_date = from_date
1467 
    args.to_date = to_date
3014 chandransh 1468 
    args.statuses = statuses
94 ashish 1469 
    args.write(self._oprot)
1470 
    self._oprot.writeMessageEnd()
1471 
    self._oprot.trans.flush()
1472 
 
483 rajveer 1473 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1475 
    if mtype == TMessageType.EXCEPTION:
1476 
      x = TApplicationException()
1477 
      x.read(self._iprot)
1478 
      self._iprot.readMessageEnd()
1479 
      raise x
483 rajveer 1480 
    result = getOrdersForCustomer_result()
94 ashish 1481 
    result.read(self._iprot)
1482 
    self._iprot.readMessageEnd()
3431 rajveer 1483 
    if result.success is not None:
94 ashish 1484 
      return result.success
3431 rajveer 1485 
    if result.ex is not None:
94 ashish 1486 
      raise result.ex
483 rajveer 1487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1488 
 
483 rajveer 1489 
  def createOrder(self, order):
94 ashish 1490 
    """
1491 
    Parameters:
483 rajveer 1492 
     - order
94 ashish 1493 
    """
483 rajveer 1494 
    self.send_createOrder(order)
1495 
    return self.recv_createOrder()
94 ashish 1496 
 
483 rajveer 1497 
  def send_createOrder(self, order):
1498 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1499 
    args = createOrder_args()
1500 
    args.order = order
94 ashish 1501 
    args.write(self._oprot)
1502 
    self._oprot.writeMessageEnd()
1503 
    self._oprot.trans.flush()
1504 
 
483 rajveer 1505 
  def recv_createOrder(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 = createOrder_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, "createOrder failed: unknown result");
94 ashish 1520 
 
483 rajveer 1521 
  def getOrder(self, id):
94 ashish 1522 
    """
1523 
    Parameters:
483 rajveer 1524 
     - id
94 ashish 1525 
    """
483 rajveer 1526 
    self.send_getOrder(id)
1527 
    return self.recv_getOrder()
94 ashish 1528 
 
483 rajveer 1529 
  def send_getOrder(self, id):
1530 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1531 
    args = getOrder_args()
1532 
    args.id = id
94 ashish 1533 
    args.write(self._oprot)
1534 
    self._oprot.writeMessageEnd()
1535 
    self._oprot.trans.flush()
1536 
 
483 rajveer 1537 
  def recv_getOrder(self, ):
94 ashish 1538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1539 
    if mtype == TMessageType.EXCEPTION:
1540 
      x = TApplicationException()
1541 
      x.read(self._iprot)
1542 
      self._iprot.readMessageEnd()
1543 
      raise x
483 rajveer 1544 
    result = getOrder_result()
94 ashish 1545 
    result.read(self._iprot)
1546 
    self._iprot.readMessageEnd()
3431 rajveer 1547 
    if result.success is not None:
94 ashish 1548 
      return result.success
3431 rajveer 1549 
    if result.ex is not None:
94 ashish 1550 
      raise result.ex
483 rajveer 1551 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1552 
 
483 rajveer 1553 
  def getLineItemsForOrder(self, orderId):
94 ashish 1554 
    """
1555 
    Parameters:
483 rajveer 1556 
     - orderId
94 ashish 1557 
    """
483 rajveer 1558 
    self.send_getLineItemsForOrder(orderId)
1559 
    return self.recv_getLineItemsForOrder()
94 ashish 1560 
 
483 rajveer 1561 
  def send_getLineItemsForOrder(self, orderId):
1562 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1563 
    args = getLineItemsForOrder_args()
1564 
    args.orderId = orderId
94 ashish 1565 
    args.write(self._oprot)
1566 
    self._oprot.writeMessageEnd()
1567 
    self._oprot.trans.flush()
1568 
 
483 rajveer 1569 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1571 
    if mtype == TMessageType.EXCEPTION:
1572 
      x = TApplicationException()
1573 
      x.read(self._iprot)
1574 
      self._iprot.readMessageEnd()
1575 
      raise x
483 rajveer 1576 
    result = getLineItemsForOrder_result()
94 ashish 1577 
    result.read(self._iprot)
1578 
    self._iprot.readMessageEnd()
3431 rajveer 1579 
    if result.success is not None:
94 ashish 1580 
      return result.success
3431 rajveer 1581 
    if result.ex is not None:
94 ashish 1582 
      raise result.ex
483 rajveer 1583 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1584 
 
1528 ankur.sing 1585 
  def getOrderForCustomer(self, orderId, customerId):
1586 
    """
1587 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1588 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1589 
 
1528 ankur.sing 1590 
    Parameters:
1591 
     - orderId
1592 
     - customerId
1593 
    """
1594 
    self.send_getOrderForCustomer(orderId, customerId)
1595 
    return self.recv_getOrderForCustomer()
1596 
 
1597 
  def send_getOrderForCustomer(self, orderId, customerId):
1598 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1599 
    args = getOrderForCustomer_args()
1600 
    args.orderId = orderId
1601 
    args.customerId = customerId
1602 
    args.write(self._oprot)
1603 
    self._oprot.writeMessageEnd()
1604 
    self._oprot.trans.flush()
1605 
 
1606 
  def recv_getOrderForCustomer(self, ):
1607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1608 
    if mtype == TMessageType.EXCEPTION:
1609 
      x = TApplicationException()
1610 
      x.read(self._iprot)
1611 
      self._iprot.readMessageEnd()
1612 
      raise x
1613 
    result = getOrderForCustomer_result()
1614 
    result.read(self._iprot)
1615 
    self._iprot.readMessageEnd()
3431 rajveer 1616 
    if result.success is not None:
1528 ankur.sing 1617 
      return result.success
3431 rajveer 1618 
    if result.ex is not None:
1528 ankur.sing 1619 
      raise result.ex
1620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1621 
 
4444 rajveer 1622 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1623 
    """
1624 
    Parameters:
4394 rajveer 1625 
     - type
4444 rajveer 1626 
     - warehouseId
4394 rajveer 1627 
     - status
1628 
     - timestamp
3064 chandransh 1629 
    """
4444 rajveer 1630 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1631 
    return self.recv_getAlerts()
1632 
 
4444 rajveer 1633 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1634 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1635 
    args = getAlerts_args()
4394 rajveer 1636 
    args.type = type
4444 rajveer 1637 
    args.warehouseId = warehouseId
4394 rajveer 1638 
    args.status = status
1639 
    args.timestamp = timestamp
3064 chandransh 1640 
    args.write(self._oprot)
1641 
    self._oprot.writeMessageEnd()
1642 
    self._oprot.trans.flush()
1643 
 
1644 
  def recv_getAlerts(self, ):
1645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1646 
    if mtype == TMessageType.EXCEPTION:
1647 
      x = TApplicationException()
1648 
      x.read(self._iprot)
1649 
      self._iprot.readMessageEnd()
1650 
      raise x
1651 
    result = getAlerts_result()
1652 
    result.read(self._iprot)
1653 
    self._iprot.readMessageEnd()
3431 rajveer 1654 
    if result.success is not None:
3064 chandransh 1655 
      return result.success
1656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1657 
 
4444 rajveer 1658 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1659 
    """
1660 
    Parameters:
1661 
     - type
4444 rajveer 1662 
     - warehouseId
4394 rajveer 1663 
     - description
3064 chandransh 1664 
    """
4444 rajveer 1665 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1666 
    self.recv_addAlert()
3064 chandransh 1667 
 
4444 rajveer 1668 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1669 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1670 
    args = addAlert_args()
3064 chandransh 1671 
    args.type = type
4444 rajveer 1672 
    args.warehouseId = warehouseId
4394 rajveer 1673 
    args.description = description
3064 chandransh 1674 
    args.write(self._oprot)
1675 
    self._oprot.writeMessageEnd()
1676 
    self._oprot.trans.flush()
1677 
 
4394 rajveer 1678 
  def recv_addAlert(self, ):
3064 chandransh 1679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1680 
    if mtype == TMessageType.EXCEPTION:
1681 
      x = TApplicationException()
1682 
      x.read(self._iprot)
1683 
      self._iprot.readMessageEnd()
1684 
      raise x
4394 rajveer 1685 
    result = addAlert_result()
3064 chandransh 1686 
    result.read(self._iprot)
1687 
    self._iprot.readMessageEnd()
1688 
    return
1689 
 
4444 rajveer 1690 
  def markAlertsAsSeen(self, warehouseId):
1691 
    """
1692 
    Parameters:
1693 
     - warehouseId
1694 
    """
1695 
    self.send_markAlertsAsSeen(warehouseId)
1696 
    self.recv_markAlertsAsSeen()
1697 
 
1698 
  def send_markAlertsAsSeen(self, warehouseId):
1699 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1700 
    args = markAlertsAsSeen_args()
1701 
    args.warehouseId = warehouseId
1702 
    args.write(self._oprot)
1703 
    self._oprot.writeMessageEnd()
1704 
    self._oprot.trans.flush()
1705 
 
1706 
  def recv_markAlertsAsSeen(self, ):
1707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1708 
    if mtype == TMessageType.EXCEPTION:
1709 
      x = TApplicationException()
1710 
      x.read(self._iprot)
1711 
      self._iprot.readMessageEnd()
1712 
      raise x
1713 
    result = markAlertsAsSeen_result()
1714 
    result.read(self._iprot)
1715 
    self._iprot.readMessageEnd()
1716 
    return
1717 
 
3064 chandransh 1718 
  def getValidOrderCount(self, ):
1719 
    """
1720 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1721 
    """
1722 
    self.send_getValidOrderCount()
1723 
    return self.recv_getValidOrderCount()
1724 
 
1725 
  def send_getValidOrderCount(self, ):
1726 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1727 
    args = getValidOrderCount_args()
1728 
    args.write(self._oprot)
1729 
    self._oprot.writeMessageEnd()
1730 
    self._oprot.trans.flush()
1731 
 
1732 
  def recv_getValidOrderCount(self, ):
1733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1734 
    if mtype == TMessageType.EXCEPTION:
1735 
      x = TApplicationException()
1736 
      x.read(self._iprot)
1737 
      self._iprot.readMessageEnd()
1738 
      raise x
1739 
    result = getValidOrderCount_result()
1740 
    result.read(self._iprot)
1741 
    self._iprot.readMessageEnd()
3431 rajveer 1742 
    if result.success is not None:
3064 chandransh 1743 
      return result.success
1744 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1745 
 
1746 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1747 
    """
1748 
    Returns the number of distinct customers who have done successful transactions
1749 
    """
1750 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1751 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1752 
 
1753 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1754 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1755 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1756 
    args.write(self._oprot)
1757 
    self._oprot.writeMessageEnd()
1758 
    self._oprot.trans.flush()
1759 
 
1760 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1762 
    if mtype == TMessageType.EXCEPTION:
1763 
      x = TApplicationException()
1764 
      x.read(self._iprot)
1765 
      self._iprot.readMessageEnd()
1766 
      raise x
1767 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1768 
    result.read(self._iprot)
1769 
    self._iprot.readMessageEnd()
3431 rajveer 1770 
    if result.success is not None:
3064 chandransh 1771 
      return result.success
1772 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1773 
 
1774 
  def getValidOrdersAmountRange(self, ):
1775 
    """
1776 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1777 
    List contains two values, first minimum amount and second maximum amount.
1778 
    """
1779 
    self.send_getValidOrdersAmountRange()
1780 
    return self.recv_getValidOrdersAmountRange()
1781 
 
1782 
  def send_getValidOrdersAmountRange(self, ):
1783 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1784 
    args = getValidOrdersAmountRange_args()
1785 
    args.write(self._oprot)
1786 
    self._oprot.writeMessageEnd()
1787 
    self._oprot.trans.flush()
1788 
 
1789 
  def recv_getValidOrdersAmountRange(self, ):
1790 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1791 
    if mtype == TMessageType.EXCEPTION:
1792 
      x = TApplicationException()
1793 
      x.read(self._iprot)
1794 
      self._iprot.readMessageEnd()
1795 
      raise x
1796 
    result = getValidOrdersAmountRange_result()
1797 
    result.read(self._iprot)
1798 
    self._iprot.readMessageEnd()
3431 rajveer 1799 
    if result.success is not None:
3064 chandransh 1800 
      return result.success
1801 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1802 
 
1803 
  def getValidOrders(self, limit):
1804 
    """
1805 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1806 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1807 
 
3064 chandransh 1808 
    Parameters:
1809 
     - limit
1810 
    """
1811 
    self.send_getValidOrders(limit)
1812 
    return self.recv_getValidOrders()
1813 
 
1814 
  def send_getValidOrders(self, limit):
1815 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1816 
    args = getValidOrders_args()
1817 
    args.limit = limit
1818 
    args.write(self._oprot)
1819 
    self._oprot.writeMessageEnd()
1820 
    self._oprot.trans.flush()
1821 
 
1822 
  def recv_getValidOrders(self, ):
1823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1824 
    if mtype == TMessageType.EXCEPTION:
1825 
      x = TApplicationException()
1826 
      x.read(self._iprot)
1827 
      self._iprot.readMessageEnd()
1828 
      raise x
1829 
    result = getValidOrders_result()
1830 
    result.read(self._iprot)
1831 
    self._iprot.readMessageEnd()
3431 rajveer 1832 
    if result.success is not None:
3064 chandransh 1833 
      return result.success
1834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1835 
 
1220 chandransh 1836 
  def batchOrders(self, warehouseId):
1837 
    """
1838 
    Create a batch of all the pending orders for the given warehouse.
1839 
    The returned list is orderd by created_timestamp.
1840 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1841 
 
1220 chandransh 1842 
    Parameters:
1843 
     - warehouseId
1844 
    """
1845 
    self.send_batchOrders(warehouseId)
1846 
    return self.recv_batchOrders()
1847 
 
1848 
  def send_batchOrders(self, warehouseId):
1849 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1850 
    args = batchOrders_args()
1851 
    args.warehouseId = warehouseId
1852 
    args.write(self._oprot)
1853 
    self._oprot.writeMessageEnd()
1854 
    self._oprot.trans.flush()
1855 
 
1856 
  def recv_batchOrders(self, ):
1857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1858 
    if mtype == TMessageType.EXCEPTION:
1859 
      x = TApplicationException()
1860 
      x.read(self._iprot)
1861 
      self._iprot.readMessageEnd()
1862 
      raise x
1863 
    result = batchOrders_result()
1864 
    result.read(self._iprot)
1865 
    self._iprot.readMessageEnd()
3431 rajveer 1866 
    if result.success is not None:
1220 chandransh 1867 
      return result.success
3431 rajveer 1868 
    if result.ex is not None:
1220 chandransh 1869 
      raise result.ex
1870 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1871 
 
1208 chandransh 1872 
  def markOrderAsOutOfStock(self, orderId):
1873 
    """
1874 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1875 
 
1208 chandransh 1876 
    Parameters:
1877 
     - orderId
1878 
    """
1879 
    self.send_markOrderAsOutOfStock(orderId)
1880 
    return self.recv_markOrderAsOutOfStock()
1881 
 
1882 
  def send_markOrderAsOutOfStock(self, orderId):
1883 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1884 
    args = markOrderAsOutOfStock_args()
1885 
    args.orderId = orderId
1886 
    args.write(self._oprot)
1887 
    self._oprot.writeMessageEnd()
1888 
    self._oprot.trans.flush()
1889 
 
1890 
  def recv_markOrderAsOutOfStock(self, ):
1891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1892 
    if mtype == TMessageType.EXCEPTION:
1893 
      x = TApplicationException()
1894 
      x.read(self._iprot)
1895 
      self._iprot.readMessageEnd()
1896 
      raise x
1897 
    result = markOrderAsOutOfStock_result()
1898 
    result.read(self._iprot)
1899 
    self._iprot.readMessageEnd()
3431 rajveer 1900 
    if result.success is not None:
1208 chandransh 1901 
      return result.success
3431 rajveer 1902 
    if result.ex is not None:
1208 chandransh 1903 
      raise result.ex
1904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1905 
 
3064 chandransh 1906 
  def verifyOrder(self, orderId):
759 chandransh 1907 
    """
3064 chandransh 1908 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1909 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1910 
    used for all other orders as well.
1911 
    Throws an exception if no such order exists.
3431 rajveer 1912 
 
759 chandransh 1913 
    Parameters:
3064 chandransh 1914 
     - orderId
759 chandransh 1915 
    """
3064 chandransh 1916 
    self.send_verifyOrder(orderId)
1917 
    return self.recv_verifyOrder()
759 chandransh 1918 
 
3064 chandransh 1919 
  def send_verifyOrder(self, orderId):
1920 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1921 
    args = verifyOrder_args()
1922 
    args.orderId = orderId
759 chandransh 1923 
    args.write(self._oprot)
1924 
    self._oprot.writeMessageEnd()
1925 
    self._oprot.trans.flush()
1926 
 
3064 chandransh 1927 
  def recv_verifyOrder(self, ):
759 chandransh 1928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1929 
    if mtype == TMessageType.EXCEPTION:
1930 
      x = TApplicationException()
1931 
      x.read(self._iprot)
1932 
      self._iprot.readMessageEnd()
1933 
      raise x
3064 chandransh 1934 
    result = verifyOrder_result()
759 chandransh 1935 
    result.read(self._iprot)
1936 
    self._iprot.readMessageEnd()
3431 rajveer 1937 
    if result.success is not None:
759 chandransh 1938 
      return result.success
3431 rajveer 1939 
    if result.ex is not None:
759 chandransh 1940 
      raise result.ex
3064 chandransh 1941 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1942 
 
3064 chandransh 1943 
  def acceptOrder(self, orderId):
1113 chandransh 1944 
    """
3064 chandransh 1945 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1946 
    given order is not a COD order, it also captures the payment if the same has
1947 
    not been captured.
1948 
    Throws an exception if no such order exists.
3431 rajveer 1949 
 
1113 chandransh 1950 
    Parameters:
3064 chandransh 1951 
     - orderId
1113 chandransh 1952 
    """
3064 chandransh 1953 
    self.send_acceptOrder(orderId)
1954 
    return self.recv_acceptOrder()
1113 chandransh 1955 
 
3064 chandransh 1956 
  def send_acceptOrder(self, orderId):
1957 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1958 
    args = acceptOrder_args()
1959 
    args.orderId = orderId
1113 chandransh 1960 
    args.write(self._oprot)
1961 
    self._oprot.writeMessageEnd()
1962 
    self._oprot.trans.flush()
1963 
 
3064 chandransh 1964 
  def recv_acceptOrder(self, ):
1113 chandransh 1965 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1966 
    if mtype == TMessageType.EXCEPTION:
1967 
      x = TApplicationException()
1968 
      x.read(self._iprot)
1969 
      self._iprot.readMessageEnd()
1970 
      raise x
3064 chandransh 1971 
    result = acceptOrder_result()
1113 chandransh 1972 
    result.read(self._iprot)
1973 
    self._iprot.readMessageEnd()
3431 rajveer 1974 
    if result.success is not None:
1113 chandransh 1975 
      return result.success
3431 rajveer 1976 
    if result.ex is not None:
1113 chandransh 1977 
      raise result.ex
3064 chandransh 1978 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1979 
 
4283 anupam.sin 1980 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 1981 
    """
3064 chandransh 1982 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 1983 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1984 
    the IMEI no. if a -1 is supplied.
1985 
    Also, it generates an invoice number for the order, marks the order as
1986 
    BILLED and sets the billing timestamp.
1987 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1988 
 
1135 chandransh 1989 
    Parameters:
3064 chandransh 1990 
     - orderId
1991 
     - invoice_number
4283 anupam.sin 1992 
     - imeiNumber
1993 
     - itemNumber
3064 chandransh 1994 
     - billed_by
4264 rajveer 1995 
     - jacketNumber
4283 anupam.sin 1996 
     - billingType
1997 
     - vendorId
1135 chandransh 1998 
    """
4283 anupam.sin 1999 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 2000 
    return self.recv_addBillingDetails()
1135 chandransh 2001 
 
4283 anupam.sin 2002 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 2003 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2004 
    args = addBillingDetails_args()
2005 
    args.orderId = orderId
2006 
    args.invoice_number = invoice_number
4283 anupam.sin 2007 
    args.imeiNumber = imeiNumber
2008 
    args.itemNumber = itemNumber
3064 chandransh 2009 
    args.billed_by = billed_by
4264 rajveer 2010 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2011 
    args.billingType = billingType
2012 
    args.vendorId = vendorId
1135 chandransh 2013 
    args.write(self._oprot)
2014 
    self._oprot.writeMessageEnd()
2015 
    self._oprot.trans.flush()
2016 
 
3064 chandransh 2017 
  def recv_addBillingDetails(self, ):
1135 chandransh 2018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2019 
    if mtype == TMessageType.EXCEPTION:
2020 
      x = TApplicationException()
2021 
      x.read(self._iprot)
2022 
      self._iprot.readMessageEnd()
2023 
      raise x
3064 chandransh 2024 
    result = addBillingDetails_result()
1135 chandransh 2025 
    result.read(self._iprot)
2026 
    self._iprot.readMessageEnd()
3431 rajveer 2027 
    if result.success is not None:
3064 chandransh 2028 
      return result.success
3431 rajveer 2029 
    if result.ex is not None:
1135 chandransh 2030 
      raise result.ex
3064 chandransh 2031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2032 
 
3064 chandransh 2033 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2034 
    """
3064 chandransh 2035 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2036 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2037 
 
1408 ankur.sing 2038 
    Parameters:
3064 chandransh 2039 
     - warehouseId
1408 ankur.sing 2040 
     - providerId
3064 chandransh 2041 
     - cod
1408 ankur.sing 2042 
    """
3064 chandransh 2043 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2044 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2045 
 
3064 chandransh 2046 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2047 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2048 
    args = markOrdersAsManifested_args()
2049 
    args.warehouseId = warehouseId
1408 ankur.sing 2050 
    args.providerId = providerId
3064 chandransh 2051 
    args.cod = cod
1408 ankur.sing 2052 
    args.write(self._oprot)
2053 
    self._oprot.writeMessageEnd()
2054 
    self._oprot.trans.flush()
2055 
 
3064 chandransh 2056 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2058 
    if mtype == TMessageType.EXCEPTION:
2059 
      x = TApplicationException()
2060 
      x.read(self._iprot)
2061 
      self._iprot.readMessageEnd()
2062 
      raise x
3064 chandransh 2063 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2064 
    result.read(self._iprot)
2065 
    self._iprot.readMessageEnd()
3431 rajveer 2066 
    if result.success is not None:
1408 ankur.sing 2067 
      return result.success
3431 rajveer 2068 
    if result.ex is not None:
3064 chandransh 2069 
      raise result.ex
2070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2071 
 
4410 rajveer 2072 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2073 
    """
2074 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2075 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2076 
 
2077 
    Parameters:
2078 
     - warehouseId
2079 
     - providerId
2080 
     - cod
2081 
    """
2082 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2083 
    return self.recv_markOrdersAsShippedFromWarehouse()
2084 
 
2085 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2086 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2087 
    args = markOrdersAsShippedFromWarehouse_args()
2088 
    args.warehouseId = warehouseId
2089 
    args.providerId = providerId
2090 
    args.cod = cod
2091 
    args.write(self._oprot)
2092 
    self._oprot.writeMessageEnd()
2093 
    self._oprot.trans.flush()
2094 
 
2095 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2097 
    if mtype == TMessageType.EXCEPTION:
2098 
      x = TApplicationException()
2099 
      x.read(self._iprot)
2100 
      self._iprot.readMessageEnd()
2101 
      raise x
2102 
    result = markOrdersAsShippedFromWarehouse_result()
2103 
    result.read(self._iprot)
2104 
    self._iprot.readMessageEnd()
2105 
    if result.success is not None:
2106 
      return result.success
2107 
    if result.ex is not None:
2108 
      raise result.ex
2109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2110 
 
3064 chandransh 2111 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2112 
    """
3064 chandransh 2113 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2114 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2115 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2116 
 
94 ashish 2117 
    Parameters:
3064 chandransh 2118 
     - providerId
2119 
     - pickupDetails
304 ashish 2120 
    """
3064 chandransh 2121 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2122 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2123 
 
3064 chandransh 2124 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2125 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2126 
    args = markOrdersAsPickedUp_args()
2127 
    args.providerId = providerId
2128 
    args.pickupDetails = pickupDetails
304 ashish 2129 
    args.write(self._oprot)
2130 
    self._oprot.writeMessageEnd()
2131 
    self._oprot.trans.flush()
2132 
 
3064 chandransh 2133 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2135 
    if mtype == TMessageType.EXCEPTION:
2136 
      x = TApplicationException()
2137 
      x.read(self._iprot)
2138 
      self._iprot.readMessageEnd()
2139 
      raise x
3064 chandransh 2140 
    result = markOrdersAsPickedUp_result()
304 ashish 2141 
    result.read(self._iprot)
2142 
    self._iprot.readMessageEnd()
3431 rajveer 2143 
    if result.success is not None:
304 ashish 2144 
      return result.success
3431 rajveer 2145 
    if result.ex is not None:
3064 chandransh 2146 
      raise result.ex
2147 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2148 
 
3064 chandransh 2149 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2150 
    """
3064 chandransh 2151 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2152 
    the name of the receiver.
2153 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2154 
 
304 ashish 2155 
    Parameters:
3064 chandransh 2156 
     - providerId
2157 
     - deliveredOrders
304 ashish 2158 
    """
3064 chandransh 2159 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2160 
    self.recv_markOrdersAsDelivered()
304 ashish 2161 
 
3064 chandransh 2162 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2163 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2164 
    args = markOrdersAsDelivered_args()
2165 
    args.providerId = providerId
2166 
    args.deliveredOrders = deliveredOrders
304 ashish 2167 
    args.write(self._oprot)
2168 
    self._oprot.writeMessageEnd()
2169 
    self._oprot.trans.flush()
2170 
 
3064 chandransh 2171 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2173 
    if mtype == TMessageType.EXCEPTION:
2174 
      x = TApplicationException()
2175 
      x.read(self._iprot)
2176 
      self._iprot.readMessageEnd()
2177 
      raise x
3064 chandransh 2178 
    result = markOrdersAsDelivered_result()
304 ashish 2179 
    result.read(self._iprot)
2180 
    self._iprot.readMessageEnd()
3431 rajveer 2181 
    if result.ex is not None:
3064 chandransh 2182 
      raise result.ex
304 ashish 2183 
    return
2184 
 
3064 chandransh 2185 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2186 
    """
3064 chandransh 2187 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2188 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2189 
 
3064 chandransh 2190 
    Parameters:
2191 
     - providerId
2192 
     - returnedOrders
1596 ankur.sing 2193 
    """
3064 chandransh 2194 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2195 
    self.recv_markOrdersAsFailed()
304 ashish 2196 
 
3064 chandransh 2197 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2198 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2199 
    args = markOrdersAsFailed_args()
2200 
    args.providerId = providerId
2201 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2202 
    args.write(self._oprot)
2203 
    self._oprot.writeMessageEnd()
2204 
    self._oprot.trans.flush()
2205 
 
3064 chandransh 2206 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2207 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2208 
    if mtype == TMessageType.EXCEPTION:
2209 
      x = TApplicationException()
2210 
      x.read(self._iprot)
2211 
      self._iprot.readMessageEnd()
2212 
      raise x
3064 chandransh 2213 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2214 
    result.read(self._iprot)
2215 
    self._iprot.readMessageEnd()
3431 rajveer 2216 
    if result.ex is not None:
3064 chandransh 2217 
      raise result.ex
2218 
    return
1596 ankur.sing 2219 
 
3064 chandransh 2220 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2221 
    """
3064 chandransh 2222 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2223 
 
3064 chandransh 2224 
    Parameters:
2225 
     - providerId
2226 
     - undeliveredOrders
1627 ankur.sing 2227 
    """
3064 chandransh 2228 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2229 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2230 
 
3064 chandransh 2231 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2232 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2233 
    args = updateNonDeliveryReason_args()
2234 
    args.providerId = providerId
2235 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2236 
    args.write(self._oprot)
2237 
    self._oprot.writeMessageEnd()
2238 
    self._oprot.trans.flush()
2239 
 
3064 chandransh 2240 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2241 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2242 
    if mtype == TMessageType.EXCEPTION:
2243 
      x = TApplicationException()
2244 
      x.read(self._iprot)
2245 
      self._iprot.readMessageEnd()
2246 
      raise x
3064 chandransh 2247 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2248 
    result.read(self._iprot)
2249 
    self._iprot.readMessageEnd()
3431 rajveer 2250 
    if result.ex is not None:
3064 chandransh 2251 
      raise result.ex
2252 
    return
1627 ankur.sing 2253 
 
3064 chandransh 2254 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2255 
    """
3064 chandransh 2256 
    Returns the list of orders whose delivery time has passed but have not been
2257 
    delivered yet for the given provider and warehouse. To get a complete list of
2258 
    undelivered orders, pass them as -1.
2259 
    Returns an empty list if no such orders exist.
3431 rajveer 2260 
 
1886 ankur.sing 2261 
    Parameters:
3064 chandransh 2262 
     - providerId
2263 
     - warehouseId
1886 ankur.sing 2264 
    """
3064 chandransh 2265 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2266 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2267 
 
3064 chandransh 2268 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2269 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2270 
    args = getUndeliveredOrders_args()
2271 
    args.providerId = providerId
2272 
    args.warehouseId = warehouseId
1886 ankur.sing 2273 
    args.write(self._oprot)
2274 
    self._oprot.writeMessageEnd()
2275 
    self._oprot.trans.flush()
2276 
 
3064 chandransh 2277 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 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 = getUndeliveredOrders_result()
1886 ankur.sing 2285 
    result.read(self._iprot)
2286 
    self._iprot.readMessageEnd()
3431 rajveer 2287 
    if result.success is not None:
1886 ankur.sing 2288 
      return result.success
3064 chandransh 2289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2290 
 
2536 chandransh 2291 
  def toggleDOAFlag(self, orderId):
2292 
    """
2293 
    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.
2294 
    Returns the final flag status.
2295 
    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 2296 
 
2536 chandransh 2297 
    Parameters:
2298 
     - orderId
2299 
    """
2300 
    self.send_toggleDOAFlag(orderId)
2301 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2302 
 
2536 chandransh 2303 
  def send_toggleDOAFlag(self, orderId):
2304 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2305 
    args = toggleDOAFlag_args()
2306 
    args.orderId = orderId
2307 
    args.write(self._oprot)
2308 
    self._oprot.writeMessageEnd()
2309 
    self._oprot.trans.flush()
2310 
 
2311 
  def recv_toggleDOAFlag(self, ):
2312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2313 
    if mtype == TMessageType.EXCEPTION:
2314 
      x = TApplicationException()
2315 
      x.read(self._iprot)
2316 
      self._iprot.readMessageEnd()
2317 
      raise x
2318 
    result = toggleDOAFlag_result()
2319 
    result.read(self._iprot)
2320 
    self._iprot.readMessageEnd()
3431 rajveer 2321 
    if result.success is not None:
2536 chandransh 2322 
      return result.success
3431 rajveer 2323 
    if result.ex is not None:
2536 chandransh 2324 
      raise result.ex
2325 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2326 
 
4454 rajveer 2327 
  def markOrderDoaRequestReceived(self, orderId):
2328 
    """
2329 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2330 
 
2331 
    Parameters:
2332 
     - orderId
2333 
    """
2334 
    self.send_markOrderDoaRequestReceived(orderId)
2335 
    return self.recv_markOrderDoaRequestReceived()
2336 
 
2337 
  def send_markOrderDoaRequestReceived(self, orderId):
2338 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2339 
    args = markOrderDoaRequestReceived_args()
2340 
    args.orderId = orderId
2341 
    args.write(self._oprot)
2342 
    self._oprot.writeMessageEnd()
2343 
    self._oprot.trans.flush()
2344 
 
2345 
  def recv_markOrderDoaRequestReceived(self, ):
2346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2347 
    if mtype == TMessageType.EXCEPTION:
2348 
      x = TApplicationException()
2349 
      x.read(self._iprot)
2350 
      self._iprot.readMessageEnd()
2351 
      raise x
2352 
    result = markOrderDoaRequestReceived_result()
2353 
    result.read(self._iprot)
2354 
    self._iprot.readMessageEnd()
2355 
    if result.success is not None:
2356 
      return result.success
2357 
    if result.ex is not None:
2358 
      raise result.ex
2359 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2360 
 
2361 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2362 
    """
2363 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2364 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2365 
 
2366 
    Parameters:
2367 
     - orderId
2368 
     - isAuthorized
2369 
    """
2370 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2371 
    return self.recv_markOrderDoaRequestAuthorized()
2372 
 
2373 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2374 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2375 
    args = markOrderDoaRequestAuthorized_args()
2376 
    args.orderId = orderId
2377 
    args.isAuthorized = isAuthorized
2378 
    args.write(self._oprot)
2379 
    self._oprot.writeMessageEnd()
2380 
    self._oprot.trans.flush()
2381 
 
2382 
  def recv_markOrderDoaRequestAuthorized(self, ):
2383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2384 
    if mtype == TMessageType.EXCEPTION:
2385 
      x = TApplicationException()
2386 
      x.read(self._iprot)
2387 
      self._iprot.readMessageEnd()
2388 
      raise x
2389 
    result = markOrderDoaRequestAuthorized_result()
2390 
    result.read(self._iprot)
2391 
    self._iprot.readMessageEnd()
2392 
    if result.success is not None:
2393 
      return result.success
2394 
    if result.ex is not None:
2395 
      raise result.ex
2396 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2397 
 
4488 rajveer 2398 
  def markOrderReturnRequestReceived(self, orderId):
2399 
    """
2400 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2401 
 
2402 
    Parameters:
2403 
     - orderId
2404 
    """
2405 
    self.send_markOrderReturnRequestReceived(orderId)
2406 
    return self.recv_markOrderReturnRequestReceived()
2407 
 
2408 
  def send_markOrderReturnRequestReceived(self, orderId):
2409 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2410 
    args = markOrderReturnRequestReceived_args()
2411 
    args.orderId = orderId
2412 
    args.write(self._oprot)
2413 
    self._oprot.writeMessageEnd()
2414 
    self._oprot.trans.flush()
2415 
 
2416 
  def recv_markOrderReturnRequestReceived(self, ):
2417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2418 
    if mtype == TMessageType.EXCEPTION:
2419 
      x = TApplicationException()
2420 
      x.read(self._iprot)
2421 
      self._iprot.readMessageEnd()
2422 
      raise x
2423 
    result = markOrderReturnRequestReceived_result()
2424 
    result.read(self._iprot)
2425 
    self._iprot.readMessageEnd()
2426 
    if result.success is not None:
2427 
      return result.success
2428 
    if result.ex is not None:
2429 
      raise result.ex
2430 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2431 
 
2432 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2433 
    """
2434 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2435 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2436 
 
2437 
    Parameters:
2438 
     - orderId
2439 
     - isAuthorized
2440 
    """
2441 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2442 
    return self.recv_markOrderReturnRequestAuthorized()
2443 
 
2444 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2445 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2446 
    args = markOrderReturnRequestAuthorized_args()
2447 
    args.orderId = orderId
2448 
    args.isAuthorized = isAuthorized
2449 
    args.write(self._oprot)
2450 
    self._oprot.writeMessageEnd()
2451 
    self._oprot.trans.flush()
2452 
 
2453 
  def recv_markOrderReturnRequestAuthorized(self, ):
2454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2455 
    if mtype == TMessageType.EXCEPTION:
2456 
      x = TApplicationException()
2457 
      x.read(self._iprot)
2458 
      self._iprot.readMessageEnd()
2459 
      raise x
2460 
    result = markOrderReturnRequestAuthorized_result()
2461 
    result.read(self._iprot)
2462 
    self._iprot.readMessageEnd()
2463 
    if result.success is not None:
2464 
      return result.success
2465 
    if result.ex is not None:
2466 
      raise result.ex
2467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2468 
 
2536 chandransh 2469 
  def requestPickupNumber(self, orderId):
2470 
    """
2471 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2472 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2473 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2474 
    For any other status, it returns false.
2475 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2476 
 
2536 chandransh 2477 
    Parameters:
2478 
     - orderId
2479 
    """
2480 
    self.send_requestPickupNumber(orderId)
2481 
    return self.recv_requestPickupNumber()
2482 
 
2483 
  def send_requestPickupNumber(self, orderId):
2484 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2485 
    args = requestPickupNumber_args()
2486 
    args.orderId = orderId
2487 
    args.write(self._oprot)
2488 
    self._oprot.writeMessageEnd()
2489 
    self._oprot.trans.flush()
2490 
 
2491 
  def recv_requestPickupNumber(self, ):
2492 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2493 
    if mtype == TMessageType.EXCEPTION:
2494 
      x = TApplicationException()
2495 
      x.read(self._iprot)
2496 
      self._iprot.readMessageEnd()
2497 
      raise x
2498 
    result = requestPickupNumber_result()
2499 
    result.read(self._iprot)
2500 
    self._iprot.readMessageEnd()
3431 rajveer 2501 
    if result.success is not None:
2536 chandransh 2502 
      return result.success
3431 rajveer 2503 
    if result.ex is not None:
2536 chandransh 2504 
      raise result.ex
2505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2506 
 
2507 
  def authorizePickup(self, orderId, pickupNumber):
2508 
    """
4452 rajveer 2509 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2510 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2511 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2512 
    	3. Returns true
2591 chandransh 2513 
    If the order is in any other status, it returns false.
2536 chandransh 2514 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2515 
 
2536 chandransh 2516 
    Parameters:
2517 
     - orderId
2518 
     - pickupNumber
2519 
    """
2520 
    self.send_authorizePickup(orderId, pickupNumber)
2521 
    return self.recv_authorizePickup()
2522 
 
2523 
  def send_authorizePickup(self, orderId, pickupNumber):
2524 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2525 
    args = authorizePickup_args()
2526 
    args.orderId = orderId
2527 
    args.pickupNumber = pickupNumber
2528 
    args.write(self._oprot)
2529 
    self._oprot.writeMessageEnd()
2530 
    self._oprot.trans.flush()
2531 
 
2532 
  def recv_authorizePickup(self, ):
2533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2534 
    if mtype == TMessageType.EXCEPTION:
2535 
      x = TApplicationException()
2536 
      x.read(self._iprot)
2537 
      self._iprot.readMessageEnd()
2538 
      raise x
2539 
    result = authorizePickup_result()
2540 
    result.read(self._iprot)
2541 
    self._iprot.readMessageEnd()
3431 rajveer 2542 
    if result.success is not None:
2536 chandransh 2543 
      return result.success
3431 rajveer 2544 
    if result.ex is not None:
2536 chandransh 2545 
      raise result.ex
2546 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2547 
 
2764 chandransh 2548 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2549 
    """
2550 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2551 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2552 
 
2764 chandransh 2553 
    Parameters:
2554 
     - providerId
2555 
     - pickupDetails
2556 
    """
2557 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2558 
    return self.recv_markDoasAsPickedUp()
2559 
 
2560 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2561 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2562 
    args = markDoasAsPickedUp_args()
2563 
    args.providerId = providerId
2564 
    args.pickupDetails = pickupDetails
2565 
    args.write(self._oprot)
2566 
    self._oprot.writeMessageEnd()
2567 
    self._oprot.trans.flush()
2568 
 
2569 
  def recv_markDoasAsPickedUp(self, ):
2570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2571 
    if mtype == TMessageType.EXCEPTION:
2572 
      x = TApplicationException()
2573 
      x.read(self._iprot)
2574 
      self._iprot.readMessageEnd()
2575 
      raise x
2576 
    result = markDoasAsPickedUp_result()
2577 
    result.read(self._iprot)
2578 
    self._iprot.readMessageEnd()
3431 rajveer 2579 
    if result.success is not None:
2764 chandransh 2580 
      return result.success
2581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2582 
 
4479 rajveer 2583 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2584 
    """
4452 rajveer 2585 
    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 2586 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2587 
    If the order is in any other state, it returns false.
2588 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2589 
 
2591 chandransh 2590 
    Parameters:
2591 
     - orderId
4479 rajveer 2592 
     - receiveCondition
2591 chandransh 2593 
    """
4479 rajveer 2594 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2595 
    return self.recv_receiveReturn()
2536 chandransh 2596 
 
4479 rajveer 2597 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2598 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2599 
    args = receiveReturn_args()
2591 chandransh 2600 
    args.orderId = orderId
4479 rajveer 2601 
    args.receiveCondition = receiveCondition
2591 chandransh 2602 
    args.write(self._oprot)
2603 
    self._oprot.writeMessageEnd()
2604 
    self._oprot.trans.flush()
2605 
 
2616 chandransh 2606 
  def recv_receiveReturn(self, ):
2591 chandransh 2607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2608 
    if mtype == TMessageType.EXCEPTION:
2609 
      x = TApplicationException()
2610 
      x.read(self._iprot)
2611 
      self._iprot.readMessageEnd()
2612 
      raise x
2616 chandransh 2613 
    result = receiveReturn_result()
2591 chandransh 2614 
    result.read(self._iprot)
2615 
    self._iprot.readMessageEnd()
3431 rajveer 2616 
    if result.success is not None:
2591 chandransh 2617 
      return result.success
3431 rajveer 2618 
    if result.ex is not None:
2591 chandransh 2619 
      raise result.ex
2616 chandransh 2620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2621 
 
2622 
  def validateDoa(self, orderId, isValid):
2623 
    """
4452 rajveer 2624 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2625 
    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 2626 
    If the order is in any other state, it returns false.
2627 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2628 
 
2591 chandransh 2629 
    Parameters:
2630 
     - orderId
2631 
     - isValid
2632 
    """
2633 
    self.send_validateDoa(orderId, isValid)
2634 
    return self.recv_validateDoa()
2635 
 
2636 
  def send_validateDoa(self, orderId, isValid):
2637 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2638 
    args = validateDoa_args()
2639 
    args.orderId = orderId
2640 
    args.isValid = isValid
2641 
    args.write(self._oprot)
2642 
    self._oprot.writeMessageEnd()
2643 
    self._oprot.trans.flush()
2644 
 
2645 
  def recv_validateDoa(self, ):
2646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2647 
    if mtype == TMessageType.EXCEPTION:
2648 
      x = TApplicationException()
2649 
      x.read(self._iprot)
2650 
      self._iprot.readMessageEnd()
2651 
      raise x
2652 
    result = validateDoa_result()
2653 
    result.read(self._iprot)
2654 
    self._iprot.readMessageEnd()
3431 rajveer 2655 
    if result.success is not None:
2591 chandransh 2656 
      return result.success
3431 rajveer 2657 
    if result.ex is not None:
2591 chandransh 2658 
      raise result.ex
2659 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2660 
 
4495 rajveer 2661 
  def validateReturnProduct(self, orderId, isUsable):
2662 
    """
2663 
    Parameters:
2664 
     - orderId
2665 
     - isUsable
2666 
    """
2667 
    self.send_validateReturnProduct(orderId, isUsable)
2668 
    return self.recv_validateReturnProduct()
2669 
 
2670 
  def send_validateReturnProduct(self, orderId, isUsable):
2671 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2672 
    args = validateReturnProduct_args()
2673 
    args.orderId = orderId
2674 
    args.isUsable = isUsable
2675 
    args.write(self._oprot)
2676 
    self._oprot.writeMessageEnd()
2677 
    self._oprot.trans.flush()
2678 
 
2679 
  def recv_validateReturnProduct(self, ):
2680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2681 
    if mtype == TMessageType.EXCEPTION:
2682 
      x = TApplicationException()
2683 
      x.read(self._iprot)
2684 
      self._iprot.readMessageEnd()
2685 
      raise x
2686 
    result = validateReturnProduct_result()
2687 
    result.read(self._iprot)
2688 
    self._iprot.readMessageEnd()
2689 
    if result.success is not None:
2690 
      return result.success
2691 
    if result.ex is not None:
2692 
      raise result.ex
2693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2694 
 
2616 chandransh 2695 
  def reshipOrder(self, orderId):
2696 
    """
4484 rajveer 2697 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2698 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2699 
    	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 2700 
 
2701 
    If the order is in DOA_CERT_VALID state, it does the following:
2702 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2703 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2704 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2705 
 
2616 chandransh 2706 
    Returns the id of the newly created order.
3431 rajveer 2707 
 
2616 chandransh 2708 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2709 
 
2616 chandransh 2710 
    Parameters:
2711 
     - orderId
2712 
    """
2713 
    self.send_reshipOrder(orderId)
2714 
    return self.recv_reshipOrder()
2591 chandransh 2715 
 
2616 chandransh 2716 
  def send_reshipOrder(self, orderId):
2717 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2718 
    args = reshipOrder_args()
2719 
    args.orderId = orderId
2720 
    args.write(self._oprot)
2721 
    self._oprot.writeMessageEnd()
2722 
    self._oprot.trans.flush()
2723 
 
2724 
  def recv_reshipOrder(self, ):
2725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2726 
    if mtype == TMessageType.EXCEPTION:
2727 
      x = TApplicationException()
2728 
      x.read(self._iprot)
2729 
      self._iprot.readMessageEnd()
2730 
      raise x
2731 
    result = reshipOrder_result()
2732 
    result.read(self._iprot)
2733 
    self._iprot.readMessageEnd()
3431 rajveer 2734 
    if result.success is not None:
2616 chandransh 2735 
      return result.success
3431 rajveer 2736 
    if result.ex is not None:
2616 chandransh 2737 
      raise result.ex
2738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2739 
 
3226 chandransh 2740 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2741 
    """
4484 rajveer 2742 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2743 
    	1. Creates a refund request for batch processing.
2744 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 2745 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2746 
 
2616 chandransh 2747 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2748 
    	1. Creates a refund request for batch processing.
3226 chandransh 2749 
    	2. Cancels the reservation of the item in the warehouse.
2750 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2751 
 
3226 chandransh 2752 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2753 
    	1. Cancels the reservation of the item in the warehouse.
2754 
    	2. Marks the current order as CANCELED.
2755 
 
2756 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2757 
 
2616 chandransh 2758 
    Returns True if it is successful, False otherwise.
3431 rajveer 2759 
 
2616 chandransh 2760 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2761 
 
2616 chandransh 2762 
    Parameters:
2763 
     - orderId
3226 chandransh 2764 
     - refundedBy
2765 
     - reason
2616 chandransh 2766 
    """
3226 chandransh 2767 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2768 
    return self.recv_refundOrder()
2769 
 
3226 chandransh 2770 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2771 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2772 
    args = refundOrder_args()
2773 
    args.orderId = orderId
3226 chandransh 2774 
    args.refundedBy = refundedBy
2775 
    args.reason = reason
2616 chandransh 2776 
    args.write(self._oprot)
2777 
    self._oprot.writeMessageEnd()
2778 
    self._oprot.trans.flush()
2779 
 
2780 
  def recv_refundOrder(self, ):
2781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2782 
    if mtype == TMessageType.EXCEPTION:
2783 
      x = TApplicationException()
2784 
      x.read(self._iprot)
2785 
      self._iprot.readMessageEnd()
2786 
      raise x
2787 
    result = refundOrder_result()
2788 
    result.read(self._iprot)
2789 
    self._iprot.readMessageEnd()
3431 rajveer 2790 
    if result.success is not None:
2616 chandransh 2791 
      return result.success
3431 rajveer 2792 
    if result.ex is not None:
2616 chandransh 2793 
      raise result.ex
2794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2795 
 
2690 chandransh 2796 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2797 
    """
2798 
    Get all return orders created between the from and to dates for the given warehouse.
2799 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2800 
 
2690 chandransh 2801 
    Parameters:
2802 
     - warehouseId
2803 
     - fromDate
2804 
     - toDate
2805 
    """
2806 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2807 
    return self.recv_getReturnOrders()
2616 chandransh 2808 
 
2690 chandransh 2809 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2810 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2811 
    args = getReturnOrders_args()
2812 
    args.warehouseId = warehouseId
2813 
    args.fromDate = fromDate
2814 
    args.toDate = toDate
2815 
    args.write(self._oprot)
2816 
    self._oprot.writeMessageEnd()
2817 
    self._oprot.trans.flush()
2818 
 
2819 
  def recv_getReturnOrders(self, ):
2820 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2821 
    if mtype == TMessageType.EXCEPTION:
2822 
      x = TApplicationException()
2823 
      x.read(self._iprot)
2824 
      self._iprot.readMessageEnd()
2825 
      raise x
2826 
    result = getReturnOrders_result()
2827 
    result.read(self._iprot)
2828 
    self._iprot.readMessageEnd()
3431 rajveer 2829 
    if result.success is not None:
2690 chandransh 2830 
      return result.success
2831 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2832 
 
2700 chandransh 2833 
  def getReturnOrder(self, id):
2834 
    """
2835 
    Returns the ReturnOrder corresponding to the given id.
2836 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2837 
 
2700 chandransh 2838 
    Parameters:
2839 
     - id
2840 
    """
2841 
    self.send_getReturnOrder(id)
2842 
    return self.recv_getReturnOrder()
2843 
 
2844 
  def send_getReturnOrder(self, id):
2845 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2846 
    args = getReturnOrder_args()
2847 
    args.id = id
2848 
    args.write(self._oprot)
2849 
    self._oprot.writeMessageEnd()
2850 
    self._oprot.trans.flush()
2851 
 
2852 
  def recv_getReturnOrder(self, ):
2853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2854 
    if mtype == TMessageType.EXCEPTION:
2855 
      x = TApplicationException()
2856 
      x.read(self._iprot)
2857 
      self._iprot.readMessageEnd()
2858 
      raise x
2859 
    result = getReturnOrder_result()
2860 
    result.read(self._iprot)
2861 
    self._iprot.readMessageEnd()
3431 rajveer 2862 
    if result.success is not None:
2700 chandransh 2863 
      return result.success
3431 rajveer 2864 
    if result.ex is not None:
2700 chandransh 2865 
      raise result.ex
2866 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2867 
 
2690 chandransh 2868 
  def processReturn(self, returnOrderId):
2869 
    """
2870 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2871 
 
2690 chandransh 2872 
    Parameters:
2873 
     - returnOrderId
2874 
    """
2875 
    self.send_processReturn(returnOrderId)
2876 
    self.recv_processReturn()
2877 
 
2878 
  def send_processReturn(self, returnOrderId):
2879 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2880 
    args = processReturn_args()
2881 
    args.returnOrderId = returnOrderId
2882 
    args.write(self._oprot)
2883 
    self._oprot.writeMessageEnd()
2884 
    self._oprot.trans.flush()
2885 
 
2886 
  def recv_processReturn(self, ):
2887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2888 
    if mtype == TMessageType.EXCEPTION:
2889 
      x = TApplicationException()
2890 
      x.read(self._iprot)
2891 
      self._iprot.readMessageEnd()
2892 
      raise x
2893 
    result = processReturn_result()
2894 
    result.read(self._iprot)
2895 
    self._iprot.readMessageEnd()
3431 rajveer 2896 
    if result.ex is not None:
2690 chandransh 2897 
      raise result.ex
2898 
    return
2899 
 
2819 chandransh 2900 
  def createPurchaseOrder(self, warehouseId):
2901 
    """
2902 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2903 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2904 
 
2819 chandransh 2905 
    Parameters:
2906 
     - warehouseId
2907 
    """
2908 
    self.send_createPurchaseOrder(warehouseId)
2909 
    return self.recv_createPurchaseOrder()
2690 chandransh 2910 
 
2819 chandransh 2911 
  def send_createPurchaseOrder(self, warehouseId):
2912 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2913 
    args = createPurchaseOrder_args()
2914 
    args.warehouseId = warehouseId
2915 
    args.write(self._oprot)
2916 
    self._oprot.writeMessageEnd()
2917 
    self._oprot.trans.flush()
2918 
 
2919 
  def recv_createPurchaseOrder(self, ):
2920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2921 
    if mtype == TMessageType.EXCEPTION:
2922 
      x = TApplicationException()
2923 
      x.read(self._iprot)
2924 
      self._iprot.readMessageEnd()
2925 
      raise x
2926 
    result = createPurchaseOrder_result()
2927 
    result.read(self._iprot)
2928 
    self._iprot.readMessageEnd()
3431 rajveer 2929 
    if result.success is not None:
2819 chandransh 2930 
      return result.success
3431 rajveer 2931 
    if result.ex is not None:
2819 chandransh 2932 
      raise result.ex
2933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2934 
 
3451 chandransh 2935 
  def updateWeight(self, orderId, weight):
2936 
    """
2937 
    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 2938 
 
3451 chandransh 2939 
    Parameters:
2940 
     - orderId
2941 
     - weight
2942 
    """
2943 
    self.send_updateWeight(orderId, weight)
2944 
    return self.recv_updateWeight()
2945 
 
2946 
  def send_updateWeight(self, orderId, weight):
2947 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2948 
    args = updateWeight_args()
2949 
    args.orderId = orderId
2950 
    args.weight = weight
2951 
    args.write(self._oprot)
2952 
    self._oprot.writeMessageEnd()
2953 
    self._oprot.trans.flush()
2954 
 
2955 
  def recv_updateWeight(self, ):
2956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2957 
    if mtype == TMessageType.EXCEPTION:
2958 
      x = TApplicationException()
2959 
      x.read(self._iprot)
2960 
      self._iprot.readMessageEnd()
2961 
      raise x
2962 
    result = updateWeight_result()
2963 
    result.read(self._iprot)
2964 
    self._iprot.readMessageEnd()
2965 
    if result.success is not None:
2966 
      return result.success
2967 
    if result.ex is not None:
2968 
      raise result.ex
2969 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2970 
 
3469 chandransh 2971 
  def changeItem(self, orderId, itemId):
2972 
    """
2973 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2974 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2975 
 
3469 chandransh 2976 
    Parameters:
2977 
     - orderId
2978 
     - itemId
2979 
    """
2980 
    self.send_changeItem(orderId, itemId)
2981 
    return self.recv_changeItem()
2982 
 
2983 
  def send_changeItem(self, orderId, itemId):
2984 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2985 
    args = changeItem_args()
2986 
    args.orderId = orderId
2987 
    args.itemId = itemId
2988 
    args.write(self._oprot)
2989 
    self._oprot.writeMessageEnd()
2990 
    self._oprot.trans.flush()
2991 
 
2992 
  def recv_changeItem(self, ):
2993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2994 
    if mtype == TMessageType.EXCEPTION:
2995 
      x = TApplicationException()
2996 
      x.read(self._iprot)
2997 
      self._iprot.readMessageEnd()
2998 
      raise x
2999 
    result = changeItem_result()
3000 
    result.read(self._iprot)
3001 
    self._iprot.readMessageEnd()
3002 
    if result.success is not None:
3003 
      return result.success
3004 
    if result.ex is not None:
3005 
      raise result.ex
3006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3007 
 
3008 
  def shiftToWarehouse(self, orderId, warehouseId):
3009 
    """
3010 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3011 
 
3012 
    Parameters:
3013 
     - orderId
3014 
     - warehouseId
3015 
    """
3016 
    self.send_shiftToWarehouse(orderId, warehouseId)
3017 
    return self.recv_shiftToWarehouse()
3018 
 
3019 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3020 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3021 
    args = shiftToWarehouse_args()
3022 
    args.orderId = orderId
3023 
    args.warehouseId = warehouseId
3024 
    args.write(self._oprot)
3025 
    self._oprot.writeMessageEnd()
3026 
    self._oprot.trans.flush()
3027 
 
3028 
  def recv_shiftToWarehouse(self, ):
3029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3030 
    if mtype == TMessageType.EXCEPTION:
3031 
      x = TApplicationException()
3032 
      x.read(self._iprot)
3033 
      self._iprot.readMessageEnd()
3034 
      raise x
3035 
    result = shiftToWarehouse_result()
3036 
    result.read(self._iprot)
3037 
    self._iprot.readMessageEnd()
3038 
    if result.success is not None:
3039 
      return result.success
3040 
    if result.ex is not None:
3041 
      raise result.ex
3042 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3043 
 
3986 chandransh 3044 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3045 
    """
3046 
    Adds the given delay reason to the given order.
3986 chandransh 3047 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3048 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3049 
 
3553 chandransh 3050 
    Parameters:
3051 
     - orderId
3052 
     - delayReason
3986 chandransh 3053 
     - furtherDelay
3553 chandransh 3054 
    """
3986 chandransh 3055 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 3056 
    return self.recv_addDelayReason()
3057 
 
3986 chandransh 3058 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3059 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3060 
    args = addDelayReason_args()
3061 
    args.orderId = orderId
3062 
    args.delayReason = delayReason
3986 chandransh 3063 
    args.furtherDelay = furtherDelay
3553 chandransh 3064 
    args.write(self._oprot)
3065 
    self._oprot.writeMessageEnd()
3066 
    self._oprot.trans.flush()
3067 
 
3068 
  def recv_addDelayReason(self, ):
3069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3070 
    if mtype == TMessageType.EXCEPTION:
3071 
      x = TApplicationException()
3072 
      x.read(self._iprot)
3073 
      self._iprot.readMessageEnd()
3074 
      raise x
3075 
    result = addDelayReason_result()
3076 
    result.read(self._iprot)
3077 
    self._iprot.readMessageEnd()
3078 
    if result.success is not None:
3079 
      return result.success
3080 
    if result.ex is not None:
3081 
      raise result.ex
3082 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3083 
 
3956 chandransh 3084 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3085 
    """
3086 
    Marks the COD orders with given AWB nos. as having been processed.
3087 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3088 
 
3956 chandransh 3089 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3090 
    1. There is no order corresponding to an AWB number.
3091 
    2. The captured amount for a payment exceeds the total payment.
3092 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3093 
 
3094 
    Parameters:
3095 
     - collectedAmountMap
3096 
     - xferBy
3097 
     - xferTxnId
3098 
     - xferDate
3099 
    """
3100 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3101 
    return self.recv_reconcileCodCollection()
3102 
 
3103 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3104 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3105 
    args = reconcileCodCollection_args()
3106 
    args.collectedAmountMap = collectedAmountMap
3107 
    args.xferBy = xferBy
3108 
    args.xferTxnId = xferTxnId
3109 
    args.xferDate = xferDate
3110 
    args.write(self._oprot)
3111 
    self._oprot.writeMessageEnd()
3112 
    self._oprot.trans.flush()
3113 
 
3114 
  def recv_reconcileCodCollection(self, ):
3115 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3116 
    if mtype == TMessageType.EXCEPTION:
3117 
      x = TApplicationException()
3118 
      x.read(self._iprot)
3119 
      self._iprot.readMessageEnd()
3120 
      raise x
3121 
    result = reconcileCodCollection_result()
3122 
    result.read(self._iprot)
3123 
    self._iprot.readMessageEnd()
3124 
    if result.success is not None:
3125 
      return result.success
3126 
    if result.ex is not None:
3127 
      raise result.ex
3128 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3129 
 
4008 mandeep.dh 3130 
  def getTransactionsRequiringExtraProcessing(self, category):
3131 
    """
4065 mandeep.dh 3132 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3133 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3134 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3135 
 
4008 mandeep.dh 3136 
    Parameters:
3137 
     - category
3138 
    """
3139 
    self.send_getTransactionsRequiringExtraProcessing(category)
3140 
    return self.recv_getTransactionsRequiringExtraProcessing()
3141 
 
3142 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3143 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3144 
    args = getTransactionsRequiringExtraProcessing_args()
3145 
    args.category = category
3146 
    args.write(self._oprot)
3147 
    self._oprot.writeMessageEnd()
3148 
    self._oprot.trans.flush()
3149 
 
3150 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3152 
    if mtype == TMessageType.EXCEPTION:
3153 
      x = TApplicationException()
3154 
      x.read(self._iprot)
3155 
      self._iprot.readMessageEnd()
3156 
      raise x
3157 
    result = getTransactionsRequiringExtraProcessing_result()
3158 
    result.read(self._iprot)
3159 
    self._iprot.readMessageEnd()
3160 
    if result.success is not None:
3161 
      return result.success
3162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3163 
 
3164 
  def markTransactionAsProcessed(self, transactionId, category):
3165 
    """
3166 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3167 
    It essentially deletes the transaction id record for a particular
3168 
    processing type category (if present) from DB.
3169 
    This is currently used by CRM application.
4008 mandeep.dh 3170 
 
3171 
    Parameters:
3172 
     - transactionId
3173 
     - category
3174 
    """
3175 
    self.send_markTransactionAsProcessed(transactionId, category)
3176 
    self.recv_markTransactionAsProcessed()
3177 
 
3178 
  def send_markTransactionAsProcessed(self, transactionId, category):
3179 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3180 
    args = markTransactionAsProcessed_args()
3181 
    args.transactionId = transactionId
3182 
    args.category = category
3183 
    args.write(self._oprot)
3184 
    self._oprot.writeMessageEnd()
3185 
    self._oprot.trans.flush()
3186 
 
3187 
  def recv_markTransactionAsProcessed(self, ):
3188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3189 
    if mtype == TMessageType.EXCEPTION:
3190 
      x = TApplicationException()
3191 
      x.read(self._iprot)
3192 
      self._iprot.readMessageEnd()
3193 
      raise x
3194 
    result = markTransactionAsProcessed_result()
3195 
    result.read(self._iprot)
3196 
    self._iprot.readMessageEnd()
3197 
    return
3198 
 
4018 chandransh 3199 
  def getItemWiseRiskyOrdersCount(self, ):
3200 
    """
3201 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3202 
    is defined as one whose shipping date is about to expire.
3203 
    """
3204 
    self.send_getItemWiseRiskyOrdersCount()
3205 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3206 
 
4018 chandransh 3207 
  def send_getItemWiseRiskyOrdersCount(self, ):
3208 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3209 
    args = getItemWiseRiskyOrdersCount_args()
3210 
    args.write(self._oprot)
3211 
    self._oprot.writeMessageEnd()
3212 
    self._oprot.trans.flush()
3213 
 
3214 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3216 
    if mtype == TMessageType.EXCEPTION:
3217 
      x = TApplicationException()
3218 
      x.read(self._iprot)
3219 
      self._iprot.readMessageEnd()
3220 
      raise x
3221 
    result = getItemWiseRiskyOrdersCount_result()
3222 
    result.read(self._iprot)
3223 
    self._iprot.readMessageEnd()
3224 
    if result.success is not None:
3225 
      return result.success
3226 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3227 
 
4295 varun.gupt 3228 
  def getOrdersForItemIds(self, itemIds):
3229 
    """
3230 
    Returns a list of all orders which have items with given id
3231 
 
3232 
    Parameters:
3233 
     - itemIds
3234 
    """
3235 
    self.send_getOrdersForItemIds(itemIds)
3236 
    return self.recv_getOrdersForItemIds()
3237 
 
3238 
  def send_getOrdersForItemIds(self, itemIds):
3239 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3240 
    args = getOrdersForItemIds_args()
3241 
    args.itemIds = itemIds
3242 
    args.write(self._oprot)
3243 
    self._oprot.writeMessageEnd()
3244 
    self._oprot.trans.flush()
3245 
 
3246 
  def recv_getOrdersForItemIds(self, ):
3247 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3248 
    if mtype == TMessageType.EXCEPTION:
3249 
      x = TApplicationException()
3250 
      x.read(self._iprot)
3251 
      self._iprot.readMessageEnd()
3252 
      raise x
3253 
    result = getOrdersForItemIds_result()
3254 
    result.read(self._iprot)
3255 
    self._iprot.readMessageEnd()
3256 
    if result.success is not None:
3257 
      return result.success
3258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3259 
 
4247 rajveer 3260 
  def markOrderCancellationRequestReceived(self, orderId):
3261 
    """
3262 
    Mark order as cancellation request received. If customer sends request of cancellation of
3263 
    a particular order, this method will be called. It will just change status of the order
3264 
    depending on its current status. It also records the previous status, so that we can move
3265 
    back to that status if cancellation request is denied.
4018 chandransh 3266 
 
4247 rajveer 3267 
    Parameters:
3268 
     - orderId
3269 
    """
3270 
    self.send_markOrderCancellationRequestReceived(orderId)
3271 
    self.recv_markOrderCancellationRequestReceived()
3272 
 
3273 
  def send_markOrderCancellationRequestReceived(self, orderId):
3274 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3275 
    args = markOrderCancellationRequestReceived_args()
3276 
    args.orderId = orderId
3277 
    args.write(self._oprot)
3278 
    self._oprot.writeMessageEnd()
3279 
    self._oprot.trans.flush()
3280 
 
3281 
  def recv_markOrderCancellationRequestReceived(self, ):
3282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3283 
    if mtype == TMessageType.EXCEPTION:
3284 
      x = TApplicationException()
3285 
      x.read(self._iprot)
3286 
      self._iprot.readMessageEnd()
3287 
      raise x
3288 
    result = markOrderCancellationRequestReceived_result()
3289 
    result.read(self._iprot)
3290 
    self._iprot.readMessageEnd()
3291 
    if result.ex is not None:
3292 
      raise result.ex
3293 
    return
3294 
 
3295 
  def markOrderCancellationRequestConfirmed(self, orderId):
3296 
    """
3297 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3298 
    cancellation request confirmed. After this OM will be able to cancel the order.
3299 
 
3300 
    Parameters:
3301 
     - orderId
3302 
    """
3303 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3304 
    self.recv_markOrderCancellationRequestConfirmed()
3305 
 
3306 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3307 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3308 
    args = markOrderCancellationRequestConfirmed_args()
3309 
    args.orderId = orderId
3310 
    args.write(self._oprot)
3311 
    self._oprot.writeMessageEnd()
3312 
    self._oprot.trans.flush()
3313 
 
3314 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3316 
    if mtype == TMessageType.EXCEPTION:
3317 
      x = TApplicationException()
3318 
      x.read(self._iprot)
3319 
      self._iprot.readMessageEnd()
3320 
      raise x
3321 
    result = markOrderCancellationRequestConfirmed_result()
3322 
    result.read(self._iprot)
3323 
    self._iprot.readMessageEnd()
3324 
    if result.ex is not None:
3325 
      raise result.ex
3326 
    return
3327 
 
3328 
  def markOrderCancellationRequestDenied(self, orderId):
3329 
    """
3330 
    If we decide to not to cancel order, we will move the order ro previous status.
3331 
 
3332 
    Parameters:
3333 
     - orderId
3334 
    """
3335 
    self.send_markOrderCancellationRequestDenied(orderId)
3336 
    self.recv_markOrderCancellationRequestDenied()
3337 
 
3338 
  def send_markOrderCancellationRequestDenied(self, orderId):
3339 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3340 
    args = markOrderCancellationRequestDenied_args()
3341 
    args.orderId = orderId
3342 
    args.write(self._oprot)
3343 
    self._oprot.writeMessageEnd()
3344 
    self._oprot.trans.flush()
3345 
 
3346 
  def recv_markOrderCancellationRequestDenied(self, ):
3347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3348 
    if mtype == TMessageType.EXCEPTION:
3349 
      x = TApplicationException()
3350 
      x.read(self._iprot)
3351 
      self._iprot.readMessageEnd()
3352 
      raise x
3353 
    result = markOrderCancellationRequestDenied_result()
3354 
    result.read(self._iprot)
3355 
    self._iprot.readMessageEnd()
3356 
    if result.ex is not None:
3357 
      raise result.ex
3358 
    return
3359 
 
4258 rajveer 3360 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3361 
    """
4258 rajveer 3362 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3363 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3364 
 
3365 
    Parameters:
4258 rajveer 3366 
     - transactionId
4247 rajveer 3367 
    """
4258 rajveer 3368 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3369 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3370 
 
4258 rajveer 3371 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3372 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3373 
    args = markTransactionAsPaymentFlagRemoved_args()
3374 
    args.transactionId = transactionId
4247 rajveer 3375 
    args.write(self._oprot)
3376 
    self._oprot.writeMessageEnd()
3377 
    self._oprot.trans.flush()
3378 
 
4258 rajveer 3379 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3381 
    if mtype == TMessageType.EXCEPTION:
3382 
      x = TApplicationException()
3383 
      x.read(self._iprot)
3384 
      self._iprot.readMessageEnd()
3385 
      raise x
4258 rajveer 3386 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3387 
    result.read(self._iprot)
3388 
    self._iprot.readMessageEnd()
3389 
    if result.ex is not None:
3390 
      raise result.ex
3391 
    return
3392 
 
4259 anupam.sin 3393 
  def refundTransaction(self, transactionId, refundedBy, reason):
3394 
    """
3395 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3396 
    need to be cancelled
4247 rajveer 3397 
 
4259 anupam.sin 3398 
    Parameters:
3399 
     - transactionId
3400 
     - refundedBy
3401 
     - reason
3402 
    """
3403 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3404 
    self.recv_refundTransaction()
3405 
 
3406 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3407 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3408 
    args = refundTransaction_args()
3409 
    args.transactionId = transactionId
3410 
    args.refundedBy = refundedBy
3411 
    args.reason = reason
3412 
    args.write(self._oprot)
3413 
    self._oprot.writeMessageEnd()
3414 
    self._oprot.trans.flush()
3415 
 
3416 
  def recv_refundTransaction(self, ):
3417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3418 
    if mtype == TMessageType.EXCEPTION:
3419 
      x = TApplicationException()
3420 
      x.read(self._iprot)
3421 
      self._iprot.readMessageEnd()
3422 
      raise x
3423 
    result = refundTransaction_result()
3424 
    result.read(self._iprot)
3425 
    self._iprot.readMessageEnd()
3426 
    if result.ex is not None:
3427 
      raise result.ex
3428 
    return
3429 
 
4324 mandeep.dh 3430 
  def updateShipmentAddress(self, orderId, addressId):
3431 
    """
3432 
    Updates shipment address of an order. Delivery and shipping date estimates
3433 
    etc. are also updated here.
3434 
 
3435 
    Throws TransactionServiceException in case address change is not
3436 
    possible due to certain reasons such as new pincode in address is
3437 
    not serviceable etc.
3438 
 
3439 
    Parameters:
3440 
     - orderId
3441 
     - addressId
3442 
    """
3443 
    self.send_updateShipmentAddress(orderId, addressId)
3444 
    self.recv_updateShipmentAddress()
3445 
 
3446 
  def send_updateShipmentAddress(self, orderId, addressId):
3447 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3448 
    args = updateShipmentAddress_args()
3449 
    args.orderId = orderId
3450 
    args.addressId = addressId
3451 
    args.write(self._oprot)
3452 
    self._oprot.writeMessageEnd()
3453 
    self._oprot.trans.flush()
3454 
 
3455 
  def recv_updateShipmentAddress(self, ):
3456 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3457 
    if mtype == TMessageType.EXCEPTION:
3458 
      x = TApplicationException()
3459 
      x.read(self._iprot)
3460 
      self._iprot.readMessageEnd()
3461 
      raise x
3462 
    result = updateShipmentAddress_result()
3463 
    result.read(self._iprot)
3464 
    self._iprot.readMessageEnd()
3465 
    if result.ex is not None:
3466 
      raise result.ex
3467 
    return
3468 
 
4285 rajveer 3469 
  def acceptOrdersForItemId(self, itemId, inventory):
3470 
    """
3471 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3472 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3473 
 
4285 rajveer 3474 
    Parameters:
3475 
     - itemId
3476 
     - inventory
3477 
    """
3478 
    self.send_acceptOrdersForItemId(itemId, inventory)
3479 
    return self.recv_acceptOrdersForItemId()
3480 
 
3481 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3482 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3483 
    args = acceptOrdersForItemId_args()
3484 
    args.itemId = itemId
3485 
    args.inventory = inventory
3486 
    args.write(self._oprot)
3487 
    self._oprot.writeMessageEnd()
3488 
    self._oprot.trans.flush()
3489 
 
3490 
  def recv_acceptOrdersForItemId(self, ):
3491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3492 
    if mtype == TMessageType.EXCEPTION:
3493 
      x = TApplicationException()
3494 
      x.read(self._iprot)
3495 
      self._iprot.readMessageEnd()
3496 
      raise x
3497 
    result = acceptOrdersForItemId_result()
3498 
    result.read(self._iprot)
3499 
    self._iprot.readMessageEnd()
3500 
    if result.success is not None:
3501 
      return result.success
3502 
    if result.ex is not None:
3503 
      raise result.ex
3504 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3505 
 
4369 rajveer 3506 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3507 
    """
3508 
    Parameters:
3509 
     - vendorId
3510 
     - itemId
3511 
     - quantity
3512 
     - estimate
4369 rajveer 3513 
     - isReminder
4303 rajveer 3514 
    """
4369 rajveer 3515 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3516 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3517 
 
4369 rajveer 3518 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3519 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3520 
    args = markOrdersAsPORaised_args()
3521 
    args.vendorId = vendorId
3522 
    args.itemId = itemId
3523 
    args.quantity = quantity
3524 
    args.estimate = estimate
4369 rajveer 3525 
    args.isReminder = isReminder
4303 rajveer 3526 
    args.write(self._oprot)
3527 
    self._oprot.writeMessageEnd()
3528 
    self._oprot.trans.flush()
3529 
 
3530 
  def recv_markOrdersAsPORaised(self, ):
3531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3532 
    if mtype == TMessageType.EXCEPTION:
3533 
      x = TApplicationException()
3534 
      x.read(self._iprot)
3535 
      self._iprot.readMessageEnd()
3536 
      raise x
3537 
    result = markOrdersAsPORaised_result()
3538 
    result.read(self._iprot)
3539 
    self._iprot.readMessageEnd()
3540 
    if result.ex is not None:
3541 
      raise result.ex
3542 
    return
3543 
 
4369 rajveer 3544 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3545 
    """
3546 
    Parameters:
3547 
     - vendorId
3548 
     - itemId
3549 
     - quantity
3550 
     - estimate
4369 rajveer 3551 
     - isReminder
4303 rajveer 3552 
    """
4369 rajveer 3553 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3554 
    self.recv_markOrdersAsReversalInitiated()
3555 
 
4369 rajveer 3556 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3557 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3558 
    args = markOrdersAsReversalInitiated_args()
3559 
    args.vendorId = vendorId
3560 
    args.itemId = itemId
3561 
    args.quantity = quantity
3562 
    args.estimate = estimate
4369 rajveer 3563 
    args.isReminder = isReminder
4303 rajveer 3564 
    args.write(self._oprot)
3565 
    self._oprot.writeMessageEnd()
3566 
    self._oprot.trans.flush()
3567 
 
3568 
  def recv_markOrdersAsReversalInitiated(self, ):
3569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3570 
    if mtype == TMessageType.EXCEPTION:
3571 
      x = TApplicationException()
3572 
      x.read(self._iprot)
3573 
      self._iprot.readMessageEnd()
3574 
      raise x
3575 
    result = markOrdersAsReversalInitiated_result()
3576 
    result.read(self._iprot)
3577 
    self._iprot.readMessageEnd()
3578 
    if result.ex is not None:
3579 
      raise result.ex
3580 
    return
3581 
 
4369 rajveer 3582 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3583 
    """
3584 
    Parameters:
3585 
     - vendorId
3586 
     - itemId
3587 
     - quantity
3588 
     - estimate
4369 rajveer 3589 
     - isReminder
4303 rajveer 3590 
    """
4369 rajveer 3591 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3592 
    self.recv_markOrdersAsNotAvailabke()
3593 
 
4369 rajveer 3594 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3595 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3596 
    args = markOrdersAsNotAvailabke_args()
3597 
    args.vendorId = vendorId
3598 
    args.itemId = itemId
3599 
    args.quantity = quantity
3600 
    args.estimate = estimate
4369 rajveer 3601 
    args.isReminder = isReminder
4303 rajveer 3602 
    args.write(self._oprot)
3603 
    self._oprot.writeMessageEnd()
3604 
    self._oprot.trans.flush()
3605 
 
3606 
  def recv_markOrdersAsNotAvailabke(self, ):
3607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3608 
    if mtype == TMessageType.EXCEPTION:
3609 
      x = TApplicationException()
3610 
      x.read(self._iprot)
3611 
      self._iprot.readMessageEnd()
3612 
      raise x
3613 
    result = markOrdersAsNotAvailabke_result()
3614 
    result.read(self._iprot)
3615 
    self._iprot.readMessageEnd()
3616 
    if result.ex is not None:
3617 
      raise result.ex
3618 
    return
3619 
 
4369 rajveer 3620 
  def markOrdersAsTimeout(self, vendorId):
3621 
    """
3622 
    Parameters:
3623 
     - vendorId
3624 
    """
3625 
    self.send_markOrdersAsTimeout(vendorId)
3626 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3627 
 
4369 rajveer 3628 
  def send_markOrdersAsTimeout(self, vendorId):
3629 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3630 
    args = markOrdersAsTimeout_args()
3631 
    args.vendorId = vendorId
3632 
    args.write(self._oprot)
3633 
    self._oprot.writeMessageEnd()
3634 
    self._oprot.trans.flush()
3635 
 
3636 
  def recv_markOrdersAsTimeout(self, ):
3637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3638 
    if mtype == TMessageType.EXCEPTION:
3639 
      x = TApplicationException()
3640 
      x.read(self._iprot)
3641 
      self._iprot.readMessageEnd()
3642 
      raise x
3643 
    result = markOrdersAsTimeout_result()
3644 
    result.read(self._iprot)
3645 
    self._iprot.readMessageEnd()
3646 
    if result.success is not None:
3647 
      return result.success
3648 
    if result.ex is not None:
3649 
      raise result.ex
3650 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3651 
 
4386 anupam.sin 3652 
  def getOrderForAwb(self, awb):
3653 
    """
3654 
    Returns the order corresponding to an AWB number
4369 rajveer 3655 
 
4386 anupam.sin 3656 
    Parameters:
3657 
     - awb
3658 
    """
3659 
    self.send_getOrderForAwb(awb)
3660 
    return self.recv_getOrderForAwb()
3661 
 
3662 
  def send_getOrderForAwb(self, awb):
3663 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3664 
    args = getOrderForAwb_args()
3665 
    args.awb = awb
3666 
    args.write(self._oprot)
3667 
    self._oprot.writeMessageEnd()
3668 
    self._oprot.trans.flush()
3669 
 
3670 
  def recv_getOrderForAwb(self, ):
3671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3672 
    if mtype == TMessageType.EXCEPTION:
3673 
      x = TApplicationException()
3674 
      x.read(self._iprot)
3675 
      self._iprot.readMessageEnd()
3676 
      raise x
3677 
    result = getOrderForAwb_result()
3678 
    result.read(self._iprot)
3679 
    self._iprot.readMessageEnd()
3680 
    if result.success is not None:
3681 
      return result.success
3682 
    if result.ex is not None:
3683 
      raise result.ex
3684 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3685 
 
3686 
 
3376 rajveer 3687 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3688 
  def __init__(self, handler):
3376 rajveer 3689 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3690 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3691 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3692 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3693 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3694 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3695 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3696 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3697 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3698 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3699 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3700 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3701 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3702 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3703 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3704 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3705 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3706 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3707 
    self._processMap["createOrder"] = Processor.process_createOrder
3708 
    self._processMap["getOrder"] = Processor.process_getOrder
3709 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3710 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3711 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 3712 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 3713 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 3714 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3715 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3716 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3717 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3718 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3719 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3720 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3721 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3722 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
759 chandransh 3723 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 3724 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 3725 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3726 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3727 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3728 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3729 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3730 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4454 rajveer 3731 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
3732 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 3733 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
3734 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 3735 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3736 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3737 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3738 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3739 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 3740 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 3741 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3742 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3743 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3744 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3745 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3746 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3747 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3748 
    self._processMap["changeItem"] = Processor.process_changeItem
3749 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3750 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3751 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3752 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3753 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3754 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 3755 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 3756 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3757 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3758 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3759 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3760 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 3761 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 3762 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 3763 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
3764 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
3765 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 3766 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4386 anupam.sin 3767 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
94 ashish 3768 
 
3769 
  def process(self, iprot, oprot):
3770 
    (name, type, seqid) = iprot.readMessageBegin()
3771 
    if name not in self._processMap:
3772 
      iprot.skip(TType.STRUCT)
3773 
      iprot.readMessageEnd()
3774 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3775 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3776 
      x.write(oprot)
3777 
      oprot.writeMessageEnd()
3778 
      oprot.trans.flush()
3779 
      return
3780 
    else:
3781 
      self._processMap[name](self, seqid, iprot, oprot)
3782 
    return True
3783 
 
3784 
  def process_createTransaction(self, seqid, iprot, oprot):
3785 
    args = createTransaction_args()
3786 
    args.read(iprot)
3787 
    iprot.readMessageEnd()
3788 
    result = createTransaction_result()
3789 
    try:
132 ashish 3790 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3791 
    except TransactionServiceException, ex:
3792 
      result.ex = ex
3793 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3794 
    result.write(oprot)
3795 
    oprot.writeMessageEnd()
3796 
    oprot.trans.flush()
3797 
 
3798 
  def process_getTransaction(self, seqid, iprot, oprot):
3799 
    args = getTransaction_args()
3800 
    args.read(iprot)
3801 
    iprot.readMessageEnd()
3802 
    result = getTransaction_result()
3803 
    try:
3804 
      result.success = self._handler.getTransaction(args.id)
3805 
    except TransactionServiceException, ex:
3806 
      result.ex = ex
3807 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3808 
    result.write(oprot)
3809 
    oprot.writeMessageEnd()
3810 
    oprot.trans.flush()
3811 
 
3812 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3813 
    args = getTransactionsForCustomer_args()
3814 
    args.read(iprot)
3815 
    iprot.readMessageEnd()
3816 
    result = getTransactionsForCustomer_result()
3817 
    try:
3818 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3819 
    except TransactionServiceException, ex:
3820 
      result.ex = ex
3821 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3822 
    result.write(oprot)
3823 
    oprot.writeMessageEnd()
3824 
    oprot.trans.flush()
3825 
 
132 ashish 3826 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3827 
    args = getTransactionsForShoppingCartId_args()
3828 
    args.read(iprot)
3829 
    iprot.readMessageEnd()
3830 
    result = getTransactionsForShoppingCartId_result()
3831 
    try:
3832 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3833 
    except TransactionServiceException, ex:
3834 
      result.ex = ex
3835 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3836 
    result.write(oprot)
3837 
    oprot.writeMessageEnd()
3838 
    oprot.trans.flush()
3839 
 
94 ashish 3840 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3841 
    args = getTransactionStatus_args()
3842 
    args.read(iprot)
3843 
    iprot.readMessageEnd()
3844 
    result = getTransactionStatus_result()
3845 
    try:
3846 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3847 
    except TransactionServiceException, ex:
3848 
      result.ex = ex
3849 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3850 
    result.write(oprot)
3851 
    oprot.writeMessageEnd()
3852 
    oprot.trans.flush()
3853 
 
3854 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3855 
    args = changeTransactionStatus_args()
3856 
    args.read(iprot)
3857 
    iprot.readMessageEnd()
3858 
    result = changeTransactionStatus_result()
3859 
    try:
3860 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3861 
    except TransactionServiceException, ex:
3862 
      result.ex = ex
3863 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3864 
    result.write(oprot)
3865 
    oprot.writeMessageEnd()
3866 
    oprot.trans.flush()
3867 
 
1398 varun.gupt 3868 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3869 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3870 
    args.read(iprot)
3871 
    iprot.readMessageEnd()
1398 varun.gupt 3872 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3873 
    try:
1398 varun.gupt 3874 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3875 
    except TransactionServiceException, ex:
3876 
      result.ex = ex
1398 varun.gupt 3877 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3878 
    result.write(oprot)
3879 
    oprot.writeMessageEnd()
3880 
    oprot.trans.flush()
3881 
 
483 rajveer 3882 
  def process_getAllOrders(self, seqid, iprot, oprot):
3883 
    args = getAllOrders_args()
94 ashish 3884 
    args.read(iprot)
3885 
    iprot.readMessageEnd()
483 rajveer 3886 
    result = getAllOrders_result()
94 ashish 3887 
    try:
483 rajveer 3888 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3889 
    except TransactionServiceException, ex:
3890 
      result.ex = ex
483 rajveer 3891 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3892 
    result.write(oprot)
3893 
    oprot.writeMessageEnd()
3894 
    oprot.trans.flush()
3895 
 
4133 chandransh 3896 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3897 
    args = getOrdersInBatch_args()
3898 
    args.read(iprot)
3899 
    iprot.readMessageEnd()
3900 
    result = getOrdersInBatch_result()
3901 
    try:
3902 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3903 
    except TransactionServiceException, ex:
3904 
      result.ex = ex
3905 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3906 
    result.write(oprot)
3907 
    oprot.writeMessageEnd()
3908 
    oprot.trans.flush()
3909 
 
3910 
  def process_getOrderCount(self, seqid, iprot, oprot):
3911 
    args = getOrderCount_args()
3912 
    args.read(iprot)
3913 
    iprot.readMessageEnd()
3914 
    result = getOrderCount_result()
3915 
    try:
3916 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3917 
    except TransactionServiceException, ex:
3918 
      result.ex = ex
3919 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3920 
    result.write(oprot)
3921 
    oprot.writeMessageEnd()
3922 
    oprot.trans.flush()
3923 
 
999 varun.gupt 3924 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3925 
    args = getOrdersByBillingDate_args()
3926 
    args.read(iprot)
3927 
    iprot.readMessageEnd()
3928 
    result = getOrdersByBillingDate_result()
3929 
    try:
3930 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3931 
    except TransactionServiceException, ex:
3932 
      result.ex = ex
3933 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3934 
    result.write(oprot)
3935 
    oprot.writeMessageEnd()
3936 
    oprot.trans.flush()
3937 
 
3427 chandransh 3938 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3939 
    args = getOrdersByShippingDate_args()
3940 
    args.read(iprot)
3941 
    iprot.readMessageEnd()
3942 
    result = getOrdersByShippingDate_result()
3943 
    try:
3451 chandransh 3944 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3945 
    except TransactionServiceException, ex:
3946 
      result.ex = ex
3947 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3948 
    result.write(oprot)
3949 
    oprot.writeMessageEnd()
3950 
    oprot.trans.flush()
3951 
 
1382 varun.gupt 3952 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3953 
    args = getReturnableOrdersForCustomer_args()
3954 
    args.read(iprot)
3955 
    iprot.readMessageEnd()
3956 
    result = getReturnableOrdersForCustomer_result()
3957 
    try:
3958 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3959 
    except TransactionServiceException, ex:
3960 
      result.ex = ex
3961 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3962 
    result.write(oprot)
3963 
    oprot.writeMessageEnd()
3964 
    oprot.trans.flush()
3965 
 
3966 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3967 
    args = getCancellableOrdersForCustomer_args()
3968 
    args.read(iprot)
3969 
    iprot.readMessageEnd()
3970 
    result = getCancellableOrdersForCustomer_result()
3971 
    try:
3972 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3973 
    except TransactionServiceException, ex:
3974 
      result.ex = ex
3975 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3976 
    result.write(oprot)
3977 
    oprot.writeMessageEnd()
3978 
    oprot.trans.flush()
3979 
 
483 rajveer 3980 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3981 
    args = changeOrderStatus_args()
94 ashish 3982 
    args.read(iprot)
3983 
    iprot.readMessageEnd()
483 rajveer 3984 
    result = changeOrderStatus_result()
94 ashish 3985 
    try:
483 rajveer 3986 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3987 
    except TransactionServiceException, ex:
3988 
      result.ex = ex
483 rajveer 3989 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3990 
    result.write(oprot)
3991 
    oprot.writeMessageEnd()
3992 
    oprot.trans.flush()
3993 
 
483 rajveer 3994 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3995 
    args = getOrdersForTransaction_args()
94 ashish 3996 
    args.read(iprot)
3997 
    iprot.readMessageEnd()
483 rajveer 3998 
    result = getOrdersForTransaction_result()
94 ashish 3999 
    try:
1528 ankur.sing 4000 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4001 
    except TransactionServiceException, ex:
4002 
      result.ex = ex
483 rajveer 4003 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4004 
    result.write(oprot)
4005 
    oprot.writeMessageEnd()
4006 
    oprot.trans.flush()
4007 
 
483 rajveer 4008 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4009 
    args = getOrdersForCustomer_args()
94 ashish 4010 
    args.read(iprot)
4011 
    iprot.readMessageEnd()
483 rajveer 4012 
    result = getOrdersForCustomer_result()
94 ashish 4013 
    try:
3014 chandransh 4014 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4015 
    except TransactionServiceException, ex:
4016 
      result.ex = ex
483 rajveer 4017 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4018 
    result.write(oprot)
4019 
    oprot.writeMessageEnd()
4020 
    oprot.trans.flush()
4021 
 
483 rajveer 4022 
  def process_createOrder(self, seqid, iprot, oprot):
4023 
    args = createOrder_args()
94 ashish 4024 
    args.read(iprot)
4025 
    iprot.readMessageEnd()
483 rajveer 4026 
    result = createOrder_result()
94 ashish 4027 
    try:
483 rajveer 4028 
      result.success = self._handler.createOrder(args.order)
94 ashish 4029 
    except TransactionServiceException, ex:
4030 
      result.ex = ex
483 rajveer 4031 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4032 
    result.write(oprot)
4033 
    oprot.writeMessageEnd()
4034 
    oprot.trans.flush()
4035 
 
483 rajveer 4036 
  def process_getOrder(self, seqid, iprot, oprot):
4037 
    args = getOrder_args()
94 ashish 4038 
    args.read(iprot)
4039 
    iprot.readMessageEnd()
483 rajveer 4040 
    result = getOrder_result()
94 ashish 4041 
    try:
483 rajveer 4042 
      result.success = self._handler.getOrder(args.id)
94 ashish 4043 
    except TransactionServiceException, ex:
4044 
      result.ex = ex
483 rajveer 4045 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4046 
    result.write(oprot)
4047 
    oprot.writeMessageEnd()
4048 
    oprot.trans.flush()
4049 
 
483 rajveer 4050 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4051 
    args = getLineItemsForOrder_args()
94 ashish 4052 
    args.read(iprot)
4053 
    iprot.readMessageEnd()
483 rajveer 4054 
    result = getLineItemsForOrder_result()
94 ashish 4055 
    try:
483 rajveer 4056 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4057 
    except TransactionServiceException, ex:
4058 
      result.ex = ex
483 rajveer 4059 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4060 
    result.write(oprot)
4061 
    oprot.writeMessageEnd()
4062 
    oprot.trans.flush()
4063 
 
1528 ankur.sing 4064 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4065 
    args = getOrderForCustomer_args()
4066 
    args.read(iprot)
4067 
    iprot.readMessageEnd()
4068 
    result = getOrderForCustomer_result()
4069 
    try:
4070 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4071 
    except TransactionServiceException, ex:
4072 
      result.ex = ex
4073 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4074 
    result.write(oprot)
4075 
    oprot.writeMessageEnd()
4076 
    oprot.trans.flush()
4077 
 
3064 chandransh 4078 
  def process_getAlerts(self, seqid, iprot, oprot):
4079 
    args = getAlerts_args()
4080 
    args.read(iprot)
4081 
    iprot.readMessageEnd()
4082 
    result = getAlerts_result()
4444 rajveer 4083 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4084 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4085 
    result.write(oprot)
4086 
    oprot.writeMessageEnd()
4087 
    oprot.trans.flush()
4088 
 
4394 rajveer 4089 
  def process_addAlert(self, seqid, iprot, oprot):
4090 
    args = addAlert_args()
3064 chandransh 4091 
    args.read(iprot)
4092 
    iprot.readMessageEnd()
4394 rajveer 4093 
    result = addAlert_result()
4444 rajveer 4094 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4095 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4096 
    result.write(oprot)
4097 
    oprot.writeMessageEnd()
4098 
    oprot.trans.flush()
4099 
 
4444 rajveer 4100 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4101 
    args = markAlertsAsSeen_args()
4102 
    args.read(iprot)
4103 
    iprot.readMessageEnd()
4104 
    result = markAlertsAsSeen_result()
4105 
    self._handler.markAlertsAsSeen(args.warehouseId)
4106 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4107 
    result.write(oprot)
4108 
    oprot.writeMessageEnd()
4109 
    oprot.trans.flush()
4110 
 
3064 chandransh 4111 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4112 
    args = getValidOrderCount_args()
4113 
    args.read(iprot)
4114 
    iprot.readMessageEnd()
4115 
    result = getValidOrderCount_result()
4116 
    result.success = self._handler.getValidOrderCount()
4117 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4118 
    result.write(oprot)
4119 
    oprot.writeMessageEnd()
4120 
    oprot.trans.flush()
4121 
 
4122 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4123 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4124 
    args.read(iprot)
4125 
    iprot.readMessageEnd()
4126 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4127 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4128 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4129 
    result.write(oprot)
4130 
    oprot.writeMessageEnd()
4131 
    oprot.trans.flush()
4132 
 
4133 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4134 
    args = getValidOrdersAmountRange_args()
4135 
    args.read(iprot)
4136 
    iprot.readMessageEnd()
4137 
    result = getValidOrdersAmountRange_result()
4138 
    result.success = self._handler.getValidOrdersAmountRange()
4139 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4140 
    result.write(oprot)
4141 
    oprot.writeMessageEnd()
4142 
    oprot.trans.flush()
4143 
 
4144 
  def process_getValidOrders(self, seqid, iprot, oprot):
4145 
    args = getValidOrders_args()
4146 
    args.read(iprot)
4147 
    iprot.readMessageEnd()
4148 
    result = getValidOrders_result()
4149 
    result.success = self._handler.getValidOrders(args.limit)
4150 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4151 
    result.write(oprot)
4152 
    oprot.writeMessageEnd()
4153 
    oprot.trans.flush()
4154 
 
1220 chandransh 4155 
  def process_batchOrders(self, seqid, iprot, oprot):
4156 
    args = batchOrders_args()
4157 
    args.read(iprot)
4158 
    iprot.readMessageEnd()
4159 
    result = batchOrders_result()
4160 
    try:
4161 
      result.success = self._handler.batchOrders(args.warehouseId)
4162 
    except TransactionServiceException, ex:
4163 
      result.ex = ex
4164 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4165 
    result.write(oprot)
4166 
    oprot.writeMessageEnd()
4167 
    oprot.trans.flush()
4168 
 
1208 chandransh 4169 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4170 
    args = markOrderAsOutOfStock_args()
4171 
    args.read(iprot)
4172 
    iprot.readMessageEnd()
4173 
    result = markOrderAsOutOfStock_result()
4174 
    try:
4175 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4176 
    except TransactionServiceException, ex:
4177 
      result.ex = ex
4178 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4179 
    result.write(oprot)
4180 
    oprot.writeMessageEnd()
4181 
    oprot.trans.flush()
4182 
 
3064 chandransh 4183 
  def process_verifyOrder(self, seqid, iprot, oprot):
4184 
    args = verifyOrder_args()
759 chandransh 4185 
    args.read(iprot)
4186 
    iprot.readMessageEnd()
3064 chandransh 4187 
    result = verifyOrder_result()
759 chandransh 4188 
    try:
3064 chandransh 4189 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4190 
    except TransactionServiceException, ex:
4191 
      result.ex = ex
3064 chandransh 4192 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4193 
    result.write(oprot)
4194 
    oprot.writeMessageEnd()
4195 
    oprot.trans.flush()
4196 
 
3064 chandransh 4197 
  def process_acceptOrder(self, seqid, iprot, oprot):
4198 
    args = acceptOrder_args()
1113 chandransh 4199 
    args.read(iprot)
4200 
    iprot.readMessageEnd()
3064 chandransh 4201 
    result = acceptOrder_result()
1113 chandransh 4202 
    try:
3064 chandransh 4203 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4204 
    except TransactionServiceException, ex:
4205 
      result.ex = ex
3064 chandransh 4206 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4207 
    result.write(oprot)
4208 
    oprot.writeMessageEnd()
4209 
    oprot.trans.flush()
4210 
 
3064 chandransh 4211 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4212 
    args = addBillingDetails_args()
1135 chandransh 4213 
    args.read(iprot)
4214 
    iprot.readMessageEnd()
3064 chandransh 4215 
    result = addBillingDetails_result()
1135 chandransh 4216 
    try:
4283 anupam.sin 4217 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.imeiNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.vendorId)
1135 chandransh 4218 
    except TransactionServiceException, ex:
4219 
      result.ex = ex
3064 chandransh 4220 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4221 
    result.write(oprot)
4222 
    oprot.writeMessageEnd()
4223 
    oprot.trans.flush()
4224 
 
3064 chandransh 4225 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4226 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4227 
    args.read(iprot)
4228 
    iprot.readMessageEnd()
3064 chandransh 4229 
    result = markOrdersAsManifested_result()
4230 
    try:
4231 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4232 
    except TransactionServiceException, ex:
4233 
      result.ex = ex
4234 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4235 
    result.write(oprot)
4236 
    oprot.writeMessageEnd()
4237 
    oprot.trans.flush()
4238 
 
4410 rajveer 4239 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4240 
    args = markOrdersAsShippedFromWarehouse_args()
4241 
    args.read(iprot)
4242 
    iprot.readMessageEnd()
4243 
    result = markOrdersAsShippedFromWarehouse_result()
4244 
    try:
4245 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4246 
    except TransactionServiceException, ex:
4247 
      result.ex = ex
4248 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4249 
    result.write(oprot)
4250 
    oprot.writeMessageEnd()
4251 
    oprot.trans.flush()
4252 
 
3064 chandransh 4253 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4254 
    args = markOrdersAsPickedUp_args()
304 ashish 4255 
    args.read(iprot)
4256 
    iprot.readMessageEnd()
3064 chandransh 4257 
    result = markOrdersAsPickedUp_result()
4258 
    try:
4259 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4260 
    except TransactionServiceException, ex:
4261 
      result.ex = ex
4262 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4263 
    result.write(oprot)
4264 
    oprot.writeMessageEnd()
4265 
    oprot.trans.flush()
94 ashish 4266 
 
3064 chandransh 4267 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4268 
    args = markOrdersAsDelivered_args()
304 ashish 4269 
    args.read(iprot)
4270 
    iprot.readMessageEnd()
3064 chandransh 4271 
    result = markOrdersAsDelivered_result()
4272 
    try:
4273 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4274 
    except TransactionServiceException, ex:
4275 
      result.ex = ex
4276 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4277 
    result.write(oprot)
4278 
    oprot.writeMessageEnd()
4279 
    oprot.trans.flush()
4280 
 
3064 chandransh 4281 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4282 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4283 
    args.read(iprot)
4284 
    iprot.readMessageEnd()
3064 chandransh 4285 
    result = markOrdersAsFailed_result()
4286 
    try:
4287 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4288 
    except TransactionServiceException, ex:
4289 
      result.ex = ex
4290 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4291 
    result.write(oprot)
4292 
    oprot.writeMessageEnd()
4293 
    oprot.trans.flush()
304 ashish 4294 
 
3064 chandransh 4295 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4296 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4297 
    args.read(iprot)
4298 
    iprot.readMessageEnd()
3064 chandransh 4299 
    result = updateNonDeliveryReason_result()
4300 
    try:
4301 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
4302 
    except TransactionServiceException, ex:
4303 
      result.ex = ex
4304 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4305 
    result.write(oprot)
4306 
    oprot.writeMessageEnd()
4307 
    oprot.trans.flush()
1596 ankur.sing 4308 
 
3064 chandransh 4309 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4310 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4311 
    args.read(iprot)
4312 
    iprot.readMessageEnd()
3064 chandransh 4313 
    result = getUndeliveredOrders_result()
4314 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4315 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4316 
    result.write(oprot)
4317 
    oprot.writeMessageEnd()
4318 
    oprot.trans.flush()
4319 
 
2536 chandransh 4320 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4321 
    args = toggleDOAFlag_args()
4322 
    args.read(iprot)
4323 
    iprot.readMessageEnd()
4324 
    result = toggleDOAFlag_result()
4325 
    try:
4326 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4327 
    except TransactionServiceException, ex:
4328 
      result.ex = ex
4329 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4330 
    result.write(oprot)
4331 
    oprot.writeMessageEnd()
4332 
    oprot.trans.flush()
1886 ankur.sing 4333 
 
4454 rajveer 4334 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
4335 
    args = markOrderDoaRequestReceived_args()
4336 
    args.read(iprot)
4337 
    iprot.readMessageEnd()
4338 
    result = markOrderDoaRequestReceived_result()
4339 
    try:
4340 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
4341 
    except TransactionServiceException, ex:
4342 
      result.ex = ex
4343 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
4344 
    result.write(oprot)
4345 
    oprot.writeMessageEnd()
4346 
    oprot.trans.flush()
4347 
 
4348 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
4349 
    args = markOrderDoaRequestAuthorized_args()
4350 
    args.read(iprot)
4351 
    iprot.readMessageEnd()
4352 
    result = markOrderDoaRequestAuthorized_result()
4353 
    try:
4354 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
4355 
    except TransactionServiceException, ex:
4356 
      result.ex = ex
4357 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
4358 
    result.write(oprot)
4359 
    oprot.writeMessageEnd()
4360 
    oprot.trans.flush()
4361 
 
4488 rajveer 4362 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
4363 
    args = markOrderReturnRequestReceived_args()
4364 
    args.read(iprot)
4365 
    iprot.readMessageEnd()
4366 
    result = markOrderReturnRequestReceived_result()
4367 
    try:
4368 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
4369 
    except TransactionServiceException, ex:
4370 
      result.ex = ex
4371 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
4372 
    result.write(oprot)
4373 
    oprot.writeMessageEnd()
4374 
    oprot.trans.flush()
4375 
 
4376 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
4377 
    args = markOrderReturnRequestAuthorized_args()
4378 
    args.read(iprot)
4379 
    iprot.readMessageEnd()
4380 
    result = markOrderReturnRequestAuthorized_result()
4381 
    try:
4382 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
4383 
    except TransactionServiceException, ex:
4384 
      result.ex = ex
4385 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
4386 
    result.write(oprot)
4387 
    oprot.writeMessageEnd()
4388 
    oprot.trans.flush()
4389 
 
2536 chandransh 4390 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
4391 
    args = requestPickupNumber_args()
4392 
    args.read(iprot)
4393 
    iprot.readMessageEnd()
4394 
    result = requestPickupNumber_result()
4395 
    try:
4396 
      result.success = self._handler.requestPickupNumber(args.orderId)
4397 
    except TransactionServiceException, ex:
4398 
      result.ex = ex
4399 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
4400 
    result.write(oprot)
4401 
    oprot.writeMessageEnd()
4402 
    oprot.trans.flush()
4403 
 
4404 
  def process_authorizePickup(self, seqid, iprot, oprot):
4405 
    args = authorizePickup_args()
4406 
    args.read(iprot)
4407 
    iprot.readMessageEnd()
4408 
    result = authorizePickup_result()
4409 
    try:
4410 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
4411 
    except TransactionServiceException, ex:
4412 
      result.ex = ex
4413 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4414 
    result.write(oprot)
4415 
    oprot.writeMessageEnd()
4416 
    oprot.trans.flush()
4417 
 
2764 chandransh 4418 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4419 
    args = markDoasAsPickedUp_args()
4420 
    args.read(iprot)
4421 
    iprot.readMessageEnd()
4422 
    result = markDoasAsPickedUp_result()
4423 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4424 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4425 
    result.write(oprot)
4426 
    oprot.writeMessageEnd()
4427 
    oprot.trans.flush()
4428 
 
2616 chandransh 4429 
  def process_receiveReturn(self, seqid, iprot, oprot):
4430 
    args = receiveReturn_args()
2591 chandransh 4431 
    args.read(iprot)
4432 
    iprot.readMessageEnd()
2616 chandransh 4433 
    result = receiveReturn_result()
2591 chandransh 4434 
    try:
4479 rajveer 4435 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 4436 
    except TransactionServiceException, ex:
4437 
      result.ex = ex
2616 chandransh 4438 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4439 
    result.write(oprot)
4440 
    oprot.writeMessageEnd()
4441 
    oprot.trans.flush()
2536 chandransh 4442 
 
2591 chandransh 4443 
  def process_validateDoa(self, seqid, iprot, oprot):
4444 
    args = validateDoa_args()
4445 
    args.read(iprot)
4446 
    iprot.readMessageEnd()
4447 
    result = validateDoa_result()
4448 
    try:
4449 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4450 
    except TransactionServiceException, ex:
4451 
      result.ex = ex
4452 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4453 
    result.write(oprot)
4454 
    oprot.writeMessageEnd()
4455 
    oprot.trans.flush()
4456 
 
4495 rajveer 4457 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
4458 
    args = validateReturnProduct_args()
4459 
    args.read(iprot)
4460 
    iprot.readMessageEnd()
4461 
    result = validateReturnProduct_result()
4462 
    try:
4463 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
4464 
    except TransactionServiceException, ex:
4465 
      result.ex = ex
4466 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
4467 
    result.write(oprot)
4468 
    oprot.writeMessageEnd()
4469 
    oprot.trans.flush()
4470 
 
2616 chandransh 4471 
  def process_reshipOrder(self, seqid, iprot, oprot):
4472 
    args = reshipOrder_args()
4473 
    args.read(iprot)
4474 
    iprot.readMessageEnd()
4475 
    result = reshipOrder_result()
4476 
    try:
4477 
      result.success = self._handler.reshipOrder(args.orderId)
4478 
    except TransactionServiceException, ex:
4479 
      result.ex = ex
4480 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4481 
    result.write(oprot)
4482 
    oprot.writeMessageEnd()
4483 
    oprot.trans.flush()
2591 chandransh 4484 
 
2616 chandransh 4485 
  def process_refundOrder(self, seqid, iprot, oprot):
4486 
    args = refundOrder_args()
4487 
    args.read(iprot)
4488 
    iprot.readMessageEnd()
4489 
    result = refundOrder_result()
4490 
    try:
3226 chandransh 4491 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4492 
    except TransactionServiceException, ex:
4493 
      result.ex = ex
4494 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4495 
    result.write(oprot)
4496 
    oprot.writeMessageEnd()
4497 
    oprot.trans.flush()
4498 
 
2690 chandransh 4499 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4500 
    args = getReturnOrders_args()
4501 
    args.read(iprot)
4502 
    iprot.readMessageEnd()
4503 
    result = getReturnOrders_result()
4504 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4505 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4506 
    result.write(oprot)
4507 
    oprot.writeMessageEnd()
4508 
    oprot.trans.flush()
2616 chandransh 4509 
 
2700 chandransh 4510 
  def process_getReturnOrder(self, seqid, iprot, oprot):
4511 
    args = getReturnOrder_args()
4512 
    args.read(iprot)
4513 
    iprot.readMessageEnd()
4514 
    result = getReturnOrder_result()
4515 
    try:
4516 
      result.success = self._handler.getReturnOrder(args.id)
4517 
    except TransactionServiceException, ex:
4518 
      result.ex = ex
4519 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
4520 
    result.write(oprot)
4521 
    oprot.writeMessageEnd()
4522 
    oprot.trans.flush()
4523 
 
2690 chandransh 4524 
  def process_processReturn(self, seqid, iprot, oprot):
4525 
    args = processReturn_args()
4526 
    args.read(iprot)
4527 
    iprot.readMessageEnd()
4528 
    result = processReturn_result()
4529 
    try:
4530 
      self._handler.processReturn(args.returnOrderId)
4531 
    except TransactionServiceException, ex:
4532 
      result.ex = ex
4533 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
4534 
    result.write(oprot)
4535 
    oprot.writeMessageEnd()
4536 
    oprot.trans.flush()
4537 
 
2819 chandransh 4538 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
4539 
    args = createPurchaseOrder_args()
4540 
    args.read(iprot)
4541 
    iprot.readMessageEnd()
4542 
    result = createPurchaseOrder_result()
4543 
    try:
4544 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
4545 
    except TransactionServiceException, ex:
4546 
      result.ex = ex
4547 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
4548 
    result.write(oprot)
4549 
    oprot.writeMessageEnd()
4550 
    oprot.trans.flush()
2690 chandransh 4551 
 
3451 chandransh 4552 
  def process_updateWeight(self, seqid, iprot, oprot):
4553 
    args = updateWeight_args()
4554 
    args.read(iprot)
4555 
    iprot.readMessageEnd()
4556 
    result = updateWeight_result()
4557 
    try:
4558 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
4559 
    except TransactionServiceException, ex:
4560 
      result.ex = ex
4561 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
4562 
    result.write(oprot)
4563 
    oprot.writeMessageEnd()
4564 
    oprot.trans.flush()
2819 chandransh 4565 
 
3469 chandransh 4566 
  def process_changeItem(self, seqid, iprot, oprot):
4567 
    args = changeItem_args()
4568 
    args.read(iprot)
4569 
    iprot.readMessageEnd()
4570 
    result = changeItem_result()
4571 
    try:
4572 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
4573 
    except TransactionServiceException, ex:
4574 
      result.ex = ex
4575 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
4576 
    result.write(oprot)
4577 
    oprot.writeMessageEnd()
4578 
    oprot.trans.flush()
3451 chandransh 4579 
 
3469 chandransh 4580 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
4581 
    args = shiftToWarehouse_args()
4582 
    args.read(iprot)
4583 
    iprot.readMessageEnd()
4584 
    result = shiftToWarehouse_result()
4585 
    try:
4586 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
4587 
    except TransactionServiceException, ex:
4588 
      result.ex = ex
4589 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
4590 
    result.write(oprot)
4591 
    oprot.writeMessageEnd()
4592 
    oprot.trans.flush()
4593 
 
3553 chandransh 4594 
  def process_addDelayReason(self, seqid, iprot, oprot):
4595 
    args = addDelayReason_args()
4596 
    args.read(iprot)
4597 
    iprot.readMessageEnd()
4598 
    result = addDelayReason_result()
4599 
    try:
3986 chandransh 4600 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 4601 
    except TransactionServiceException, ex:
4602 
      result.ex = ex
4603 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
4604 
    result.write(oprot)
4605 
    oprot.writeMessageEnd()
4606 
    oprot.trans.flush()
3469 chandransh 4607 
 
3956 chandransh 4608 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
4609 
    args = reconcileCodCollection_args()
4610 
    args.read(iprot)
4611 
    iprot.readMessageEnd()
4612 
    result = reconcileCodCollection_result()
4613 
    try:
4614 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
4615 
    except TransactionServiceException, ex:
4616 
      result.ex = ex
4617 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
4618 
    result.write(oprot)
4619 
    oprot.writeMessageEnd()
4620 
    oprot.trans.flush()
3553 chandransh 4621 
 
4008 mandeep.dh 4622 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
4623 
    args = getTransactionsRequiringExtraProcessing_args()
4624 
    args.read(iprot)
4625 
    iprot.readMessageEnd()
4626 
    result = getTransactionsRequiringExtraProcessing_result()
4627 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
4628 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
4629 
    result.write(oprot)
4630 
    oprot.writeMessageEnd()
4631 
    oprot.trans.flush()
3956 chandransh 4632 
 
4008 mandeep.dh 4633 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
4634 
    args = markTransactionAsProcessed_args()
4635 
    args.read(iprot)
4636 
    iprot.readMessageEnd()
4637 
    result = markTransactionAsProcessed_result()
4638 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
4639 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
4640 
    result.write(oprot)
4641 
    oprot.writeMessageEnd()
4642 
    oprot.trans.flush()
4643 
 
4018 chandransh 4644 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
4645 
    args = getItemWiseRiskyOrdersCount_args()
4646 
    args.read(iprot)
4647 
    iprot.readMessageEnd()
4648 
    result = getItemWiseRiskyOrdersCount_result()
4649 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
4650 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
4651 
    result.write(oprot)
4652 
    oprot.writeMessageEnd()
4653 
    oprot.trans.flush()
4008 mandeep.dh 4654 
 
4295 varun.gupt 4655 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
4656 
    args = getOrdersForItemIds_args()
4657 
    args.read(iprot)
4658 
    iprot.readMessageEnd()
4659 
    result = getOrdersForItemIds_result()
4660 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
4661 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
4662 
    result.write(oprot)
4663 
    oprot.writeMessageEnd()
4664 
    oprot.trans.flush()
4665 
 
4247 rajveer 4666 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
4667 
    args = markOrderCancellationRequestReceived_args()
4668 
    args.read(iprot)
4669 
    iprot.readMessageEnd()
4670 
    result = markOrderCancellationRequestReceived_result()
4671 
    try:
4672 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
4673 
    except TransactionServiceException, ex:
4674 
      result.ex = ex
4675 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
4676 
    result.write(oprot)
4677 
    oprot.writeMessageEnd()
4678 
    oprot.trans.flush()
4018 chandransh 4679 
 
4247 rajveer 4680 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
4681 
    args = markOrderCancellationRequestConfirmed_args()
4682 
    args.read(iprot)
4683 
    iprot.readMessageEnd()
4684 
    result = markOrderCancellationRequestConfirmed_result()
4685 
    try:
4686 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
4687 
    except TransactionServiceException, ex:
4688 
      result.ex = ex
4689 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
4690 
    result.write(oprot)
4691 
    oprot.writeMessageEnd()
4692 
    oprot.trans.flush()
4693 
 
4694 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4695 
    args = markOrderCancellationRequestDenied_args()
4696 
    args.read(iprot)
4697 
    iprot.readMessageEnd()
4698 
    result = markOrderCancellationRequestDenied_result()
4699 
    try:
4700 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4701 
    except TransactionServiceException, ex:
4702 
      result.ex = ex
4703 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4704 
    result.write(oprot)
4705 
    oprot.writeMessageEnd()
4706 
    oprot.trans.flush()
4707 
 
4258 rajveer 4708 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4709 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4710 
    args.read(iprot)
4711 
    iprot.readMessageEnd()
4258 rajveer 4712 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4713 
    try:
4258 rajveer 4714 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4715 
    except TransactionServiceException, ex:
4716 
      result.ex = ex
4258 rajveer 4717 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4718 
    result.write(oprot)
4719 
    oprot.writeMessageEnd()
4720 
    oprot.trans.flush()
4721 
 
4259 anupam.sin 4722 
  def process_refundTransaction(self, seqid, iprot, oprot):
4723 
    args = refundTransaction_args()
4724 
    args.read(iprot)
4725 
    iprot.readMessageEnd()
4726 
    result = refundTransaction_result()
4727 
    try:
4728 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4729 
    except TransactionServiceException, ex:
4730 
      result.ex = ex
4731 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4732 
    result.write(oprot)
4733 
    oprot.writeMessageEnd()
4734 
    oprot.trans.flush()
4247 rajveer 4735 
 
4324 mandeep.dh 4736 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
4737 
    args = updateShipmentAddress_args()
4738 
    args.read(iprot)
4739 
    iprot.readMessageEnd()
4740 
    result = updateShipmentAddress_result()
4741 
    try:
4742 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
4743 
    except TransactionServiceException, ex:
4744 
      result.ex = ex
4745 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
4746 
    result.write(oprot)
4747 
    oprot.writeMessageEnd()
4748 
    oprot.trans.flush()
4749 
 
4285 rajveer 4750 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
4751 
    args = acceptOrdersForItemId_args()
4752 
    args.read(iprot)
4753 
    iprot.readMessageEnd()
4754 
    result = acceptOrdersForItemId_result()
4755 
    try:
4756 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
4757 
    except TransactionServiceException, ex:
4758 
      result.ex = ex
4759 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
4760 
    result.write(oprot)
4761 
    oprot.writeMessageEnd()
4762 
    oprot.trans.flush()
4259 anupam.sin 4763 
 
4303 rajveer 4764 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
4765 
    args = markOrdersAsPORaised_args()
4766 
    args.read(iprot)
4767 
    iprot.readMessageEnd()
4768 
    result = markOrdersAsPORaised_result()
4769 
    try:
4369 rajveer 4770 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4771 
    except TransactionServiceException, ex:
4772 
      result.ex = ex
4773 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
4774 
    result.write(oprot)
4775 
    oprot.writeMessageEnd()
4776 
    oprot.trans.flush()
4285 rajveer 4777 
 
4303 rajveer 4778 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
4779 
    args = markOrdersAsReversalInitiated_args()
4780 
    args.read(iprot)
4781 
    iprot.readMessageEnd()
4782 
    result = markOrdersAsReversalInitiated_result()
4783 
    try:
4369 rajveer 4784 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4785 
    except TransactionServiceException, ex:
4786 
      result.ex = ex
4787 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
4788 
    result.write(oprot)
4789 
    oprot.writeMessageEnd()
4790 
    oprot.trans.flush()
4791 
 
4792 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
4793 
    args = markOrdersAsNotAvailabke_args()
4794 
    args.read(iprot)
4795 
    iprot.readMessageEnd()
4796 
    result = markOrdersAsNotAvailabke_result()
4797 
    try:
4369 rajveer 4798 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4799 
    except TransactionServiceException, ex:
4800 
      result.ex = ex
4801 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
4802 
    result.write(oprot)
4803 
    oprot.writeMessageEnd()
4804 
    oprot.trans.flush()
4805 
 
4369 rajveer 4806 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
4807 
    args = markOrdersAsTimeout_args()
4808 
    args.read(iprot)
4809 
    iprot.readMessageEnd()
4810 
    result = markOrdersAsTimeout_result()
4811 
    try:
4812 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
4813 
    except TransactionServiceException, ex:
4814 
      result.ex = ex
4815 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
4816 
    result.write(oprot)
4817 
    oprot.writeMessageEnd()
4818 
    oprot.trans.flush()
4303 rajveer 4819 
 
4386 anupam.sin 4820 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
4821 
    args = getOrderForAwb_args()
4822 
    args.read(iprot)
4823 
    iprot.readMessageEnd()
4824 
    result = getOrderForAwb_result()
4825 
    try:
4826 
      result.success = self._handler.getOrderForAwb(args.awb)
4827 
    except TransactionServiceException, ex:
4828 
      result.ex = ex
4829 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
4830 
    result.write(oprot)
4831 
    oprot.writeMessageEnd()
4832 
    oprot.trans.flush()
4369 rajveer 4833 
 
4386 anupam.sin 4834 
 
94 ashish 4835 
# HELPER FUNCTIONS AND STRUCTURES
4836 
 
4837 
class createTransaction_args:
4838 
  """
4839 
  Attributes:
4840 
   - transaction
4841 
  """
4842 
 
4843 
  thrift_spec = (
4844 
    None, # 0
4845 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4846 
  )
4847 
 
4848 
  def __init__(self, transaction=None,):
4849 
    self.transaction = transaction
4850 
 
4851 
  def read(self, iprot):
4852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4854 
      return
4855 
    iprot.readStructBegin()
4856 
    while True:
4857 
      (fname, ftype, fid) = iprot.readFieldBegin()
4858 
      if ftype == TType.STOP:
4859 
        break
4860 
      if fid == 1:
4861 
        if ftype == TType.STRUCT:
4862 
          self.transaction = Transaction()
4863 
          self.transaction.read(iprot)
4864 
        else:
4865 
          iprot.skip(ftype)
4866 
      else:
4867 
        iprot.skip(ftype)
4868 
      iprot.readFieldEnd()
4869 
    iprot.readStructEnd()
4870 
 
4871 
  def write(self, oprot):
4872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4874 
      return
4875 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4876 
    if self.transaction is not None:
94 ashish 4877 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4878 
      self.transaction.write(oprot)
4879 
      oprot.writeFieldEnd()
4880 
    oprot.writeFieldStop()
4881 
    oprot.writeStructEnd()
4882 
 
3431 rajveer 4883 
  def validate(self):
4884 
    return
4885 
 
4886 
 
94 ashish 4887 
  def __repr__(self):
4888 
    L = ['%s=%r' % (key, value)
4889 
      for key, value in self.__dict__.iteritems()]
4890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4891 
 
4892 
  def __eq__(self, other):
4893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4894 
 
4895 
  def __ne__(self, other):
4896 
    return not (self == other)
4897 
 
4898 
class createTransaction_result:
4899 
  """
4900 
  Attributes:
132 ashish 4901 
   - success
94 ashish 4902 
   - ex
4903 
  """
4904 
 
4905 
  thrift_spec = (
132 ashish 4906 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4907 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4908 
  )
4909 
 
132 ashish 4910 
  def __init__(self, success=None, ex=None,):
4911 
    self.success = success
94 ashish 4912 
    self.ex = ex
4913 
 
4914 
  def read(self, iprot):
4915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4917 
      return
4918 
    iprot.readStructBegin()
4919 
    while True:
4920 
      (fname, ftype, fid) = iprot.readFieldBegin()
4921 
      if ftype == TType.STOP:
4922 
        break
132 ashish 4923 
      if fid == 0:
4924 
        if ftype == TType.I64:
4925 
          self.success = iprot.readI64();
4926 
        else:
4927 
          iprot.skip(ftype)
4928 
      elif fid == 1:
94 ashish 4929 
        if ftype == TType.STRUCT:
4930 
          self.ex = TransactionServiceException()
4931 
          self.ex.read(iprot)
4932 
        else:
4933 
          iprot.skip(ftype)
4934 
      else:
4935 
        iprot.skip(ftype)
4936 
      iprot.readFieldEnd()
4937 
    iprot.readStructEnd()
4938 
 
4939 
  def write(self, oprot):
4940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4942 
      return
4943 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4944 
    if self.success is not None:
132 ashish 4945 
      oprot.writeFieldBegin('success', TType.I64, 0)
4946 
      oprot.writeI64(self.success)
4947 
      oprot.writeFieldEnd()
3431 rajveer 4948 
    if self.ex is not None:
94 ashish 4949 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4950 
      self.ex.write(oprot)
4951 
      oprot.writeFieldEnd()
4952 
    oprot.writeFieldStop()
4953 
    oprot.writeStructEnd()
4954 
 
3431 rajveer 4955 
  def validate(self):
4956 
    return
4957 
 
4958 
 
94 ashish 4959 
  def __repr__(self):
4960 
    L = ['%s=%r' % (key, value)
4961 
      for key, value in self.__dict__.iteritems()]
4962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4963 
 
4964 
  def __eq__(self, other):
4965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4966 
 
4967 
  def __ne__(self, other):
4968 
    return not (self == other)
4969 
 
4970 
class getTransaction_args:
4971 
  """
4972 
  Attributes:
4973 
   - id
4974 
  """
4975 
 
4976 
  thrift_spec = (
4977 
    None, # 0
4978 
    (1, TType.I64, 'id', None, None, ), # 1
4979 
  )
4980 
 
4981 
  def __init__(self, id=None,):
4982 
    self.id = id
4983 
 
4984 
  def read(self, iprot):
4985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4987 
      return
4988 
    iprot.readStructBegin()
4989 
    while True:
4990 
      (fname, ftype, fid) = iprot.readFieldBegin()
4991 
      if ftype == TType.STOP:
4992 
        break
4993 
      if fid == 1:
4994 
        if ftype == TType.I64:
4995 
          self.id = iprot.readI64();
4996 
        else:
4997 
          iprot.skip(ftype)
4998 
      else:
4999 
        iprot.skip(ftype)
5000 
      iprot.readFieldEnd()
5001 
    iprot.readStructEnd()
5002 
 
5003 
  def write(self, oprot):
5004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5006 
      return
5007 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 5008 
    if self.id is not None:
94 ashish 5009 
      oprot.writeFieldBegin('id', TType.I64, 1)
5010 
      oprot.writeI64(self.id)
5011 
      oprot.writeFieldEnd()
5012 
    oprot.writeFieldStop()
5013 
    oprot.writeStructEnd()
5014 
 
3431 rajveer 5015 
  def validate(self):
5016 
    return
5017 
 
5018 
 
94 ashish 5019 
  def __repr__(self):
5020 
    L = ['%s=%r' % (key, value)
5021 
      for key, value in self.__dict__.iteritems()]
5022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5023 
 
5024 
  def __eq__(self, other):
5025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5026 
 
5027 
  def __ne__(self, other):
5028 
    return not (self == other)
5029 
 
5030 
class getTransaction_result:
5031 
  """
5032 
  Attributes:
5033 
   - success
5034 
   - ex
5035 
  """
5036 
 
5037 
  thrift_spec = (
5038 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
5039 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5040 
  )
5041 
 
5042 
  def __init__(self, success=None, ex=None,):
5043 
    self.success = success
5044 
    self.ex = ex
5045 
 
5046 
  def read(self, iprot):
5047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5049 
      return
5050 
    iprot.readStructBegin()
5051 
    while True:
5052 
      (fname, ftype, fid) = iprot.readFieldBegin()
5053 
      if ftype == TType.STOP:
5054 
        break
5055 
      if fid == 0:
5056 
        if ftype == TType.STRUCT:
5057 
          self.success = Transaction()
5058 
          self.success.read(iprot)
5059 
        else:
5060 
          iprot.skip(ftype)
5061 
      elif fid == 1:
5062 
        if ftype == TType.STRUCT:
5063 
          self.ex = TransactionServiceException()
5064 
          self.ex.read(iprot)
5065 
        else:
5066 
          iprot.skip(ftype)
5067 
      else:
5068 
        iprot.skip(ftype)
5069 
      iprot.readFieldEnd()
5070 
    iprot.readStructEnd()
5071 
 
5072 
  def write(self, oprot):
5073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5075 
      return
5076 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 5077 
    if self.success is not None:
94 ashish 5078 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5079 
      self.success.write(oprot)
5080 
      oprot.writeFieldEnd()
3431 rajveer 5081 
    if self.ex is not None:
94 ashish 5082 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5083 
      self.ex.write(oprot)
5084 
      oprot.writeFieldEnd()
5085 
    oprot.writeFieldStop()
5086 
    oprot.writeStructEnd()
5087 
 
3431 rajveer 5088 
  def validate(self):
5089 
    return
5090 
 
5091 
 
94 ashish 5092 
  def __repr__(self):
5093 
    L = ['%s=%r' % (key, value)
5094 
      for key, value in self.__dict__.iteritems()]
5095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5096 
 
5097 
  def __eq__(self, other):
5098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5099 
 
5100 
  def __ne__(self, other):
5101 
    return not (self == other)
5102 
 
5103 
class getTransactionsForCustomer_args:
5104 
  """
5105 
  Attributes:
5106 
   - customerId
5107 
   - from_date
5108 
   - to_date
5109 
   - status
5110 
  """
5111 
 
5112 
  thrift_spec = (
5113 
    None, # 0
5114 
    (1, TType.I64, 'customerId', None, None, ), # 1
5115 
    (2, TType.I64, 'from_date', None, None, ), # 2
5116 
    (3, TType.I64, 'to_date', None, None, ), # 3
5117 
    (4, TType.I32, 'status', None, None, ), # 4
5118 
  )
5119 
 
5120 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
5121 
    self.customerId = customerId
5122 
    self.from_date = from_date
5123 
    self.to_date = to_date
5124 
    self.status = status
5125 
 
5126 
  def read(self, iprot):
5127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5129 
      return
5130 
    iprot.readStructBegin()
5131 
    while True:
5132 
      (fname, ftype, fid) = iprot.readFieldBegin()
5133 
      if ftype == TType.STOP:
5134 
        break
5135 
      if fid == 1:
5136 
        if ftype == TType.I64:
5137 
          self.customerId = iprot.readI64();
5138 
        else:
5139 
          iprot.skip(ftype)
5140 
      elif fid == 2:
5141 
        if ftype == TType.I64:
5142 
          self.from_date = iprot.readI64();
5143 
        else:
5144 
          iprot.skip(ftype)
5145 
      elif fid == 3:
5146 
        if ftype == TType.I64:
5147 
          self.to_date = iprot.readI64();
5148 
        else:
5149 
          iprot.skip(ftype)
5150 
      elif fid == 4:
5151 
        if ftype == TType.I32:
5152 
          self.status = iprot.readI32();
5153 
        else:
5154 
          iprot.skip(ftype)
5155 
      else:
5156 
        iprot.skip(ftype)
5157 
      iprot.readFieldEnd()
5158 
    iprot.readStructEnd()
5159 
 
5160 
  def write(self, oprot):
5161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5163 
      return
5164 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 5165 
    if self.customerId is not None:
94 ashish 5166 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5167 
      oprot.writeI64(self.customerId)
5168 
      oprot.writeFieldEnd()
3431 rajveer 5169 
    if self.from_date is not None:
94 ashish 5170 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5171 
      oprot.writeI64(self.from_date)
5172 
      oprot.writeFieldEnd()
3431 rajveer 5173 
    if self.to_date is not None:
94 ashish 5174 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5175 
      oprot.writeI64(self.to_date)
5176 
      oprot.writeFieldEnd()
3431 rajveer 5177 
    if self.status is not None:
94 ashish 5178 
      oprot.writeFieldBegin('status', TType.I32, 4)
5179 
      oprot.writeI32(self.status)
5180 
      oprot.writeFieldEnd()
5181 
    oprot.writeFieldStop()
5182 
    oprot.writeStructEnd()
5183 
 
3431 rajveer 5184 
  def validate(self):
5185 
    return
5186 
 
5187 
 
94 ashish 5188 
  def __repr__(self):
5189 
    L = ['%s=%r' % (key, value)
5190 
      for key, value in self.__dict__.iteritems()]
5191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5192 
 
5193 
  def __eq__(self, other):
5194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5195 
 
5196 
  def __ne__(self, other):
5197 
    return not (self == other)
5198 
 
5199 
class getTransactionsForCustomer_result:
5200 
  """
5201 
  Attributes:
5202 
   - success
5203 
   - ex
5204 
  """
5205 
 
5206 
  thrift_spec = (
5207 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5208 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5209 
  )
5210 
 
5211 
  def __init__(self, success=None, ex=None,):
5212 
    self.success = success
5213 
    self.ex = ex
5214 
 
5215 
  def read(self, iprot):
5216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5218 
      return
5219 
    iprot.readStructBegin()
5220 
    while True:
5221 
      (fname, ftype, fid) = iprot.readFieldBegin()
5222 
      if ftype == TType.STOP:
5223 
        break
5224 
      if fid == 0:
5225 
        if ftype == TType.LIST:
5226 
          self.success = []
685 chandransh 5227 
          (_etype17, _size14) = iprot.readListBegin()
5228 
          for _i18 in xrange(_size14):
5229 
            _elem19 = Transaction()
5230 
            _elem19.read(iprot)
5231 
            self.success.append(_elem19)
94 ashish 5232 
          iprot.readListEnd()
5233 
        else:
5234 
          iprot.skip(ftype)
5235 
      elif fid == 1:
5236 
        if ftype == TType.STRUCT:
5237 
          self.ex = TransactionServiceException()
5238 
          self.ex.read(iprot)
5239 
        else:
5240 
          iprot.skip(ftype)
5241 
      else:
5242 
        iprot.skip(ftype)
5243 
      iprot.readFieldEnd()
5244 
    iprot.readStructEnd()
5245 
 
5246 
  def write(self, oprot):
5247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5249 
      return
5250 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 5251 
    if self.success is not None:
94 ashish 5252 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5253 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5254 
      for iter20 in self.success:
5255 
        iter20.write(oprot)
94 ashish 5256 
      oprot.writeListEnd()
5257 
      oprot.writeFieldEnd()
3431 rajveer 5258 
    if self.ex is not None:
94 ashish 5259 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5260 
      self.ex.write(oprot)
5261 
      oprot.writeFieldEnd()
5262 
    oprot.writeFieldStop()
5263 
    oprot.writeStructEnd()
5264 
 
3431 rajveer 5265 
  def validate(self):
5266 
    return
5267 
 
5268 
 
94 ashish 5269 
  def __repr__(self):
5270 
    L = ['%s=%r' % (key, value)
5271 
      for key, value in self.__dict__.iteritems()]
5272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5273 
 
5274 
  def __eq__(self, other):
5275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5276 
 
5277 
  def __ne__(self, other):
5278 
    return not (self == other)
5279 
 
132 ashish 5280 
class getTransactionsForShoppingCartId_args:
5281 
  """
5282 
  Attributes:
5283 
   - shoppingCartId
5284 
  """
5285 
 
5286 
  thrift_spec = (
5287 
    None, # 0
5288 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
5289 
  )
5290 
 
5291 
  def __init__(self, shoppingCartId=None,):
5292 
    self.shoppingCartId = shoppingCartId
5293 
 
5294 
  def read(self, iprot):
5295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5297 
      return
5298 
    iprot.readStructBegin()
5299 
    while True:
5300 
      (fname, ftype, fid) = iprot.readFieldBegin()
5301 
      if ftype == TType.STOP:
5302 
        break
5303 
      if fid == 1:
5304 
        if ftype == TType.I64:
5305 
          self.shoppingCartId = iprot.readI64();
5306 
        else:
5307 
          iprot.skip(ftype)
5308 
      else:
5309 
        iprot.skip(ftype)
5310 
      iprot.readFieldEnd()
5311 
    iprot.readStructEnd()
5312 
 
5313 
  def write(self, oprot):
5314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5316 
      return
5317 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 5318 
    if self.shoppingCartId is not None:
132 ashish 5319 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
5320 
      oprot.writeI64(self.shoppingCartId)
5321 
      oprot.writeFieldEnd()
5322 
    oprot.writeFieldStop()
5323 
    oprot.writeStructEnd()
5324 
 
3431 rajveer 5325 
  def validate(self):
5326 
    return
5327 
 
5328 
 
132 ashish 5329 
  def __repr__(self):
5330 
    L = ['%s=%r' % (key, value)
5331 
      for key, value in self.__dict__.iteritems()]
5332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5333 
 
5334 
  def __eq__(self, other):
5335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5336 
 
5337 
  def __ne__(self, other):
5338 
    return not (self == other)
5339 
 
5340 
class getTransactionsForShoppingCartId_result:
5341 
  """
5342 
  Attributes:
5343 
   - success
5344 
   - ex
5345 
  """
5346 
 
5347 
  thrift_spec = (
5348 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5349 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5350 
  )
5351 
 
5352 
  def __init__(self, success=None, ex=None,):
5353 
    self.success = success
5354 
    self.ex = ex
5355 
 
5356 
  def read(self, iprot):
5357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5359 
      return
5360 
    iprot.readStructBegin()
5361 
    while True:
5362 
      (fname, ftype, fid) = iprot.readFieldBegin()
5363 
      if ftype == TType.STOP:
5364 
        break
5365 
      if fid == 0:
5366 
        if ftype == TType.LIST:
5367 
          self.success = []
685 chandransh 5368 
          (_etype24, _size21) = iprot.readListBegin()
5369 
          for _i25 in xrange(_size21):
5370 
            _elem26 = Transaction()
5371 
            _elem26.read(iprot)
5372 
            self.success.append(_elem26)
132 ashish 5373 
          iprot.readListEnd()
5374 
        else:
5375 
          iprot.skip(ftype)
5376 
      elif fid == 1:
5377 
        if ftype == TType.STRUCT:
5378 
          self.ex = TransactionServiceException()
5379 
          self.ex.read(iprot)
5380 
        else:
5381 
          iprot.skip(ftype)
5382 
      else:
5383 
        iprot.skip(ftype)
5384 
      iprot.readFieldEnd()
5385 
    iprot.readStructEnd()
5386 
 
5387 
  def write(self, oprot):
5388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5390 
      return
5391 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 5392 
    if self.success is not None:
132 ashish 5393 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5394 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5395 
      for iter27 in self.success:
5396 
        iter27.write(oprot)
132 ashish 5397 
      oprot.writeListEnd()
5398 
      oprot.writeFieldEnd()
3431 rajveer 5399 
    if self.ex is not None:
132 ashish 5400 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5401 
      self.ex.write(oprot)
5402 
      oprot.writeFieldEnd()
5403 
    oprot.writeFieldStop()
5404 
    oprot.writeStructEnd()
5405 
 
3431 rajveer 5406 
  def validate(self):
5407 
    return
5408 
 
5409 
 
132 ashish 5410 
  def __repr__(self):
5411 
    L = ['%s=%r' % (key, value)
5412 
      for key, value in self.__dict__.iteritems()]
5413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5414 
 
5415 
  def __eq__(self, other):
5416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5417 
 
5418 
  def __ne__(self, other):
5419 
    return not (self == other)
5420 
 
94 ashish 5421 
class getTransactionStatus_args:
5422 
  """
5423 
  Attributes:
5424 
   - transactionId
5425 
  """
5426 
 
5427 
  thrift_spec = (
5428 
    None, # 0
5429 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5430 
  )
5431 
 
5432 
  def __init__(self, transactionId=None,):
5433 
    self.transactionId = transactionId
5434 
 
5435 
  def read(self, iprot):
5436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5438 
      return
5439 
    iprot.readStructBegin()
5440 
    while True:
5441 
      (fname, ftype, fid) = iprot.readFieldBegin()
5442 
      if ftype == TType.STOP:
5443 
        break
5444 
      if fid == 1:
5445 
        if ftype == TType.I64:
5446 
          self.transactionId = iprot.readI64();
5447 
        else:
5448 
          iprot.skip(ftype)
5449 
      else:
5450 
        iprot.skip(ftype)
5451 
      iprot.readFieldEnd()
5452 
    iprot.readStructEnd()
5453 
 
5454 
  def write(self, oprot):
5455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5457 
      return
5458 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 5459 
    if self.transactionId is not None:
94 ashish 5460 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5461 
      oprot.writeI64(self.transactionId)
5462 
      oprot.writeFieldEnd()
5463 
    oprot.writeFieldStop()
5464 
    oprot.writeStructEnd()
5465 
 
3431 rajveer 5466 
  def validate(self):
5467 
    return
5468 
 
5469 
 
94 ashish 5470 
  def __repr__(self):
5471 
    L = ['%s=%r' % (key, value)
5472 
      for key, value in self.__dict__.iteritems()]
5473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5474 
 
5475 
  def __eq__(self, other):
5476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5477 
 
5478 
  def __ne__(self, other):
5479 
    return not (self == other)
5480 
 
5481 
class getTransactionStatus_result:
5482 
  """
5483 
  Attributes:
5484 
   - success
5485 
   - ex
5486 
  """
5487 
 
5488 
  thrift_spec = (
5489 
    (0, TType.I32, 'success', None, None, ), # 0
5490 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5491 
  )
5492 
 
5493 
  def __init__(self, success=None, ex=None,):
5494 
    self.success = success
5495 
    self.ex = ex
5496 
 
5497 
  def read(self, iprot):
5498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5500 
      return
5501 
    iprot.readStructBegin()
5502 
    while True:
5503 
      (fname, ftype, fid) = iprot.readFieldBegin()
5504 
      if ftype == TType.STOP:
5505 
        break
5506 
      if fid == 0:
5507 
        if ftype == TType.I32:
5508 
          self.success = iprot.readI32();
5509 
        else:
5510 
          iprot.skip(ftype)
5511 
      elif fid == 1:
5512 
        if ftype == TType.STRUCT:
5513 
          self.ex = TransactionServiceException()
5514 
          self.ex.read(iprot)
5515 
        else:
5516 
          iprot.skip(ftype)
5517 
      else:
5518 
        iprot.skip(ftype)
5519 
      iprot.readFieldEnd()
5520 
    iprot.readStructEnd()
5521 
 
5522 
  def write(self, oprot):
5523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5525 
      return
5526 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 5527 
    if self.success is not None:
94 ashish 5528 
      oprot.writeFieldBegin('success', TType.I32, 0)
5529 
      oprot.writeI32(self.success)
5530 
      oprot.writeFieldEnd()
3431 rajveer 5531 
    if self.ex is not None:
94 ashish 5532 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5533 
      self.ex.write(oprot)
5534 
      oprot.writeFieldEnd()
5535 
    oprot.writeFieldStop()
5536 
    oprot.writeStructEnd()
5537 
 
3431 rajveer 5538 
  def validate(self):
5539 
    return
5540 
 
5541 
 
94 ashish 5542 
  def __repr__(self):
5543 
    L = ['%s=%r' % (key, value)
5544 
      for key, value in self.__dict__.iteritems()]
5545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5546 
 
5547 
  def __eq__(self, other):
5548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5549 
 
5550 
  def __ne__(self, other):
5551 
    return not (self == other)
5552 
 
5553 
class changeTransactionStatus_args:
5554 
  """
5555 
  Attributes:
5556 
   - transactionId
5557 
   - status
5558 
   - description
5559 
  """
5560 
 
5561 
  thrift_spec = (
5562 
    None, # 0
5563 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5564 
    (2, TType.I32, 'status', None, None, ), # 2
5565 
    (3, TType.STRING, 'description', None, None, ), # 3
5566 
  )
5567 
 
5568 
  def __init__(self, transactionId=None, status=None, description=None,):
5569 
    self.transactionId = transactionId
5570 
    self.status = status
5571 
    self.description = description
5572 
 
5573 
  def read(self, iprot):
5574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5576 
      return
5577 
    iprot.readStructBegin()
5578 
    while True:
5579 
      (fname, ftype, fid) = iprot.readFieldBegin()
5580 
      if ftype == TType.STOP:
5581 
        break
5582 
      if fid == 1:
5583 
        if ftype == TType.I64:
5584 
          self.transactionId = iprot.readI64();
5585 
        else:
5586 
          iprot.skip(ftype)
5587 
      elif fid == 2:
5588 
        if ftype == TType.I32:
5589 
          self.status = iprot.readI32();
5590 
        else:
5591 
          iprot.skip(ftype)
5592 
      elif fid == 3:
5593 
        if ftype == TType.STRING:
5594 
          self.description = iprot.readString();
5595 
        else:
5596 
          iprot.skip(ftype)
5597 
      else:
5598 
        iprot.skip(ftype)
5599 
      iprot.readFieldEnd()
5600 
    iprot.readStructEnd()
5601 
 
5602 
  def write(self, oprot):
5603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5605 
      return
5606 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 5607 
    if self.transactionId is not None:
94 ashish 5608 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5609 
      oprot.writeI64(self.transactionId)
5610 
      oprot.writeFieldEnd()
3431 rajveer 5611 
    if self.status is not None:
94 ashish 5612 
      oprot.writeFieldBegin('status', TType.I32, 2)
5613 
      oprot.writeI32(self.status)
5614 
      oprot.writeFieldEnd()
3431 rajveer 5615 
    if self.description is not None:
94 ashish 5616 
      oprot.writeFieldBegin('description', TType.STRING, 3)
5617 
      oprot.writeString(self.description)
5618 
      oprot.writeFieldEnd()
5619 
    oprot.writeFieldStop()
5620 
    oprot.writeStructEnd()
5621 
 
3431 rajveer 5622 
  def validate(self):
5623 
    return
5624 
 
5625 
 
94 ashish 5626 
  def __repr__(self):
5627 
    L = ['%s=%r' % (key, value)
5628 
      for key, value in self.__dict__.iteritems()]
5629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5630 
 
5631 
  def __eq__(self, other):
5632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5633 
 
5634 
  def __ne__(self, other):
5635 
    return not (self == other)
5636 
 
5637 
class changeTransactionStatus_result:
5638 
  """
5639 
  Attributes:
5640 
   - success
5641 
   - ex
5642 
  """
5643 
 
5644 
  thrift_spec = (
5645 
    (0, TType.BOOL, 'success', None, None, ), # 0
5646 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5647 
  )
5648 
 
5649 
  def __init__(self, success=None, ex=None,):
5650 
    self.success = success
5651 
    self.ex = ex
5652 
 
5653 
  def read(self, iprot):
5654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5656 
      return
5657 
    iprot.readStructBegin()
5658 
    while True:
5659 
      (fname, ftype, fid) = iprot.readFieldBegin()
5660 
      if ftype == TType.STOP:
5661 
        break
5662 
      if fid == 0:
5663 
        if ftype == TType.BOOL:
5664 
          self.success = iprot.readBool();
5665 
        else:
5666 
          iprot.skip(ftype)
5667 
      elif fid == 1:
5668 
        if ftype == TType.STRUCT:
5669 
          self.ex = TransactionServiceException()
5670 
          self.ex.read(iprot)
5671 
        else:
5672 
          iprot.skip(ftype)
5673 
      else:
5674 
        iprot.skip(ftype)
5675 
      iprot.readFieldEnd()
5676 
    iprot.readStructEnd()
5677 
 
5678 
  def write(self, oprot):
5679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5681 
      return
5682 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 5683 
    if self.success is not None:
94 ashish 5684 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5685 
      oprot.writeBool(self.success)
5686 
      oprot.writeFieldEnd()
3431 rajveer 5687 
    if self.ex is not None:
94 ashish 5688 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5689 
      self.ex.write(oprot)
5690 
      oprot.writeFieldEnd()
5691 
    oprot.writeFieldStop()
5692 
    oprot.writeStructEnd()
5693 
 
3431 rajveer 5694 
  def validate(self):
5695 
    return
5696 
 
5697 
 
94 ashish 5698 
  def __repr__(self):
5699 
    L = ['%s=%r' % (key, value)
5700 
      for key, value in self.__dict__.iteritems()]
5701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5702 
 
5703 
  def __eq__(self, other):
5704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5705 
 
5706 
  def __ne__(self, other):
5707 
    return not (self == other)
5708 
 
1398 varun.gupt 5709 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 5710 
  """
5711 
  Attributes:
5712 
   - transactionId
5713 
  """
5714 
 
5715 
  thrift_spec = (
5716 
    None, # 0
5717 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5718 
  )
5719 
 
5720 
  def __init__(self, transactionId=None,):
5721 
    self.transactionId = transactionId
5722 
 
5723 
  def read(self, iprot):
5724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5726 
      return
5727 
    iprot.readStructBegin()
5728 
    while True:
5729 
      (fname, ftype, fid) = iprot.readFieldBegin()
5730 
      if ftype == TType.STOP:
5731 
        break
5732 
      if fid == 1:
5733 
        if ftype == TType.I64:
5734 
          self.transactionId = iprot.readI64();
5735 
        else:
5736 
          iprot.skip(ftype)
5737 
      else:
5738 
        iprot.skip(ftype)
5739 
      iprot.readFieldEnd()
5740 
    iprot.readStructEnd()
5741 
 
5742 
  def write(self, oprot):
5743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5745 
      return
1398 varun.gupt 5746 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 5747 
    if self.transactionId is not None:
1382 varun.gupt 5748 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5749 
      oprot.writeI64(self.transactionId)
5750 
      oprot.writeFieldEnd()
5751 
    oprot.writeFieldStop()
5752 
    oprot.writeStructEnd()
5753 
 
3431 rajveer 5754 
  def validate(self):
5755 
    return
5756 
 
5757 
 
1382 varun.gupt 5758 
  def __repr__(self):
5759 
    L = ['%s=%r' % (key, value)
5760 
      for key, value in self.__dict__.iteritems()]
5761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5762 
 
5763 
  def __eq__(self, other):
5764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5765 
 
5766 
  def __ne__(self, other):
5767 
    return not (self == other)
5768 
 
1398 varun.gupt 5769 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 5770 
  """
5771 
  Attributes:
5772 
   - success
5773 
   - ex
5774 
  """
5775 
 
5776 
  thrift_spec = (
5777 
    (0, TType.BOOL, 'success', None, None, ), # 0
5778 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5779 
  )
5780 
 
5781 
  def __init__(self, success=None, ex=None,):
5782 
    self.success = success
5783 
    self.ex = ex
5784 
 
5785 
  def read(self, iprot):
5786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5788 
      return
5789 
    iprot.readStructBegin()
5790 
    while True:
5791 
      (fname, ftype, fid) = iprot.readFieldBegin()
5792 
      if ftype == TType.STOP:
5793 
        break
5794 
      if fid == 0:
5795 
        if ftype == TType.BOOL:
5796 
          self.success = iprot.readBool();
5797 
        else:
5798 
          iprot.skip(ftype)
5799 
      elif fid == 1:
5800 
        if ftype == TType.STRUCT:
5801 
          self.ex = TransactionServiceException()
5802 
          self.ex.read(iprot)
5803 
        else:
5804 
          iprot.skip(ftype)
5805 
      else:
5806 
        iprot.skip(ftype)
5807 
      iprot.readFieldEnd()
5808 
    iprot.readStructEnd()
5809 
 
5810 
  def write(self, oprot):
5811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5813 
      return
1398 varun.gupt 5814 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5815 
    if self.success is not None:
1382 varun.gupt 5816 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5817 
      oprot.writeBool(self.success)
5818 
      oprot.writeFieldEnd()
3431 rajveer 5819 
    if self.ex is not None:
1382 varun.gupt 5820 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5821 
      self.ex.write(oprot)
5822 
      oprot.writeFieldEnd()
5823 
    oprot.writeFieldStop()
5824 
    oprot.writeStructEnd()
5825 
 
3431 rajveer 5826 
  def validate(self):
5827 
    return
5828 
 
5829 
 
1382 varun.gupt 5830 
  def __repr__(self):
5831 
    L = ['%s=%r' % (key, value)
5832 
      for key, value in self.__dict__.iteritems()]
5833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5834 
 
5835 
  def __eq__(self, other):
5836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5837 
 
5838 
  def __ne__(self, other):
5839 
    return not (self == other)
5840 
 
483 rajveer 5841 
class getAllOrders_args:
94 ashish 5842 
  """
5843 
  Attributes:
483 rajveer 5844 
   - status
5845 
   - from_date
5846 
   - to_date
5847 
   - warehouse_id
94 ashish 5848 
  """
5849 
 
5850 
  thrift_spec = (
5851 
    None, # 0
483 rajveer 5852 
    (1, TType.I32, 'status', None, None, ), # 1
5853 
    (2, TType.I64, 'from_date', None, None, ), # 2
5854 
    (3, TType.I64, 'to_date', None, None, ), # 3
5855 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5856 
  )
5857 
 
483 rajveer 5858 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5859 
    self.status = status
5860 
    self.from_date = from_date
5861 
    self.to_date = to_date
5862 
    self.warehouse_id = warehouse_id
94 ashish 5863 
 
5864 
  def read(self, iprot):
5865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5867 
      return
5868 
    iprot.readStructBegin()
5869 
    while True:
5870 
      (fname, ftype, fid) = iprot.readFieldBegin()
5871 
      if ftype == TType.STOP:
5872 
        break
5873 
      if fid == 1:
483 rajveer 5874 
        if ftype == TType.I32:
5875 
          self.status = iprot.readI32();
94 ashish 5876 
        else:
5877 
          iprot.skip(ftype)
483 rajveer 5878 
      elif fid == 2:
5879 
        if ftype == TType.I64:
5880 
          self.from_date = iprot.readI64();
94 ashish 5881 
        else:
5882 
          iprot.skip(ftype)
483 rajveer 5883 
      elif fid == 3:
5884 
        if ftype == TType.I64:
5885 
          self.to_date = iprot.readI64();
94 ashish 5886 
        else:
5887 
          iprot.skip(ftype)
483 rajveer 5888 
      elif fid == 4:
94 ashish 5889 
        if ftype == TType.I64:
483 rajveer 5890 
          self.warehouse_id = iprot.readI64();
94 ashish 5891 
        else:
5892 
          iprot.skip(ftype)
5893 
      else:
5894 
        iprot.skip(ftype)
5895 
      iprot.readFieldEnd()
5896 
    iprot.readStructEnd()
5897 
 
5898 
  def write(self, oprot):
5899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5901 
      return
483 rajveer 5902 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5903 
    if self.status is not None:
483 rajveer 5904 
      oprot.writeFieldBegin('status', TType.I32, 1)
5905 
      oprot.writeI32(self.status)
94 ashish 5906 
      oprot.writeFieldEnd()
3431 rajveer 5907 
    if self.from_date is not None:
483 rajveer 5908 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5909 
      oprot.writeI64(self.from_date)
94 ashish 5910 
      oprot.writeFieldEnd()
3431 rajveer 5911 
    if self.to_date is not None:
483 rajveer 5912 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5913 
      oprot.writeI64(self.to_date)
94 ashish 5914 
      oprot.writeFieldEnd()
3431 rajveer 5915 
    if self.warehouse_id is not None:
483 rajveer 5916 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5917 
      oprot.writeI64(self.warehouse_id)
94 ashish 5918 
      oprot.writeFieldEnd()
5919 
    oprot.writeFieldStop()
5920 
    oprot.writeStructEnd()
5921 
 
3431 rajveer 5922 
  def validate(self):
5923 
    return
5924 
 
5925 
 
94 ashish 5926 
  def __repr__(self):
5927 
    L = ['%s=%r' % (key, value)
5928 
      for key, value in self.__dict__.iteritems()]
5929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5930 
 
5931 
  def __eq__(self, other):
5932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5933 
 
5934 
  def __ne__(self, other):
5935 
    return not (self == other)
5936 
 
483 rajveer 5937 
class getAllOrders_result:
94 ashish 5938 
  """
5939 
  Attributes:
5940 
   - success
5941 
   - ex
5942 
  """
5943 
 
5944 
  thrift_spec = (
483 rajveer 5945 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5946 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5947 
  )
5948 
 
5949 
  def __init__(self, success=None, ex=None,):
5950 
    self.success = success
5951 
    self.ex = ex
5952 
 
5953 
  def read(self, iprot):
5954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5956 
      return
5957 
    iprot.readStructBegin()
5958 
    while True:
5959 
      (fname, ftype, fid) = iprot.readFieldBegin()
5960 
      if ftype == TType.STOP:
5961 
        break
5962 
      if fid == 0:
483 rajveer 5963 
        if ftype == TType.LIST:
5964 
          self.success = []
685 chandransh 5965 
          (_etype31, _size28) = iprot.readListBegin()
5966 
          for _i32 in xrange(_size28):
5967 
            _elem33 = Order()
5968 
            _elem33.read(iprot)
5969 
            self.success.append(_elem33)
483 rajveer 5970 
          iprot.readListEnd()
94 ashish 5971 
        else:
5972 
          iprot.skip(ftype)
5973 
      elif fid == 1:
5974 
        if ftype == TType.STRUCT:
5975 
          self.ex = TransactionServiceException()
5976 
          self.ex.read(iprot)
5977 
        else:
5978 
          iprot.skip(ftype)
5979 
      else:
5980 
        iprot.skip(ftype)
5981 
      iprot.readFieldEnd()
5982 
    iprot.readStructEnd()
5983 
 
5984 
  def write(self, oprot):
5985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5987 
      return
483 rajveer 5988 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5989 
    if self.success is not None:
483 rajveer 5990 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5991 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5992 
      for iter34 in self.success:
5993 
        iter34.write(oprot)
483 rajveer 5994 
      oprot.writeListEnd()
94 ashish 5995 
      oprot.writeFieldEnd()
3431 rajveer 5996 
    if self.ex is not None:
94 ashish 5997 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5998 
      self.ex.write(oprot)
5999 
      oprot.writeFieldEnd()
6000 
    oprot.writeFieldStop()
6001 
    oprot.writeStructEnd()
6002 
 
3431 rajveer 6003 
  def validate(self):
6004 
    return
6005 
 
6006 
 
94 ashish 6007 
  def __repr__(self):
6008 
    L = ['%s=%r' % (key, value)
6009 
      for key, value in self.__dict__.iteritems()]
6010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6011 
 
6012 
  def __eq__(self, other):
6013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6014 
 
6015 
  def __ne__(self, other):
6016 
    return not (self == other)
6017 
 
4133 chandransh 6018 
class getOrdersInBatch_args:
6019 
  """
6020 
  Attributes:
6021 
   - statuses
6022 
   - offset
6023 
   - limit
6024 
   - warehouse_id
6025 
  """
6026 
 
6027 
  thrift_spec = (
6028 
    None, # 0
6029 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6030 
    (2, TType.I64, 'offset', None, None, ), # 2
6031 
    (3, TType.I64, 'limit', None, None, ), # 3
6032 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6033 
  )
6034 
 
6035 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
6036 
    self.statuses = statuses
6037 
    self.offset = offset
6038 
    self.limit = limit
6039 
    self.warehouse_id = warehouse_id
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.LIST:
6052 
          self.statuses = []
6053 
          (_etype38, _size35) = iprot.readListBegin()
6054 
          for _i39 in xrange(_size35):
6055 
            _elem40 = iprot.readI32();
6056 
            self.statuses.append(_elem40)
6057 
          iprot.readListEnd()
6058 
        else:
6059 
          iprot.skip(ftype)
6060 
      elif fid == 2:
6061 
        if ftype == TType.I64:
6062 
          self.offset = iprot.readI64();
6063 
        else:
6064 
          iprot.skip(ftype)
6065 
      elif fid == 3:
6066 
        if ftype == TType.I64:
6067 
          self.limit = iprot.readI64();
6068 
        else:
6069 
          iprot.skip(ftype)
6070 
      elif fid == 4:
6071 
        if ftype == TType.I64:
6072 
          self.warehouse_id = iprot.readI64();
6073 
        else:
6074 
          iprot.skip(ftype)
6075 
      else:
6076 
        iprot.skip(ftype)
6077 
      iprot.readFieldEnd()
6078 
    iprot.readStructEnd()
6079 
 
6080 
  def write(self, oprot):
6081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6083 
      return
6084 
    oprot.writeStructBegin('getOrdersInBatch_args')
6085 
    if self.statuses is not None:
6086 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6087 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6088 
      for iter41 in self.statuses:
6089 
        oprot.writeI32(iter41)
6090 
      oprot.writeListEnd()
6091 
      oprot.writeFieldEnd()
6092 
    if self.offset is not None:
6093 
      oprot.writeFieldBegin('offset', TType.I64, 2)
6094 
      oprot.writeI64(self.offset)
6095 
      oprot.writeFieldEnd()
6096 
    if self.limit is not None:
6097 
      oprot.writeFieldBegin('limit', TType.I64, 3)
6098 
      oprot.writeI64(self.limit)
6099 
      oprot.writeFieldEnd()
6100 
    if self.warehouse_id is not None:
6101 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6102 
      oprot.writeI64(self.warehouse_id)
6103 
      oprot.writeFieldEnd()
6104 
    oprot.writeFieldStop()
6105 
    oprot.writeStructEnd()
6106 
 
6107 
  def validate(self):
6108 
    return
6109 
 
6110 
 
6111 
  def __repr__(self):
6112 
    L = ['%s=%r' % (key, value)
6113 
      for key, value in self.__dict__.iteritems()]
6114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6115 
 
6116 
  def __eq__(self, other):
6117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6118 
 
6119 
  def __ne__(self, other):
6120 
    return not (self == other)
6121 
 
6122 
class getOrdersInBatch_result:
6123 
  """
6124 
  Attributes:
6125 
   - success
6126 
   - ex
6127 
  """
6128 
 
6129 
  thrift_spec = (
6130 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6131 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6132 
  )
6133 
 
6134 
  def __init__(self, success=None, ex=None,):
6135 
    self.success = success
6136 
    self.ex = ex
6137 
 
6138 
  def read(self, iprot):
6139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6141 
      return
6142 
    iprot.readStructBegin()
6143 
    while True:
6144 
      (fname, ftype, fid) = iprot.readFieldBegin()
6145 
      if ftype == TType.STOP:
6146 
        break
6147 
      if fid == 0:
6148 
        if ftype == TType.LIST:
6149 
          self.success = []
6150 
          (_etype45, _size42) = iprot.readListBegin()
6151 
          for _i46 in xrange(_size42):
6152 
            _elem47 = Order()
6153 
            _elem47.read(iprot)
6154 
            self.success.append(_elem47)
6155 
          iprot.readListEnd()
6156 
        else:
6157 
          iprot.skip(ftype)
6158 
      elif fid == 1:
6159 
        if ftype == TType.STRUCT:
6160 
          self.ex = TransactionServiceException()
6161 
          self.ex.read(iprot)
6162 
        else:
6163 
          iprot.skip(ftype)
6164 
      else:
6165 
        iprot.skip(ftype)
6166 
      iprot.readFieldEnd()
6167 
    iprot.readStructEnd()
6168 
 
6169 
  def write(self, oprot):
6170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6172 
      return
6173 
    oprot.writeStructBegin('getOrdersInBatch_result')
6174 
    if self.success is not None:
6175 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6176 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6177 
      for iter48 in self.success:
6178 
        iter48.write(oprot)
6179 
      oprot.writeListEnd()
6180 
      oprot.writeFieldEnd()
6181 
    if self.ex is not None:
6182 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6183 
      self.ex.write(oprot)
6184 
      oprot.writeFieldEnd()
6185 
    oprot.writeFieldStop()
6186 
    oprot.writeStructEnd()
6187 
 
6188 
  def validate(self):
6189 
    return
6190 
 
6191 
 
6192 
  def __repr__(self):
6193 
    L = ['%s=%r' % (key, value)
6194 
      for key, value in self.__dict__.iteritems()]
6195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6196 
 
6197 
  def __eq__(self, other):
6198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6199 
 
6200 
  def __ne__(self, other):
6201 
    return not (self == other)
6202 
 
6203 
class getOrderCount_args:
6204 
  """
6205 
  Attributes:
6206 
   - statuses
6207 
   - warehouseId
6208 
  """
6209 
 
6210 
  thrift_spec = (
6211 
    None, # 0
6212 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6213 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6214 
  )
6215 
 
6216 
  def __init__(self, statuses=None, warehouseId=None,):
6217 
    self.statuses = statuses
6218 
    self.warehouseId = warehouseId
6219 
 
6220 
  def read(self, iprot):
6221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6223 
      return
6224 
    iprot.readStructBegin()
6225 
    while True:
6226 
      (fname, ftype, fid) = iprot.readFieldBegin()
6227 
      if ftype == TType.STOP:
6228 
        break
6229 
      if fid == 1:
6230 
        if ftype == TType.LIST:
6231 
          self.statuses = []
6232 
          (_etype52, _size49) = iprot.readListBegin()
6233 
          for _i53 in xrange(_size49):
6234 
            _elem54 = iprot.readI32();
6235 
            self.statuses.append(_elem54)
6236 
          iprot.readListEnd()
6237 
        else:
6238 
          iprot.skip(ftype)
6239 
      elif fid == 2:
6240 
        if ftype == TType.I64:
6241 
          self.warehouseId = iprot.readI64();
6242 
        else:
6243 
          iprot.skip(ftype)
6244 
      else:
6245 
        iprot.skip(ftype)
6246 
      iprot.readFieldEnd()
6247 
    iprot.readStructEnd()
6248 
 
6249 
  def write(self, oprot):
6250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6252 
      return
6253 
    oprot.writeStructBegin('getOrderCount_args')
6254 
    if self.statuses is not None:
6255 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6256 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6257 
      for iter55 in self.statuses:
6258 
        oprot.writeI32(iter55)
6259 
      oprot.writeListEnd()
6260 
      oprot.writeFieldEnd()
6261 
    if self.warehouseId is not None:
6262 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6263 
      oprot.writeI64(self.warehouseId)
6264 
      oprot.writeFieldEnd()
6265 
    oprot.writeFieldStop()
6266 
    oprot.writeStructEnd()
6267 
 
6268 
  def validate(self):
6269 
    return
6270 
 
6271 
 
6272 
  def __repr__(self):
6273 
    L = ['%s=%r' % (key, value)
6274 
      for key, value in self.__dict__.iteritems()]
6275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6276 
 
6277 
  def __eq__(self, other):
6278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6279 
 
6280 
  def __ne__(self, other):
6281 
    return not (self == other)
6282 
 
6283 
class getOrderCount_result:
6284 
  """
6285 
  Attributes:
6286 
   - success
6287 
   - ex
6288 
  """
6289 
 
6290 
  thrift_spec = (
6291 
    (0, TType.I32, 'success', None, None, ), # 0
6292 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6293 
  )
6294 
 
6295 
  def __init__(self, success=None, ex=None,):
6296 
    self.success = success
6297 
    self.ex = ex
6298 
 
6299 
  def read(self, iprot):
6300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6302 
      return
6303 
    iprot.readStructBegin()
6304 
    while True:
6305 
      (fname, ftype, fid) = iprot.readFieldBegin()
6306 
      if ftype == TType.STOP:
6307 
        break
6308 
      if fid == 0:
6309 
        if ftype == TType.I32:
6310 
          self.success = iprot.readI32();
6311 
        else:
6312 
          iprot.skip(ftype)
6313 
      elif fid == 1:
6314 
        if ftype == TType.STRUCT:
6315 
          self.ex = TransactionServiceException()
6316 
          self.ex.read(iprot)
6317 
        else:
6318 
          iprot.skip(ftype)
6319 
      else:
6320 
        iprot.skip(ftype)
6321 
      iprot.readFieldEnd()
6322 
    iprot.readStructEnd()
6323 
 
6324 
  def write(self, oprot):
6325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6327 
      return
6328 
    oprot.writeStructBegin('getOrderCount_result')
6329 
    if self.success is not None:
6330 
      oprot.writeFieldBegin('success', TType.I32, 0)
6331 
      oprot.writeI32(self.success)
6332 
      oprot.writeFieldEnd()
6333 
    if self.ex is not None:
6334 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6335 
      self.ex.write(oprot)
6336 
      oprot.writeFieldEnd()
6337 
    oprot.writeFieldStop()
6338 
    oprot.writeStructEnd()
6339 
 
6340 
  def validate(self):
6341 
    return
6342 
 
6343 
 
6344 
  def __repr__(self):
6345 
    L = ['%s=%r' % (key, value)
6346 
      for key, value in self.__dict__.iteritems()]
6347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6348 
 
6349 
  def __eq__(self, other):
6350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6351 
 
6352 
  def __ne__(self, other):
6353 
    return not (self == other)
6354 
 
999 varun.gupt 6355 
class getOrdersByBillingDate_args:
6356 
  """
6357 
  Attributes:
6358 
   - status
6359 
   - start_billing_date
6360 
   - end_billing_date
6361 
   - warehouse_id
6362 
  """
6363 
 
6364 
  thrift_spec = (
6365 
    None, # 0
6366 
    (1, TType.I32, 'status', None, None, ), # 1
6367 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
6368 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
6369 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6370 
  )
6371 
 
6372 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
6373 
    self.status = status
6374 
    self.start_billing_date = start_billing_date
6375 
    self.end_billing_date = end_billing_date
6376 
    self.warehouse_id = warehouse_id
6377 
 
6378 
  def read(self, iprot):
6379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6381 
      return
6382 
    iprot.readStructBegin()
6383 
    while True:
6384 
      (fname, ftype, fid) = iprot.readFieldBegin()
6385 
      if ftype == TType.STOP:
6386 
        break
6387 
      if fid == 1:
6388 
        if ftype == TType.I32:
6389 
          self.status = iprot.readI32();
6390 
        else:
6391 
          iprot.skip(ftype)
6392 
      elif fid == 2:
6393 
        if ftype == TType.I64:
6394 
          self.start_billing_date = iprot.readI64();
6395 
        else:
6396 
          iprot.skip(ftype)
6397 
      elif fid == 3:
6398 
        if ftype == TType.I64:
6399 
          self.end_billing_date = iprot.readI64();
6400 
        else:
6401 
          iprot.skip(ftype)
6402 
      elif fid == 4:
6403 
        if ftype == TType.I64:
6404 
          self.warehouse_id = iprot.readI64();
6405 
        else:
6406 
          iprot.skip(ftype)
6407 
      else:
6408 
        iprot.skip(ftype)
6409 
      iprot.readFieldEnd()
6410 
    iprot.readStructEnd()
6411 
 
6412 
  def write(self, oprot):
6413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6415 
      return
6416 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 6417 
    if self.status is not None:
999 varun.gupt 6418 
      oprot.writeFieldBegin('status', TType.I32, 1)
6419 
      oprot.writeI32(self.status)
6420 
      oprot.writeFieldEnd()
3431 rajveer 6421 
    if self.start_billing_date is not None:
999 varun.gupt 6422 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
6423 
      oprot.writeI64(self.start_billing_date)
6424 
      oprot.writeFieldEnd()
3431 rajveer 6425 
    if self.end_billing_date is not None:
999 varun.gupt 6426 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
6427 
      oprot.writeI64(self.end_billing_date)
6428 
      oprot.writeFieldEnd()
3431 rajveer 6429 
    if self.warehouse_id is not None:
999 varun.gupt 6430 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6431 
      oprot.writeI64(self.warehouse_id)
6432 
      oprot.writeFieldEnd()
6433 
    oprot.writeFieldStop()
6434 
    oprot.writeStructEnd()
6435 
 
3431 rajveer 6436 
  def validate(self):
6437 
    return
6438 
 
6439 
 
999 varun.gupt 6440 
  def __repr__(self):
6441 
    L = ['%s=%r' % (key, value)
6442 
      for key, value in self.__dict__.iteritems()]
6443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6444 
 
6445 
  def __eq__(self, other):
6446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6447 
 
6448 
  def __ne__(self, other):
6449 
    return not (self == other)
6450 
 
6451 
class getOrdersByBillingDate_result:
6452 
  """
6453 
  Attributes:
6454 
   - success
6455 
   - ex
6456 
  """
6457 
 
6458 
  thrift_spec = (
6459 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6460 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6461 
  )
6462 
 
6463 
  def __init__(self, success=None, ex=None,):
6464 
    self.success = success
6465 
    self.ex = ex
6466 
 
6467 
  def read(self, iprot):
6468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6470 
      return
6471 
    iprot.readStructBegin()
6472 
    while True:
6473 
      (fname, ftype, fid) = iprot.readFieldBegin()
6474 
      if ftype == TType.STOP:
6475 
        break
6476 
      if fid == 0:
6477 
        if ftype == TType.LIST:
6478 
          self.success = []
4133 chandransh 6479 
          (_etype59, _size56) = iprot.readListBegin()
6480 
          for _i60 in xrange(_size56):
6481 
            _elem61 = Order()
6482 
            _elem61.read(iprot)
6483 
            self.success.append(_elem61)
999 varun.gupt 6484 
          iprot.readListEnd()
6485 
        else:
6486 
          iprot.skip(ftype)
6487 
      elif fid == 1:
6488 
        if ftype == TType.STRUCT:
6489 
          self.ex = TransactionServiceException()
6490 
          self.ex.read(iprot)
6491 
        else:
6492 
          iprot.skip(ftype)
6493 
      else:
6494 
        iprot.skip(ftype)
6495 
      iprot.readFieldEnd()
6496 
    iprot.readStructEnd()
6497 
 
6498 
  def write(self, oprot):
6499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6501 
      return
6502 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 6503 
    if self.success is not None:
999 varun.gupt 6504 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6505 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6506 
      for iter62 in self.success:
6507 
        iter62.write(oprot)
999 varun.gupt 6508 
      oprot.writeListEnd()
6509 
      oprot.writeFieldEnd()
3431 rajveer 6510 
    if self.ex is not None:
999 varun.gupt 6511 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6512 
      self.ex.write(oprot)
6513 
      oprot.writeFieldEnd()
6514 
    oprot.writeFieldStop()
6515 
    oprot.writeStructEnd()
6516 
 
3431 rajveer 6517 
  def validate(self):
6518 
    return
6519 
 
6520 
 
999 varun.gupt 6521 
  def __repr__(self):
6522 
    L = ['%s=%r' % (key, value)
6523 
      for key, value in self.__dict__.iteritems()]
6524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6525 
 
6526 
  def __eq__(self, other):
6527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6528 
 
6529 
  def __ne__(self, other):
6530 
    return not (self == other)
6531 
 
3427 chandransh 6532 
class getOrdersByShippingDate_args:
6533 
  """
6534 
  Attributes:
6535 
   - fromShippingDate
6536 
   - toShippingDate
6537 
   - providerId
6538 
   - warehouseId
3451 chandransh 6539 
   - cod
3427 chandransh 6540 
  """
6541 
 
6542 
  thrift_spec = (
6543 
    None, # 0
6544 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
6545 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
6546 
    (3, TType.I64, 'providerId', None, None, ), # 3
6547 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 6548 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 6549 
  )
6550 
 
3451 chandransh 6551 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 6552 
    self.fromShippingDate = fromShippingDate
6553 
    self.toShippingDate = toShippingDate
6554 
    self.providerId = providerId
6555 
    self.warehouseId = warehouseId
3451 chandransh 6556 
    self.cod = cod
3427 chandransh 6557 
 
6558 
  def read(self, iprot):
6559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6561 
      return
6562 
    iprot.readStructBegin()
6563 
    while True:
6564 
      (fname, ftype, fid) = iprot.readFieldBegin()
6565 
      if ftype == TType.STOP:
6566 
        break
6567 
      if fid == 1:
6568 
        if ftype == TType.I64:
6569 
          self.fromShippingDate = iprot.readI64();
6570 
        else:
6571 
          iprot.skip(ftype)
6572 
      elif fid == 2:
6573 
        if ftype == TType.I64:
6574 
          self.toShippingDate = iprot.readI64();
6575 
        else:
6576 
          iprot.skip(ftype)
6577 
      elif fid == 3:
6578 
        if ftype == TType.I64:
6579 
          self.providerId = iprot.readI64();
6580 
        else:
6581 
          iprot.skip(ftype)
6582 
      elif fid == 4:
6583 
        if ftype == TType.I64:
6584 
          self.warehouseId = iprot.readI64();
6585 
        else:
6586 
          iprot.skip(ftype)
3451 chandransh 6587 
      elif fid == 5:
6588 
        if ftype == TType.BOOL:
6589 
          self.cod = iprot.readBool();
6590 
        else:
6591 
          iprot.skip(ftype)
3427 chandransh 6592 
      else:
6593 
        iprot.skip(ftype)
6594 
      iprot.readFieldEnd()
6595 
    iprot.readStructEnd()
6596 
 
6597 
  def write(self, oprot):
6598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6600 
      return
6601 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 6602 
    if self.fromShippingDate is not None:
3427 chandransh 6603 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
6604 
      oprot.writeI64(self.fromShippingDate)
6605 
      oprot.writeFieldEnd()
3431 rajveer 6606 
    if self.toShippingDate is not None:
3427 chandransh 6607 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
6608 
      oprot.writeI64(self.toShippingDate)
6609 
      oprot.writeFieldEnd()
3431 rajveer 6610 
    if self.providerId is not None:
3427 chandransh 6611 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
6612 
      oprot.writeI64(self.providerId)
6613 
      oprot.writeFieldEnd()
3431 rajveer 6614 
    if self.warehouseId is not None:
3427 chandransh 6615 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
6616 
      oprot.writeI64(self.warehouseId)
6617 
      oprot.writeFieldEnd()
3451 chandransh 6618 
    if self.cod is not None:
6619 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
6620 
      oprot.writeBool(self.cod)
6621 
      oprot.writeFieldEnd()
3427 chandransh 6622 
    oprot.writeFieldStop()
6623 
    oprot.writeStructEnd()
6624 
 
3431 rajveer 6625 
  def validate(self):
6626 
    return
6627 
 
6628 
 
3427 chandransh 6629 
  def __repr__(self):
6630 
    L = ['%s=%r' % (key, value)
6631 
      for key, value in self.__dict__.iteritems()]
6632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6633 
 
6634 
  def __eq__(self, other):
6635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6636 
 
6637 
  def __ne__(self, other):
6638 
    return not (self == other)
6639 
 
6640 
class getOrdersByShippingDate_result:
6641 
  """
6642 
  Attributes:
6643 
   - success
6644 
   - ex
6645 
  """
6646 
 
6647 
  thrift_spec = (
6648 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6649 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6650 
  )
6651 
 
6652 
  def __init__(self, success=None, ex=None,):
6653 
    self.success = success
6654 
    self.ex = ex
6655 
 
6656 
  def read(self, iprot):
6657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6659 
      return
6660 
    iprot.readStructBegin()
6661 
    while True:
6662 
      (fname, ftype, fid) = iprot.readFieldBegin()
6663 
      if ftype == TType.STOP:
6664 
        break
6665 
      if fid == 0:
6666 
        if ftype == TType.LIST:
6667 
          self.success = []
4133 chandransh 6668 
          (_etype66, _size63) = iprot.readListBegin()
6669 
          for _i67 in xrange(_size63):
6670 
            _elem68 = Order()
6671 
            _elem68.read(iprot)
6672 
            self.success.append(_elem68)
3427 chandransh 6673 
          iprot.readListEnd()
6674 
        else:
6675 
          iprot.skip(ftype)
6676 
      elif fid == 1:
6677 
        if ftype == TType.STRUCT:
6678 
          self.ex = TransactionServiceException()
6679 
          self.ex.read(iprot)
6680 
        else:
6681 
          iprot.skip(ftype)
6682 
      else:
6683 
        iprot.skip(ftype)
6684 
      iprot.readFieldEnd()
6685 
    iprot.readStructEnd()
6686 
 
6687 
  def write(self, oprot):
6688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6690 
      return
6691 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 6692 
    if self.success is not None:
3427 chandransh 6693 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6694 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6695 
      for iter69 in self.success:
6696 
        iter69.write(oprot)
3427 chandransh 6697 
      oprot.writeListEnd()
6698 
      oprot.writeFieldEnd()
3431 rajveer 6699 
    if self.ex is not None:
3427 chandransh 6700 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6701 
      self.ex.write(oprot)
6702 
      oprot.writeFieldEnd()
6703 
    oprot.writeFieldStop()
6704 
    oprot.writeStructEnd()
6705 
 
3431 rajveer 6706 
  def validate(self):
6707 
    return
6708 
 
6709 
 
3427 chandransh 6710 
  def __repr__(self):
6711 
    L = ['%s=%r' % (key, value)
6712 
      for key, value in self.__dict__.iteritems()]
6713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6714 
 
6715 
  def __eq__(self, other):
6716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6717 
 
6718 
  def __ne__(self, other):
6719 
    return not (self == other)
6720 
 
1382 varun.gupt 6721 
class getReturnableOrdersForCustomer_args:
6722 
  """
6723 
  Attributes:
6724 
   - customer_id
6725 
   - limit
6726 
  """
6727 
 
6728 
  thrift_spec = (
6729 
    None, # 0
6730 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6731 
    (2, TType.I64, 'limit', None, None, ), # 2
6732 
  )
6733 
 
6734 
  def __init__(self, customer_id=None, limit=None,):
6735 
    self.customer_id = customer_id
6736 
    self.limit = limit
6737 
 
6738 
  def read(self, iprot):
6739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6741 
      return
6742 
    iprot.readStructBegin()
6743 
    while True:
6744 
      (fname, ftype, fid) = iprot.readFieldBegin()
6745 
      if ftype == TType.STOP:
6746 
        break
6747 
      if fid == 1:
6748 
        if ftype == TType.I64:
6749 
          self.customer_id = iprot.readI64();
6750 
        else:
6751 
          iprot.skip(ftype)
6752 
      elif fid == 2:
6753 
        if ftype == TType.I64:
6754 
          self.limit = iprot.readI64();
6755 
        else:
6756 
          iprot.skip(ftype)
6757 
      else:
6758 
        iprot.skip(ftype)
6759 
      iprot.readFieldEnd()
6760 
    iprot.readStructEnd()
6761 
 
6762 
  def write(self, oprot):
6763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6765 
      return
6766 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 6767 
    if self.customer_id is not None:
1382 varun.gupt 6768 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6769 
      oprot.writeI64(self.customer_id)
6770 
      oprot.writeFieldEnd()
3431 rajveer 6771 
    if self.limit is not None:
1382 varun.gupt 6772 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6773 
      oprot.writeI64(self.limit)
6774 
      oprot.writeFieldEnd()
6775 
    oprot.writeFieldStop()
6776 
    oprot.writeStructEnd()
6777 
 
3431 rajveer 6778 
  def validate(self):
6779 
    return
6780 
 
6781 
 
1382 varun.gupt 6782 
  def __repr__(self):
6783 
    L = ['%s=%r' % (key, value)
6784 
      for key, value in self.__dict__.iteritems()]
6785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6786 
 
6787 
  def __eq__(self, other):
6788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6789 
 
6790 
  def __ne__(self, other):
6791 
    return not (self == other)
6792 
 
6793 
class getReturnableOrdersForCustomer_result:
6794 
  """
6795 
  Attributes:
6796 
   - success
6797 
   - ex
6798 
  """
6799 
 
6800 
  thrift_spec = (
6801 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6802 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6803 
  )
6804 
 
6805 
  def __init__(self, success=None, ex=None,):
6806 
    self.success = success
6807 
    self.ex = ex
6808 
 
6809 
  def read(self, iprot):
6810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6812 
      return
6813 
    iprot.readStructBegin()
6814 
    while True:
6815 
      (fname, ftype, fid) = iprot.readFieldBegin()
6816 
      if ftype == TType.STOP:
6817 
        break
6818 
      if fid == 0:
6819 
        if ftype == TType.LIST:
6820 
          self.success = []
4133 chandransh 6821 
          (_etype73, _size70) = iprot.readListBegin()
6822 
          for _i74 in xrange(_size70):
6823 
            _elem75 = iprot.readI64();
6824 
            self.success.append(_elem75)
1382 varun.gupt 6825 
          iprot.readListEnd()
6826 
        else:
6827 
          iprot.skip(ftype)
6828 
      elif fid == 1:
6829 
        if ftype == TType.STRUCT:
6830 
          self.ex = TransactionServiceException()
6831 
          self.ex.read(iprot)
6832 
        else:
6833 
          iprot.skip(ftype)
6834 
      else:
6835 
        iprot.skip(ftype)
6836 
      iprot.readFieldEnd()
6837 
    iprot.readStructEnd()
6838 
 
6839 
  def write(self, oprot):
6840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6842 
      return
6843 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6844 
    if self.success is not None:
1382 varun.gupt 6845 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6846 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6847 
      for iter76 in self.success:
6848 
        oprot.writeI64(iter76)
1382 varun.gupt 6849 
      oprot.writeListEnd()
6850 
      oprot.writeFieldEnd()
3431 rajveer 6851 
    if self.ex is not None:
1382 varun.gupt 6852 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6853 
      self.ex.write(oprot)
6854 
      oprot.writeFieldEnd()
6855 
    oprot.writeFieldStop()
6856 
    oprot.writeStructEnd()
6857 
 
3431 rajveer 6858 
  def validate(self):
6859 
    return
6860 
 
6861 
 
1382 varun.gupt 6862 
  def __repr__(self):
6863 
    L = ['%s=%r' % (key, value)
6864 
      for key, value in self.__dict__.iteritems()]
6865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6866 
 
6867 
  def __eq__(self, other):
6868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6869 
 
6870 
  def __ne__(self, other):
6871 
    return not (self == other)
6872 
 
6873 
class getCancellableOrdersForCustomer_args:
6874 
  """
6875 
  Attributes:
6876 
   - customer_id
6877 
   - limit
6878 
  """
6879 
 
6880 
  thrift_spec = (
6881 
    None, # 0
6882 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6883 
    (2, TType.I64, 'limit', None, None, ), # 2
6884 
  )
6885 
 
6886 
  def __init__(self, customer_id=None, limit=None,):
6887 
    self.customer_id = customer_id
6888 
    self.limit = limit
6889 
 
6890 
  def read(self, iprot):
6891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6893 
      return
6894 
    iprot.readStructBegin()
6895 
    while True:
6896 
      (fname, ftype, fid) = iprot.readFieldBegin()
6897 
      if ftype == TType.STOP:
6898 
        break
6899 
      if fid == 1:
6900 
        if ftype == TType.I64:
6901 
          self.customer_id = iprot.readI64();
6902 
        else:
6903 
          iprot.skip(ftype)
6904 
      elif fid == 2:
6905 
        if ftype == TType.I64:
6906 
          self.limit = iprot.readI64();
6907 
        else:
6908 
          iprot.skip(ftype)
6909 
      else:
6910 
        iprot.skip(ftype)
6911 
      iprot.readFieldEnd()
6912 
    iprot.readStructEnd()
6913 
 
6914 
  def write(self, oprot):
6915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6917 
      return
6918 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6919 
    if self.customer_id is not None:
1382 varun.gupt 6920 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6921 
      oprot.writeI64(self.customer_id)
6922 
      oprot.writeFieldEnd()
3431 rajveer 6923 
    if self.limit is not None:
1382 varun.gupt 6924 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6925 
      oprot.writeI64(self.limit)
6926 
      oprot.writeFieldEnd()
6927 
    oprot.writeFieldStop()
6928 
    oprot.writeStructEnd()
6929 
 
3431 rajveer 6930 
  def validate(self):
6931 
    return
6932 
 
6933 
 
1382 varun.gupt 6934 
  def __repr__(self):
6935 
    L = ['%s=%r' % (key, value)
6936 
      for key, value in self.__dict__.iteritems()]
6937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6938 
 
6939 
  def __eq__(self, other):
6940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6941 
 
6942 
  def __ne__(self, other):
6943 
    return not (self == other)
6944 
 
6945 
class getCancellableOrdersForCustomer_result:
6946 
  """
6947 
  Attributes:
6948 
   - success
6949 
   - ex
6950 
  """
6951 
 
6952 
  thrift_spec = (
6953 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6954 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6955 
  )
6956 
 
6957 
  def __init__(self, success=None, ex=None,):
6958 
    self.success = success
6959 
    self.ex = ex
6960 
 
6961 
  def read(self, iprot):
6962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6964 
      return
6965 
    iprot.readStructBegin()
6966 
    while True:
6967 
      (fname, ftype, fid) = iprot.readFieldBegin()
6968 
      if ftype == TType.STOP:
6969 
        break
6970 
      if fid == 0:
6971 
        if ftype == TType.LIST:
6972 
          self.success = []
4133 chandransh 6973 
          (_etype80, _size77) = iprot.readListBegin()
6974 
          for _i81 in xrange(_size77):
6975 
            _elem82 = iprot.readI64();
6976 
            self.success.append(_elem82)
1382 varun.gupt 6977 
          iprot.readListEnd()
6978 
        else:
6979 
          iprot.skip(ftype)
6980 
      elif fid == 1:
6981 
        if ftype == TType.STRUCT:
6982 
          self.ex = TransactionServiceException()
6983 
          self.ex.read(iprot)
6984 
        else:
6985 
          iprot.skip(ftype)
6986 
      else:
6987 
        iprot.skip(ftype)
6988 
      iprot.readFieldEnd()
6989 
    iprot.readStructEnd()
6990 
 
6991 
  def write(self, oprot):
6992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6994 
      return
6995 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6996 
    if self.success is not None:
1382 varun.gupt 6997 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6998 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6999 
      for iter83 in self.success:
7000 
        oprot.writeI64(iter83)
1382 varun.gupt 7001 
      oprot.writeListEnd()
7002 
      oprot.writeFieldEnd()
3431 rajveer 7003 
    if self.ex is not None:
1382 varun.gupt 7004 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7005 
      self.ex.write(oprot)
7006 
      oprot.writeFieldEnd()
7007 
    oprot.writeFieldStop()
7008 
    oprot.writeStructEnd()
7009 
 
3431 rajveer 7010 
  def validate(self):
7011 
    return
7012 
 
7013 
 
1382 varun.gupt 7014 
  def __repr__(self):
7015 
    L = ['%s=%r' % (key, value)
7016 
      for key, value in self.__dict__.iteritems()]
7017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7018 
 
7019 
  def __eq__(self, other):
7020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7021 
 
7022 
  def __ne__(self, other):
7023 
    return not (self == other)
7024 
 
483 rajveer 7025 
class changeOrderStatus_args:
94 ashish 7026 
  """
7027 
  Attributes:
483 rajveer 7028 
   - orderId
7029 
   - status
7030 
   - description
94 ashish 7031 
  """
7032 
 
7033 
  thrift_spec = (
7034 
    None, # 0
483 rajveer 7035 
    (1, TType.I64, 'orderId', None, None, ), # 1
7036 
    (2, TType.I32, 'status', None, None, ), # 2
7037 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 7038 
  )
7039 
 
483 rajveer 7040 
  def __init__(self, orderId=None, status=None, description=None,):
7041 
    self.orderId = orderId
7042 
    self.status = status
7043 
    self.description = description
94 ashish 7044 
 
7045 
  def read(self, iprot):
7046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7048 
      return
7049 
    iprot.readStructBegin()
7050 
    while True:
7051 
      (fname, ftype, fid) = iprot.readFieldBegin()
7052 
      if ftype == TType.STOP:
7053 
        break
7054 
      if fid == 1:
7055 
        if ftype == TType.I64:
483 rajveer 7056 
          self.orderId = iprot.readI64();
94 ashish 7057 
        else:
7058 
          iprot.skip(ftype)
7059 
      elif fid == 2:
483 rajveer 7060 
        if ftype == TType.I32:
7061 
          self.status = iprot.readI32();
94 ashish 7062 
        else:
7063 
          iprot.skip(ftype)
483 rajveer 7064 
      elif fid == 3:
7065 
        if ftype == TType.STRING:
7066 
          self.description = iprot.readString();
7067 
        else:
7068 
          iprot.skip(ftype)
94 ashish 7069 
      else:
7070 
        iprot.skip(ftype)
7071 
      iprot.readFieldEnd()
7072 
    iprot.readStructEnd()
7073 
 
7074 
  def write(self, oprot):
7075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7077 
      return
483 rajveer 7078 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 7079 
    if self.orderId is not None:
483 rajveer 7080 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7081 
      oprot.writeI64(self.orderId)
94 ashish 7082 
      oprot.writeFieldEnd()
3431 rajveer 7083 
    if self.status is not None:
483 rajveer 7084 
      oprot.writeFieldBegin('status', TType.I32, 2)
7085 
      oprot.writeI32(self.status)
94 ashish 7086 
      oprot.writeFieldEnd()
3431 rajveer 7087 
    if self.description is not None:
483 rajveer 7088 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7089 
      oprot.writeString(self.description)
7090 
      oprot.writeFieldEnd()
94 ashish 7091 
    oprot.writeFieldStop()
7092 
    oprot.writeStructEnd()
7093 
 
3431 rajveer 7094 
  def validate(self):
7095 
    return
7096 
 
7097 
 
94 ashish 7098 
  def __repr__(self):
7099 
    L = ['%s=%r' % (key, value)
7100 
      for key, value in self.__dict__.iteritems()]
7101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7102 
 
7103 
  def __eq__(self, other):
7104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7105 
 
7106 
  def __ne__(self, other):
7107 
    return not (self == other)
7108 
 
483 rajveer 7109 
class changeOrderStatus_result:
94 ashish 7110 
  """
7111 
  Attributes:
7112 
   - success
7113 
   - ex
7114 
  """
7115 
 
7116 
  thrift_spec = (
7117 
    (0, TType.BOOL, 'success', None, None, ), # 0
7118 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7119 
  )
7120 
 
7121 
  def __init__(self, success=None, ex=None,):
7122 
    self.success = success
7123 
    self.ex = ex
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 == 0:
7135 
        if ftype == TType.BOOL:
7136 
          self.success = iprot.readBool();
7137 
        else:
7138 
          iprot.skip(ftype)
7139 
      elif fid == 1:
7140 
        if ftype == TType.STRUCT:
7141 
          self.ex = TransactionServiceException()
7142 
          self.ex.read(iprot)
7143 
        else:
7144 
          iprot.skip(ftype)
7145 
      else:
7146 
        iprot.skip(ftype)
7147 
      iprot.readFieldEnd()
7148 
    iprot.readStructEnd()
7149 
 
7150 
  def write(self, oprot):
7151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7153 
      return
483 rajveer 7154 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 7155 
    if self.success is not None:
94 ashish 7156 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7157 
      oprot.writeBool(self.success)
7158 
      oprot.writeFieldEnd()
3431 rajveer 7159 
    if self.ex is not None:
94 ashish 7160 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7161 
      self.ex.write(oprot)
7162 
      oprot.writeFieldEnd()
7163 
    oprot.writeFieldStop()
7164 
    oprot.writeStructEnd()
7165 
 
3431 rajveer 7166 
  def validate(self):
7167 
    return
7168 
 
7169 
 
94 ashish 7170 
  def __repr__(self):
7171 
    L = ['%s=%r' % (key, value)
7172 
      for key, value in self.__dict__.iteritems()]
7173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7174 
 
7175 
  def __eq__(self, other):
7176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7177 
 
7178 
  def __ne__(self, other):
7179 
    return not (self == other)
7180 
 
3064 chandransh 7181 
class getOrdersForTransaction_args:
494 rajveer 7182 
  """
7183 
  Attributes:
3064 chandransh 7184 
   - transactionId
7185 
   - customerId
494 rajveer 7186 
  """
7187 
 
7188 
  thrift_spec = (
7189 
    None, # 0
3064 chandransh 7190 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7191 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 7192 
  )
7193 
 
3064 chandransh 7194 
  def __init__(self, transactionId=None, customerId=None,):
7195 
    self.transactionId = transactionId
7196 
    self.customerId = customerId
494 rajveer 7197 
 
7198 
  def read(self, iprot):
7199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7201 
      return
7202 
    iprot.readStructBegin()
7203 
    while True:
7204 
      (fname, ftype, fid) = iprot.readFieldBegin()
7205 
      if ftype == TType.STOP:
7206 
        break
7207 
      if fid == 1:
7208 
        if ftype == TType.I64:
3064 chandransh 7209 
          self.transactionId = iprot.readI64();
494 rajveer 7210 
        else:
7211 
          iprot.skip(ftype)
7212 
      elif fid == 2:
3064 chandransh 7213 
        if ftype == TType.I64:
7214 
          self.customerId = iprot.readI64();
494 rajveer 7215 
        else:
7216 
          iprot.skip(ftype)
7217 
      else:
7218 
        iprot.skip(ftype)
7219 
      iprot.readFieldEnd()
7220 
    iprot.readStructEnd()
7221 
 
7222 
  def write(self, oprot):
7223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7225 
      return
3064 chandransh 7226 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 7227 
    if self.transactionId is not None:
3064 chandransh 7228 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7229 
      oprot.writeI64(self.transactionId)
494 rajveer 7230 
      oprot.writeFieldEnd()
3431 rajveer 7231 
    if self.customerId is not None:
3064 chandransh 7232 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
7233 
      oprot.writeI64(self.customerId)
494 rajveer 7234 
      oprot.writeFieldEnd()
7235 
    oprot.writeFieldStop()
7236 
    oprot.writeStructEnd()
7237 
 
3431 rajveer 7238 
  def validate(self):
7239 
    return
7240 
 
7241 
 
494 rajveer 7242 
  def __repr__(self):
7243 
    L = ['%s=%r' % (key, value)
7244 
      for key, value in self.__dict__.iteritems()]
7245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7246 
 
7247 
  def __eq__(self, other):
7248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7249 
 
7250 
  def __ne__(self, other):
7251 
    return not (self == other)
7252 
 
3064 chandransh 7253 
class getOrdersForTransaction_result:
494 rajveer 7254 
  """
7255 
  Attributes:
7256 
   - success
7257 
   - ex
7258 
  """
7259 
 
7260 
  thrift_spec = (
3064 chandransh 7261 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 7262 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7263 
  )
7264 
 
7265 
  def __init__(self, success=None, ex=None,):
7266 
    self.success = success
7267 
    self.ex = ex
7268 
 
7269 
  def read(self, iprot):
7270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7272 
      return
7273 
    iprot.readStructBegin()
7274 
    while True:
7275 
      (fname, ftype, fid) = iprot.readFieldBegin()
7276 
      if ftype == TType.STOP:
7277 
        break
7278 
      if fid == 0:
3064 chandransh 7279 
        if ftype == TType.LIST:
7280 
          self.success = []
4133 chandransh 7281 
          (_etype87, _size84) = iprot.readListBegin()
7282 
          for _i88 in xrange(_size84):
7283 
            _elem89 = Order()
7284 
            _elem89.read(iprot)
7285 
            self.success.append(_elem89)
3064 chandransh 7286 
          iprot.readListEnd()
494 rajveer 7287 
        else:
7288 
          iprot.skip(ftype)
7289 
      elif fid == 1:
7290 
        if ftype == TType.STRUCT:
7291 
          self.ex = TransactionServiceException()
7292 
          self.ex.read(iprot)
7293 
        else:
7294 
          iprot.skip(ftype)
7295 
      else:
7296 
        iprot.skip(ftype)
7297 
      iprot.readFieldEnd()
7298 
    iprot.readStructEnd()
7299 
 
7300 
  def write(self, oprot):
7301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7303 
      return
3064 chandransh 7304 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 7305 
    if self.success is not None:
3064 chandransh 7306 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7307 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7308 
      for iter90 in self.success:
7309 
        iter90.write(oprot)
3064 chandransh 7310 
      oprot.writeListEnd()
494 rajveer 7311 
      oprot.writeFieldEnd()
3431 rajveer 7312 
    if self.ex is not None:
494 rajveer 7313 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7314 
      self.ex.write(oprot)
7315 
      oprot.writeFieldEnd()
7316 
    oprot.writeFieldStop()
7317 
    oprot.writeStructEnd()
7318 
 
3431 rajveer 7319 
  def validate(self):
7320 
    return
7321 
 
7322 
 
494 rajveer 7323 
  def __repr__(self):
7324 
    L = ['%s=%r' % (key, value)
7325 
      for key, value in self.__dict__.iteritems()]
7326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7327 
 
7328 
  def __eq__(self, other):
7329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7330 
 
7331 
  def __ne__(self, other):
7332 
    return not (self == other)
7333 
 
3064 chandransh 7334 
class getOrdersForCustomer_args:
1149 chandransh 7335 
  """
7336 
  Attributes:
3064 chandransh 7337 
   - customerId
7338 
   - from_date
7339 
   - to_date
7340 
   - statuses
1149 chandransh 7341 
  """
7342 
 
7343 
  thrift_spec = (
7344 
    None, # 0
3064 chandransh 7345 
    (1, TType.I64, 'customerId', None, None, ), # 1
7346 
    (2, TType.I64, 'from_date', None, None, ), # 2
7347 
    (3, TType.I64, 'to_date', None, None, ), # 3
7348 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 7349 
  )
7350 
 
3064 chandransh 7351 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
7352 
    self.customerId = customerId
7353 
    self.from_date = from_date
7354 
    self.to_date = to_date
7355 
    self.statuses = statuses
1149 chandransh 7356 
 
7357 
  def read(self, iprot):
7358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7360 
      return
7361 
    iprot.readStructBegin()
7362 
    while True:
7363 
      (fname, ftype, fid) = iprot.readFieldBegin()
7364 
      if ftype == TType.STOP:
7365 
        break
7366 
      if fid == 1:
7367 
        if ftype == TType.I64:
3064 chandransh 7368 
          self.customerId = iprot.readI64();
1149 chandransh 7369 
        else:
7370 
          iprot.skip(ftype)
7371 
      elif fid == 2:
7372 
        if ftype == TType.I64:
3064 chandransh 7373 
          self.from_date = iprot.readI64();
1149 chandransh 7374 
        else:
7375 
          iprot.skip(ftype)
2783 chandransh 7376 
      elif fid == 3:
7377 
        if ftype == TType.I64:
3064 chandransh 7378 
          self.to_date = iprot.readI64();
2783 chandransh 7379 
        else:
7380 
          iprot.skip(ftype)
7381 
      elif fid == 4:
3064 chandransh 7382 
        if ftype == TType.LIST:
7383 
          self.statuses = []
4133 chandransh 7384 
          (_etype94, _size91) = iprot.readListBegin()
7385 
          for _i95 in xrange(_size91):
7386 
            _elem96 = iprot.readI32();
7387 
            self.statuses.append(_elem96)
3064 chandransh 7388 
          iprot.readListEnd()
2783 chandransh 7389 
        else:
7390 
          iprot.skip(ftype)
1149 chandransh 7391 
      else:
7392 
        iprot.skip(ftype)
7393 
      iprot.readFieldEnd()
7394 
    iprot.readStructEnd()
7395 
 
7396 
  def write(self, oprot):
7397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7399 
      return
3064 chandransh 7400 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 7401 
    if self.customerId is not None:
3064 chandransh 7402 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7403 
      oprot.writeI64(self.customerId)
1149 chandransh 7404 
      oprot.writeFieldEnd()
3431 rajveer 7405 
    if self.from_date is not None:
3064 chandransh 7406 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7407 
      oprot.writeI64(self.from_date)
1149 chandransh 7408 
      oprot.writeFieldEnd()
3431 rajveer 7409 
    if self.to_date is not None:
3064 chandransh 7410 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7411 
      oprot.writeI64(self.to_date)
2783 chandransh 7412 
      oprot.writeFieldEnd()
3431 rajveer 7413 
    if self.statuses is not None:
3064 chandransh 7414 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
7415 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 7416 
      for iter97 in self.statuses:
7417 
        oprot.writeI32(iter97)
3064 chandransh 7418 
      oprot.writeListEnd()
2783 chandransh 7419 
      oprot.writeFieldEnd()
1149 chandransh 7420 
    oprot.writeFieldStop()
7421 
    oprot.writeStructEnd()
7422 
 
3431 rajveer 7423 
  def validate(self):
7424 
    return
7425 
 
7426 
 
1149 chandransh 7427 
  def __repr__(self):
7428 
    L = ['%s=%r' % (key, value)
7429 
      for key, value in self.__dict__.iteritems()]
7430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7431 
 
7432 
  def __eq__(self, other):
7433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7434 
 
7435 
  def __ne__(self, other):
7436 
    return not (self == other)
7437 
 
3064 chandransh 7438 
class getOrdersForCustomer_result:
1149 chandransh 7439 
  """
7440 
  Attributes:
7441 
   - success
7442 
   - ex
7443 
  """
7444 
 
7445 
  thrift_spec = (
3064 chandransh 7446 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 7447 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7448 
  )
7449 
 
7450 
  def __init__(self, success=None, ex=None,):
7451 
    self.success = success
7452 
    self.ex = ex
7453 
 
7454 
  def read(self, iprot):
7455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7457 
      return
7458 
    iprot.readStructBegin()
7459 
    while True:
7460 
      (fname, ftype, fid) = iprot.readFieldBegin()
7461 
      if ftype == TType.STOP:
7462 
        break
7463 
      if fid == 0:
3064 chandransh 7464 
        if ftype == TType.LIST:
7465 
          self.success = []
4133 chandransh 7466 
          (_etype101, _size98) = iprot.readListBegin()
7467 
          for _i102 in xrange(_size98):
7468 
            _elem103 = Order()
7469 
            _elem103.read(iprot)
7470 
            self.success.append(_elem103)
3064 chandransh 7471 
          iprot.readListEnd()
1149 chandransh 7472 
        else:
7473 
          iprot.skip(ftype)
7474 
      elif fid == 1:
7475 
        if ftype == TType.STRUCT:
7476 
          self.ex = TransactionServiceException()
7477 
          self.ex.read(iprot)
7478 
        else:
7479 
          iprot.skip(ftype)
7480 
      else:
7481 
        iprot.skip(ftype)
7482 
      iprot.readFieldEnd()
7483 
    iprot.readStructEnd()
7484 
 
7485 
  def write(self, oprot):
7486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7488 
      return
3064 chandransh 7489 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 7490 
    if self.success is not None:
3064 chandransh 7491 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7492 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7493 
      for iter104 in self.success:
7494 
        iter104.write(oprot)
3064 chandransh 7495 
      oprot.writeListEnd()
1149 chandransh 7496 
      oprot.writeFieldEnd()
3431 rajveer 7497 
    if self.ex is not None:
1149 chandransh 7498 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7499 
      self.ex.write(oprot)
7500 
      oprot.writeFieldEnd()
7501 
    oprot.writeFieldStop()
7502 
    oprot.writeStructEnd()
7503 
 
3431 rajveer 7504 
  def validate(self):
7505 
    return
7506 
 
7507 
 
1149 chandransh 7508 
  def __repr__(self):
7509 
    L = ['%s=%r' % (key, value)
7510 
      for key, value in self.__dict__.iteritems()]
7511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7512 
 
7513 
  def __eq__(self, other):
7514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7515 
 
7516 
  def __ne__(self, other):
7517 
    return not (self == other)
7518 
 
3064 chandransh 7519 
class createOrder_args:
921 rajveer 7520 
  """
7521 
  Attributes:
3064 chandransh 7522 
   - order
921 rajveer 7523 
  """
7524 
 
7525 
  thrift_spec = (
7526 
    None, # 0
3064 chandransh 7527 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 7528 
  )
7529 
 
3064 chandransh 7530 
  def __init__(self, order=None,):
7531 
    self.order = order
921 rajveer 7532 
 
7533 
  def read(self, iprot):
7534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7536 
      return
7537 
    iprot.readStructBegin()
7538 
    while True:
7539 
      (fname, ftype, fid) = iprot.readFieldBegin()
7540 
      if ftype == TType.STOP:
7541 
        break
7542 
      if fid == 1:
3064 chandransh 7543 
        if ftype == TType.STRUCT:
7544 
          self.order = Order()
7545 
          self.order.read(iprot)
921 rajveer 7546 
        else:
7547 
          iprot.skip(ftype)
7548 
      else:
7549 
        iprot.skip(ftype)
7550 
      iprot.readFieldEnd()
7551 
    iprot.readStructEnd()
7552 
 
7553 
  def write(self, oprot):
7554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7556 
      return
3064 chandransh 7557 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 7558 
    if self.order is not None:
3064 chandransh 7559 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
7560 
      self.order.write(oprot)
921 rajveer 7561 
      oprot.writeFieldEnd()
7562 
    oprot.writeFieldStop()
7563 
    oprot.writeStructEnd()
7564 
 
3431 rajveer 7565 
  def validate(self):
7566 
    return
7567 
 
7568 
 
921 rajveer 7569 
  def __repr__(self):
7570 
    L = ['%s=%r' % (key, value)
7571 
      for key, value in self.__dict__.iteritems()]
7572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7573 
 
7574 
  def __eq__(self, other):
7575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7576 
 
7577 
  def __ne__(self, other):
7578 
    return not (self == other)
7579 
 
3064 chandransh 7580 
class createOrder_result:
921 rajveer 7581 
  """
7582 
  Attributes:
7583 
   - success
7584 
   - ex
7585 
  """
7586 
 
7587 
  thrift_spec = (
3064 chandransh 7588 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 7589 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7590 
  )
7591 
 
7592 
  def __init__(self, success=None, ex=None,):
7593 
    self.success = success
7594 
    self.ex = ex
7595 
 
7596 
  def read(self, iprot):
7597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7599 
      return
7600 
    iprot.readStructBegin()
7601 
    while True:
7602 
      (fname, ftype, fid) = iprot.readFieldBegin()
7603 
      if ftype == TType.STOP:
7604 
        break
7605 
      if fid == 0:
3064 chandransh 7606 
        if ftype == TType.I64:
7607 
          self.success = iprot.readI64();
921 rajveer 7608 
        else:
7609 
          iprot.skip(ftype)
7610 
      elif fid == 1:
7611 
        if ftype == TType.STRUCT:
7612 
          self.ex = TransactionServiceException()
7613 
          self.ex.read(iprot)
7614 
        else:
7615 
          iprot.skip(ftype)
7616 
      else:
7617 
        iprot.skip(ftype)
7618 
      iprot.readFieldEnd()
7619 
    iprot.readStructEnd()
7620 
 
7621 
  def write(self, oprot):
7622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7624 
      return
3064 chandransh 7625 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 7626 
    if self.success is not None:
3064 chandransh 7627 
      oprot.writeFieldBegin('success', TType.I64, 0)
7628 
      oprot.writeI64(self.success)
921 rajveer 7629 
      oprot.writeFieldEnd()
3431 rajveer 7630 
    if self.ex is not None:
921 rajveer 7631 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7632 
      self.ex.write(oprot)
7633 
      oprot.writeFieldEnd()
7634 
    oprot.writeFieldStop()
7635 
    oprot.writeStructEnd()
7636 
 
3431 rajveer 7637 
  def validate(self):
7638 
    return
7639 
 
7640 
 
921 rajveer 7641 
  def __repr__(self):
7642 
    L = ['%s=%r' % (key, value)
7643 
      for key, value in self.__dict__.iteritems()]
7644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7645 
 
7646 
  def __eq__(self, other):
7647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7648 
 
7649 
  def __ne__(self, other):
7650 
    return not (self == other)
7651 
 
3064 chandransh 7652 
class getOrder_args:
921 rajveer 7653 
  """
7654 
  Attributes:
3064 chandransh 7655 
   - id
921 rajveer 7656 
  """
7657 
 
7658 
  thrift_spec = (
7659 
    None, # 0
3064 chandransh 7660 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 7661 
  )
7662 
 
3064 chandransh 7663 
  def __init__(self, id=None,):
7664 
    self.id = id
921 rajveer 7665 
 
7666 
  def read(self, iprot):
7667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7669 
      return
7670 
    iprot.readStructBegin()
7671 
    while True:
7672 
      (fname, ftype, fid) = iprot.readFieldBegin()
7673 
      if ftype == TType.STOP:
7674 
        break
7675 
      if fid == 1:
7676 
        if ftype == TType.I64:
3064 chandransh 7677 
          self.id = iprot.readI64();
921 rajveer 7678 
        else:
7679 
          iprot.skip(ftype)
7680 
      else:
7681 
        iprot.skip(ftype)
7682 
      iprot.readFieldEnd()
7683 
    iprot.readStructEnd()
7684 
 
7685 
  def write(self, oprot):
7686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7688 
      return
3064 chandransh 7689 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 7690 
    if self.id is not None:
3064 chandransh 7691 
      oprot.writeFieldBegin('id', TType.I64, 1)
7692 
      oprot.writeI64(self.id)
921 rajveer 7693 
      oprot.writeFieldEnd()
7694 
    oprot.writeFieldStop()
7695 
    oprot.writeStructEnd()
7696 
 
3431 rajveer 7697 
  def validate(self):
7698 
    return
7699 
 
7700 
 
921 rajveer 7701 
  def __repr__(self):
7702 
    L = ['%s=%r' % (key, value)
7703 
      for key, value in self.__dict__.iteritems()]
7704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7705 
 
7706 
  def __eq__(self, other):
7707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7708 
 
7709 
  def __ne__(self, other):
7710 
    return not (self == other)
7711 
 
3064 chandransh 7712 
class getOrder_result:
921 rajveer 7713 
  """
7714 
  Attributes:
7715 
   - success
7716 
   - ex
7717 
  """
7718 
 
7719 
  thrift_spec = (
3064 chandransh 7720 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 7721 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7722 
  )
7723 
 
7724 
  def __init__(self, success=None, ex=None,):
7725 
    self.success = success
7726 
    self.ex = ex
7727 
 
7728 
  def read(self, iprot):
7729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7731 
      return
7732 
    iprot.readStructBegin()
7733 
    while True:
7734 
      (fname, ftype, fid) = iprot.readFieldBegin()
7735 
      if ftype == TType.STOP:
7736 
        break
7737 
      if fid == 0:
3064 chandransh 7738 
        if ftype == TType.STRUCT:
7739 
          self.success = Order()
7740 
          self.success.read(iprot)
921 rajveer 7741 
        else:
7742 
          iprot.skip(ftype)
7743 
      elif fid == 1:
7744 
        if ftype == TType.STRUCT:
7745 
          self.ex = TransactionServiceException()
7746 
          self.ex.read(iprot)
7747 
        else:
7748 
          iprot.skip(ftype)
7749 
      else:
7750 
        iprot.skip(ftype)
7751 
      iprot.readFieldEnd()
7752 
    iprot.readStructEnd()
7753 
 
7754 
  def write(self, oprot):
7755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7757 
      return
3064 chandransh 7758 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 7759 
    if self.success is not None:
3064 chandransh 7760 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7761 
      self.success.write(oprot)
921 rajveer 7762 
      oprot.writeFieldEnd()
3431 rajveer 7763 
    if self.ex is not None:
921 rajveer 7764 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7765 
      self.ex.write(oprot)
7766 
      oprot.writeFieldEnd()
7767 
    oprot.writeFieldStop()
7768 
    oprot.writeStructEnd()
7769 
 
3431 rajveer 7770 
  def validate(self):
7771 
    return
7772 
 
7773 
 
921 rajveer 7774 
  def __repr__(self):
7775 
    L = ['%s=%r' % (key, value)
7776 
      for key, value in self.__dict__.iteritems()]
7777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7778 
 
7779 
  def __eq__(self, other):
7780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7781 
 
7782 
  def __ne__(self, other):
7783 
    return not (self == other)
7784 
 
3064 chandransh 7785 
class getLineItemsForOrder_args:
94 ashish 7786 
  """
7787 
  Attributes:
3064 chandransh 7788 
   - orderId
94 ashish 7789 
  """
7790 
 
7791 
  thrift_spec = (
7792 
    None, # 0
3064 chandransh 7793 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7794 
  )
7795 
 
3064 chandransh 7796 
  def __init__(self, orderId=None,):
7797 
    self.orderId = orderId
94 ashish 7798 
 
7799 
  def read(self, iprot):
7800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7802 
      return
7803 
    iprot.readStructBegin()
7804 
    while True:
7805 
      (fname, ftype, fid) = iprot.readFieldBegin()
7806 
      if ftype == TType.STOP:
7807 
        break
7808 
      if fid == 1:
7809 
        if ftype == TType.I64:
3064 chandransh 7810 
          self.orderId = iprot.readI64();
94 ashish 7811 
        else:
7812 
          iprot.skip(ftype)
7813 
      else:
7814 
        iprot.skip(ftype)
7815 
      iprot.readFieldEnd()
7816 
    iprot.readStructEnd()
7817 
 
7818 
  def write(self, oprot):
7819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7821 
      return
3064 chandransh 7822 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7823 
    if self.orderId is not None:
3064 chandransh 7824 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7825 
      oprot.writeI64(self.orderId)
94 ashish 7826 
      oprot.writeFieldEnd()
7827 
    oprot.writeFieldStop()
7828 
    oprot.writeStructEnd()
7829 
 
3431 rajveer 7830 
  def validate(self):
7831 
    return
7832 
 
7833 
 
94 ashish 7834 
  def __repr__(self):
7835 
    L = ['%s=%r' % (key, value)
7836 
      for key, value in self.__dict__.iteritems()]
7837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7838 
 
7839 
  def __eq__(self, other):
7840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7841 
 
7842 
  def __ne__(self, other):
7843 
    return not (self == other)
7844 
 
3064 chandransh 7845 
class getLineItemsForOrder_result:
94 ashish 7846 
  """
7847 
  Attributes:
7848 
   - success
7849 
   - ex
7850 
  """
7851 
 
7852 
  thrift_spec = (
3064 chandransh 7853 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7854 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7855 
  )
7856 
 
7857 
  def __init__(self, success=None, ex=None,):
7858 
    self.success = success
7859 
    self.ex = ex
7860 
 
7861 
  def read(self, iprot):
7862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7864 
      return
7865 
    iprot.readStructBegin()
7866 
    while True:
7867 
      (fname, ftype, fid) = iprot.readFieldBegin()
7868 
      if ftype == TType.STOP:
7869 
        break
7870 
      if fid == 0:
483 rajveer 7871 
        if ftype == TType.LIST:
7872 
          self.success = []
4133 chandransh 7873 
          (_etype108, _size105) = iprot.readListBegin()
7874 
          for _i109 in xrange(_size105):
7875 
            _elem110 = LineItem()
7876 
            _elem110.read(iprot)
7877 
            self.success.append(_elem110)
483 rajveer 7878 
          iprot.readListEnd()
94 ashish 7879 
        else:
7880 
          iprot.skip(ftype)
7881 
      elif fid == 1:
7882 
        if ftype == TType.STRUCT:
7883 
          self.ex = TransactionServiceException()
7884 
          self.ex.read(iprot)
7885 
        else:
7886 
          iprot.skip(ftype)
7887 
      else:
7888 
        iprot.skip(ftype)
7889 
      iprot.readFieldEnd()
7890 
    iprot.readStructEnd()
7891 
 
7892 
  def write(self, oprot):
7893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7895 
      return
3064 chandransh 7896 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7897 
    if self.success is not None:
483 rajveer 7898 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7899 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7900 
      for iter111 in self.success:
7901 
        iter111.write(oprot)
483 rajveer 7902 
      oprot.writeListEnd()
94 ashish 7903 
      oprot.writeFieldEnd()
3431 rajveer 7904 
    if self.ex is not None:
94 ashish 7905 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7906 
      self.ex.write(oprot)
7907 
      oprot.writeFieldEnd()
7908 
    oprot.writeFieldStop()
7909 
    oprot.writeStructEnd()
7910 
 
3431 rajveer 7911 
  def validate(self):
7912 
    return
7913 
 
7914 
 
94 ashish 7915 
  def __repr__(self):
7916 
    L = ['%s=%r' % (key, value)
7917 
      for key, value in self.__dict__.iteritems()]
7918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7919 
 
7920 
  def __eq__(self, other):
7921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7922 
 
7923 
  def __ne__(self, other):
7924 
    return not (self == other)
7925 
 
3064 chandransh 7926 
class getOrderForCustomer_args:
94 ashish 7927 
  """
7928 
  Attributes:
3064 chandransh 7929 
   - orderId
483 rajveer 7930 
   - customerId
94 ashish 7931 
  """
7932 
 
7933 
  thrift_spec = (
7934 
    None, # 0
3064 chandransh 7935 
    (1, TType.I64, 'orderId', None, None, ), # 1
7936 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7937 
  )
7938 
 
3064 chandransh 7939 
  def __init__(self, orderId=None, customerId=None,):
7940 
    self.orderId = orderId
483 rajveer 7941 
    self.customerId = customerId
94 ashish 7942 
 
7943 
  def read(self, iprot):
7944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7946 
      return
7947 
    iprot.readStructBegin()
7948 
    while True:
7949 
      (fname, ftype, fid) = iprot.readFieldBegin()
7950 
      if ftype == TType.STOP:
7951 
        break
7952 
      if fid == 1:
7953 
        if ftype == TType.I64:
3064 chandransh 7954 
          self.orderId = iprot.readI64();
94 ashish 7955 
        else:
7956 
          iprot.skip(ftype)
7957 
      elif fid == 2:
7958 
        if ftype == TType.I64:
3064 chandransh 7959 
          self.customerId = iprot.readI64();
94 ashish 7960 
        else:
7961 
          iprot.skip(ftype)
7962 
      else:
7963 
        iprot.skip(ftype)
7964 
      iprot.readFieldEnd()
7965 
    iprot.readStructEnd()
7966 
 
7967 
  def write(self, oprot):
7968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7970 
      return
3064 chandransh 7971 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 7972 
    if self.orderId is not None:
3064 chandransh 7973 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7974 
      oprot.writeI64(self.orderId)
7975 
      oprot.writeFieldEnd()
3431 rajveer 7976 
    if self.customerId is not None:
3064 chandransh 7977 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7978 
      oprot.writeI64(self.customerId)
94 ashish 7979 
      oprot.writeFieldEnd()
7980 
    oprot.writeFieldStop()
7981 
    oprot.writeStructEnd()
7982 
 
3431 rajveer 7983 
  def validate(self):
7984 
    return
7985 
 
7986 
 
94 ashish 7987 
  def __repr__(self):
7988 
    L = ['%s=%r' % (key, value)
7989 
      for key, value in self.__dict__.iteritems()]
7990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7991 
 
7992 
  def __eq__(self, other):
7993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7994 
 
7995 
  def __ne__(self, other):
7996 
    return not (self == other)
7997 
 
3064 chandransh 7998 
class getOrderForCustomer_result:
94 ashish 7999 
  """
8000 
  Attributes:
8001 
   - success
8002 
   - ex
8003 
  """
8004 
 
8005 
  thrift_spec = (
3064 chandransh 8006 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 8007 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8008 
  )
8009 
 
8010 
  def __init__(self, success=None, ex=None,):
8011 
    self.success = success
8012 
    self.ex = ex
8013 
 
8014 
  def read(self, iprot):
8015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8017 
      return
8018 
    iprot.readStructBegin()
8019 
    while True:
8020 
      (fname, ftype, fid) = iprot.readFieldBegin()
8021 
      if ftype == TType.STOP:
8022 
        break
8023 
      if fid == 0:
3064 chandransh 8024 
        if ftype == TType.STRUCT:
8025 
          self.success = Order()
8026 
          self.success.read(iprot)
94 ashish 8027 
        else:
8028 
          iprot.skip(ftype)
8029 
      elif fid == 1:
8030 
        if ftype == TType.STRUCT:
8031 
          self.ex = TransactionServiceException()
8032 
          self.ex.read(iprot)
8033 
        else:
8034 
          iprot.skip(ftype)
8035 
      else:
8036 
        iprot.skip(ftype)
8037 
      iprot.readFieldEnd()
8038 
    iprot.readStructEnd()
8039 
 
8040 
  def write(self, oprot):
8041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8043 
      return
3064 chandransh 8044 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 8045 
    if self.success is not None:
3064 chandransh 8046 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8047 
      self.success.write(oprot)
94 ashish 8048 
      oprot.writeFieldEnd()
3431 rajveer 8049 
    if self.ex is not None:
94 ashish 8050 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8051 
      self.ex.write(oprot)
8052 
      oprot.writeFieldEnd()
8053 
    oprot.writeFieldStop()
8054 
    oprot.writeStructEnd()
8055 
 
3431 rajveer 8056 
  def validate(self):
8057 
    return
8058 
 
8059 
 
94 ashish 8060 
  def __repr__(self):
8061 
    L = ['%s=%r' % (key, value)
8062 
      for key, value in self.__dict__.iteritems()]
8063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8064 
 
8065 
  def __eq__(self, other):
8066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8067 
 
8068 
  def __ne__(self, other):
8069 
    return not (self == other)
8070 
 
3064 chandransh 8071 
class getAlerts_args:
94 ashish 8072 
  """
8073 
  Attributes:
4394 rajveer 8074 
   - type
4444 rajveer 8075 
   - warehouseId
4394 rajveer 8076 
   - status
8077 
   - timestamp
94 ashish 8078 
  """
8079 
 
8080 
  thrift_spec = (
8081 
    None, # 0
4394 rajveer 8082 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8083 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8084 
    (3, TType.I64, 'status', None, None, ), # 3
8085 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 8086 
  )
8087 
 
4444 rajveer 8088 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 8089 
    self.type = type
4444 rajveer 8090 
    self.warehouseId = warehouseId
4394 rajveer 8091 
    self.status = status
8092 
    self.timestamp = timestamp
94 ashish 8093 
 
8094 
  def read(self, iprot):
8095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8097 
      return
8098 
    iprot.readStructBegin()
8099 
    while True:
8100 
      (fname, ftype, fid) = iprot.readFieldBegin()
8101 
      if ftype == TType.STOP:
8102 
        break
8103 
      if fid == 1:
3064 chandransh 8104 
        if ftype == TType.I64:
4394 rajveer 8105 
          self.type = iprot.readI64();
94 ashish 8106 
        else:
8107 
          iprot.skip(ftype)
3064 chandransh 8108 
      elif fid == 2:
4394 rajveer 8109 
        if ftype == TType.I64:
4444 rajveer 8110 
          self.warehouseId = iprot.readI64();
3064 chandransh 8111 
        else:
8112 
          iprot.skip(ftype)
4394 rajveer 8113 
      elif fid == 3:
8114 
        if ftype == TType.I64:
4444 rajveer 8115 
          self.status = iprot.readI64();
8116 
        else:
8117 
          iprot.skip(ftype)
8118 
      elif fid == 4:
8119 
        if ftype == TType.I64:
4394 rajveer 8120 
          self.timestamp = iprot.readI64();
8121 
        else:
8122 
          iprot.skip(ftype)
94 ashish 8123 
      else:
8124 
        iprot.skip(ftype)
8125 
      iprot.readFieldEnd()
8126 
    iprot.readStructEnd()
8127 
 
8128 
  def write(self, oprot):
8129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8131 
      return
3064 chandransh 8132 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 8133 
    if self.type is not None:
8134 
      oprot.writeFieldBegin('type', TType.I64, 1)
8135 
      oprot.writeI64(self.type)
94 ashish 8136 
      oprot.writeFieldEnd()
4444 rajveer 8137 
    if self.warehouseId is not None:
8138 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8139 
      oprot.writeI64(self.warehouseId)
8140 
      oprot.writeFieldEnd()
4394 rajveer 8141 
    if self.status is not None:
4444 rajveer 8142 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 8143 
      oprot.writeI64(self.status)
3064 chandransh 8144 
      oprot.writeFieldEnd()
4394 rajveer 8145 
    if self.timestamp is not None:
4444 rajveer 8146 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 8147 
      oprot.writeI64(self.timestamp)
8148 
      oprot.writeFieldEnd()
94 ashish 8149 
    oprot.writeFieldStop()
8150 
    oprot.writeStructEnd()
8151 
 
3431 rajveer 8152 
  def validate(self):
8153 
    return
8154 
 
8155 
 
94 ashish 8156 
  def __repr__(self):
8157 
    L = ['%s=%r' % (key, value)
8158 
      for key, value in self.__dict__.iteritems()]
8159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8160 
 
8161 
  def __eq__(self, other):
8162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8163 
 
8164 
  def __ne__(self, other):
8165 
    return not (self == other)
8166 
 
3064 chandransh 8167 
class getAlerts_result:
94 ashish 8168 
  """
8169 
  Attributes:
8170 
   - success
8171 
  """
8172 
 
8173 
  thrift_spec = (
3064 chandransh 8174 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 8175 
  )
8176 
 
3064 chandransh 8177 
  def __init__(self, success=None,):
94 ashish 8178 
    self.success = success
8179 
 
8180 
  def read(self, iprot):
8181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8183 
      return
8184 
    iprot.readStructBegin()
8185 
    while True:
8186 
      (fname, ftype, fid) = iprot.readFieldBegin()
8187 
      if ftype == TType.STOP:
8188 
        break
8189 
      if fid == 0:
3064 chandransh 8190 
        if ftype == TType.LIST:
8191 
          self.success = []
4133 chandransh 8192 
          (_etype115, _size112) = iprot.readListBegin()
8193 
          for _i116 in xrange(_size112):
8194 
            _elem117 = Alert()
8195 
            _elem117.read(iprot)
8196 
            self.success.append(_elem117)
3064 chandransh 8197 
          iprot.readListEnd()
94 ashish 8198 
        else:
8199 
          iprot.skip(ftype)
8200 
      else:
8201 
        iprot.skip(ftype)
8202 
      iprot.readFieldEnd()
8203 
    iprot.readStructEnd()
8204 
 
8205 
  def write(self, oprot):
8206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8208 
      return
3064 chandransh 8209 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 8210 
    if self.success is not None:
3064 chandransh 8211 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8212 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8213 
      for iter118 in self.success:
8214 
        iter118.write(oprot)
3064 chandransh 8215 
      oprot.writeListEnd()
94 ashish 8216 
      oprot.writeFieldEnd()
8217 
    oprot.writeFieldStop()
8218 
    oprot.writeStructEnd()
8219 
 
3431 rajveer 8220 
  def validate(self):
8221 
    return
8222 
 
8223 
 
94 ashish 8224 
  def __repr__(self):
8225 
    L = ['%s=%r' % (key, value)
8226 
      for key, value in self.__dict__.iteritems()]
8227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8228 
 
8229 
  def __eq__(self, other):
8230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8231 
 
8232 
  def __ne__(self, other):
8233 
    return not (self == other)
8234 
 
4394 rajveer 8235 
class addAlert_args:
94 ashish 8236 
  """
8237 
  Attributes:
3064 chandransh 8238 
   - type
4444 rajveer 8239 
   - warehouseId
4394 rajveer 8240 
   - description
94 ashish 8241 
  """
8242 
 
8243 
  thrift_spec = (
8244 
    None, # 0
4394 rajveer 8245 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8246 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8247 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8248 
  )
8249 
 
4444 rajveer 8250 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 8251 
    self.type = type
4444 rajveer 8252 
    self.warehouseId = warehouseId
4394 rajveer 8253 
    self.description = description
94 ashish 8254 
 
8255 
  def read(self, iprot):
8256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8258 
      return
8259 
    iprot.readStructBegin()
8260 
    while True:
8261 
      (fname, ftype, fid) = iprot.readFieldBegin()
8262 
      if ftype == TType.STOP:
8263 
        break
8264 
      if fid == 1:
8265 
        if ftype == TType.I64:
4394 rajveer 8266 
          self.type = iprot.readI64();
94 ashish 8267 
        else:
8268 
          iprot.skip(ftype)
3064 chandransh 8269 
      elif fid == 2:
4444 rajveer 8270 
        if ftype == TType.I64:
8271 
          self.warehouseId = iprot.readI64();
8272 
        else:
8273 
          iprot.skip(ftype)
8274 
      elif fid == 3:
3064 chandransh 8275 
        if ftype == TType.STRING:
4394 rajveer 8276 
          self.description = iprot.readString();
3064 chandransh 8277 
        else:
8278 
          iprot.skip(ftype)
94 ashish 8279 
      else:
8280 
        iprot.skip(ftype)
8281 
      iprot.readFieldEnd()
8282 
    iprot.readStructEnd()
8283 
 
8284 
  def write(self, oprot):
8285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8287 
      return
4394 rajveer 8288 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 8289 
    if self.type is not None:
4394 rajveer 8290 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 8291 
      oprot.writeI64(self.type)
8292 
      oprot.writeFieldEnd()
4444 rajveer 8293 
    if self.warehouseId is not None:
8294 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8295 
      oprot.writeI64(self.warehouseId)
8296 
      oprot.writeFieldEnd()
4394 rajveer 8297 
    if self.description is not None:
4444 rajveer 8298 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 8299 
      oprot.writeString(self.description)
3064 chandransh 8300 
      oprot.writeFieldEnd()
94 ashish 8301 
    oprot.writeFieldStop()
8302 
    oprot.writeStructEnd()
8303 
 
3431 rajveer 8304 
  def validate(self):
8305 
    return
8306 
 
8307 
 
94 ashish 8308 
  def __repr__(self):
8309 
    L = ['%s=%r' % (key, value)
8310 
      for key, value in self.__dict__.iteritems()]
8311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8312 
 
8313 
  def __eq__(self, other):
8314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8315 
 
8316 
  def __ne__(self, other):
8317 
    return not (self == other)
8318 
 
4394 rajveer 8319 
class addAlert_result:
3064 chandransh 8320 
 
8321 
  thrift_spec = (
8322 
  )
8323 
 
8324 
  def read(self, iprot):
8325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8327 
      return
8328 
    iprot.readStructBegin()
8329 
    while True:
8330 
      (fname, ftype, fid) = iprot.readFieldBegin()
8331 
      if ftype == TType.STOP:
8332 
        break
8333 
      else:
8334 
        iprot.skip(ftype)
8335 
      iprot.readFieldEnd()
8336 
    iprot.readStructEnd()
8337 
 
8338 
  def write(self, oprot):
8339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8341 
      return
4394 rajveer 8342 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 8343 
    oprot.writeFieldStop()
8344 
    oprot.writeStructEnd()
8345 
 
3431 rajveer 8346 
  def validate(self):
8347 
    return
8348 
 
8349 
 
3064 chandransh 8350 
  def __repr__(self):
8351 
    L = ['%s=%r' % (key, value)
8352 
      for key, value in self.__dict__.iteritems()]
8353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8354 
 
8355 
  def __eq__(self, other):
8356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8357 
 
8358 
  def __ne__(self, other):
8359 
    return not (self == other)
8360 
 
4444 rajveer 8361 
class markAlertsAsSeen_args:
8362 
  """
8363 
  Attributes:
8364 
   - warehouseId
8365 
  """
8366 
 
8367 
  thrift_spec = (
8368 
    None, # 0
8369 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8370 
  )
8371 
 
8372 
  def __init__(self, warehouseId=None,):
8373 
    self.warehouseId = warehouseId
8374 
 
8375 
  def read(self, iprot):
8376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8378 
      return
8379 
    iprot.readStructBegin()
8380 
    while True:
8381 
      (fname, ftype, fid) = iprot.readFieldBegin()
8382 
      if ftype == TType.STOP:
8383 
        break
8384 
      if fid == 1:
8385 
        if ftype == TType.I64:
8386 
          self.warehouseId = iprot.readI64();
8387 
        else:
8388 
          iprot.skip(ftype)
8389 
      else:
8390 
        iprot.skip(ftype)
8391 
      iprot.readFieldEnd()
8392 
    iprot.readStructEnd()
8393 
 
8394 
  def write(self, oprot):
8395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8397 
      return
8398 
    oprot.writeStructBegin('markAlertsAsSeen_args')
8399 
    if self.warehouseId is not None:
8400 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8401 
      oprot.writeI64(self.warehouseId)
8402 
      oprot.writeFieldEnd()
8403 
    oprot.writeFieldStop()
8404 
    oprot.writeStructEnd()
8405 
 
8406 
  def validate(self):
8407 
    return
8408 
 
8409 
 
8410 
  def __repr__(self):
8411 
    L = ['%s=%r' % (key, value)
8412 
      for key, value in self.__dict__.iteritems()]
8413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8414 
 
8415 
  def __eq__(self, other):
8416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8417 
 
8418 
  def __ne__(self, other):
8419 
    return not (self == other)
8420 
 
8421 
class markAlertsAsSeen_result:
8422 
 
8423 
  thrift_spec = (
8424 
  )
8425 
 
8426 
  def read(self, iprot):
8427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8429 
      return
8430 
    iprot.readStructBegin()
8431 
    while True:
8432 
      (fname, ftype, fid) = iprot.readFieldBegin()
8433 
      if ftype == TType.STOP:
8434 
        break
8435 
      else:
8436 
        iprot.skip(ftype)
8437 
      iprot.readFieldEnd()
8438 
    iprot.readStructEnd()
8439 
 
8440 
  def write(self, oprot):
8441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8443 
      return
8444 
    oprot.writeStructBegin('markAlertsAsSeen_result')
8445 
    oprot.writeFieldStop()
8446 
    oprot.writeStructEnd()
8447 
 
8448 
  def validate(self):
8449 
    return
8450 
 
8451 
 
8452 
  def __repr__(self):
8453 
    L = ['%s=%r' % (key, value)
8454 
      for key, value in self.__dict__.iteritems()]
8455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8456 
 
8457 
  def __eq__(self, other):
8458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8459 
 
8460 
  def __ne__(self, other):
8461 
    return not (self == other)
8462 
 
3064 chandransh 8463 
class getValidOrderCount_args:
8464 
 
8465 
  thrift_spec = (
8466 
  )
8467 
 
8468 
  def read(self, iprot):
8469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8471 
      return
8472 
    iprot.readStructBegin()
8473 
    while True:
8474 
      (fname, ftype, fid) = iprot.readFieldBegin()
8475 
      if ftype == TType.STOP:
8476 
        break
8477 
      else:
8478 
        iprot.skip(ftype)
8479 
      iprot.readFieldEnd()
8480 
    iprot.readStructEnd()
8481 
 
8482 
  def write(self, oprot):
8483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8485 
      return
8486 
    oprot.writeStructBegin('getValidOrderCount_args')
8487 
    oprot.writeFieldStop()
8488 
    oprot.writeStructEnd()
8489 
 
3431 rajveer 8490 
  def validate(self):
8491 
    return
8492 
 
8493 
 
3064 chandransh 8494 
  def __repr__(self):
8495 
    L = ['%s=%r' % (key, value)
8496 
      for key, value in self.__dict__.iteritems()]
8497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8498 
 
8499 
  def __eq__(self, other):
8500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8501 
 
8502 
  def __ne__(self, other):
8503 
    return not (self == other)
8504 
 
8505 
class getValidOrderCount_result:
94 ashish 8506 
  """
8507 
  Attributes:
8508 
   - success
8509 
  """
8510 
 
8511 
  thrift_spec = (
3064 chandransh 8512 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8513 
  )
8514 
 
3064 chandransh 8515 
  def __init__(self, success=None,):
94 ashish 8516 
    self.success = success
8517 
 
8518 
  def read(self, iprot):
8519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8521 
      return
8522 
    iprot.readStructBegin()
8523 
    while True:
8524 
      (fname, ftype, fid) = iprot.readFieldBegin()
8525 
      if ftype == TType.STOP:
8526 
        break
8527 
      if fid == 0:
3064 chandransh 8528 
        if ftype == TType.I64:
8529 
          self.success = iprot.readI64();
94 ashish 8530 
        else:
8531 
          iprot.skip(ftype)
8532 
      else:
8533 
        iprot.skip(ftype)
8534 
      iprot.readFieldEnd()
8535 
    iprot.readStructEnd()
8536 
 
8537 
  def write(self, oprot):
8538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8540 
      return
3064 chandransh 8541 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 8542 
    if self.success is not None:
3064 chandransh 8543 
      oprot.writeFieldBegin('success', TType.I64, 0)
8544 
      oprot.writeI64(self.success)
94 ashish 8545 
      oprot.writeFieldEnd()
8546 
    oprot.writeFieldStop()
8547 
    oprot.writeStructEnd()
8548 
 
3431 rajveer 8549 
  def validate(self):
8550 
    return
8551 
 
8552 
 
94 ashish 8553 
  def __repr__(self):
8554 
    L = ['%s=%r' % (key, value)
8555 
      for key, value in self.__dict__.iteritems()]
8556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8557 
 
8558 
  def __eq__(self, other):
8559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8560 
 
8561 
  def __ne__(self, other):
8562 
    return not (self == other)
8563 
 
3064 chandransh 8564 
class getNoOfCustomersWithSuccessfulTransaction_args:
8565 
 
8566 
  thrift_spec = (
8567 
  )
8568 
 
8569 
  def read(self, iprot):
8570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8572 
      return
8573 
    iprot.readStructBegin()
8574 
    while True:
8575 
      (fname, ftype, fid) = iprot.readFieldBegin()
8576 
      if ftype == TType.STOP:
8577 
        break
8578 
      else:
8579 
        iprot.skip(ftype)
8580 
      iprot.readFieldEnd()
8581 
    iprot.readStructEnd()
8582 
 
8583 
  def write(self, oprot):
8584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8586 
      return
8587 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
8588 
    oprot.writeFieldStop()
8589 
    oprot.writeStructEnd()
8590 
 
3431 rajveer 8591 
  def validate(self):
8592 
    return
8593 
 
8594 
 
3064 chandransh 8595 
  def __repr__(self):
8596 
    L = ['%s=%r' % (key, value)
8597 
      for key, value in self.__dict__.iteritems()]
8598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8599 
 
8600 
  def __eq__(self, other):
8601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8602 
 
8603 
  def __ne__(self, other):
8604 
    return not (self == other)
8605 
 
8606 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 8607 
  """
8608 
  Attributes:
3064 chandransh 8609 
   - success
94 ashish 8610 
  """
8611 
 
8612 
  thrift_spec = (
3064 chandransh 8613 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8614 
  )
8615 
 
3064 chandransh 8616 
  def __init__(self, success=None,):
8617 
    self.success = success
94 ashish 8618 
 
8619 
  def read(self, iprot):
8620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8622 
      return
8623 
    iprot.readStructBegin()
8624 
    while True:
8625 
      (fname, ftype, fid) = iprot.readFieldBegin()
8626 
      if ftype == TType.STOP:
8627 
        break
3064 chandransh 8628 
      if fid == 0:
94 ashish 8629 
        if ftype == TType.I64:
3064 chandransh 8630 
          self.success = iprot.readI64();
94 ashish 8631 
        else:
8632 
          iprot.skip(ftype)
8633 
      else:
8634 
        iprot.skip(ftype)
8635 
      iprot.readFieldEnd()
8636 
    iprot.readStructEnd()
8637 
 
8638 
  def write(self, oprot):
8639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8641 
      return
3064 chandransh 8642 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 8643 
    if self.success is not None:
3064 chandransh 8644 
      oprot.writeFieldBegin('success', TType.I64, 0)
8645 
      oprot.writeI64(self.success)
94 ashish 8646 
      oprot.writeFieldEnd()
8647 
    oprot.writeFieldStop()
8648 
    oprot.writeStructEnd()
8649 
 
3431 rajveer 8650 
  def validate(self):
8651 
    return
8652 
 
8653 
 
94 ashish 8654 
  def __repr__(self):
8655 
    L = ['%s=%r' % (key, value)
8656 
      for key, value in self.__dict__.iteritems()]
8657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8658 
 
8659 
  def __eq__(self, other):
8660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8661 
 
8662 
  def __ne__(self, other):
8663 
    return not (self == other)
8664 
 
3064 chandransh 8665 
class getValidOrdersAmountRange_args:
8666 
 
8667 
  thrift_spec = (
8668 
  )
8669 
 
8670 
  def read(self, iprot):
8671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8673 
      return
8674 
    iprot.readStructBegin()
8675 
    while True:
8676 
      (fname, ftype, fid) = iprot.readFieldBegin()
8677 
      if ftype == TType.STOP:
8678 
        break
8679 
      else:
8680 
        iprot.skip(ftype)
8681 
      iprot.readFieldEnd()
8682 
    iprot.readStructEnd()
8683 
 
8684 
  def write(self, oprot):
8685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8687 
      return
8688 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
8689 
    oprot.writeFieldStop()
8690 
    oprot.writeStructEnd()
8691 
 
3431 rajveer 8692 
  def validate(self):
8693 
    return
8694 
 
8695 
 
3064 chandransh 8696 
  def __repr__(self):
8697 
    L = ['%s=%r' % (key, value)
8698 
      for key, value in self.__dict__.iteritems()]
8699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8700 
 
8701 
  def __eq__(self, other):
8702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8703 
 
8704 
  def __ne__(self, other):
8705 
    return not (self == other)
8706 
 
8707 
class getValidOrdersAmountRange_result:
94 ashish 8708 
  """
8709 
  Attributes:
8710 
   - success
8711 
  """
8712 
 
8713 
  thrift_spec = (
3064 chandransh 8714 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 8715 
  )
8716 
 
3064 chandransh 8717 
  def __init__(self, success=None,):
94 ashish 8718 
    self.success = success
8719 
 
8720 
  def read(self, iprot):
8721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8723 
      return
8724 
    iprot.readStructBegin()
8725 
    while True:
8726 
      (fname, ftype, fid) = iprot.readFieldBegin()
8727 
      if ftype == TType.STOP:
8728 
        break
8729 
      if fid == 0:
483 rajveer 8730 
        if ftype == TType.LIST:
8731 
          self.success = []
4133 chandransh 8732 
          (_etype122, _size119) = iprot.readListBegin()
8733 
          for _i123 in xrange(_size119):
8734 
            _elem124 = iprot.readDouble();
8735 
            self.success.append(_elem124)
483 rajveer 8736 
          iprot.readListEnd()
94 ashish 8737 
        else:
8738 
          iprot.skip(ftype)
8739 
      else:
8740 
        iprot.skip(ftype)
8741 
      iprot.readFieldEnd()
8742 
    iprot.readStructEnd()
8743 
 
8744 
  def write(self, oprot):
8745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8747 
      return
3064 chandransh 8748 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 8749 
    if self.success is not None:
483 rajveer 8750 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 8751 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 8752 
      for iter125 in self.success:
8753 
        oprot.writeDouble(iter125)
483 rajveer 8754 
      oprot.writeListEnd()
94 ashish 8755 
      oprot.writeFieldEnd()
8756 
    oprot.writeFieldStop()
8757 
    oprot.writeStructEnd()
8758 
 
3431 rajveer 8759 
  def validate(self):
8760 
    return
8761 
 
8762 
 
94 ashish 8763 
  def __repr__(self):
8764 
    L = ['%s=%r' % (key, value)
8765 
      for key, value in self.__dict__.iteritems()]
8766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8767 
 
8768 
  def __eq__(self, other):
8769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8770 
 
8771 
  def __ne__(self, other):
8772 
    return not (self == other)
8773 
 
3064 chandransh 8774 
class getValidOrders_args:
1528 ankur.sing 8775 
  """
8776 
  Attributes:
3064 chandransh 8777 
   - limit
1528 ankur.sing 8778 
  """
8779 
 
8780 
  thrift_spec = (
8781 
    None, # 0
3064 chandransh 8782 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 8783 
  )
8784 
 
3064 chandransh 8785 
  def __init__(self, limit=None,):
8786 
    self.limit = limit
1528 ankur.sing 8787 
 
8788 
  def read(self, iprot):
8789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8791 
      return
8792 
    iprot.readStructBegin()
8793 
    while True:
8794 
      (fname, ftype, fid) = iprot.readFieldBegin()
8795 
      if ftype == TType.STOP:
8796 
        break
8797 
      if fid == 1:
8798 
        if ftype == TType.I64:
3064 chandransh 8799 
          self.limit = iprot.readI64();
1528 ankur.sing 8800 
        else:
8801 
          iprot.skip(ftype)
8802 
      else:
8803 
        iprot.skip(ftype)
8804 
      iprot.readFieldEnd()
8805 
    iprot.readStructEnd()
8806 
 
8807 
  def write(self, oprot):
8808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8810 
      return
3064 chandransh 8811 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 8812 
    if self.limit is not None:
3064 chandransh 8813 
      oprot.writeFieldBegin('limit', TType.I64, 1)
8814 
      oprot.writeI64(self.limit)
1528 ankur.sing 8815 
      oprot.writeFieldEnd()
8816 
    oprot.writeFieldStop()
8817 
    oprot.writeStructEnd()
8818 
 
3431 rajveer 8819 
  def validate(self):
8820 
    return
8821 
 
8822 
 
1528 ankur.sing 8823 
  def __repr__(self):
8824 
    L = ['%s=%r' % (key, value)
8825 
      for key, value in self.__dict__.iteritems()]
8826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8827 
 
8828 
  def __eq__(self, other):
8829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8830 
 
8831 
  def __ne__(self, other):
8832 
    return not (self == other)
8833 
 
3064 chandransh 8834 
class getValidOrders_result:
1528 ankur.sing 8835 
  """
8836 
  Attributes:
8837 
   - success
8838 
  """
8839 
 
8840 
  thrift_spec = (
3064 chandransh 8841 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 8842 
  )
8843 
 
3064 chandransh 8844 
  def __init__(self, success=None,):
1528 ankur.sing 8845 
    self.success = success
8846 
 
8847 
  def read(self, iprot):
8848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8850 
      return
8851 
    iprot.readStructBegin()
8852 
    while True:
8853 
      (fname, ftype, fid) = iprot.readFieldBegin()
8854 
      if ftype == TType.STOP:
8855 
        break
8856 
      if fid == 0:
3064 chandransh 8857 
        if ftype == TType.LIST:
8858 
          self.success = []
4133 chandransh 8859 
          (_etype129, _size126) = iprot.readListBegin()
8860 
          for _i130 in xrange(_size126):
8861 
            _elem131 = Order()
8862 
            _elem131.read(iprot)
8863 
            self.success.append(_elem131)
3064 chandransh 8864 
          iprot.readListEnd()
1528 ankur.sing 8865 
        else:
8866 
          iprot.skip(ftype)
8867 
      else:
8868 
        iprot.skip(ftype)
8869 
      iprot.readFieldEnd()
8870 
    iprot.readStructEnd()
8871 
 
8872 
  def write(self, oprot):
8873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8875 
      return
3064 chandransh 8876 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 8877 
    if self.success is not None:
3064 chandransh 8878 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8879 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8880 
      for iter132 in self.success:
8881 
        iter132.write(oprot)
3064 chandransh 8882 
      oprot.writeListEnd()
1528 ankur.sing 8883 
      oprot.writeFieldEnd()
8884 
    oprot.writeFieldStop()
8885 
    oprot.writeStructEnd()
8886 
 
3431 rajveer 8887 
  def validate(self):
8888 
    return
8889 
 
8890 
 
1528 ankur.sing 8891 
  def __repr__(self):
8892 
    L = ['%s=%r' % (key, value)
8893 
      for key, value in self.__dict__.iteritems()]
8894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8895 
 
8896 
  def __eq__(self, other):
8897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8898 
 
8899 
  def __ne__(self, other):
8900 
    return not (self == other)
8901 
 
1220 chandransh 8902 
class batchOrders_args:
8903 
  """
8904 
  Attributes:
8905 
   - warehouseId
8906 
  """
8907 
 
8908 
  thrift_spec = (
8909 
    None, # 0
8910 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8911 
  )
8912 
 
8913 
  def __init__(self, warehouseId=None,):
8914 
    self.warehouseId = warehouseId
8915 
 
8916 
  def read(self, iprot):
8917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8919 
      return
8920 
    iprot.readStructBegin()
8921 
    while True:
8922 
      (fname, ftype, fid) = iprot.readFieldBegin()
8923 
      if ftype == TType.STOP:
8924 
        break
8925 
      if fid == 1:
8926 
        if ftype == TType.I64:
8927 
          self.warehouseId = iprot.readI64();
8928 
        else:
8929 
          iprot.skip(ftype)
8930 
      else:
8931 
        iprot.skip(ftype)
8932 
      iprot.readFieldEnd()
8933 
    iprot.readStructEnd()
8934 
 
8935 
  def write(self, oprot):
8936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8938 
      return
8939 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 8940 
    if self.warehouseId is not None:
1220 chandransh 8941 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8942 
      oprot.writeI64(self.warehouseId)
8943 
      oprot.writeFieldEnd()
8944 
    oprot.writeFieldStop()
8945 
    oprot.writeStructEnd()
8946 
 
3431 rajveer 8947 
  def validate(self):
8948 
    return
8949 
 
8950 
 
1220 chandransh 8951 
  def __repr__(self):
8952 
    L = ['%s=%r' % (key, value)
8953 
      for key, value in self.__dict__.iteritems()]
8954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8955 
 
8956 
  def __eq__(self, other):
8957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8958 
 
8959 
  def __ne__(self, other):
8960 
    return not (self == other)
8961 
 
8962 
class batchOrders_result:
8963 
  """
8964 
  Attributes:
8965 
   - success
8966 
   - ex
8967 
  """
8968 
 
8969 
  thrift_spec = (
8970 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8971 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8972 
  )
8973 
 
8974 
  def __init__(self, success=None, ex=None,):
8975 
    self.success = success
8976 
    self.ex = ex
8977 
 
8978 
  def read(self, iprot):
8979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8981 
      return
8982 
    iprot.readStructBegin()
8983 
    while True:
8984 
      (fname, ftype, fid) = iprot.readFieldBegin()
8985 
      if ftype == TType.STOP:
8986 
        break
8987 
      if fid == 0:
8988 
        if ftype == TType.LIST:
8989 
          self.success = []
4133 chandransh 8990 
          (_etype136, _size133) = iprot.readListBegin()
8991 
          for _i137 in xrange(_size133):
8992 
            _elem138 = Order()
8993 
            _elem138.read(iprot)
8994 
            self.success.append(_elem138)
1220 chandransh 8995 
          iprot.readListEnd()
8996 
        else:
8997 
          iprot.skip(ftype)
8998 
      elif fid == 1:
8999 
        if ftype == TType.STRUCT:
9000 
          self.ex = TransactionServiceException()
9001 
          self.ex.read(iprot)
9002 
        else:
9003 
          iprot.skip(ftype)
9004 
      else:
9005 
        iprot.skip(ftype)
9006 
      iprot.readFieldEnd()
9007 
    iprot.readStructEnd()
9008 
 
9009 
  def write(self, oprot):
9010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9012 
      return
9013 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 9014 
    if self.success is not None:
1220 chandransh 9015 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9016 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9017 
      for iter139 in self.success:
9018 
        iter139.write(oprot)
1220 chandransh 9019 
      oprot.writeListEnd()
9020 
      oprot.writeFieldEnd()
3431 rajveer 9021 
    if self.ex is not None:
1220 chandransh 9022 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9023 
      self.ex.write(oprot)
9024 
      oprot.writeFieldEnd()
9025 
    oprot.writeFieldStop()
9026 
    oprot.writeStructEnd()
9027 
 
3431 rajveer 9028 
  def validate(self):
9029 
    return
9030 
 
9031 
 
1220 chandransh 9032 
  def __repr__(self):
9033 
    L = ['%s=%r' % (key, value)
9034 
      for key, value in self.__dict__.iteritems()]
9035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9036 
 
9037 
  def __eq__(self, other):
9038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9039 
 
9040 
  def __ne__(self, other):
9041 
    return not (self == other)
9042 
 
1208 chandransh 9043 
class markOrderAsOutOfStock_args:
9044 
  """
9045 
  Attributes:
9046 
   - orderId
9047 
  """
9048 
 
9049 
  thrift_spec = (
9050 
    None, # 0
9051 
    (1, TType.I64, 'orderId', None, None, ), # 1
9052 
  )
9053 
 
9054 
  def __init__(self, orderId=None,):
9055 
    self.orderId = orderId
9056 
 
9057 
  def read(self, iprot):
9058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9060 
      return
9061 
    iprot.readStructBegin()
9062 
    while True:
9063 
      (fname, ftype, fid) = iprot.readFieldBegin()
9064 
      if ftype == TType.STOP:
9065 
        break
9066 
      if fid == 1:
9067 
        if ftype == TType.I64:
9068 
          self.orderId = iprot.readI64();
9069 
        else:
9070 
          iprot.skip(ftype)
9071 
      else:
9072 
        iprot.skip(ftype)
9073 
      iprot.readFieldEnd()
9074 
    iprot.readStructEnd()
9075 
 
9076 
  def write(self, oprot):
9077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9079 
      return
9080 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 9081 
    if self.orderId is not None:
1208 chandransh 9082 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9083 
      oprot.writeI64(self.orderId)
9084 
      oprot.writeFieldEnd()
9085 
    oprot.writeFieldStop()
9086 
    oprot.writeStructEnd()
9087 
 
3431 rajveer 9088 
  def validate(self):
9089 
    return
9090 
 
9091 
 
1208 chandransh 9092 
  def __repr__(self):
9093 
    L = ['%s=%r' % (key, value)
9094 
      for key, value in self.__dict__.iteritems()]
9095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9096 
 
9097 
  def __eq__(self, other):
9098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9099 
 
9100 
  def __ne__(self, other):
9101 
    return not (self == other)
9102 
 
9103 
class markOrderAsOutOfStock_result:
9104 
  """
9105 
  Attributes:
9106 
   - success
9107 
   - ex
9108 
  """
9109 
 
9110 
  thrift_spec = (
9111 
    (0, TType.BOOL, 'success', None, None, ), # 0
9112 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9113 
  )
9114 
 
9115 
  def __init__(self, success=None, ex=None,):
9116 
    self.success = success
9117 
    self.ex = ex
9118 
 
9119 
  def read(self, iprot):
9120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9122 
      return
9123 
    iprot.readStructBegin()
9124 
    while True:
9125 
      (fname, ftype, fid) = iprot.readFieldBegin()
9126 
      if ftype == TType.STOP:
9127 
        break
9128 
      if fid == 0:
9129 
        if ftype == TType.BOOL:
9130 
          self.success = iprot.readBool();
9131 
        else:
9132 
          iprot.skip(ftype)
9133 
      elif fid == 1:
9134 
        if ftype == TType.STRUCT:
9135 
          self.ex = TransactionServiceException()
9136 
          self.ex.read(iprot)
9137 
        else:
9138 
          iprot.skip(ftype)
9139 
      else:
9140 
        iprot.skip(ftype)
9141 
      iprot.readFieldEnd()
9142 
    iprot.readStructEnd()
9143 
 
9144 
  def write(self, oprot):
9145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9147 
      return
9148 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 9149 
    if self.success is not None:
1208 chandransh 9150 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9151 
      oprot.writeBool(self.success)
9152 
      oprot.writeFieldEnd()
3431 rajveer 9153 
    if self.ex is not None:
1208 chandransh 9154 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9155 
      self.ex.write(oprot)
9156 
      oprot.writeFieldEnd()
9157 
    oprot.writeFieldStop()
9158 
    oprot.writeStructEnd()
9159 
 
3431 rajveer 9160 
  def validate(self):
9161 
    return
9162 
 
9163 
 
1208 chandransh 9164 
  def __repr__(self):
9165 
    L = ['%s=%r' % (key, value)
9166 
      for key, value in self.__dict__.iteritems()]
9167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9168 
 
9169 
  def __eq__(self, other):
9170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9171 
 
9172 
  def __ne__(self, other):
9173 
    return not (self == other)
9174 
 
3064 chandransh 9175 
class verifyOrder_args:
759 chandransh 9176 
  """
9177 
  Attributes:
3064 chandransh 9178 
   - orderId
759 chandransh 9179 
  """
9180 
 
9181 
  thrift_spec = (
9182 
    None, # 0
3064 chandransh 9183 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 9184 
  )
9185 
 
3064 chandransh 9186 
  def __init__(self, orderId=None,):
9187 
    self.orderId = orderId
759 chandransh 9188 
 
9189 
  def read(self, iprot):
9190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9192 
      return
9193 
    iprot.readStructBegin()
9194 
    while True:
9195 
      (fname, ftype, fid) = iprot.readFieldBegin()
9196 
      if ftype == TType.STOP:
9197 
        break
9198 
      if fid == 1:
9199 
        if ftype == TType.I64:
3064 chandransh 9200 
          self.orderId = iprot.readI64();
759 chandransh 9201 
        else:
9202 
          iprot.skip(ftype)
9203 
      else:
9204 
        iprot.skip(ftype)
9205 
      iprot.readFieldEnd()
9206 
    iprot.readStructEnd()
9207 
 
9208 
  def write(self, oprot):
9209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9211 
      return
3064 chandransh 9212 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 9213 
    if self.orderId is not None:
3064 chandransh 9214 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9215 
      oprot.writeI64(self.orderId)
759 chandransh 9216 
      oprot.writeFieldEnd()
9217 
    oprot.writeFieldStop()
9218 
    oprot.writeStructEnd()
9219 
 
3431 rajveer 9220 
  def validate(self):
9221 
    return
9222 
 
9223 
 
759 chandransh 9224 
  def __repr__(self):
9225 
    L = ['%s=%r' % (key, value)
9226 
      for key, value in self.__dict__.iteritems()]
9227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9228 
 
9229 
  def __eq__(self, other):
9230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9231 
 
9232 
  def __ne__(self, other):
9233 
    return not (self == other)
9234 
 
3064 chandransh 9235 
class verifyOrder_result:
759 chandransh 9236 
  """
9237 
  Attributes:
9238 
   - success
9239 
   - ex
9240 
  """
9241 
 
9242 
  thrift_spec = (
9243 
    (0, TType.BOOL, 'success', None, None, ), # 0
9244 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9245 
  )
9246 
 
9247 
  def __init__(self, success=None, ex=None,):
9248 
    self.success = success
9249 
    self.ex = ex
9250 
 
9251 
  def read(self, iprot):
9252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9254 
      return
9255 
    iprot.readStructBegin()
9256 
    while True:
9257 
      (fname, ftype, fid) = iprot.readFieldBegin()
9258 
      if ftype == TType.STOP:
9259 
        break
9260 
      if fid == 0:
9261 
        if ftype == TType.BOOL:
9262 
          self.success = iprot.readBool();
9263 
        else:
9264 
          iprot.skip(ftype)
9265 
      elif fid == 1:
9266 
        if ftype == TType.STRUCT:
9267 
          self.ex = TransactionServiceException()
9268 
          self.ex.read(iprot)
9269 
        else:
9270 
          iprot.skip(ftype)
9271 
      else:
9272 
        iprot.skip(ftype)
9273 
      iprot.readFieldEnd()
9274 
    iprot.readStructEnd()
9275 
 
9276 
  def write(self, oprot):
9277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9279 
      return
3064 chandransh 9280 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 9281 
    if self.success is not None:
759 chandransh 9282 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9283 
      oprot.writeBool(self.success)
9284 
      oprot.writeFieldEnd()
3431 rajveer 9285 
    if self.ex is not None:
759 chandransh 9286 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9287 
      self.ex.write(oprot)
9288 
      oprot.writeFieldEnd()
9289 
    oprot.writeFieldStop()
9290 
    oprot.writeStructEnd()
9291 
 
3431 rajveer 9292 
  def validate(self):
9293 
    return
9294 
 
9295 
 
759 chandransh 9296 
  def __repr__(self):
9297 
    L = ['%s=%r' % (key, value)
9298 
      for key, value in self.__dict__.iteritems()]
9299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9300 
 
9301 
  def __eq__(self, other):
9302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9303 
 
9304 
  def __ne__(self, other):
9305 
    return not (self == other)
9306 
 
3064 chandransh 9307 
class acceptOrder_args:
1113 chandransh 9308 
  """
9309 
  Attributes:
3064 chandransh 9310 
   - orderId
1113 chandransh 9311 
  """
9312 
 
9313 
  thrift_spec = (
9314 
    None, # 0
3064 chandransh 9315 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 9316 
  )
9317 
 
3064 chandransh 9318 
  def __init__(self, orderId=None,):
9319 
    self.orderId = orderId
1113 chandransh 9320 
 
9321 
  def read(self, iprot):
9322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9324 
      return
9325 
    iprot.readStructBegin()
9326 
    while True:
9327 
      (fname, ftype, fid) = iprot.readFieldBegin()
9328 
      if ftype == TType.STOP:
9329 
        break
9330 
      if fid == 1:
9331 
        if ftype == TType.I64:
3064 chandransh 9332 
          self.orderId = iprot.readI64();
1113 chandransh 9333 
        else:
9334 
          iprot.skip(ftype)
9335 
      else:
9336 
        iprot.skip(ftype)
9337 
      iprot.readFieldEnd()
9338 
    iprot.readStructEnd()
9339 
 
9340 
  def write(self, oprot):
9341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9343 
      return
3064 chandransh 9344 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 9345 
    if self.orderId is not None:
3064 chandransh 9346 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9347 
      oprot.writeI64(self.orderId)
1113 chandransh 9348 
      oprot.writeFieldEnd()
9349 
    oprot.writeFieldStop()
9350 
    oprot.writeStructEnd()
9351 
 
3431 rajveer 9352 
  def validate(self):
9353 
    return
9354 
 
9355 
 
1113 chandransh 9356 
  def __repr__(self):
9357 
    L = ['%s=%r' % (key, value)
9358 
      for key, value in self.__dict__.iteritems()]
9359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9360 
 
9361 
  def __eq__(self, other):
9362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9363 
 
9364 
  def __ne__(self, other):
9365 
    return not (self == other)
9366 
 
3064 chandransh 9367 
class acceptOrder_result:
1113 chandransh 9368 
  """
9369 
  Attributes:
9370 
   - success
9371 
   - ex
9372 
  """
9373 
 
9374 
  thrift_spec = (
3064 chandransh 9375 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 9376 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9377 
  )
9378 
 
9379 
  def __init__(self, success=None, ex=None,):
9380 
    self.success = success
9381 
    self.ex = ex
9382 
 
9383 
  def read(self, iprot):
9384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9386 
      return
9387 
    iprot.readStructBegin()
9388 
    while True:
9389 
      (fname, ftype, fid) = iprot.readFieldBegin()
9390 
      if ftype == TType.STOP:
9391 
        break
9392 
      if fid == 0:
3064 chandransh 9393 
        if ftype == TType.BOOL:
9394 
          self.success = iprot.readBool();
1113 chandransh 9395 
        else:
9396 
          iprot.skip(ftype)
9397 
      elif fid == 1:
9398 
        if ftype == TType.STRUCT:
9399 
          self.ex = TransactionServiceException()
9400 
          self.ex.read(iprot)
9401 
        else:
9402 
          iprot.skip(ftype)
9403 
      else:
9404 
        iprot.skip(ftype)
9405 
      iprot.readFieldEnd()
9406 
    iprot.readStructEnd()
9407 
 
9408 
  def write(self, oprot):
9409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9411 
      return
3064 chandransh 9412 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 9413 
    if self.success is not None:
3064 chandransh 9414 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9415 
      oprot.writeBool(self.success)
1113 chandransh 9416 
      oprot.writeFieldEnd()
3431 rajveer 9417 
    if self.ex is not None:
1113 chandransh 9418 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9419 
      self.ex.write(oprot)
9420 
      oprot.writeFieldEnd()
9421 
    oprot.writeFieldStop()
9422 
    oprot.writeStructEnd()
9423 
 
3431 rajveer 9424 
  def validate(self):
9425 
    return
9426 
 
9427 
 
1113 chandransh 9428 
  def __repr__(self):
9429 
    L = ['%s=%r' % (key, value)
9430 
      for key, value in self.__dict__.iteritems()]
9431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9432 
 
9433 
  def __eq__(self, other):
9434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9435 
 
9436 
  def __ne__(self, other):
9437 
    return not (self == other)
9438 
 
3064 chandransh 9439 
class addBillingDetails_args:
1135 chandransh 9440 
  """
9441 
  Attributes:
3064 chandransh 9442 
   - orderId
9443 
   - invoice_number
4283 anupam.sin 9444 
   - imeiNumber
9445 
   - itemNumber
3064 chandransh 9446 
   - billed_by
4264 rajveer 9447 
   - jacketNumber
4283 anupam.sin 9448 
   - billingType
9449 
   - vendorId
1135 chandransh 9450 
  """
9451 
 
9452 
  thrift_spec = (
9453 
    None, # 0
3064 chandransh 9454 
    (1, TType.I64, 'orderId', None, None, ), # 1
9455 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 9456 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
9457 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
9458 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
9459 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
9460 
    (7, TType.I64, 'billingType', None, None, ), # 7
9461 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 9462 
  )
9463 
 
4283 anupam.sin 9464 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 9465 
    self.orderId = orderId
9466 
    self.invoice_number = invoice_number
4283 anupam.sin 9467 
    self.imeiNumber = imeiNumber
9468 
    self.itemNumber = itemNumber
3064 chandransh 9469 
    self.billed_by = billed_by
4264 rajveer 9470 
    self.jacketNumber = jacketNumber
4283 anupam.sin 9471 
    self.billingType = billingType
9472 
    self.vendorId = vendorId
1135 chandransh 9473 
 
9474 
  def read(self, iprot):
9475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9477 
      return
9478 
    iprot.readStructBegin()
9479 
    while True:
9480 
      (fname, ftype, fid) = iprot.readFieldBegin()
9481 
      if ftype == TType.STOP:
9482 
        break
9483 
      if fid == 1:
9484 
        if ftype == TType.I64:
3064 chandransh 9485 
          self.orderId = iprot.readI64();
1135 chandransh 9486 
        else:
9487 
          iprot.skip(ftype)
9488 
      elif fid == 2:
3064 chandransh 9489 
        if ftype == TType.STRING:
9490 
          self.invoice_number = iprot.readString();
1135 chandransh 9491 
        else:
9492 
          iprot.skip(ftype)
3064 chandransh 9493 
      elif fid == 3:
4264 rajveer 9494 
        if ftype == TType.I64:
3064 chandransh 9495 
          self.imeiNumber = iprot.readI64();
9496 
        else:
9497 
          iprot.skip(ftype)
9498 
      elif fid == 4:
9499 
        if ftype == TType.STRING:
9500 
          self.itemNumber = iprot.readString();
9501 
        else:
9502 
          iprot.skip(ftype)
9503 
      elif fid == 5:
9504 
        if ftype == TType.STRING:
4283 anupam.sin 9505 
          self.billed_by = iprot.readString();
3064 chandransh 9506 
        else:
9507 
          iprot.skip(ftype)
9508 
      elif fid == 6:
9509 
        if ftype == TType.I64:
4283 anupam.sin 9510 
          self.jacketNumber = iprot.readI64();
9511 
        else:
9512 
          iprot.skip(ftype)
9513 
      elif fid == 7:
9514 
        if ftype == TType.I64:
3064 chandransh 9515 
          self.billingType = iprot.readI64();
9516 
        else:
9517 
          iprot.skip(ftype)
4283 anupam.sin 9518 
      elif fid == 8:
9519 
        if ftype == TType.I64:
9520 
          self.vendorId = iprot.readI64();
9521 
        else:
9522 
          iprot.skip(ftype)
1246 chandransh 9523 
      else:
9524 
        iprot.skip(ftype)
9525 
      iprot.readFieldEnd()
9526 
    iprot.readStructEnd()
9527 
 
9528 
  def write(self, oprot):
9529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9531 
      return
4283 anupam.sin 9532 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 9533 
    if self.orderId is not None:
3064 chandransh 9534 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9535 
      oprot.writeI64(self.orderId)
1246 chandransh 9536 
      oprot.writeFieldEnd()
4283 anupam.sin 9537 
    if self.invoice_number is not None:
9538 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
9539 
      oprot.writeString(self.invoice_number)
1246 chandransh 9540 
      oprot.writeFieldEnd()
3431 rajveer 9541 
    if self.imeiNumber is not None:
3064 chandransh 9542 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
9543 
      oprot.writeI64(self.imeiNumber)
9544 
      oprot.writeFieldEnd()
3431 rajveer 9545 
    if self.itemNumber is not None:
3064 chandransh 9546 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
9547 
      oprot.writeString(self.itemNumber)
9548 
      oprot.writeFieldEnd()
4283 anupam.sin 9549 
    if self.billed_by is not None:
9550 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
9551 
      oprot.writeString(self.billed_by)
3064 chandransh 9552 
      oprot.writeFieldEnd()
4283 anupam.sin 9553 
    if self.jacketNumber is not None:
9554 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
9555 
      oprot.writeI64(self.jacketNumber)
9556 
      oprot.writeFieldEnd()
3431 rajveer 9557 
    if self.billingType is not None:
4283 anupam.sin 9558 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 9559 
      oprot.writeI64(self.billingType)
9560 
      oprot.writeFieldEnd()
4283 anupam.sin 9561 
    if self.vendorId is not None:
9562 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
9563 
      oprot.writeI64(self.vendorId)
9564 
      oprot.writeFieldEnd()
1246 chandransh 9565 
    oprot.writeFieldStop()
9566 
    oprot.writeStructEnd()
9567 
 
3431 rajveer 9568 
  def validate(self):
9569 
    return
9570 
 
9571 
 
1246 chandransh 9572 
  def __repr__(self):
9573 
    L = ['%s=%r' % (key, value)
9574 
      for key, value in self.__dict__.iteritems()]
9575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9576 
 
9577 
  def __eq__(self, other):
9578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9579 
 
9580 
  def __ne__(self, other):
9581 
    return not (self == other)
9582 
 
4283 anupam.sin 9583 
class addBillingDetails_result:
1246 chandransh 9584 
  """
9585 
  Attributes:
3064 chandransh 9586 
   - success
1246 chandransh 9587 
   - ex
9588 
  """
9589 
 
9590 
  thrift_spec = (
3064 chandransh 9591 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 9592 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9593 
  )
9594 
 
3064 chandransh 9595 
  def __init__(self, success=None, ex=None,):
9596 
    self.success = success
1246 chandransh 9597 
    self.ex = ex
9598 
 
9599 
  def read(self, iprot):
9600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9602 
      return
9603 
    iprot.readStructBegin()
9604 
    while True:
9605 
      (fname, ftype, fid) = iprot.readFieldBegin()
9606 
      if ftype == TType.STOP:
9607 
        break
3064 chandransh 9608 
      if fid == 0:
9609 
        if ftype == TType.BOOL:
9610 
          self.success = iprot.readBool();
9611 
        else:
9612 
          iprot.skip(ftype)
9613 
      elif fid == 1:
1246 chandransh 9614 
        if ftype == TType.STRUCT:
9615 
          self.ex = TransactionServiceException()
9616 
          self.ex.read(iprot)
9617 
        else:
9618 
          iprot.skip(ftype)
9619 
      else:
9620 
        iprot.skip(ftype)
9621 
      iprot.readFieldEnd()
9622 
    iprot.readStructEnd()
9623 
 
9624 
  def write(self, oprot):
9625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9627 
      return
4283 anupam.sin 9628 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 9629 
    if self.success is not None:
3064 chandransh 9630 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9631 
      oprot.writeBool(self.success)
9632 
      oprot.writeFieldEnd()
3431 rajveer 9633 
    if self.ex is not None:
1246 chandransh 9634 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9635 
      self.ex.write(oprot)
9636 
      oprot.writeFieldEnd()
9637 
    oprot.writeFieldStop()
9638 
    oprot.writeStructEnd()
9639 
 
3431 rajveer 9640 
  def validate(self):
9641 
    return
9642 
 
9643 
 
1246 chandransh 9644 
  def __repr__(self):
9645 
    L = ['%s=%r' % (key, value)
9646 
      for key, value in self.__dict__.iteritems()]
9647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9648 
 
9649 
  def __eq__(self, other):
9650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9651 
 
9652 
  def __ne__(self, other):
9653 
    return not (self == other)
9654 
 
3064 chandransh 9655 
class markOrdersAsManifested_args:
1408 ankur.sing 9656 
  """
9657 
  Attributes:
3064 chandransh 9658 
   - warehouseId
1408 ankur.sing 9659 
   - providerId
3064 chandransh 9660 
   - cod
1408 ankur.sing 9661 
  """
9662 
 
9663 
  thrift_spec = (
9664 
    None, # 0
3064 chandransh 9665 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9666 
    (2, TType.I64, 'providerId', None, None, ), # 2
9667 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 9668 
  )
9669 
 
3064 chandransh 9670 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9671 
    self.warehouseId = warehouseId
1408 ankur.sing 9672 
    self.providerId = providerId
3064 chandransh 9673 
    self.cod = cod
1408 ankur.sing 9674 
 
9675 
  def read(self, iprot):
9676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9678 
      return
9679 
    iprot.readStructBegin()
9680 
    while True:
9681 
      (fname, ftype, fid) = iprot.readFieldBegin()
9682 
      if ftype == TType.STOP:
9683 
        break
9684 
      if fid == 1:
9685 
        if ftype == TType.I64:
3064 chandransh 9686 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 9687 
        else:
9688 
          iprot.skip(ftype)
9689 
      elif fid == 2:
9690 
        if ftype == TType.I64:
3064 chandransh 9691 
          self.providerId = iprot.readI64();
1408 ankur.sing 9692 
        else:
9693 
          iprot.skip(ftype)
3064 chandransh 9694 
      elif fid == 3:
9695 
        if ftype == TType.BOOL:
9696 
          self.cod = iprot.readBool();
9697 
        else:
9698 
          iprot.skip(ftype)
1408 ankur.sing 9699 
      else:
9700 
        iprot.skip(ftype)
9701 
      iprot.readFieldEnd()
9702 
    iprot.readStructEnd()
9703 
 
9704 
  def write(self, oprot):
9705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9707 
      return
3064 chandransh 9708 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 9709 
    if self.warehouseId is not None:
3064 chandransh 9710 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9711 
      oprot.writeI64(self.warehouseId)
9712 
      oprot.writeFieldEnd()
3431 rajveer 9713 
    if self.providerId is not None:
3064 chandransh 9714 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9715 
      oprot.writeI64(self.providerId)
9716 
      oprot.writeFieldEnd()
3431 rajveer 9717 
    if self.cod is not None:
3064 chandransh 9718 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9719 
      oprot.writeBool(self.cod)
1408 ankur.sing 9720 
      oprot.writeFieldEnd()
9721 
    oprot.writeFieldStop()
9722 
    oprot.writeStructEnd()
9723 
 
3431 rajveer 9724 
  def validate(self):
9725 
    return
9726 
 
9727 
 
1408 ankur.sing 9728 
  def __repr__(self):
9729 
    L = ['%s=%r' % (key, value)
9730 
      for key, value in self.__dict__.iteritems()]
9731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9732 
 
9733 
  def __eq__(self, other):
9734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9735 
 
9736 
  def __ne__(self, other):
9737 
    return not (self == other)
9738 
 
3064 chandransh 9739 
class markOrdersAsManifested_result:
1408 ankur.sing 9740 
  """
9741 
  Attributes:
9742 
   - success
3064 chandransh 9743 
   - ex
1408 ankur.sing 9744 
  """
9745 
 
9746 
  thrift_spec = (
3064 chandransh 9747 
    (0, TType.BOOL, 'success', None, None, ), # 0
9748 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 9749 
  )
9750 
 
3064 chandransh 9751 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 9752 
    self.success = success
3064 chandransh 9753 
    self.ex = ex
1408 ankur.sing 9754 
 
9755 
  def read(self, iprot):
9756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9758 
      return
9759 
    iprot.readStructBegin()
9760 
    while True:
9761 
      (fname, ftype, fid) = iprot.readFieldBegin()
9762 
      if ftype == TType.STOP:
9763 
        break
9764 
      if fid == 0:
3064 chandransh 9765 
        if ftype == TType.BOOL:
9766 
          self.success = iprot.readBool();
1408 ankur.sing 9767 
        else:
9768 
          iprot.skip(ftype)
3064 chandransh 9769 
      elif fid == 1:
9770 
        if ftype == TType.STRUCT:
9771 
          self.ex = TransactionServiceException()
9772 
          self.ex.read(iprot)
9773 
        else:
9774 
          iprot.skip(ftype)
1408 ankur.sing 9775 
      else:
9776 
        iprot.skip(ftype)
9777 
      iprot.readFieldEnd()
9778 
    iprot.readStructEnd()
9779 
 
9780 
  def write(self, oprot):
9781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9783 
      return
3064 chandransh 9784 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 9785 
    if self.success is not None:
3064 chandransh 9786 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9787 
      oprot.writeBool(self.success)
1408 ankur.sing 9788 
      oprot.writeFieldEnd()
3431 rajveer 9789 
    if self.ex is not None:
3064 chandransh 9790 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9791 
      self.ex.write(oprot)
9792 
      oprot.writeFieldEnd()
1408 ankur.sing 9793 
    oprot.writeFieldStop()
9794 
    oprot.writeStructEnd()
9795 
 
3431 rajveer 9796 
  def validate(self):
9797 
    return
9798 
 
9799 
 
1408 ankur.sing 9800 
  def __repr__(self):
9801 
    L = ['%s=%r' % (key, value)
9802 
      for key, value in self.__dict__.iteritems()]
9803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9804 
 
9805 
  def __eq__(self, other):
9806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9807 
 
9808 
  def __ne__(self, other):
9809 
    return not (self == other)
9810 
 
4410 rajveer 9811 
class markOrdersAsShippedFromWarehouse_args:
9812 
  """
9813 
  Attributes:
9814 
   - warehouseId
9815 
   - providerId
9816 
   - cod
9817 
  """
9818 
 
9819 
  thrift_spec = (
9820 
    None, # 0
9821 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9822 
    (2, TType.I64, 'providerId', None, None, ), # 2
9823 
    (3, TType.BOOL, 'cod', None, None, ), # 3
9824 
  )
9825 
 
9826 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9827 
    self.warehouseId = warehouseId
9828 
    self.providerId = providerId
9829 
    self.cod = cod
9830 
 
9831 
  def read(self, iprot):
9832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9834 
      return
9835 
    iprot.readStructBegin()
9836 
    while True:
9837 
      (fname, ftype, fid) = iprot.readFieldBegin()
9838 
      if ftype == TType.STOP:
9839 
        break
9840 
      if fid == 1:
9841 
        if ftype == TType.I64:
9842 
          self.warehouseId = iprot.readI64();
9843 
        else:
9844 
          iprot.skip(ftype)
9845 
      elif fid == 2:
9846 
        if ftype == TType.I64:
9847 
          self.providerId = iprot.readI64();
9848 
        else:
9849 
          iprot.skip(ftype)
9850 
      elif fid == 3:
9851 
        if ftype == TType.BOOL:
9852 
          self.cod = iprot.readBool();
9853 
        else:
9854 
          iprot.skip(ftype)
9855 
      else:
9856 
        iprot.skip(ftype)
9857 
      iprot.readFieldEnd()
9858 
    iprot.readStructEnd()
9859 
 
9860 
  def write(self, oprot):
9861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9863 
      return
9864 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
9865 
    if self.warehouseId is not None:
9866 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9867 
      oprot.writeI64(self.warehouseId)
9868 
      oprot.writeFieldEnd()
9869 
    if self.providerId is not None:
9870 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
9871 
      oprot.writeI64(self.providerId)
9872 
      oprot.writeFieldEnd()
9873 
    if self.cod is not None:
9874 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9875 
      oprot.writeBool(self.cod)
9876 
      oprot.writeFieldEnd()
9877 
    oprot.writeFieldStop()
9878 
    oprot.writeStructEnd()
9879 
 
9880 
  def validate(self):
9881 
    return
9882 
 
9883 
 
9884 
  def __repr__(self):
9885 
    L = ['%s=%r' % (key, value)
9886 
      for key, value in self.__dict__.iteritems()]
9887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9888 
 
9889 
  def __eq__(self, other):
9890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9891 
 
9892 
  def __ne__(self, other):
9893 
    return not (self == other)
9894 
 
9895 
class markOrdersAsShippedFromWarehouse_result:
9896 
  """
9897 
  Attributes:
9898 
   - success
9899 
   - ex
9900 
  """
9901 
 
9902 
  thrift_spec = (
9903 
    (0, TType.BOOL, 'success', None, None, ), # 0
9904 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9905 
  )
9906 
 
9907 
  def __init__(self, success=None, ex=None,):
9908 
    self.success = success
9909 
    self.ex = ex
9910 
 
9911 
  def read(self, iprot):
9912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9914 
      return
9915 
    iprot.readStructBegin()
9916 
    while True:
9917 
      (fname, ftype, fid) = iprot.readFieldBegin()
9918 
      if ftype == TType.STOP:
9919 
        break
9920 
      if fid == 0:
9921 
        if ftype == TType.BOOL:
9922 
          self.success = iprot.readBool();
9923 
        else:
9924 
          iprot.skip(ftype)
9925 
      elif fid == 1:
9926 
        if ftype == TType.STRUCT:
9927 
          self.ex = TransactionServiceException()
9928 
          self.ex.read(iprot)
9929 
        else:
9930 
          iprot.skip(ftype)
9931 
      else:
9932 
        iprot.skip(ftype)
9933 
      iprot.readFieldEnd()
9934 
    iprot.readStructEnd()
9935 
 
9936 
  def write(self, oprot):
9937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9939 
      return
9940 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
9941 
    if self.success is not None:
9942 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9943 
      oprot.writeBool(self.success)
9944 
      oprot.writeFieldEnd()
9945 
    if self.ex is not None:
9946 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9947 
      self.ex.write(oprot)
9948 
      oprot.writeFieldEnd()
9949 
    oprot.writeFieldStop()
9950 
    oprot.writeStructEnd()
9951 
 
9952 
  def validate(self):
9953 
    return
9954 
 
9955 
 
9956 
  def __repr__(self):
9957 
    L = ['%s=%r' % (key, value)
9958 
      for key, value in self.__dict__.iteritems()]
9959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9960 
 
9961 
  def __eq__(self, other):
9962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9963 
 
9964 
  def __ne__(self, other):
9965 
    return not (self == other)
9966 
 
3064 chandransh 9967 
class markOrdersAsPickedUp_args:
304 ashish 9968 
  """
9969 
  Attributes:
3064 chandransh 9970 
   - providerId
9971 
   - pickupDetails
304 ashish 9972 
  """
94 ashish 9973 
 
304 ashish 9974 
  thrift_spec = (
9975 
    None, # 0
3064 chandransh 9976 
    (1, TType.I64, 'providerId', None, None, ), # 1
9977 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9978 
  )
9979 
 
3064 chandransh 9980 
  def __init__(self, providerId=None, pickupDetails=None,):
9981 
    self.providerId = providerId
9982 
    self.pickupDetails = pickupDetails
304 ashish 9983 
 
9984 
  def read(self, iprot):
9985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9987 
      return
9988 
    iprot.readStructBegin()
9989 
    while True:
9990 
      (fname, ftype, fid) = iprot.readFieldBegin()
9991 
      if ftype == TType.STOP:
9992 
        break
9993 
      if fid == 1:
9994 
        if ftype == TType.I64:
3064 chandransh 9995 
          self.providerId = iprot.readI64();
304 ashish 9996 
        else:
9997 
          iprot.skip(ftype)
9998 
      elif fid == 2:
3064 chandransh 9999 
        if ftype == TType.MAP:
10000 
          self.pickupDetails = {}
4133 chandransh 10001 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
10002 
          for _i144 in xrange(_size140):
10003 
            _key145 = iprot.readString();
10004 
            _val146 = iprot.readString();
10005 
            self.pickupDetails[_key145] = _val146
3064 chandransh 10006 
          iprot.readMapEnd()
304 ashish 10007 
        else:
10008 
          iprot.skip(ftype)
10009 
      else:
10010 
        iprot.skip(ftype)
10011 
      iprot.readFieldEnd()
10012 
    iprot.readStructEnd()
10013 
 
10014 
  def write(self, oprot):
10015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10017 
      return
3064 chandransh 10018 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 10019 
    if self.providerId is not None:
3064 chandransh 10020 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10021 
      oprot.writeI64(self.providerId)
304 ashish 10022 
      oprot.writeFieldEnd()
3431 rajveer 10023 
    if self.pickupDetails is not None:
3064 chandransh 10024 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10025 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10026 
      for kiter147,viter148 in self.pickupDetails.items():
10027 
        oprot.writeString(kiter147)
10028 
        oprot.writeString(viter148)
3064 chandransh 10029 
      oprot.writeMapEnd()
304 ashish 10030 
      oprot.writeFieldEnd()
10031 
    oprot.writeFieldStop()
10032 
    oprot.writeStructEnd()
10033 
 
3431 rajveer 10034 
  def validate(self):
10035 
    return
10036 
 
10037 
 
304 ashish 10038 
  def __repr__(self):
10039 
    L = ['%s=%r' % (key, value)
10040 
      for key, value in self.__dict__.iteritems()]
10041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10042 
 
10043 
  def __eq__(self, other):
10044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10045 
 
10046 
  def __ne__(self, other):
10047 
    return not (self == other)
10048 
 
3064 chandransh 10049 
class markOrdersAsPickedUp_result:
304 ashish 10050 
  """
10051 
  Attributes:
10052 
   - success
3064 chandransh 10053 
   - ex
304 ashish 10054 
  """
10055 
 
10056 
  thrift_spec = (
3064 chandransh 10057 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10058 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10059 
  )
10060 
 
3064 chandransh 10061 
  def __init__(self, success=None, ex=None,):
304 ashish 10062 
    self.success = success
3064 chandransh 10063 
    self.ex = ex
304 ashish 10064 
 
10065 
  def read(self, iprot):
10066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10068 
      return
10069 
    iprot.readStructBegin()
10070 
    while True:
10071 
      (fname, ftype, fid) = iprot.readFieldBegin()
10072 
      if ftype == TType.STOP:
10073 
        break
10074 
      if fid == 0:
10075 
        if ftype == TType.LIST:
10076 
          self.success = []
4133 chandransh 10077 
          (_etype152, _size149) = iprot.readListBegin()
10078 
          for _i153 in xrange(_size149):
10079 
            _elem154 = Order()
10080 
            _elem154.read(iprot)
10081 
            self.success.append(_elem154)
304 ashish 10082 
          iprot.readListEnd()
10083 
        else:
10084 
          iprot.skip(ftype)
3064 chandransh 10085 
      elif fid == 1:
10086 
        if ftype == TType.STRUCT:
10087 
          self.ex = TransactionServiceException()
10088 
          self.ex.read(iprot)
10089 
        else:
10090 
          iprot.skip(ftype)
304 ashish 10091 
      else:
10092 
        iprot.skip(ftype)
10093 
      iprot.readFieldEnd()
10094 
    iprot.readStructEnd()
10095 
 
10096 
  def write(self, oprot):
10097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10099 
      return
3064 chandransh 10100 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 10101 
    if self.success is not None:
304 ashish 10102 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10103 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10104 
      for iter155 in self.success:
10105 
        iter155.write(oprot)
304 ashish 10106 
      oprot.writeListEnd()
10107 
      oprot.writeFieldEnd()
3431 rajveer 10108 
    if self.ex is not None:
3064 chandransh 10109 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10110 
      self.ex.write(oprot)
10111 
      oprot.writeFieldEnd()
304 ashish 10112 
    oprot.writeFieldStop()
10113 
    oprot.writeStructEnd()
10114 
 
3431 rajveer 10115 
  def validate(self):
10116 
    return
10117 
 
10118 
 
304 ashish 10119 
  def __repr__(self):
10120 
    L = ['%s=%r' % (key, value)
10121 
      for key, value in self.__dict__.iteritems()]
10122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10123 
 
10124 
  def __eq__(self, other):
10125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10126 
 
10127 
  def __ne__(self, other):
10128 
    return not (self == other)
10129 
 
3064 chandransh 10130 
class markOrdersAsDelivered_args:
304 ashish 10131 
  """
10132 
  Attributes:
3064 chandransh 10133 
   - providerId
10134 
   - deliveredOrders
304 ashish 10135 
  """
10136 
 
10137 
  thrift_spec = (
10138 
    None, # 0
3064 chandransh 10139 
    (1, TType.I64, 'providerId', None, None, ), # 1
10140 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10141 
  )
10142 
 
3064 chandransh 10143 
  def __init__(self, providerId=None, deliveredOrders=None,):
10144 
    self.providerId = providerId
10145 
    self.deliveredOrders = deliveredOrders
304 ashish 10146 
 
10147 
  def read(self, iprot):
10148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10150 
      return
10151 
    iprot.readStructBegin()
10152 
    while True:
10153 
      (fname, ftype, fid) = iprot.readFieldBegin()
10154 
      if ftype == TType.STOP:
10155 
        break
10156 
      if fid == 1:
10157 
        if ftype == TType.I64:
3064 chandransh 10158 
          self.providerId = iprot.readI64();
304 ashish 10159 
        else:
10160 
          iprot.skip(ftype)
10161 
      elif fid == 2:
3064 chandransh 10162 
        if ftype == TType.MAP:
10163 
          self.deliveredOrders = {}
4133 chandransh 10164 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
10165 
          for _i160 in xrange(_size156):
10166 
            _key161 = iprot.readString();
10167 
            _val162 = iprot.readString();
10168 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 10169 
          iprot.readMapEnd()
304 ashish 10170 
        else:
10171 
          iprot.skip(ftype)
10172 
      else:
10173 
        iprot.skip(ftype)
10174 
      iprot.readFieldEnd()
10175 
    iprot.readStructEnd()
10176 
 
10177 
  def write(self, oprot):
10178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10180 
      return
3064 chandransh 10181 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 10182 
    if self.providerId is not None:
3064 chandransh 10183 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10184 
      oprot.writeI64(self.providerId)
304 ashish 10185 
      oprot.writeFieldEnd()
3431 rajveer 10186 
    if self.deliveredOrders is not None:
3064 chandransh 10187 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
10188 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 10189 
      for kiter163,viter164 in self.deliveredOrders.items():
10190 
        oprot.writeString(kiter163)
10191 
        oprot.writeString(viter164)
3064 chandransh 10192 
      oprot.writeMapEnd()
304 ashish 10193 
      oprot.writeFieldEnd()
10194 
    oprot.writeFieldStop()
10195 
    oprot.writeStructEnd()
10196 
 
3431 rajveer 10197 
  def validate(self):
10198 
    return
10199 
 
10200 
 
304 ashish 10201 
  def __repr__(self):
10202 
    L = ['%s=%r' % (key, value)
10203 
      for key, value in self.__dict__.iteritems()]
10204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10205 
 
10206 
  def __eq__(self, other):
10207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10208 
 
10209 
  def __ne__(self, other):
10210 
    return not (self == other)
10211 
 
3064 chandransh 10212 
class markOrdersAsDelivered_result:
10213 
  """
10214 
  Attributes:
10215 
   - ex
10216 
  """
304 ashish 10217 
 
10218 
  thrift_spec = (
3064 chandransh 10219 
    None, # 0
10220 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10221 
  )
10222 
 
3064 chandransh 10223 
  def __init__(self, ex=None,):
10224 
    self.ex = ex
304 ashish 10225 
 
1596 ankur.sing 10226 
  def read(self, iprot):
10227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10229 
      return
10230 
    iprot.readStructBegin()
10231 
    while True:
10232 
      (fname, ftype, fid) = iprot.readFieldBegin()
10233 
      if ftype == TType.STOP:
10234 
        break
3064 chandransh 10235 
      if fid == 1:
10236 
        if ftype == TType.STRUCT:
10237 
          self.ex = TransactionServiceException()
10238 
          self.ex.read(iprot)
10239 
        else:
10240 
          iprot.skip(ftype)
1596 ankur.sing 10241 
      else:
10242 
        iprot.skip(ftype)
10243 
      iprot.readFieldEnd()
10244 
    iprot.readStructEnd()
10245 
 
10246 
  def write(self, oprot):
10247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10249 
      return
3064 chandransh 10250 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 10251 
    if self.ex is not None:
3064 chandransh 10252 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10253 
      self.ex.write(oprot)
10254 
      oprot.writeFieldEnd()
1596 ankur.sing 10255 
    oprot.writeFieldStop()
10256 
    oprot.writeStructEnd()
10257 
 
3431 rajveer 10258 
  def validate(self):
10259 
    return
10260 
 
10261 
 
1596 ankur.sing 10262 
  def __repr__(self):
10263 
    L = ['%s=%r' % (key, value)
10264 
      for key, value in self.__dict__.iteritems()]
10265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10266 
 
10267 
  def __eq__(self, other):
10268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10269 
 
10270 
  def __ne__(self, other):
10271 
    return not (self == other)
10272 
 
3064 chandransh 10273 
class markOrdersAsFailed_args:
1596 ankur.sing 10274 
  """
10275 
  Attributes:
3064 chandransh 10276 
   - providerId
10277 
   - returnedOrders
1596 ankur.sing 10278 
  """
10279 
 
10280 
  thrift_spec = (
3064 chandransh 10281 
    None, # 0
10282 
    (1, TType.I64, 'providerId', None, None, ), # 1
10283 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 10284 
  )
10285 
 
3064 chandransh 10286 
  def __init__(self, providerId=None, returnedOrders=None,):
10287 
    self.providerId = providerId
10288 
    self.returnedOrders = returnedOrders
1596 ankur.sing 10289 
 
10290 
  def read(self, iprot):
10291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10293 
      return
10294 
    iprot.readStructBegin()
10295 
    while True:
10296 
      (fname, ftype, fid) = iprot.readFieldBegin()
10297 
      if ftype == TType.STOP:
10298 
        break
3064 chandransh 10299 
      if fid == 1:
1596 ankur.sing 10300 
        if ftype == TType.I64:
3064 chandransh 10301 
          self.providerId = iprot.readI64();
1596 ankur.sing 10302 
        else:
10303 
          iprot.skip(ftype)
3064 chandransh 10304 
      elif fid == 2:
10305 
        if ftype == TType.MAP:
10306 
          self.returnedOrders = {}
4133 chandransh 10307 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
10308 
          for _i169 in xrange(_size165):
10309 
            _key170 = iprot.readString();
10310 
            _val171 = iprot.readString();
10311 
            self.returnedOrders[_key170] = _val171
3064 chandransh 10312 
          iprot.readMapEnd()
10313 
        else:
10314 
          iprot.skip(ftype)
1596 ankur.sing 10315 
      else:
10316 
        iprot.skip(ftype)
10317 
      iprot.readFieldEnd()
10318 
    iprot.readStructEnd()
10319 
 
10320 
  def write(self, oprot):
10321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10323 
      return
3064 chandransh 10324 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 10325 
    if self.providerId is not None:
3064 chandransh 10326 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10327 
      oprot.writeI64(self.providerId)
1596 ankur.sing 10328 
      oprot.writeFieldEnd()
3431 rajveer 10329 
    if self.returnedOrders is not None:
3064 chandransh 10330 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
10331 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 10332 
      for kiter172,viter173 in self.returnedOrders.items():
10333 
        oprot.writeString(kiter172)
10334 
        oprot.writeString(viter173)
3064 chandransh 10335 
      oprot.writeMapEnd()
10336 
      oprot.writeFieldEnd()
1596 ankur.sing 10337 
    oprot.writeFieldStop()
10338 
    oprot.writeStructEnd()
10339 
 
3431 rajveer 10340 
  def validate(self):
10341 
    return
10342 
 
10343 
 
1596 ankur.sing 10344 
  def __repr__(self):
10345 
    L = ['%s=%r' % (key, value)
10346 
      for key, value in self.__dict__.iteritems()]
10347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10348 
 
10349 
  def __eq__(self, other):
10350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10351 
 
10352 
  def __ne__(self, other):
10353 
    return not (self == other)
10354 
 
3064 chandransh 10355 
class markOrdersAsFailed_result:
10356 
  """
10357 
  Attributes:
10358 
   - ex
10359 
  """
1596 ankur.sing 10360 
 
1627 ankur.sing 10361 
  thrift_spec = (
3064 chandransh 10362 
    None, # 0
10363 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10364 
  )
10365 
 
3064 chandransh 10366 
  def __init__(self, ex=None,):
10367 
    self.ex = ex
10368 
 
1627 ankur.sing 10369 
  def read(self, iprot):
10370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10372 
      return
10373 
    iprot.readStructBegin()
10374 
    while True:
10375 
      (fname, ftype, fid) = iprot.readFieldBegin()
10376 
      if ftype == TType.STOP:
10377 
        break
3064 chandransh 10378 
      if fid == 1:
10379 
        if ftype == TType.STRUCT:
10380 
          self.ex = TransactionServiceException()
10381 
          self.ex.read(iprot)
10382 
        else:
10383 
          iprot.skip(ftype)
1627 ankur.sing 10384 
      else:
10385 
        iprot.skip(ftype)
10386 
      iprot.readFieldEnd()
10387 
    iprot.readStructEnd()
10388 
 
10389 
  def write(self, oprot):
10390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10392 
      return
3064 chandransh 10393 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 10394 
    if self.ex is not None:
3064 chandransh 10395 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10396 
      self.ex.write(oprot)
10397 
      oprot.writeFieldEnd()
1627 ankur.sing 10398 
    oprot.writeFieldStop()
10399 
    oprot.writeStructEnd()
10400 
 
3431 rajveer 10401 
  def validate(self):
10402 
    return
10403 
 
10404 
 
1627 ankur.sing 10405 
  def __repr__(self):
10406 
    L = ['%s=%r' % (key, value)
10407 
      for key, value in self.__dict__.iteritems()]
10408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10409 
 
10410 
  def __eq__(self, other):
10411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10412 
 
10413 
  def __ne__(self, other):
10414 
    return not (self == other)
10415 
 
3064 chandransh 10416 
class updateNonDeliveryReason_args:
1627 ankur.sing 10417 
  """
10418 
  Attributes:
3064 chandransh 10419 
   - providerId
10420 
   - undeliveredOrders
1627 ankur.sing 10421 
  """
10422 
 
10423 
  thrift_spec = (
3064 chandransh 10424 
    None, # 0
10425 
    (1, TType.I64, 'providerId', None, None, ), # 1
10426 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 10427 
  )
10428 
 
3064 chandransh 10429 
  def __init__(self, providerId=None, undeliveredOrders=None,):
10430 
    self.providerId = providerId
10431 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 10432 
 
10433 
  def read(self, iprot):
10434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10436 
      return
10437 
    iprot.readStructBegin()
10438 
    while True:
10439 
      (fname, ftype, fid) = iprot.readFieldBegin()
10440 
      if ftype == TType.STOP:
10441 
        break
3064 chandransh 10442 
      if fid == 1:
1627 ankur.sing 10443 
        if ftype == TType.I64:
3064 chandransh 10444 
          self.providerId = iprot.readI64();
1627 ankur.sing 10445 
        else:
10446 
          iprot.skip(ftype)
3064 chandransh 10447 
      elif fid == 2:
10448 
        if ftype == TType.MAP:
10449 
          self.undeliveredOrders = {}
4133 chandransh 10450 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
10451 
          for _i178 in xrange(_size174):
10452 
            _key179 = iprot.readString();
10453 
            _val180 = iprot.readString();
10454 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 10455 
          iprot.readMapEnd()
10456 
        else:
10457 
          iprot.skip(ftype)
1627 ankur.sing 10458 
      else:
10459 
        iprot.skip(ftype)
10460 
      iprot.readFieldEnd()
10461 
    iprot.readStructEnd()
10462 
 
10463 
  def write(self, oprot):
10464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10466 
      return
3064 chandransh 10467 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 10468 
    if self.providerId is not None:
3064 chandransh 10469 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10470 
      oprot.writeI64(self.providerId)
1627 ankur.sing 10471 
      oprot.writeFieldEnd()
3431 rajveer 10472 
    if self.undeliveredOrders is not None:
3064 chandransh 10473 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
10474 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 10475 
      for kiter181,viter182 in self.undeliveredOrders.items():
10476 
        oprot.writeString(kiter181)
10477 
        oprot.writeString(viter182)
3064 chandransh 10478 
      oprot.writeMapEnd()
10479 
      oprot.writeFieldEnd()
1627 ankur.sing 10480 
    oprot.writeFieldStop()
10481 
    oprot.writeStructEnd()
10482 
 
3431 rajveer 10483 
  def validate(self):
10484 
    return
10485 
 
10486 
 
1627 ankur.sing 10487 
  def __repr__(self):
10488 
    L = ['%s=%r' % (key, value)
10489 
      for key, value in self.__dict__.iteritems()]
10490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10491 
 
10492 
  def __eq__(self, other):
10493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10494 
 
10495 
  def __ne__(self, other):
10496 
    return not (self == other)
10497 
 
3064 chandransh 10498 
class updateNonDeliveryReason_result:
1627 ankur.sing 10499 
  """
10500 
  Attributes:
3064 chandransh 10501 
   - ex
1627 ankur.sing 10502 
  """
10503 
 
10504 
  thrift_spec = (
3064 chandransh 10505 
    None, # 0
10506 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10507 
  )
10508 
 
3064 chandransh 10509 
  def __init__(self, ex=None,):
10510 
    self.ex = ex
1627 ankur.sing 10511 
 
10512 
  def read(self, iprot):
10513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10515 
      return
10516 
    iprot.readStructBegin()
10517 
    while True:
10518 
      (fname, ftype, fid) = iprot.readFieldBegin()
10519 
      if ftype == TType.STOP:
10520 
        break
3064 chandransh 10521 
      if fid == 1:
10522 
        if ftype == TType.STRUCT:
10523 
          self.ex = TransactionServiceException()
10524 
          self.ex.read(iprot)
1627 ankur.sing 10525 
        else:
10526 
          iprot.skip(ftype)
10527 
      else:
10528 
        iprot.skip(ftype)
10529 
      iprot.readFieldEnd()
10530 
    iprot.readStructEnd()
10531 
 
10532 
  def write(self, oprot):
10533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10535 
      return
3064 chandransh 10536 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 10537 
    if self.ex is not None:
3064 chandransh 10538 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10539 
      self.ex.write(oprot)
1627 ankur.sing 10540 
      oprot.writeFieldEnd()
10541 
    oprot.writeFieldStop()
10542 
    oprot.writeStructEnd()
10543 
 
3431 rajveer 10544 
  def validate(self):
10545 
    return
10546 
 
10547 
 
1627 ankur.sing 10548 
  def __repr__(self):
10549 
    L = ['%s=%r' % (key, value)
10550 
      for key, value in self.__dict__.iteritems()]
10551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10552 
 
10553 
  def __eq__(self, other):
10554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10555 
 
10556 
  def __ne__(self, other):
10557 
    return not (self == other)
10558 
 
3064 chandransh 10559 
class getUndeliveredOrders_args:
1886 ankur.sing 10560 
  """
10561 
  Attributes:
3064 chandransh 10562 
   - providerId
10563 
   - warehouseId
1886 ankur.sing 10564 
  """
1627 ankur.sing 10565 
 
1886 ankur.sing 10566 
  thrift_spec = (
10567 
    None, # 0
3064 chandransh 10568 
    (1, TType.I64, 'providerId', None, None, ), # 1
10569 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 10570 
  )
10571 
 
3064 chandransh 10572 
  def __init__(self, providerId=None, warehouseId=None,):
10573 
    self.providerId = providerId
10574 
    self.warehouseId = warehouseId
1886 ankur.sing 10575 
 
10576 
  def read(self, iprot):
10577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10579 
      return
10580 
    iprot.readStructBegin()
10581 
    while True:
10582 
      (fname, ftype, fid) = iprot.readFieldBegin()
10583 
      if ftype == TType.STOP:
10584 
        break
10585 
      if fid == 1:
10586 
        if ftype == TType.I64:
3064 chandransh 10587 
          self.providerId = iprot.readI64();
1886 ankur.sing 10588 
        else:
10589 
          iprot.skip(ftype)
3064 chandransh 10590 
      elif fid == 2:
10591 
        if ftype == TType.I64:
10592 
          self.warehouseId = iprot.readI64();
10593 
        else:
10594 
          iprot.skip(ftype)
1886 ankur.sing 10595 
      else:
10596 
        iprot.skip(ftype)
10597 
      iprot.readFieldEnd()
10598 
    iprot.readStructEnd()
10599 
 
10600 
  def write(self, oprot):
10601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10603 
      return
3064 chandransh 10604 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 10605 
    if self.providerId is not None:
3064 chandransh 10606 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10607 
      oprot.writeI64(self.providerId)
1886 ankur.sing 10608 
      oprot.writeFieldEnd()
3431 rajveer 10609 
    if self.warehouseId is not None:
3064 chandransh 10610 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10611 
      oprot.writeI64(self.warehouseId)
10612 
      oprot.writeFieldEnd()
1886 ankur.sing 10613 
    oprot.writeFieldStop()
10614 
    oprot.writeStructEnd()
10615 
 
3431 rajveer 10616 
  def validate(self):
10617 
    return
10618 
 
10619 
 
1886 ankur.sing 10620 
  def __repr__(self):
10621 
    L = ['%s=%r' % (key, value)
10622 
      for key, value in self.__dict__.iteritems()]
10623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10624 
 
10625 
  def __eq__(self, other):
10626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10627 
 
10628 
  def __ne__(self, other):
10629 
    return not (self == other)
10630 
 
3064 chandransh 10631 
class getUndeliveredOrders_result:
1886 ankur.sing 10632 
  """
10633 
  Attributes:
10634 
   - success
10635 
  """
10636 
 
10637 
  thrift_spec = (
10638 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10639 
  )
10640 
 
10641 
  def __init__(self, success=None,):
10642 
    self.success = success
10643 
 
10644 
  def read(self, iprot):
10645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10647 
      return
10648 
    iprot.readStructBegin()
10649 
    while True:
10650 
      (fname, ftype, fid) = iprot.readFieldBegin()
10651 
      if ftype == TType.STOP:
10652 
        break
10653 
      if fid == 0:
10654 
        if ftype == TType.LIST:
10655 
          self.success = []
4133 chandransh 10656 
          (_etype186, _size183) = iprot.readListBegin()
10657 
          for _i187 in xrange(_size183):
10658 
            _elem188 = Order()
10659 
            _elem188.read(iprot)
10660 
            self.success.append(_elem188)
1886 ankur.sing 10661 
          iprot.readListEnd()
10662 
        else:
10663 
          iprot.skip(ftype)
10664 
      else:
10665 
        iprot.skip(ftype)
10666 
      iprot.readFieldEnd()
10667 
    iprot.readStructEnd()
10668 
 
10669 
  def write(self, oprot):
10670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10672 
      return
3064 chandransh 10673 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 10674 
    if self.success is not None:
1886 ankur.sing 10675 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10676 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10677 
      for iter189 in self.success:
10678 
        iter189.write(oprot)
1886 ankur.sing 10679 
      oprot.writeListEnd()
10680 
      oprot.writeFieldEnd()
10681 
    oprot.writeFieldStop()
10682 
    oprot.writeStructEnd()
10683 
 
3431 rajveer 10684 
  def validate(self):
10685 
    return
10686 
 
10687 
 
1886 ankur.sing 10688 
  def __repr__(self):
10689 
    L = ['%s=%r' % (key, value)
10690 
      for key, value in self.__dict__.iteritems()]
10691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10692 
 
10693 
  def __eq__(self, other):
10694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10695 
 
10696 
  def __ne__(self, other):
10697 
    return not (self == other)
10698 
 
2536 chandransh 10699 
class toggleDOAFlag_args:
10700 
  """
10701 
  Attributes:
10702 
   - orderId
10703 
  """
1886 ankur.sing 10704 
 
2536 chandransh 10705 
  thrift_spec = (
10706 
    None, # 0
10707 
    (1, TType.I64, 'orderId', None, None, ), # 1
10708 
  )
10709 
 
10710 
  def __init__(self, orderId=None,):
10711 
    self.orderId = orderId
10712 
 
10713 
  def read(self, iprot):
10714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10716 
      return
10717 
    iprot.readStructBegin()
10718 
    while True:
10719 
      (fname, ftype, fid) = iprot.readFieldBegin()
10720 
      if ftype == TType.STOP:
10721 
        break
10722 
      if fid == 1:
10723 
        if ftype == TType.I64:
10724 
          self.orderId = iprot.readI64();
10725 
        else:
10726 
          iprot.skip(ftype)
10727 
      else:
10728 
        iprot.skip(ftype)
10729 
      iprot.readFieldEnd()
10730 
    iprot.readStructEnd()
10731 
 
10732 
  def write(self, oprot):
10733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10735 
      return
10736 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 10737 
    if self.orderId is not None:
2536 chandransh 10738 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10739 
      oprot.writeI64(self.orderId)
10740 
      oprot.writeFieldEnd()
10741 
    oprot.writeFieldStop()
10742 
    oprot.writeStructEnd()
10743 
 
3431 rajveer 10744 
  def validate(self):
10745 
    return
10746 
 
10747 
 
2536 chandransh 10748 
  def __repr__(self):
10749 
    L = ['%s=%r' % (key, value)
10750 
      for key, value in self.__dict__.iteritems()]
10751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10752 
 
10753 
  def __eq__(self, other):
10754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10755 
 
10756 
  def __ne__(self, other):
10757 
    return not (self == other)
10758 
 
10759 
class toggleDOAFlag_result:
10760 
  """
10761 
  Attributes:
10762 
   - success
10763 
   - ex
10764 
  """
10765 
 
10766 
  thrift_spec = (
10767 
    (0, TType.BOOL, 'success', None, None, ), # 0
10768 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10769 
  )
10770 
 
10771 
  def __init__(self, success=None, ex=None,):
10772 
    self.success = success
10773 
    self.ex = ex
10774 
 
10775 
  def read(self, iprot):
10776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10778 
      return
10779 
    iprot.readStructBegin()
10780 
    while True:
10781 
      (fname, ftype, fid) = iprot.readFieldBegin()
10782 
      if ftype == TType.STOP:
10783 
        break
10784 
      if fid == 0:
10785 
        if ftype == TType.BOOL:
10786 
          self.success = iprot.readBool();
10787 
        else:
10788 
          iprot.skip(ftype)
10789 
      elif fid == 1:
10790 
        if ftype == TType.STRUCT:
10791 
          self.ex = TransactionServiceException()
10792 
          self.ex.read(iprot)
10793 
        else:
10794 
          iprot.skip(ftype)
10795 
      else:
10796 
        iprot.skip(ftype)
10797 
      iprot.readFieldEnd()
10798 
    iprot.readStructEnd()
10799 
 
10800 
  def write(self, oprot):
10801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10803 
      return
10804 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 10805 
    if self.success is not None:
2536 chandransh 10806 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10807 
      oprot.writeBool(self.success)
10808 
      oprot.writeFieldEnd()
3431 rajveer 10809 
    if self.ex is not None:
2536 chandransh 10810 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10811 
      self.ex.write(oprot)
10812 
      oprot.writeFieldEnd()
10813 
    oprot.writeFieldStop()
10814 
    oprot.writeStructEnd()
10815 
 
3431 rajveer 10816 
  def validate(self):
10817 
    return
10818 
 
10819 
 
2536 chandransh 10820 
  def __repr__(self):
10821 
    L = ['%s=%r' % (key, value)
10822 
      for key, value in self.__dict__.iteritems()]
10823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10824 
 
10825 
  def __eq__(self, other):
10826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10827 
 
10828 
  def __ne__(self, other):
10829 
    return not (self == other)
10830 
 
4454 rajveer 10831 
class markOrderDoaRequestReceived_args:
10832 
  """
10833 
  Attributes:
10834 
   - orderId
10835 
  """
10836 
 
10837 
  thrift_spec = (
10838 
    None, # 0
10839 
    (1, TType.I64, 'orderId', None, None, ), # 1
10840 
  )
10841 
 
10842 
  def __init__(self, orderId=None,):
10843 
    self.orderId = orderId
10844 
 
10845 
  def read(self, iprot):
10846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10848 
      return
10849 
    iprot.readStructBegin()
10850 
    while True:
10851 
      (fname, ftype, fid) = iprot.readFieldBegin()
10852 
      if ftype == TType.STOP:
10853 
        break
10854 
      if fid == 1:
10855 
        if ftype == TType.I64:
10856 
          self.orderId = iprot.readI64();
10857 
        else:
10858 
          iprot.skip(ftype)
10859 
      else:
10860 
        iprot.skip(ftype)
10861 
      iprot.readFieldEnd()
10862 
    iprot.readStructEnd()
10863 
 
10864 
  def write(self, oprot):
10865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10867 
      return
10868 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
10869 
    if self.orderId is not None:
10870 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10871 
      oprot.writeI64(self.orderId)
10872 
      oprot.writeFieldEnd()
10873 
    oprot.writeFieldStop()
10874 
    oprot.writeStructEnd()
10875 
 
10876 
  def validate(self):
10877 
    return
10878 
 
10879 
 
10880 
  def __repr__(self):
10881 
    L = ['%s=%r' % (key, value)
10882 
      for key, value in self.__dict__.iteritems()]
10883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10884 
 
10885 
  def __eq__(self, other):
10886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10887 
 
10888 
  def __ne__(self, other):
10889 
    return not (self == other)
10890 
 
10891 
class markOrderDoaRequestReceived_result:
10892 
  """
10893 
  Attributes:
10894 
   - success
10895 
   - ex
10896 
  """
10897 
 
10898 
  thrift_spec = (
10899 
    (0, TType.BOOL, 'success', None, None, ), # 0
10900 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10901 
  )
10902 
 
10903 
  def __init__(self, success=None, ex=None,):
10904 
    self.success = success
10905 
    self.ex = ex
10906 
 
10907 
  def read(self, iprot):
10908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10910 
      return
10911 
    iprot.readStructBegin()
10912 
    while True:
10913 
      (fname, ftype, fid) = iprot.readFieldBegin()
10914 
      if ftype == TType.STOP:
10915 
        break
10916 
      if fid == 0:
10917 
        if ftype == TType.BOOL:
10918 
          self.success = iprot.readBool();
10919 
        else:
10920 
          iprot.skip(ftype)
10921 
      elif fid == 1:
10922 
        if ftype == TType.STRUCT:
10923 
          self.ex = TransactionServiceException()
10924 
          self.ex.read(iprot)
10925 
        else:
10926 
          iprot.skip(ftype)
10927 
      else:
10928 
        iprot.skip(ftype)
10929 
      iprot.readFieldEnd()
10930 
    iprot.readStructEnd()
10931 
 
10932 
  def write(self, oprot):
10933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10935 
      return
10936 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
10937 
    if self.success is not None:
10938 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10939 
      oprot.writeBool(self.success)
10940 
      oprot.writeFieldEnd()
10941 
    if self.ex is not None:
10942 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10943 
      self.ex.write(oprot)
10944 
      oprot.writeFieldEnd()
10945 
    oprot.writeFieldStop()
10946 
    oprot.writeStructEnd()
10947 
 
10948 
  def validate(self):
10949 
    return
10950 
 
10951 
 
10952 
  def __repr__(self):
10953 
    L = ['%s=%r' % (key, value)
10954 
      for key, value in self.__dict__.iteritems()]
10955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10956 
 
10957 
  def __eq__(self, other):
10958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10959 
 
10960 
  def __ne__(self, other):
10961 
    return not (self == other)
10962 
 
10963 
class markOrderDoaRequestAuthorized_args:
10964 
  """
10965 
  Attributes:
10966 
   - orderId
10967 
   - isAuthorized
10968 
  """
10969 
 
10970 
  thrift_spec = (
10971 
    None, # 0
10972 
    (1, TType.I64, 'orderId', None, None, ), # 1
10973 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
10974 
  )
10975 
 
10976 
  def __init__(self, orderId=None, isAuthorized=None,):
10977 
    self.orderId = orderId
10978 
    self.isAuthorized = isAuthorized
10979 
 
10980 
  def read(self, iprot):
10981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10983 
      return
10984 
    iprot.readStructBegin()
10985 
    while True:
10986 
      (fname, ftype, fid) = iprot.readFieldBegin()
10987 
      if ftype == TType.STOP:
10988 
        break
10989 
      if fid == 1:
10990 
        if ftype == TType.I64:
10991 
          self.orderId = iprot.readI64();
10992 
        else:
10993 
          iprot.skip(ftype)
10994 
      elif fid == 2:
10995 
        if ftype == TType.BOOL:
10996 
          self.isAuthorized = iprot.readBool();
10997 
        else:
10998 
          iprot.skip(ftype)
10999 
      else:
11000 
        iprot.skip(ftype)
11001 
      iprot.readFieldEnd()
11002 
    iprot.readStructEnd()
11003 
 
11004 
  def write(self, oprot):
11005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11007 
      return
11008 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
11009 
    if self.orderId is not None:
11010 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11011 
      oprot.writeI64(self.orderId)
11012 
      oprot.writeFieldEnd()
11013 
    if self.isAuthorized is not None:
11014 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11015 
      oprot.writeBool(self.isAuthorized)
11016 
      oprot.writeFieldEnd()
11017 
    oprot.writeFieldStop()
11018 
    oprot.writeStructEnd()
11019 
 
11020 
  def validate(self):
11021 
    return
11022 
 
11023 
 
11024 
  def __repr__(self):
11025 
    L = ['%s=%r' % (key, value)
11026 
      for key, value in self.__dict__.iteritems()]
11027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11028 
 
11029 
  def __eq__(self, other):
11030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11031 
 
11032 
  def __ne__(self, other):
11033 
    return not (self == other)
11034 
 
11035 
class markOrderDoaRequestAuthorized_result:
11036 
  """
11037 
  Attributes:
11038 
   - success
11039 
   - ex
11040 
  """
11041 
 
11042 
  thrift_spec = (
11043 
    (0, TType.BOOL, 'success', None, None, ), # 0
11044 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11045 
  )
11046 
 
11047 
  def __init__(self, success=None, ex=None,):
11048 
    self.success = success
11049 
    self.ex = ex
11050 
 
11051 
  def read(self, iprot):
11052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11054 
      return
11055 
    iprot.readStructBegin()
11056 
    while True:
11057 
      (fname, ftype, fid) = iprot.readFieldBegin()
11058 
      if ftype == TType.STOP:
11059 
        break
11060 
      if fid == 0:
11061 
        if ftype == TType.BOOL:
11062 
          self.success = iprot.readBool();
11063 
        else:
11064 
          iprot.skip(ftype)
11065 
      elif fid == 1:
11066 
        if ftype == TType.STRUCT:
11067 
          self.ex = TransactionServiceException()
11068 
          self.ex.read(iprot)
11069 
        else:
11070 
          iprot.skip(ftype)
11071 
      else:
11072 
        iprot.skip(ftype)
11073 
      iprot.readFieldEnd()
11074 
    iprot.readStructEnd()
11075 
 
11076 
  def write(self, oprot):
11077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11079 
      return
11080 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
11081 
    if self.success is not None:
11082 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11083 
      oprot.writeBool(self.success)
11084 
      oprot.writeFieldEnd()
11085 
    if self.ex is not None:
11086 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11087 
      self.ex.write(oprot)
11088 
      oprot.writeFieldEnd()
11089 
    oprot.writeFieldStop()
11090 
    oprot.writeStructEnd()
11091 
 
11092 
  def validate(self):
11093 
    return
11094 
 
11095 
 
11096 
  def __repr__(self):
11097 
    L = ['%s=%r' % (key, value)
11098 
      for key, value in self.__dict__.iteritems()]
11099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11100 
 
11101 
  def __eq__(self, other):
11102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11103 
 
11104 
  def __ne__(self, other):
11105 
    return not (self == other)
11106 
 
4488 rajveer 11107 
class markOrderReturnRequestReceived_args:
11108 
  """
11109 
  Attributes:
11110 
   - orderId
11111 
  """
11112 
 
11113 
  thrift_spec = (
11114 
    None, # 0
11115 
    (1, TType.I64, 'orderId', None, None, ), # 1
11116 
  )
11117 
 
11118 
  def __init__(self, orderId=None,):
11119 
    self.orderId = orderId
11120 
 
11121 
  def read(self, iprot):
11122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11124 
      return
11125 
    iprot.readStructBegin()
11126 
    while True:
11127 
      (fname, ftype, fid) = iprot.readFieldBegin()
11128 
      if ftype == TType.STOP:
11129 
        break
11130 
      if fid == 1:
11131 
        if ftype == TType.I64:
11132 
          self.orderId = iprot.readI64();
11133 
        else:
11134 
          iprot.skip(ftype)
11135 
      else:
11136 
        iprot.skip(ftype)
11137 
      iprot.readFieldEnd()
11138 
    iprot.readStructEnd()
11139 
 
11140 
  def write(self, oprot):
11141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11143 
      return
11144 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
11145 
    if self.orderId is not None:
11146 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11147 
      oprot.writeI64(self.orderId)
11148 
      oprot.writeFieldEnd()
11149 
    oprot.writeFieldStop()
11150 
    oprot.writeStructEnd()
11151 
 
11152 
  def validate(self):
11153 
    return
11154 
 
11155 
 
11156 
  def __repr__(self):
11157 
    L = ['%s=%r' % (key, value)
11158 
      for key, value in self.__dict__.iteritems()]
11159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11160 
 
11161 
  def __eq__(self, other):
11162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11163 
 
11164 
  def __ne__(self, other):
11165 
    return not (self == other)
11166 
 
11167 
class markOrderReturnRequestReceived_result:
11168 
  """
11169 
  Attributes:
11170 
   - success
11171 
   - ex
11172 
  """
11173 
 
11174 
  thrift_spec = (
11175 
    (0, TType.BOOL, 'success', None, None, ), # 0
11176 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11177 
  )
11178 
 
11179 
  def __init__(self, success=None, ex=None,):
11180 
    self.success = success
11181 
    self.ex = ex
11182 
 
11183 
  def read(self, iprot):
11184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11186 
      return
11187 
    iprot.readStructBegin()
11188 
    while True:
11189 
      (fname, ftype, fid) = iprot.readFieldBegin()
11190 
      if ftype == TType.STOP:
11191 
        break
11192 
      if fid == 0:
11193 
        if ftype == TType.BOOL:
11194 
          self.success = iprot.readBool();
11195 
        else:
11196 
          iprot.skip(ftype)
11197 
      elif fid == 1:
11198 
        if ftype == TType.STRUCT:
11199 
          self.ex = TransactionServiceException()
11200 
          self.ex.read(iprot)
11201 
        else:
11202 
          iprot.skip(ftype)
11203 
      else:
11204 
        iprot.skip(ftype)
11205 
      iprot.readFieldEnd()
11206 
    iprot.readStructEnd()
11207 
 
11208 
  def write(self, oprot):
11209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11211 
      return
11212 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
11213 
    if self.success is not None:
11214 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11215 
      oprot.writeBool(self.success)
11216 
      oprot.writeFieldEnd()
11217 
    if self.ex is not None:
11218 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11219 
      self.ex.write(oprot)
11220 
      oprot.writeFieldEnd()
11221 
    oprot.writeFieldStop()
11222 
    oprot.writeStructEnd()
11223 
 
11224 
  def validate(self):
11225 
    return
11226 
 
11227 
 
11228 
  def __repr__(self):
11229 
    L = ['%s=%r' % (key, value)
11230 
      for key, value in self.__dict__.iteritems()]
11231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11232 
 
11233 
  def __eq__(self, other):
11234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11235 
 
11236 
  def __ne__(self, other):
11237 
    return not (self == other)
11238 
 
11239 
class markOrderReturnRequestAuthorized_args:
11240 
  """
11241 
  Attributes:
11242 
   - orderId
11243 
   - isAuthorized
11244 
  """
11245 
 
11246 
  thrift_spec = (
11247 
    None, # 0
11248 
    (1, TType.I64, 'orderId', None, None, ), # 1
11249 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11250 
  )
11251 
 
11252 
  def __init__(self, orderId=None, isAuthorized=None,):
11253 
    self.orderId = orderId
11254 
    self.isAuthorized = isAuthorized
11255 
 
11256 
  def read(self, iprot):
11257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11259 
      return
11260 
    iprot.readStructBegin()
11261 
    while True:
11262 
      (fname, ftype, fid) = iprot.readFieldBegin()
11263 
      if ftype == TType.STOP:
11264 
        break
11265 
      if fid == 1:
11266 
        if ftype == TType.I64:
11267 
          self.orderId = iprot.readI64();
11268 
        else:
11269 
          iprot.skip(ftype)
11270 
      elif fid == 2:
11271 
        if ftype == TType.BOOL:
11272 
          self.isAuthorized = iprot.readBool();
11273 
        else:
11274 
          iprot.skip(ftype)
11275 
      else:
11276 
        iprot.skip(ftype)
11277 
      iprot.readFieldEnd()
11278 
    iprot.readStructEnd()
11279 
 
11280 
  def write(self, oprot):
11281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11283 
      return
11284 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
11285 
    if self.orderId is not None:
11286 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11287 
      oprot.writeI64(self.orderId)
11288 
      oprot.writeFieldEnd()
11289 
    if self.isAuthorized is not None:
11290 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11291 
      oprot.writeBool(self.isAuthorized)
11292 
      oprot.writeFieldEnd()
11293 
    oprot.writeFieldStop()
11294 
    oprot.writeStructEnd()
11295 
 
11296 
  def validate(self):
11297 
    return
11298 
 
11299 
 
11300 
  def __repr__(self):
11301 
    L = ['%s=%r' % (key, value)
11302 
      for key, value in self.__dict__.iteritems()]
11303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11304 
 
11305 
  def __eq__(self, other):
11306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11307 
 
11308 
  def __ne__(self, other):
11309 
    return not (self == other)
11310 
 
11311 
class markOrderReturnRequestAuthorized_result:
11312 
  """
11313 
  Attributes:
11314 
   - success
11315 
   - ex
11316 
  """
11317 
 
11318 
  thrift_spec = (
11319 
    (0, TType.BOOL, 'success', None, None, ), # 0
11320 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11321 
  )
11322 
 
11323 
  def __init__(self, success=None, ex=None,):
11324 
    self.success = success
11325 
    self.ex = ex
11326 
 
11327 
  def read(self, iprot):
11328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11330 
      return
11331 
    iprot.readStructBegin()
11332 
    while True:
11333 
      (fname, ftype, fid) = iprot.readFieldBegin()
11334 
      if ftype == TType.STOP:
11335 
        break
11336 
      if fid == 0:
11337 
        if ftype == TType.BOOL:
11338 
          self.success = iprot.readBool();
11339 
        else:
11340 
          iprot.skip(ftype)
11341 
      elif fid == 1:
11342 
        if ftype == TType.STRUCT:
11343 
          self.ex = TransactionServiceException()
11344 
          self.ex.read(iprot)
11345 
        else:
11346 
          iprot.skip(ftype)
11347 
      else:
11348 
        iprot.skip(ftype)
11349 
      iprot.readFieldEnd()
11350 
    iprot.readStructEnd()
11351 
 
11352 
  def write(self, oprot):
11353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11355 
      return
11356 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
11357 
    if self.success is not None:
11358 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11359 
      oprot.writeBool(self.success)
11360 
      oprot.writeFieldEnd()
11361 
    if self.ex is not None:
11362 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11363 
      self.ex.write(oprot)
11364 
      oprot.writeFieldEnd()
11365 
    oprot.writeFieldStop()
11366 
    oprot.writeStructEnd()
11367 
 
11368 
  def validate(self):
11369 
    return
11370 
 
11371 
 
11372 
  def __repr__(self):
11373 
    L = ['%s=%r' % (key, value)
11374 
      for key, value in self.__dict__.iteritems()]
11375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11376 
 
11377 
  def __eq__(self, other):
11378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11379 
 
11380 
  def __ne__(self, other):
11381 
    return not (self == other)
11382 
 
2536 chandransh 11383 
class requestPickupNumber_args:
11384 
  """
11385 
  Attributes:
11386 
   - orderId
11387 
  """
11388 
 
11389 
  thrift_spec = (
11390 
    None, # 0
11391 
    (1, TType.I64, 'orderId', None, None, ), # 1
11392 
  )
11393 
 
11394 
  def __init__(self, orderId=None,):
11395 
    self.orderId = orderId
11396 
 
11397 
  def read(self, iprot):
11398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11400 
      return
11401 
    iprot.readStructBegin()
11402 
    while True:
11403 
      (fname, ftype, fid) = iprot.readFieldBegin()
11404 
      if ftype == TType.STOP:
11405 
        break
11406 
      if fid == 1:
11407 
        if ftype == TType.I64:
11408 
          self.orderId = iprot.readI64();
11409 
        else:
11410 
          iprot.skip(ftype)
11411 
      else:
11412 
        iprot.skip(ftype)
11413 
      iprot.readFieldEnd()
11414 
    iprot.readStructEnd()
11415 
 
11416 
  def write(self, oprot):
11417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11419 
      return
11420 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 11421 
    if self.orderId is not None:
2536 chandransh 11422 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11423 
      oprot.writeI64(self.orderId)
11424 
      oprot.writeFieldEnd()
11425 
    oprot.writeFieldStop()
11426 
    oprot.writeStructEnd()
11427 
 
3431 rajveer 11428 
  def validate(self):
11429 
    return
11430 
 
11431 
 
2536 chandransh 11432 
  def __repr__(self):
11433 
    L = ['%s=%r' % (key, value)
11434 
      for key, value in self.__dict__.iteritems()]
11435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11436 
 
11437 
  def __eq__(self, other):
11438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11439 
 
11440 
  def __ne__(self, other):
11441 
    return not (self == other)
11442 
 
11443 
class requestPickupNumber_result:
11444 
  """
11445 
  Attributes:
11446 
   - success
11447 
   - ex
11448 
  """
11449 
 
11450 
  thrift_spec = (
11451 
    (0, TType.BOOL, 'success', None, None, ), # 0
11452 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11453 
  )
11454 
 
11455 
  def __init__(self, success=None, ex=None,):
11456 
    self.success = success
11457 
    self.ex = ex
11458 
 
11459 
  def read(self, iprot):
11460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11462 
      return
11463 
    iprot.readStructBegin()
11464 
    while True:
11465 
      (fname, ftype, fid) = iprot.readFieldBegin()
11466 
      if ftype == TType.STOP:
11467 
        break
11468 
      if fid == 0:
11469 
        if ftype == TType.BOOL:
11470 
          self.success = iprot.readBool();
11471 
        else:
11472 
          iprot.skip(ftype)
11473 
      elif fid == 1:
11474 
        if ftype == TType.STRUCT:
11475 
          self.ex = TransactionServiceException()
11476 
          self.ex.read(iprot)
11477 
        else:
11478 
          iprot.skip(ftype)
11479 
      else:
11480 
        iprot.skip(ftype)
11481 
      iprot.readFieldEnd()
11482 
    iprot.readStructEnd()
11483 
 
11484 
  def write(self, oprot):
11485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11487 
      return
11488 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 11489 
    if self.success is not None:
2536 chandransh 11490 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11491 
      oprot.writeBool(self.success)
11492 
      oprot.writeFieldEnd()
3431 rajveer 11493 
    if self.ex is not None:
2536 chandransh 11494 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11495 
      self.ex.write(oprot)
11496 
      oprot.writeFieldEnd()
11497 
    oprot.writeFieldStop()
11498 
    oprot.writeStructEnd()
11499 
 
3431 rajveer 11500 
  def validate(self):
11501 
    return
11502 
 
11503 
 
2536 chandransh 11504 
  def __repr__(self):
11505 
    L = ['%s=%r' % (key, value)
11506 
      for key, value in self.__dict__.iteritems()]
11507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11508 
 
11509 
  def __eq__(self, other):
11510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11511 
 
11512 
  def __ne__(self, other):
11513 
    return not (self == other)
11514 
 
11515 
class authorizePickup_args:
11516 
  """
11517 
  Attributes:
11518 
   - orderId
11519 
   - pickupNumber
11520 
  """
11521 
 
11522 
  thrift_spec = (
11523 
    None, # 0
11524 
    (1, TType.I64, 'orderId', None, None, ), # 1
11525 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
11526 
  )
11527 
 
11528 
  def __init__(self, orderId=None, pickupNumber=None,):
11529 
    self.orderId = orderId
11530 
    self.pickupNumber = pickupNumber
11531 
 
11532 
  def read(self, iprot):
11533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11535 
      return
11536 
    iprot.readStructBegin()
11537 
    while True:
11538 
      (fname, ftype, fid) = iprot.readFieldBegin()
11539 
      if ftype == TType.STOP:
11540 
        break
11541 
      if fid == 1:
11542 
        if ftype == TType.I64:
11543 
          self.orderId = iprot.readI64();
11544 
        else:
11545 
          iprot.skip(ftype)
11546 
      elif fid == 2:
11547 
        if ftype == TType.STRING:
11548 
          self.pickupNumber = iprot.readString();
11549 
        else:
11550 
          iprot.skip(ftype)
11551 
      else:
11552 
        iprot.skip(ftype)
11553 
      iprot.readFieldEnd()
11554 
    iprot.readStructEnd()
11555 
 
11556 
  def write(self, oprot):
11557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11559 
      return
11560 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 11561 
    if self.orderId is not None:
2536 chandransh 11562 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11563 
      oprot.writeI64(self.orderId)
11564 
      oprot.writeFieldEnd()
3431 rajveer 11565 
    if self.pickupNumber is not None:
2536 chandransh 11566 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
11567 
      oprot.writeString(self.pickupNumber)
11568 
      oprot.writeFieldEnd()
11569 
    oprot.writeFieldStop()
11570 
    oprot.writeStructEnd()
11571 
 
3431 rajveer 11572 
  def validate(self):
11573 
    return
11574 
 
11575 
 
2536 chandransh 11576 
  def __repr__(self):
11577 
    L = ['%s=%r' % (key, value)
11578 
      for key, value in self.__dict__.iteritems()]
11579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11580 
 
11581 
  def __eq__(self, other):
11582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11583 
 
11584 
  def __ne__(self, other):
11585 
    return not (self == other)
11586 
 
11587 
class authorizePickup_result:
11588 
  """
11589 
  Attributes:
11590 
   - success
11591 
   - ex
11592 
  """
11593 
 
11594 
  thrift_spec = (
11595 
    (0, TType.BOOL, 'success', None, None, ), # 0
11596 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11597 
  )
11598 
 
11599 
  def __init__(self, success=None, ex=None,):
11600 
    self.success = success
11601 
    self.ex = ex
11602 
 
11603 
  def read(self, iprot):
11604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11606 
      return
11607 
    iprot.readStructBegin()
11608 
    while True:
11609 
      (fname, ftype, fid) = iprot.readFieldBegin()
11610 
      if ftype == TType.STOP:
11611 
        break
11612 
      if fid == 0:
11613 
        if ftype == TType.BOOL:
11614 
          self.success = iprot.readBool();
11615 
        else:
11616 
          iprot.skip(ftype)
11617 
      elif fid == 1:
11618 
        if ftype == TType.STRUCT:
11619 
          self.ex = TransactionServiceException()
11620 
          self.ex.read(iprot)
11621 
        else:
11622 
          iprot.skip(ftype)
11623 
      else:
11624 
        iprot.skip(ftype)
11625 
      iprot.readFieldEnd()
11626 
    iprot.readStructEnd()
11627 
 
11628 
  def write(self, oprot):
11629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11631 
      return
11632 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 11633 
    if self.success is not None:
2536 chandransh 11634 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11635 
      oprot.writeBool(self.success)
11636 
      oprot.writeFieldEnd()
3431 rajveer 11637 
    if self.ex is not None:
2536 chandransh 11638 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11639 
      self.ex.write(oprot)
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 
 
2764 chandransh 11659 
class markDoasAsPickedUp_args:
11660 
  """
11661 
  Attributes:
11662 
   - providerId
11663 
   - pickupDetails
11664 
  """
11665 
 
11666 
  thrift_spec = (
11667 
    None, # 0
11668 
    (1, TType.I64, 'providerId', None, None, ), # 1
11669 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
11670 
  )
11671 
 
11672 
  def __init__(self, providerId=None, pickupDetails=None,):
11673 
    self.providerId = providerId
11674 
    self.pickupDetails = pickupDetails
11675 
 
11676 
  def read(self, iprot):
11677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11679 
      return
11680 
    iprot.readStructBegin()
11681 
    while True:
11682 
      (fname, ftype, fid) = iprot.readFieldBegin()
11683 
      if ftype == TType.STOP:
11684 
        break
11685 
      if fid == 1:
11686 
        if ftype == TType.I64:
11687 
          self.providerId = iprot.readI64();
11688 
        else:
11689 
          iprot.skip(ftype)
11690 
      elif fid == 2:
11691 
        if ftype == TType.MAP:
11692 
          self.pickupDetails = {}
4133 chandransh 11693 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
11694 
          for _i194 in xrange(_size190):
11695 
            _key195 = iprot.readString();
11696 
            _val196 = iprot.readString();
11697 
            self.pickupDetails[_key195] = _val196
2764 chandransh 11698 
          iprot.readMapEnd()
11699 
        else:
11700 
          iprot.skip(ftype)
11701 
      else:
11702 
        iprot.skip(ftype)
11703 
      iprot.readFieldEnd()
11704 
    iprot.readStructEnd()
11705 
 
11706 
  def write(self, oprot):
11707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11709 
      return
11710 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 11711 
    if self.providerId is not None:
2764 chandransh 11712 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11713 
      oprot.writeI64(self.providerId)
11714 
      oprot.writeFieldEnd()
3431 rajveer 11715 
    if self.pickupDetails is not None:
2764 chandransh 11716 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11717 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 11718 
      for kiter197,viter198 in self.pickupDetails.items():
11719 
        oprot.writeString(kiter197)
11720 
        oprot.writeString(viter198)
2764 chandransh 11721 
      oprot.writeMapEnd()
11722 
      oprot.writeFieldEnd()
11723 
    oprot.writeFieldStop()
11724 
    oprot.writeStructEnd()
11725 
 
3431 rajveer 11726 
  def validate(self):
11727 
    return
11728 
 
11729 
 
2764 chandransh 11730 
  def __repr__(self):
11731 
    L = ['%s=%r' % (key, value)
11732 
      for key, value in self.__dict__.iteritems()]
11733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11734 
 
11735 
  def __eq__(self, other):
11736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11737 
 
11738 
  def __ne__(self, other):
11739 
    return not (self == other)
11740 
 
11741 
class markDoasAsPickedUp_result:
11742 
  """
11743 
  Attributes:
11744 
   - success
11745 
  """
11746 
 
11747 
  thrift_spec = (
11748 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11749 
  )
11750 
 
11751 
  def __init__(self, success=None,):
11752 
    self.success = success
11753 
 
11754 
  def read(self, iprot):
11755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11757 
      return
11758 
    iprot.readStructBegin()
11759 
    while True:
11760 
      (fname, ftype, fid) = iprot.readFieldBegin()
11761 
      if ftype == TType.STOP:
11762 
        break
11763 
      if fid == 0:
11764 
        if ftype == TType.LIST:
11765 
          self.success = []
4133 chandransh 11766 
          (_etype202, _size199) = iprot.readListBegin()
11767 
          for _i203 in xrange(_size199):
11768 
            _elem204 = Order()
11769 
            _elem204.read(iprot)
11770 
            self.success.append(_elem204)
2764 chandransh 11771 
          iprot.readListEnd()
11772 
        else:
11773 
          iprot.skip(ftype)
11774 
      else:
11775 
        iprot.skip(ftype)
11776 
      iprot.readFieldEnd()
11777 
    iprot.readStructEnd()
11778 
 
11779 
  def write(self, oprot):
11780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11782 
      return
11783 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 11784 
    if self.success is not None:
2764 chandransh 11785 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11786 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11787 
      for iter205 in self.success:
11788 
        iter205.write(oprot)
2764 chandransh 11789 
      oprot.writeListEnd()
11790 
      oprot.writeFieldEnd()
11791 
    oprot.writeFieldStop()
11792 
    oprot.writeStructEnd()
11793 
 
3431 rajveer 11794 
  def validate(self):
11795 
    return
11796 
 
11797 
 
2764 chandransh 11798 
  def __repr__(self):
11799 
    L = ['%s=%r' % (key, value)
11800 
      for key, value in self.__dict__.iteritems()]
11801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11802 
 
11803 
  def __eq__(self, other):
11804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11805 
 
11806 
  def __ne__(self, other):
11807 
    return not (self == other)
11808 
 
2616 chandransh 11809 
class receiveReturn_args:
2591 chandransh 11810 
  """
11811 
  Attributes:
11812 
   - orderId
4479 rajveer 11813 
   - receiveCondition
2591 chandransh 11814 
  """
2536 chandransh 11815 
 
2591 chandransh 11816 
  thrift_spec = (
11817 
    None, # 0
11818 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 11819 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 11820 
  )
11821 
 
4479 rajveer 11822 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 11823 
    self.orderId = orderId
4479 rajveer 11824 
    self.receiveCondition = receiveCondition
2591 chandransh 11825 
 
11826 
  def read(self, iprot):
11827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11829 
      return
11830 
    iprot.readStructBegin()
11831 
    while True:
11832 
      (fname, ftype, fid) = iprot.readFieldBegin()
11833 
      if ftype == TType.STOP:
11834 
        break
11835 
      if fid == 1:
11836 
        if ftype == TType.I64:
11837 
          self.orderId = iprot.readI64();
11838 
        else:
11839 
          iprot.skip(ftype)
4479 rajveer 11840 
      elif fid == 2:
11841 
        if ftype == TType.I64:
11842 
          self.receiveCondition = iprot.readI64();
11843 
        else:
11844 
          iprot.skip(ftype)
2591 chandransh 11845 
      else:
11846 
        iprot.skip(ftype)
11847 
      iprot.readFieldEnd()
11848 
    iprot.readStructEnd()
11849 
 
11850 
  def write(self, oprot):
11851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11853 
      return
2616 chandransh 11854 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 11855 
    if self.orderId is not None:
2591 chandransh 11856 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11857 
      oprot.writeI64(self.orderId)
11858 
      oprot.writeFieldEnd()
4479 rajveer 11859 
    if self.receiveCondition is not None:
11860 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
11861 
      oprot.writeI64(self.receiveCondition)
11862 
      oprot.writeFieldEnd()
2591 chandransh 11863 
    oprot.writeFieldStop()
11864 
    oprot.writeStructEnd()
11865 
 
3431 rajveer 11866 
  def validate(self):
11867 
    return
11868 
 
11869 
 
2591 chandransh 11870 
  def __repr__(self):
11871 
    L = ['%s=%r' % (key, value)
11872 
      for key, value in self.__dict__.iteritems()]
11873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11874 
 
11875 
  def __eq__(self, other):
11876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11877 
 
11878 
  def __ne__(self, other):
11879 
    return not (self == other)
11880 
 
2616 chandransh 11881 
class receiveReturn_result:
2591 chandransh 11882 
  """
11883 
  Attributes:
11884 
   - success
11885 
   - ex
11886 
  """
11887 
 
11888 
  thrift_spec = (
11889 
    (0, TType.BOOL, 'success', None, None, ), # 0
11890 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11891 
  )
11892 
 
11893 
  def __init__(self, success=None, ex=None,):
11894 
    self.success = success
11895 
    self.ex = ex
11896 
 
11897 
  def read(self, iprot):
11898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11900 
      return
11901 
    iprot.readStructBegin()
11902 
    while True:
11903 
      (fname, ftype, fid) = iprot.readFieldBegin()
11904 
      if ftype == TType.STOP:
11905 
        break
11906 
      if fid == 0:
11907 
        if ftype == TType.BOOL:
11908 
          self.success = iprot.readBool();
11909 
        else:
11910 
          iprot.skip(ftype)
11911 
      elif fid == 1:
11912 
        if ftype == TType.STRUCT:
11913 
          self.ex = TransactionServiceException()
11914 
          self.ex.read(iprot)
11915 
        else:
11916 
          iprot.skip(ftype)
11917 
      else:
11918 
        iprot.skip(ftype)
11919 
      iprot.readFieldEnd()
11920 
    iprot.readStructEnd()
11921 
 
11922 
  def write(self, oprot):
11923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11925 
      return
2616 chandransh 11926 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 11927 
    if self.success is not None:
2591 chandransh 11928 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11929 
      oprot.writeBool(self.success)
11930 
      oprot.writeFieldEnd()
3431 rajveer 11931 
    if self.ex is not None:
2591 chandransh 11932 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11933 
      self.ex.write(oprot)
11934 
      oprot.writeFieldEnd()
11935 
    oprot.writeFieldStop()
11936 
    oprot.writeStructEnd()
11937 
 
3431 rajveer 11938 
  def validate(self):
11939 
    return
11940 
 
11941 
 
2591 chandransh 11942 
  def __repr__(self):
11943 
    L = ['%s=%r' % (key, value)
11944 
      for key, value in self.__dict__.iteritems()]
11945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11946 
 
11947 
  def __eq__(self, other):
11948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11949 
 
11950 
  def __ne__(self, other):
11951 
    return not (self == other)
11952 
 
11953 
class validateDoa_args:
11954 
  """
11955 
  Attributes:
11956 
   - orderId
11957 
   - isValid
11958 
  """
11959 
 
11960 
  thrift_spec = (
11961 
    None, # 0
11962 
    (1, TType.I64, 'orderId', None, None, ), # 1
11963 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
11964 
  )
11965 
 
11966 
  def __init__(self, orderId=None, isValid=None,):
11967 
    self.orderId = orderId
11968 
    self.isValid = isValid
11969 
 
11970 
  def read(self, iprot):
11971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11973 
      return
11974 
    iprot.readStructBegin()
11975 
    while True:
11976 
      (fname, ftype, fid) = iprot.readFieldBegin()
11977 
      if ftype == TType.STOP:
11978 
        break
11979 
      if fid == 1:
11980 
        if ftype == TType.I64:
11981 
          self.orderId = iprot.readI64();
11982 
        else:
11983 
          iprot.skip(ftype)
11984 
      elif fid == 2:
11985 
        if ftype == TType.BOOL:
11986 
          self.isValid = iprot.readBool();
11987 
        else:
11988 
          iprot.skip(ftype)
11989 
      else:
11990 
        iprot.skip(ftype)
11991 
      iprot.readFieldEnd()
11992 
    iprot.readStructEnd()
11993 
 
11994 
  def write(self, oprot):
11995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11997 
      return
11998 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 11999 
    if self.orderId is not None:
2591 chandransh 12000 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12001 
      oprot.writeI64(self.orderId)
12002 
      oprot.writeFieldEnd()
3431 rajveer 12003 
    if self.isValid is not None:
2591 chandransh 12004 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
12005 
      oprot.writeBool(self.isValid)
12006 
      oprot.writeFieldEnd()
12007 
    oprot.writeFieldStop()
12008 
    oprot.writeStructEnd()
12009 
 
3431 rajveer 12010 
  def validate(self):
12011 
    return
12012 
 
12013 
 
2591 chandransh 12014 
  def __repr__(self):
12015 
    L = ['%s=%r' % (key, value)
12016 
      for key, value in self.__dict__.iteritems()]
12017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12018 
 
12019 
  def __eq__(self, other):
12020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12021 
 
12022 
  def __ne__(self, other):
12023 
    return not (self == other)
12024 
 
12025 
class validateDoa_result:
12026 
  """
12027 
  Attributes:
12028 
   - success
12029 
   - ex
12030 
  """
12031 
 
12032 
  thrift_spec = (
12033 
    (0, TType.BOOL, 'success', None, None, ), # 0
12034 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12035 
  )
12036 
 
12037 
  def __init__(self, success=None, ex=None,):
12038 
    self.success = success
12039 
    self.ex = ex
12040 
 
12041 
  def read(self, iprot):
12042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12044 
      return
12045 
    iprot.readStructBegin()
12046 
    while True:
12047 
      (fname, ftype, fid) = iprot.readFieldBegin()
12048 
      if ftype == TType.STOP:
12049 
        break
12050 
      if fid == 0:
12051 
        if ftype == TType.BOOL:
12052 
          self.success = iprot.readBool();
12053 
        else:
12054 
          iprot.skip(ftype)
12055 
      elif fid == 1:
12056 
        if ftype == TType.STRUCT:
12057 
          self.ex = TransactionServiceException()
12058 
          self.ex.read(iprot)
12059 
        else:
12060 
          iprot.skip(ftype)
12061 
      else:
12062 
        iprot.skip(ftype)
12063 
      iprot.readFieldEnd()
12064 
    iprot.readStructEnd()
12065 
 
12066 
  def write(self, oprot):
12067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12069 
      return
12070 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 12071 
    if self.success is not None:
2591 chandransh 12072 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12073 
      oprot.writeBool(self.success)
12074 
      oprot.writeFieldEnd()
3431 rajveer 12075 
    if self.ex is not None:
2591 chandransh 12076 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12077 
      self.ex.write(oprot)
12078 
      oprot.writeFieldEnd()
12079 
    oprot.writeFieldStop()
12080 
    oprot.writeStructEnd()
12081 
 
3431 rajveer 12082 
  def validate(self):
12083 
    return
12084 
 
12085 
 
2591 chandransh 12086 
  def __repr__(self):
12087 
    L = ['%s=%r' % (key, value)
12088 
      for key, value in self.__dict__.iteritems()]
12089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12090 
 
12091 
  def __eq__(self, other):
12092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12093 
 
12094 
  def __ne__(self, other):
12095 
    return not (self == other)
12096 
 
4495 rajveer 12097 
class validateReturnProduct_args:
12098 
  """
12099 
  Attributes:
12100 
   - orderId
12101 
   - isUsable
12102 
  """
12103 
 
12104 
  thrift_spec = (
12105 
    None, # 0
12106 
    (1, TType.I64, 'orderId', None, None, ), # 1
12107 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
12108 
  )
12109 
 
12110 
  def __init__(self, orderId=None, isUsable=None,):
12111 
    self.orderId = orderId
12112 
    self.isUsable = isUsable
12113 
 
12114 
  def read(self, iprot):
12115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12117 
      return
12118 
    iprot.readStructBegin()
12119 
    while True:
12120 
      (fname, ftype, fid) = iprot.readFieldBegin()
12121 
      if ftype == TType.STOP:
12122 
        break
12123 
      if fid == 1:
12124 
        if ftype == TType.I64:
12125 
          self.orderId = iprot.readI64();
12126 
        else:
12127 
          iprot.skip(ftype)
12128 
      elif fid == 2:
12129 
        if ftype == TType.BOOL:
12130 
          self.isUsable = iprot.readBool();
12131 
        else:
12132 
          iprot.skip(ftype)
12133 
      else:
12134 
        iprot.skip(ftype)
12135 
      iprot.readFieldEnd()
12136 
    iprot.readStructEnd()
12137 
 
12138 
  def write(self, oprot):
12139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12141 
      return
12142 
    oprot.writeStructBegin('validateReturnProduct_args')
12143 
    if self.orderId is not None:
12144 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12145 
      oprot.writeI64(self.orderId)
12146 
      oprot.writeFieldEnd()
12147 
    if self.isUsable is not None:
12148 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
12149 
      oprot.writeBool(self.isUsable)
12150 
      oprot.writeFieldEnd()
12151 
    oprot.writeFieldStop()
12152 
    oprot.writeStructEnd()
12153 
 
12154 
  def validate(self):
12155 
    return
12156 
 
12157 
 
12158 
  def __repr__(self):
12159 
    L = ['%s=%r' % (key, value)
12160 
      for key, value in self.__dict__.iteritems()]
12161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12162 
 
12163 
  def __eq__(self, other):
12164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12165 
 
12166 
  def __ne__(self, other):
12167 
    return not (self == other)
12168 
 
12169 
class validateReturnProduct_result:
12170 
  """
12171 
  Attributes:
12172 
   - success
12173 
   - ex
12174 
  """
12175 
 
12176 
  thrift_spec = (
12177 
    (0, TType.BOOL, 'success', None, None, ), # 0
12178 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12179 
  )
12180 
 
12181 
  def __init__(self, success=None, ex=None,):
12182 
    self.success = success
12183 
    self.ex = ex
12184 
 
12185 
  def read(self, iprot):
12186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12188 
      return
12189 
    iprot.readStructBegin()
12190 
    while True:
12191 
      (fname, ftype, fid) = iprot.readFieldBegin()
12192 
      if ftype == TType.STOP:
12193 
        break
12194 
      if fid == 0:
12195 
        if ftype == TType.BOOL:
12196 
          self.success = iprot.readBool();
12197 
        else:
12198 
          iprot.skip(ftype)
12199 
      elif fid == 1:
12200 
        if ftype == TType.STRUCT:
12201 
          self.ex = TransactionServiceException()
12202 
          self.ex.read(iprot)
12203 
        else:
12204 
          iprot.skip(ftype)
12205 
      else:
12206 
        iprot.skip(ftype)
12207 
      iprot.readFieldEnd()
12208 
    iprot.readStructEnd()
12209 
 
12210 
  def write(self, oprot):
12211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12213 
      return
12214 
    oprot.writeStructBegin('validateReturnProduct_result')
12215 
    if self.success is not None:
12216 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12217 
      oprot.writeBool(self.success)
12218 
      oprot.writeFieldEnd()
12219 
    if self.ex is not None:
12220 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12221 
      self.ex.write(oprot)
12222 
      oprot.writeFieldEnd()
12223 
    oprot.writeFieldStop()
12224 
    oprot.writeStructEnd()
12225 
 
12226 
  def validate(self):
12227 
    return
12228 
 
12229 
 
12230 
  def __repr__(self):
12231 
    L = ['%s=%r' % (key, value)
12232 
      for key, value in self.__dict__.iteritems()]
12233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12234 
 
12235 
  def __eq__(self, other):
12236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12237 
 
12238 
  def __ne__(self, other):
12239 
    return not (self == other)
12240 
 
2616 chandransh 12241 
class reshipOrder_args:
12242 
  """
12243 
  Attributes:
12244 
   - orderId
12245 
  """
2591 chandransh 12246 
 
2616 chandransh 12247 
  thrift_spec = (
12248 
    None, # 0
12249 
    (1, TType.I64, 'orderId', None, None, ), # 1
12250 
  )
12251 
 
12252 
  def __init__(self, orderId=None,):
12253 
    self.orderId = orderId
12254 
 
12255 
  def read(self, iprot):
12256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12258 
      return
12259 
    iprot.readStructBegin()
12260 
    while True:
12261 
      (fname, ftype, fid) = iprot.readFieldBegin()
12262 
      if ftype == TType.STOP:
12263 
        break
12264 
      if fid == 1:
12265 
        if ftype == TType.I64:
12266 
          self.orderId = iprot.readI64();
12267 
        else:
12268 
          iprot.skip(ftype)
12269 
      else:
12270 
        iprot.skip(ftype)
12271 
      iprot.readFieldEnd()
12272 
    iprot.readStructEnd()
12273 
 
12274 
  def write(self, oprot):
12275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12277 
      return
12278 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 12279 
    if self.orderId is not None:
2616 chandransh 12280 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12281 
      oprot.writeI64(self.orderId)
12282 
      oprot.writeFieldEnd()
12283 
    oprot.writeFieldStop()
12284 
    oprot.writeStructEnd()
12285 
 
3431 rajveer 12286 
  def validate(self):
12287 
    return
12288 
 
12289 
 
2616 chandransh 12290 
  def __repr__(self):
12291 
    L = ['%s=%r' % (key, value)
12292 
      for key, value in self.__dict__.iteritems()]
12293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12294 
 
12295 
  def __eq__(self, other):
12296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12297 
 
12298 
  def __ne__(self, other):
12299 
    return not (self == other)
12300 
 
12301 
class reshipOrder_result:
12302 
  """
12303 
  Attributes:
12304 
   - success
12305 
   - ex
12306 
  """
12307 
 
12308 
  thrift_spec = (
12309 
    (0, TType.I64, 'success', None, None, ), # 0
12310 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12311 
  )
12312 
 
12313 
  def __init__(self, success=None, ex=None,):
12314 
    self.success = success
12315 
    self.ex = ex
12316 
 
12317 
  def read(self, iprot):
12318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12320 
      return
12321 
    iprot.readStructBegin()
12322 
    while True:
12323 
      (fname, ftype, fid) = iprot.readFieldBegin()
12324 
      if ftype == TType.STOP:
12325 
        break
12326 
      if fid == 0:
12327 
        if ftype == TType.I64:
12328 
          self.success = iprot.readI64();
12329 
        else:
12330 
          iprot.skip(ftype)
12331 
      elif fid == 1:
12332 
        if ftype == TType.STRUCT:
12333 
          self.ex = TransactionServiceException()
12334 
          self.ex.read(iprot)
12335 
        else:
12336 
          iprot.skip(ftype)
12337 
      else:
12338 
        iprot.skip(ftype)
12339 
      iprot.readFieldEnd()
12340 
    iprot.readStructEnd()
12341 
 
12342 
  def write(self, oprot):
12343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12345 
      return
12346 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 12347 
    if self.success is not None:
2616 chandransh 12348 
      oprot.writeFieldBegin('success', TType.I64, 0)
12349 
      oprot.writeI64(self.success)
12350 
      oprot.writeFieldEnd()
3431 rajveer 12351 
    if self.ex is not None:
2616 chandransh 12352 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12353 
      self.ex.write(oprot)
12354 
      oprot.writeFieldEnd()
12355 
    oprot.writeFieldStop()
12356 
    oprot.writeStructEnd()
12357 
 
3431 rajveer 12358 
  def validate(self):
12359 
    return
12360 
 
12361 
 
2616 chandransh 12362 
  def __repr__(self):
12363 
    L = ['%s=%r' % (key, value)
12364 
      for key, value in self.__dict__.iteritems()]
12365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12366 
 
12367 
  def __eq__(self, other):
12368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12369 
 
12370 
  def __ne__(self, other):
12371 
    return not (self == other)
12372 
 
12373 
class refundOrder_args:
12374 
  """
12375 
  Attributes:
12376 
   - orderId
3226 chandransh 12377 
   - refundedBy
12378 
   - reason
2616 chandransh 12379 
  """
12380 
 
12381 
  thrift_spec = (
12382 
    None, # 0
12383 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 12384 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
12385 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 12386 
  )
12387 
 
3226 chandransh 12388 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 12389 
    self.orderId = orderId
3226 chandransh 12390 
    self.refundedBy = refundedBy
12391 
    self.reason = reason
2616 chandransh 12392 
 
12393 
  def read(self, iprot):
12394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12396 
      return
12397 
    iprot.readStructBegin()
12398 
    while True:
12399 
      (fname, ftype, fid) = iprot.readFieldBegin()
12400 
      if ftype == TType.STOP:
12401 
        break
12402 
      if fid == 1:
12403 
        if ftype == TType.I64:
12404 
          self.orderId = iprot.readI64();
12405 
        else:
12406 
          iprot.skip(ftype)
3226 chandransh 12407 
      elif fid == 2:
12408 
        if ftype == TType.STRING:
12409 
          self.refundedBy = iprot.readString();
12410 
        else:
12411 
          iprot.skip(ftype)
12412 
      elif fid == 3:
12413 
        if ftype == TType.STRING:
12414 
          self.reason = iprot.readString();
12415 
        else:
12416 
          iprot.skip(ftype)
2616 chandransh 12417 
      else:
12418 
        iprot.skip(ftype)
12419 
      iprot.readFieldEnd()
12420 
    iprot.readStructEnd()
12421 
 
12422 
  def write(self, oprot):
12423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12425 
      return
12426 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 12427 
    if self.orderId is not None:
2616 chandransh 12428 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12429 
      oprot.writeI64(self.orderId)
12430 
      oprot.writeFieldEnd()
3431 rajveer 12431 
    if self.refundedBy is not None:
3226 chandransh 12432 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
12433 
      oprot.writeString(self.refundedBy)
12434 
      oprot.writeFieldEnd()
3431 rajveer 12435 
    if self.reason is not None:
3226 chandransh 12436 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
12437 
      oprot.writeString(self.reason)
12438 
      oprot.writeFieldEnd()
2616 chandransh 12439 
    oprot.writeFieldStop()
12440 
    oprot.writeStructEnd()
12441 
 
3431 rajveer 12442 
  def validate(self):
12443 
    return
12444 
 
12445 
 
2616 chandransh 12446 
  def __repr__(self):
12447 
    L = ['%s=%r' % (key, value)
12448 
      for key, value in self.__dict__.iteritems()]
12449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12450 
 
12451 
  def __eq__(self, other):
12452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12453 
 
12454 
  def __ne__(self, other):
12455 
    return not (self == other)
12456 
 
12457 
class refundOrder_result:
12458 
  """
12459 
  Attributes:
12460 
   - success
12461 
   - ex
12462 
  """
12463 
 
12464 
  thrift_spec = (
12465 
    (0, TType.BOOL, 'success', None, None, ), # 0
12466 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12467 
  )
12468 
 
12469 
  def __init__(self, success=None, ex=None,):
12470 
    self.success = success
12471 
    self.ex = ex
12472 
 
12473 
  def read(self, iprot):
12474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12476 
      return
12477 
    iprot.readStructBegin()
12478 
    while True:
12479 
      (fname, ftype, fid) = iprot.readFieldBegin()
12480 
      if ftype == TType.STOP:
12481 
        break
12482 
      if fid == 0:
12483 
        if ftype == TType.BOOL:
12484 
          self.success = iprot.readBool();
12485 
        else:
12486 
          iprot.skip(ftype)
12487 
      elif fid == 1:
12488 
        if ftype == TType.STRUCT:
12489 
          self.ex = TransactionServiceException()
12490 
          self.ex.read(iprot)
12491 
        else:
12492 
          iprot.skip(ftype)
12493 
      else:
12494 
        iprot.skip(ftype)
12495 
      iprot.readFieldEnd()
12496 
    iprot.readStructEnd()
12497 
 
12498 
  def write(self, oprot):
12499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12501 
      return
12502 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 12503 
    if self.success is not None:
2616 chandransh 12504 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12505 
      oprot.writeBool(self.success)
12506 
      oprot.writeFieldEnd()
3431 rajveer 12507 
    if self.ex is not None:
2616 chandransh 12508 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12509 
      self.ex.write(oprot)
12510 
      oprot.writeFieldEnd()
12511 
    oprot.writeFieldStop()
12512 
    oprot.writeStructEnd()
12513 
 
3431 rajveer 12514 
  def validate(self):
12515 
    return
12516 
 
12517 
 
2616 chandransh 12518 
  def __repr__(self):
12519 
    L = ['%s=%r' % (key, value)
12520 
      for key, value in self.__dict__.iteritems()]
12521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12522 
 
12523 
  def __eq__(self, other):
12524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12525 
 
12526 
  def __ne__(self, other):
12527 
    return not (self == other)
12528 
 
2690 chandransh 12529 
class getReturnOrders_args:
12530 
  """
12531 
  Attributes:
12532 
   - warehouseId
12533 
   - fromDate
12534 
   - toDate
12535 
  """
2616 chandransh 12536 
 
2690 chandransh 12537 
  thrift_spec = (
12538 
    None, # 0
12539 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12540 
    (2, TType.I64, 'fromDate', None, None, ), # 2
12541 
    (3, TType.I64, 'toDate', None, None, ), # 3
12542 
  )
12543 
 
12544 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
12545 
    self.warehouseId = warehouseId
12546 
    self.fromDate = fromDate
12547 
    self.toDate = toDate
12548 
 
12549 
  def read(self, iprot):
12550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12552 
      return
12553 
    iprot.readStructBegin()
12554 
    while True:
12555 
      (fname, ftype, fid) = iprot.readFieldBegin()
12556 
      if ftype == TType.STOP:
12557 
        break
12558 
      if fid == 1:
12559 
        if ftype == TType.I64:
12560 
          self.warehouseId = iprot.readI64();
12561 
        else:
12562 
          iprot.skip(ftype)
12563 
      elif fid == 2:
12564 
        if ftype == TType.I64:
12565 
          self.fromDate = iprot.readI64();
12566 
        else:
12567 
          iprot.skip(ftype)
12568 
      elif fid == 3:
12569 
        if ftype == TType.I64:
12570 
          self.toDate = iprot.readI64();
12571 
        else:
12572 
          iprot.skip(ftype)
12573 
      else:
12574 
        iprot.skip(ftype)
12575 
      iprot.readFieldEnd()
12576 
    iprot.readStructEnd()
12577 
 
12578 
  def write(self, oprot):
12579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12581 
      return
12582 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 12583 
    if self.warehouseId is not None:
2690 chandransh 12584 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12585 
      oprot.writeI64(self.warehouseId)
12586 
      oprot.writeFieldEnd()
3431 rajveer 12587 
    if self.fromDate is not None:
2690 chandransh 12588 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
12589 
      oprot.writeI64(self.fromDate)
12590 
      oprot.writeFieldEnd()
3431 rajveer 12591 
    if self.toDate is not None:
2690 chandransh 12592 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
12593 
      oprot.writeI64(self.toDate)
12594 
      oprot.writeFieldEnd()
12595 
    oprot.writeFieldStop()
12596 
    oprot.writeStructEnd()
12597 
 
3431 rajveer 12598 
  def validate(self):
12599 
    return
12600 
 
12601 
 
2690 chandransh 12602 
  def __repr__(self):
12603 
    L = ['%s=%r' % (key, value)
12604 
      for key, value in self.__dict__.iteritems()]
12605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12606 
 
12607 
  def __eq__(self, other):
12608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12609 
 
12610 
  def __ne__(self, other):
12611 
    return not (self == other)
12612 
 
12613 
class getReturnOrders_result:
12614 
  """
12615 
  Attributes:
12616 
   - success
12617 
  """
12618 
 
12619 
  thrift_spec = (
12620 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
12621 
  )
12622 
 
12623 
  def __init__(self, success=None,):
12624 
    self.success = success
12625 
 
12626 
  def read(self, iprot):
12627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12629 
      return
12630 
    iprot.readStructBegin()
12631 
    while True:
12632 
      (fname, ftype, fid) = iprot.readFieldBegin()
12633 
      if ftype == TType.STOP:
12634 
        break
12635 
      if fid == 0:
12636 
        if ftype == TType.LIST:
12637 
          self.success = []
4133 chandransh 12638 
          (_etype209, _size206) = iprot.readListBegin()
12639 
          for _i210 in xrange(_size206):
12640 
            _elem211 = ReturnOrder()
12641 
            _elem211.read(iprot)
12642 
            self.success.append(_elem211)
2690 chandransh 12643 
          iprot.readListEnd()
12644 
        else:
12645 
          iprot.skip(ftype)
12646 
      else:
12647 
        iprot.skip(ftype)
12648 
      iprot.readFieldEnd()
12649 
    iprot.readStructEnd()
12650 
 
12651 
  def write(self, oprot):
12652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12654 
      return
12655 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 12656 
    if self.success is not None:
2690 chandransh 12657 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12658 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 12659 
      for iter212 in self.success:
12660 
        iter212.write(oprot)
2690 chandransh 12661 
      oprot.writeListEnd()
12662 
      oprot.writeFieldEnd()
12663 
    oprot.writeFieldStop()
12664 
    oprot.writeStructEnd()
12665 
 
3431 rajveer 12666 
  def validate(self):
12667 
    return
12668 
 
12669 
 
2690 chandransh 12670 
  def __repr__(self):
12671 
    L = ['%s=%r' % (key, value)
12672 
      for key, value in self.__dict__.iteritems()]
12673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12674 
 
12675 
  def __eq__(self, other):
12676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12677 
 
12678 
  def __ne__(self, other):
12679 
    return not (self == other)
12680 
 
2700 chandransh 12681 
class getReturnOrder_args:
12682 
  """
12683 
  Attributes:
12684 
   - id
12685 
  """
12686 
 
12687 
  thrift_spec = (
12688 
    None, # 0
12689 
    (1, TType.I64, 'id', None, None, ), # 1
12690 
  )
12691 
 
12692 
  def __init__(self, id=None,):
12693 
    self.id = id
12694 
 
12695 
  def read(self, iprot):
12696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12698 
      return
12699 
    iprot.readStructBegin()
12700 
    while True:
12701 
      (fname, ftype, fid) = iprot.readFieldBegin()
12702 
      if ftype == TType.STOP:
12703 
        break
12704 
      if fid == 1:
12705 
        if ftype == TType.I64:
12706 
          self.id = iprot.readI64();
12707 
        else:
12708 
          iprot.skip(ftype)
12709 
      else:
12710 
        iprot.skip(ftype)
12711 
      iprot.readFieldEnd()
12712 
    iprot.readStructEnd()
12713 
 
12714 
  def write(self, oprot):
12715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12717 
      return
12718 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 12719 
    if self.id is not None:
2700 chandransh 12720 
      oprot.writeFieldBegin('id', TType.I64, 1)
12721 
      oprot.writeI64(self.id)
12722 
      oprot.writeFieldEnd()
12723 
    oprot.writeFieldStop()
12724 
    oprot.writeStructEnd()
12725 
 
3431 rajveer 12726 
  def validate(self):
12727 
    return
12728 
 
12729 
 
2700 chandransh 12730 
  def __repr__(self):
12731 
    L = ['%s=%r' % (key, value)
12732 
      for key, value in self.__dict__.iteritems()]
12733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12734 
 
12735 
  def __eq__(self, other):
12736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12737 
 
12738 
  def __ne__(self, other):
12739 
    return not (self == other)
12740 
 
12741 
class getReturnOrder_result:
12742 
  """
12743 
  Attributes:
12744 
   - success
12745 
   - ex
12746 
  """
12747 
 
12748 
  thrift_spec = (
12749 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
12750 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12751 
  )
12752 
 
12753 
  def __init__(self, success=None, ex=None,):
12754 
    self.success = success
12755 
    self.ex = ex
12756 
 
12757 
  def read(self, iprot):
12758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12760 
      return
12761 
    iprot.readStructBegin()
12762 
    while True:
12763 
      (fname, ftype, fid) = iprot.readFieldBegin()
12764 
      if ftype == TType.STOP:
12765 
        break
12766 
      if fid == 0:
12767 
        if ftype == TType.STRUCT:
12768 
          self.success = ReturnOrder()
12769 
          self.success.read(iprot)
12770 
        else:
12771 
          iprot.skip(ftype)
12772 
      elif fid == 1:
12773 
        if ftype == TType.STRUCT:
12774 
          self.ex = TransactionServiceException()
12775 
          self.ex.read(iprot)
12776 
        else:
12777 
          iprot.skip(ftype)
12778 
      else:
12779 
        iprot.skip(ftype)
12780 
      iprot.readFieldEnd()
12781 
    iprot.readStructEnd()
12782 
 
12783 
  def write(self, oprot):
12784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12786 
      return
12787 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 12788 
    if self.success is not None:
2700 chandransh 12789 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12790 
      self.success.write(oprot)
12791 
      oprot.writeFieldEnd()
3431 rajveer 12792 
    if self.ex is not None:
2700 chandransh 12793 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12794 
      self.ex.write(oprot)
12795 
      oprot.writeFieldEnd()
12796 
    oprot.writeFieldStop()
12797 
    oprot.writeStructEnd()
12798 
 
3431 rajveer 12799 
  def validate(self):
12800 
    return
12801 
 
12802 
 
2700 chandransh 12803 
  def __repr__(self):
12804 
    L = ['%s=%r' % (key, value)
12805 
      for key, value in self.__dict__.iteritems()]
12806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12807 
 
12808 
  def __eq__(self, other):
12809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12810 
 
12811 
  def __ne__(self, other):
12812 
    return not (self == other)
12813 
 
2690 chandransh 12814 
class processReturn_args:
12815 
  """
12816 
  Attributes:
12817 
   - returnOrderId
12818 
  """
12819 
 
12820 
  thrift_spec = (
12821 
    None, # 0
12822 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
12823 
  )
12824 
 
12825 
  def __init__(self, returnOrderId=None,):
12826 
    self.returnOrderId = returnOrderId
12827 
 
12828 
  def read(self, iprot):
12829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12831 
      return
12832 
    iprot.readStructBegin()
12833 
    while True:
12834 
      (fname, ftype, fid) = iprot.readFieldBegin()
12835 
      if ftype == TType.STOP:
12836 
        break
12837 
      if fid == 1:
12838 
        if ftype == TType.I64:
12839 
          self.returnOrderId = iprot.readI64();
12840 
        else:
12841 
          iprot.skip(ftype)
12842 
      else:
12843 
        iprot.skip(ftype)
12844 
      iprot.readFieldEnd()
12845 
    iprot.readStructEnd()
12846 
 
12847 
  def write(self, oprot):
12848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12850 
      return
12851 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 12852 
    if self.returnOrderId is not None:
2690 chandransh 12853 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
12854 
      oprot.writeI64(self.returnOrderId)
12855 
      oprot.writeFieldEnd()
12856 
    oprot.writeFieldStop()
12857 
    oprot.writeStructEnd()
12858 
 
3431 rajveer 12859 
  def validate(self):
12860 
    return
12861 
 
12862 
 
2690 chandransh 12863 
  def __repr__(self):
12864 
    L = ['%s=%r' % (key, value)
12865 
      for key, value in self.__dict__.iteritems()]
12866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12867 
 
12868 
  def __eq__(self, other):
12869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12870 
 
12871 
  def __ne__(self, other):
12872 
    return not (self == other)
12873 
 
12874 
class processReturn_result:
12875 
  """
12876 
  Attributes:
12877 
   - ex
12878 
  """
12879 
 
12880 
  thrift_spec = (
12881 
    None, # 0
12882 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12883 
  )
12884 
 
12885 
  def __init__(self, ex=None,):
12886 
    self.ex = ex
12887 
 
12888 
  def read(self, iprot):
12889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12891 
      return
12892 
    iprot.readStructBegin()
12893 
    while True:
12894 
      (fname, ftype, fid) = iprot.readFieldBegin()
12895 
      if ftype == TType.STOP:
12896 
        break
12897 
      if fid == 1:
12898 
        if ftype == TType.STRUCT:
12899 
          self.ex = TransactionServiceException()
12900 
          self.ex.read(iprot)
12901 
        else:
12902 
          iprot.skip(ftype)
12903 
      else:
12904 
        iprot.skip(ftype)
12905 
      iprot.readFieldEnd()
12906 
    iprot.readStructEnd()
12907 
 
12908 
  def write(self, oprot):
12909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12911 
      return
12912 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 12913 
    if self.ex is not None:
2690 chandransh 12914 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12915 
      self.ex.write(oprot)
12916 
      oprot.writeFieldEnd()
12917 
    oprot.writeFieldStop()
12918 
    oprot.writeStructEnd()
12919 
 
3431 rajveer 12920 
  def validate(self):
12921 
    return
12922 
 
12923 
 
2690 chandransh 12924 
  def __repr__(self):
12925 
    L = ['%s=%r' % (key, value)
12926 
      for key, value in self.__dict__.iteritems()]
12927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12928 
 
12929 
  def __eq__(self, other):
12930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12931 
 
12932 
  def __ne__(self, other):
12933 
    return not (self == other)
12934 
 
2819 chandransh 12935 
class createPurchaseOrder_args:
12936 
  """
12937 
  Attributes:
12938 
   - warehouseId
12939 
  """
2690 chandransh 12940 
 
2819 chandransh 12941 
  thrift_spec = (
12942 
    None, # 0
12943 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12944 
  )
12945 
 
12946 
  def __init__(self, warehouseId=None,):
12947 
    self.warehouseId = warehouseId
12948 
 
12949 
  def read(self, iprot):
12950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12952 
      return
12953 
    iprot.readStructBegin()
12954 
    while True:
12955 
      (fname, ftype, fid) = iprot.readFieldBegin()
12956 
      if ftype == TType.STOP:
12957 
        break
12958 
      if fid == 1:
12959 
        if ftype == TType.I64:
12960 
          self.warehouseId = iprot.readI64();
12961 
        else:
12962 
          iprot.skip(ftype)
12963 
      else:
12964 
        iprot.skip(ftype)
12965 
      iprot.readFieldEnd()
12966 
    iprot.readStructEnd()
12967 
 
12968 
  def write(self, oprot):
12969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12971 
      return
12972 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 12973 
    if self.warehouseId is not None:
2819 chandransh 12974 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12975 
      oprot.writeI64(self.warehouseId)
12976 
      oprot.writeFieldEnd()
12977 
    oprot.writeFieldStop()
12978 
    oprot.writeStructEnd()
12979 
 
3431 rajveer 12980 
  def validate(self):
12981 
    return
12982 
 
12983 
 
2819 chandransh 12984 
  def __repr__(self):
12985 
    L = ['%s=%r' % (key, value)
12986 
      for key, value in self.__dict__.iteritems()]
12987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12988 
 
12989 
  def __eq__(self, other):
12990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12991 
 
12992 
  def __ne__(self, other):
12993 
    return not (self == other)
12994 
 
12995 
class createPurchaseOrder_result:
12996 
  """
12997 
  Attributes:
12998 
   - success
12999 
   - ex
13000 
  """
13001 
 
13002 
  thrift_spec = (
13003 
    (0, TType.I64, 'success', None, None, ), # 0
13004 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13005 
  )
13006 
 
13007 
  def __init__(self, success=None, ex=None,):
13008 
    self.success = success
13009 
    self.ex = ex
13010 
 
13011 
  def read(self, iprot):
13012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13014 
      return
13015 
    iprot.readStructBegin()
13016 
    while True:
13017 
      (fname, ftype, fid) = iprot.readFieldBegin()
13018 
      if ftype == TType.STOP:
13019 
        break
13020 
      if fid == 0:
13021 
        if ftype == TType.I64:
13022 
          self.success = iprot.readI64();
13023 
        else:
13024 
          iprot.skip(ftype)
13025 
      elif fid == 1:
13026 
        if ftype == TType.STRUCT:
13027 
          self.ex = TransactionServiceException()
13028 
          self.ex.read(iprot)
13029 
        else:
13030 
          iprot.skip(ftype)
13031 
      else:
13032 
        iprot.skip(ftype)
13033 
      iprot.readFieldEnd()
13034 
    iprot.readStructEnd()
13035 
 
13036 
  def write(self, oprot):
13037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13039 
      return
13040 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 13041 
    if self.success is not None:
2819 chandransh 13042 
      oprot.writeFieldBegin('success', TType.I64, 0)
13043 
      oprot.writeI64(self.success)
13044 
      oprot.writeFieldEnd()
3431 rajveer 13045 
    if self.ex is not None:
2819 chandransh 13046 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13047 
      self.ex.write(oprot)
13048 
      oprot.writeFieldEnd()
13049 
    oprot.writeFieldStop()
13050 
    oprot.writeStructEnd()
13051 
 
3431 rajveer 13052 
  def validate(self):
13053 
    return
13054 
 
13055 
 
2819 chandransh 13056 
  def __repr__(self):
13057 
    L = ['%s=%r' % (key, value)
13058 
      for key, value in self.__dict__.iteritems()]
13059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13060 
 
13061 
  def __eq__(self, other):
13062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13063 
 
13064 
  def __ne__(self, other):
13065 
    return not (self == other)
3451 chandransh 13066 
 
13067 
class updateWeight_args:
13068 
  """
13069 
  Attributes:
13070 
   - orderId
13071 
   - weight
13072 
  """
13073 
 
13074 
  thrift_spec = (
13075 
    None, # 0
13076 
    (1, TType.I64, 'orderId', None, None, ), # 1
13077 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
13078 
  )
13079 
 
13080 
  def __init__(self, orderId=None, weight=None,):
13081 
    self.orderId = orderId
13082 
    self.weight = weight
13083 
 
13084 
  def read(self, iprot):
13085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13087 
      return
13088 
    iprot.readStructBegin()
13089 
    while True:
13090 
      (fname, ftype, fid) = iprot.readFieldBegin()
13091 
      if ftype == TType.STOP:
13092 
        break
13093 
      if fid == 1:
13094 
        if ftype == TType.I64:
13095 
          self.orderId = iprot.readI64();
13096 
        else:
13097 
          iprot.skip(ftype)
13098 
      elif fid == 2:
13099 
        if ftype == TType.DOUBLE:
13100 
          self.weight = iprot.readDouble();
13101 
        else:
13102 
          iprot.skip(ftype)
13103 
      else:
13104 
        iprot.skip(ftype)
13105 
      iprot.readFieldEnd()
13106 
    iprot.readStructEnd()
13107 
 
13108 
  def write(self, oprot):
13109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13111 
      return
13112 
    oprot.writeStructBegin('updateWeight_args')
13113 
    if self.orderId is not None:
13114 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13115 
      oprot.writeI64(self.orderId)
13116 
      oprot.writeFieldEnd()
13117 
    if self.weight is not None:
13118 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
13119 
      oprot.writeDouble(self.weight)
13120 
      oprot.writeFieldEnd()
13121 
    oprot.writeFieldStop()
13122 
    oprot.writeStructEnd()
13123 
 
13124 
  def validate(self):
13125 
    return
13126 
 
13127 
 
13128 
  def __repr__(self):
13129 
    L = ['%s=%r' % (key, value)
13130 
      for key, value in self.__dict__.iteritems()]
13131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13132 
 
13133 
  def __eq__(self, other):
13134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13135 
 
13136 
  def __ne__(self, other):
13137 
    return not (self == other)
13138 
 
13139 
class updateWeight_result:
13140 
  """
13141 
  Attributes:
13142 
   - success
13143 
   - ex
13144 
  """
13145 
 
13146 
  thrift_spec = (
13147 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13148 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13149 
  )
13150 
 
13151 
  def __init__(self, success=None, ex=None,):
13152 
    self.success = success
13153 
    self.ex = ex
13154 
 
13155 
  def read(self, iprot):
13156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13158 
      return
13159 
    iprot.readStructBegin()
13160 
    while True:
13161 
      (fname, ftype, fid) = iprot.readFieldBegin()
13162 
      if ftype == TType.STOP:
13163 
        break
13164 
      if fid == 0:
13165 
        if ftype == TType.STRUCT:
13166 
          self.success = Order()
13167 
          self.success.read(iprot)
13168 
        else:
13169 
          iprot.skip(ftype)
13170 
      elif fid == 1:
13171 
        if ftype == TType.STRUCT:
13172 
          self.ex = TransactionServiceException()
13173 
          self.ex.read(iprot)
13174 
        else:
13175 
          iprot.skip(ftype)
13176 
      else:
13177 
        iprot.skip(ftype)
13178 
      iprot.readFieldEnd()
13179 
    iprot.readStructEnd()
13180 
 
13181 
  def write(self, oprot):
13182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13184 
      return
13185 
    oprot.writeStructBegin('updateWeight_result')
13186 
    if self.success is not None:
13187 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13188 
      self.success.write(oprot)
13189 
      oprot.writeFieldEnd()
13190 
    if self.ex is not None:
13191 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13192 
      self.ex.write(oprot)
13193 
      oprot.writeFieldEnd()
13194 
    oprot.writeFieldStop()
13195 
    oprot.writeStructEnd()
13196 
 
13197 
  def validate(self):
13198 
    return
13199 
 
13200 
 
13201 
  def __repr__(self):
13202 
    L = ['%s=%r' % (key, value)
13203 
      for key, value in self.__dict__.iteritems()]
13204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13205 
 
13206 
  def __eq__(self, other):
13207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13208 
 
13209 
  def __ne__(self, other):
13210 
    return not (self == other)
3469 chandransh 13211 
 
13212 
class changeItem_args:
13213 
  """
13214 
  Attributes:
13215 
   - orderId
13216 
   - itemId
13217 
  """
13218 
 
13219 
  thrift_spec = (
13220 
    None, # 0
13221 
    (1, TType.I64, 'orderId', None, None, ), # 1
13222 
    (2, TType.I64, 'itemId', None, None, ), # 2
13223 
  )
13224 
 
13225 
  def __init__(self, orderId=None, itemId=None,):
13226 
    self.orderId = orderId
13227 
    self.itemId = itemId
13228 
 
13229 
  def read(self, iprot):
13230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13232 
      return
13233 
    iprot.readStructBegin()
13234 
    while True:
13235 
      (fname, ftype, fid) = iprot.readFieldBegin()
13236 
      if ftype == TType.STOP:
13237 
        break
13238 
      if fid == 1:
13239 
        if ftype == TType.I64:
13240 
          self.orderId = iprot.readI64();
13241 
        else:
13242 
          iprot.skip(ftype)
13243 
      elif fid == 2:
13244 
        if ftype == TType.I64:
13245 
          self.itemId = iprot.readI64();
13246 
        else:
13247 
          iprot.skip(ftype)
13248 
      else:
13249 
        iprot.skip(ftype)
13250 
      iprot.readFieldEnd()
13251 
    iprot.readStructEnd()
13252 
 
13253 
  def write(self, oprot):
13254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13256 
      return
13257 
    oprot.writeStructBegin('changeItem_args')
13258 
    if self.orderId is not None:
13259 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13260 
      oprot.writeI64(self.orderId)
13261 
      oprot.writeFieldEnd()
13262 
    if self.itemId is not None:
13263 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13264 
      oprot.writeI64(self.itemId)
13265 
      oprot.writeFieldEnd()
13266 
    oprot.writeFieldStop()
13267 
    oprot.writeStructEnd()
13268 
 
13269 
  def validate(self):
13270 
    return
13271 
 
13272 
 
13273 
  def __repr__(self):
13274 
    L = ['%s=%r' % (key, value)
13275 
      for key, value in self.__dict__.iteritems()]
13276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13277 
 
13278 
  def __eq__(self, other):
13279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13280 
 
13281 
  def __ne__(self, other):
13282 
    return not (self == other)
13283 
 
13284 
class changeItem_result:
13285 
  """
13286 
  Attributes:
13287 
   - success
13288 
   - ex
13289 
  """
13290 
 
13291 
  thrift_spec = (
13292 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13293 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13294 
  )
13295 
 
13296 
  def __init__(self, success=None, ex=None,):
13297 
    self.success = success
13298 
    self.ex = ex
13299 
 
13300 
  def read(self, iprot):
13301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13303 
      return
13304 
    iprot.readStructBegin()
13305 
    while True:
13306 
      (fname, ftype, fid) = iprot.readFieldBegin()
13307 
      if ftype == TType.STOP:
13308 
        break
13309 
      if fid == 0:
13310 
        if ftype == TType.STRUCT:
13311 
          self.success = Order()
13312 
          self.success.read(iprot)
13313 
        else:
13314 
          iprot.skip(ftype)
13315 
      elif fid == 1:
13316 
        if ftype == TType.STRUCT:
13317 
          self.ex = TransactionServiceException()
13318 
          self.ex.read(iprot)
13319 
        else:
13320 
          iprot.skip(ftype)
13321 
      else:
13322 
        iprot.skip(ftype)
13323 
      iprot.readFieldEnd()
13324 
    iprot.readStructEnd()
13325 
 
13326 
  def write(self, oprot):
13327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13329 
      return
13330 
    oprot.writeStructBegin('changeItem_result')
13331 
    if self.success is not None:
13332 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13333 
      self.success.write(oprot)
13334 
      oprot.writeFieldEnd()
13335 
    if self.ex is not None:
13336 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13337 
      self.ex.write(oprot)
13338 
      oprot.writeFieldEnd()
13339 
    oprot.writeFieldStop()
13340 
    oprot.writeStructEnd()
13341 
 
13342 
  def validate(self):
13343 
    return
13344 
 
13345 
 
13346 
  def __repr__(self):
13347 
    L = ['%s=%r' % (key, value)
13348 
      for key, value in self.__dict__.iteritems()]
13349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13350 
 
13351 
  def __eq__(self, other):
13352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13353 
 
13354 
  def __ne__(self, other):
13355 
    return not (self == other)
13356 
 
13357 
class shiftToWarehouse_args:
13358 
  """
13359 
  Attributes:
13360 
   - orderId
13361 
   - warehouseId
13362 
  """
13363 
 
13364 
  thrift_spec = (
13365 
    None, # 0
13366 
    (1, TType.I64, 'orderId', None, None, ), # 1
13367 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13368 
  )
13369 
 
13370 
  def __init__(self, orderId=None, warehouseId=None,):
13371 
    self.orderId = orderId
13372 
    self.warehouseId = warehouseId
13373 
 
13374 
  def read(self, iprot):
13375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13377 
      return
13378 
    iprot.readStructBegin()
13379 
    while True:
13380 
      (fname, ftype, fid) = iprot.readFieldBegin()
13381 
      if ftype == TType.STOP:
13382 
        break
13383 
      if fid == 1:
13384 
        if ftype == TType.I64:
13385 
          self.orderId = iprot.readI64();
13386 
        else:
13387 
          iprot.skip(ftype)
13388 
      elif fid == 2:
13389 
        if ftype == TType.I64:
13390 
          self.warehouseId = iprot.readI64();
13391 
        else:
13392 
          iprot.skip(ftype)
13393 
      else:
13394 
        iprot.skip(ftype)
13395 
      iprot.readFieldEnd()
13396 
    iprot.readStructEnd()
13397 
 
13398 
  def write(self, oprot):
13399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13401 
      return
13402 
    oprot.writeStructBegin('shiftToWarehouse_args')
13403 
    if self.orderId is not None:
13404 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13405 
      oprot.writeI64(self.orderId)
13406 
      oprot.writeFieldEnd()
13407 
    if self.warehouseId is not None:
13408 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13409 
      oprot.writeI64(self.warehouseId)
13410 
      oprot.writeFieldEnd()
13411 
    oprot.writeFieldStop()
13412 
    oprot.writeStructEnd()
13413 
 
13414 
  def validate(self):
13415 
    return
13416 
 
13417 
 
13418 
  def __repr__(self):
13419 
    L = ['%s=%r' % (key, value)
13420 
      for key, value in self.__dict__.iteritems()]
13421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13422 
 
13423 
  def __eq__(self, other):
13424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13425 
 
13426 
  def __ne__(self, other):
13427 
    return not (self == other)
13428 
 
13429 
class shiftToWarehouse_result:
13430 
  """
13431 
  Attributes:
13432 
   - success
13433 
   - ex
13434 
  """
13435 
 
13436 
  thrift_spec = (
13437 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13438 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13439 
  )
13440 
 
13441 
  def __init__(self, success=None, ex=None,):
13442 
    self.success = success
13443 
    self.ex = ex
13444 
 
13445 
  def read(self, iprot):
13446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13448 
      return
13449 
    iprot.readStructBegin()
13450 
    while True:
13451 
      (fname, ftype, fid) = iprot.readFieldBegin()
13452 
      if ftype == TType.STOP:
13453 
        break
13454 
      if fid == 0:
13455 
        if ftype == TType.STRUCT:
13456 
          self.success = Order()
13457 
          self.success.read(iprot)
13458 
        else:
13459 
          iprot.skip(ftype)
13460 
      elif fid == 1:
13461 
        if ftype == TType.STRUCT:
13462 
          self.ex = TransactionServiceException()
13463 
          self.ex.read(iprot)
13464 
        else:
13465 
          iprot.skip(ftype)
13466 
      else:
13467 
        iprot.skip(ftype)
13468 
      iprot.readFieldEnd()
13469 
    iprot.readStructEnd()
13470 
 
13471 
  def write(self, oprot):
13472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13474 
      return
13475 
    oprot.writeStructBegin('shiftToWarehouse_result')
13476 
    if self.success is not None:
13477 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13478 
      self.success.write(oprot)
13479 
      oprot.writeFieldEnd()
13480 
    if self.ex is not None:
13481 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13482 
      self.ex.write(oprot)
13483 
      oprot.writeFieldEnd()
13484 
    oprot.writeFieldStop()
13485 
    oprot.writeStructEnd()
13486 
 
13487 
  def validate(self):
13488 
    return
13489 
 
13490 
 
13491 
  def __repr__(self):
13492 
    L = ['%s=%r' % (key, value)
13493 
      for key, value in self.__dict__.iteritems()]
13494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13495 
 
13496 
  def __eq__(self, other):
13497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13498 
 
13499 
  def __ne__(self, other):
13500 
    return not (self == other)
3553 chandransh 13501 
 
13502 
class addDelayReason_args:
13503 
  """
13504 
  Attributes:
13505 
   - orderId
13506 
   - delayReason
3986 chandransh 13507 
   - furtherDelay
3553 chandransh 13508 
  """
13509 
 
13510 
  thrift_spec = (
13511 
    None, # 0
13512 
    (1, TType.I64, 'orderId', None, None, ), # 1
13513 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 13514 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 13515 
  )
13516 
 
3986 chandransh 13517 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 13518 
    self.orderId = orderId
13519 
    self.delayReason = delayReason
3986 chandransh 13520 
    self.furtherDelay = furtherDelay
3553 chandransh 13521 
 
13522 
  def read(self, iprot):
13523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13525 
      return
13526 
    iprot.readStructBegin()
13527 
    while True:
13528 
      (fname, ftype, fid) = iprot.readFieldBegin()
13529 
      if ftype == TType.STOP:
13530 
        break
13531 
      if fid == 1:
13532 
        if ftype == TType.I64:
13533 
          self.orderId = iprot.readI64();
13534 
        else:
13535 
          iprot.skip(ftype)
13536 
      elif fid == 2:
13537 
        if ftype == TType.I32:
13538 
          self.delayReason = iprot.readI32();
13539 
        else:
13540 
          iprot.skip(ftype)
3986 chandransh 13541 
      elif fid == 3:
13542 
        if ftype == TType.I64:
13543 
          self.furtherDelay = iprot.readI64();
13544 
        else:
13545 
          iprot.skip(ftype)
3553 chandransh 13546 
      else:
13547 
        iprot.skip(ftype)
13548 
      iprot.readFieldEnd()
13549 
    iprot.readStructEnd()
13550 
 
13551 
  def write(self, oprot):
13552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13554 
      return
13555 
    oprot.writeStructBegin('addDelayReason_args')
13556 
    if self.orderId is not None:
13557 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13558 
      oprot.writeI64(self.orderId)
13559 
      oprot.writeFieldEnd()
13560 
    if self.delayReason is not None:
13561 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
13562 
      oprot.writeI32(self.delayReason)
13563 
      oprot.writeFieldEnd()
3986 chandransh 13564 
    if self.furtherDelay is not None:
13565 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
13566 
      oprot.writeI64(self.furtherDelay)
13567 
      oprot.writeFieldEnd()
3553 chandransh 13568 
    oprot.writeFieldStop()
13569 
    oprot.writeStructEnd()
13570 
 
13571 
  def validate(self):
13572 
    return
13573 
 
13574 
 
13575 
  def __repr__(self):
13576 
    L = ['%s=%r' % (key, value)
13577 
      for key, value in self.__dict__.iteritems()]
13578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13579 
 
13580 
  def __eq__(self, other):
13581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13582 
 
13583 
  def __ne__(self, other):
13584 
    return not (self == other)
13585 
 
13586 
class addDelayReason_result:
13587 
  """
13588 
  Attributes:
13589 
   - success
13590 
   - ex
13591 
  """
13592 
 
13593 
  thrift_spec = (
13594 
    (0, TType.BOOL, 'success', None, None, ), # 0
13595 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13596 
  )
13597 
 
13598 
  def __init__(self, success=None, ex=None,):
13599 
    self.success = success
13600 
    self.ex = ex
13601 
 
13602 
  def read(self, iprot):
13603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13605 
      return
13606 
    iprot.readStructBegin()
13607 
    while True:
13608 
      (fname, ftype, fid) = iprot.readFieldBegin()
13609 
      if ftype == TType.STOP:
13610 
        break
13611 
      if fid == 0:
13612 
        if ftype == TType.BOOL:
13613 
          self.success = iprot.readBool();
13614 
        else:
13615 
          iprot.skip(ftype)
13616 
      elif fid == 1:
13617 
        if ftype == TType.STRUCT:
13618 
          self.ex = TransactionServiceException()
13619 
          self.ex.read(iprot)
13620 
        else:
13621 
          iprot.skip(ftype)
13622 
      else:
13623 
        iprot.skip(ftype)
13624 
      iprot.readFieldEnd()
13625 
    iprot.readStructEnd()
13626 
 
13627 
  def write(self, oprot):
13628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13630 
      return
13631 
    oprot.writeStructBegin('addDelayReason_result')
13632 
    if self.success is not None:
13633 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13634 
      oprot.writeBool(self.success)
13635 
      oprot.writeFieldEnd()
13636 
    if self.ex is not None:
13637 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13638 
      self.ex.write(oprot)
13639 
      oprot.writeFieldEnd()
13640 
    oprot.writeFieldStop()
13641 
    oprot.writeStructEnd()
13642 
 
13643 
  def validate(self):
13644 
    return
13645 
 
13646 
 
13647 
  def __repr__(self):
13648 
    L = ['%s=%r' % (key, value)
13649 
      for key, value in self.__dict__.iteritems()]
13650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13651 
 
13652 
  def __eq__(self, other):
13653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13654 
 
13655 
  def __ne__(self, other):
13656 
    return not (self == other)
3956 chandransh 13657 
 
13658 
class reconcileCodCollection_args:
13659 
  """
13660 
  Attributes:
13661 
   - collectedAmountMap
13662 
   - xferBy
13663 
   - xferTxnId
13664 
   - xferDate
13665 
  """
13666 
 
13667 
  thrift_spec = (
13668 
    None, # 0
13669 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
13670 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
13671 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
13672 
    (4, TType.I64, 'xferDate', None, None, ), # 4
13673 
  )
13674 
 
13675 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
13676 
    self.collectedAmountMap = collectedAmountMap
13677 
    self.xferBy = xferBy
13678 
    self.xferTxnId = xferTxnId
13679 
    self.xferDate = xferDate
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 == 1:
13691 
        if ftype == TType.MAP:
13692 
          self.collectedAmountMap = {}
4133 chandransh 13693 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
13694 
          for _i217 in xrange(_size213):
13695 
            _key218 = iprot.readString();
13696 
            _val219 = iprot.readDouble();
13697 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 13698 
          iprot.readMapEnd()
13699 
        else:
13700 
          iprot.skip(ftype)
13701 
      elif fid == 2:
13702 
        if ftype == TType.STRING:
13703 
          self.xferBy = iprot.readString();
13704 
        else:
13705 
          iprot.skip(ftype)
13706 
      elif fid == 3:
13707 
        if ftype == TType.STRING:
13708 
          self.xferTxnId = iprot.readString();
13709 
        else:
13710 
          iprot.skip(ftype)
13711 
      elif fid == 4:
13712 
        if ftype == TType.I64:
13713 
          self.xferDate = iprot.readI64();
13714 
        else:
13715 
          iprot.skip(ftype)
13716 
      else:
13717 
        iprot.skip(ftype)
13718 
      iprot.readFieldEnd()
13719 
    iprot.readStructEnd()
13720 
 
13721 
  def write(self, oprot):
13722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13724 
      return
13725 
    oprot.writeStructBegin('reconcileCodCollection_args')
13726 
    if self.collectedAmountMap is not None:
13727 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
13728 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 13729 
      for kiter220,viter221 in self.collectedAmountMap.items():
13730 
        oprot.writeString(kiter220)
13731 
        oprot.writeDouble(viter221)
3956 chandransh 13732 
      oprot.writeMapEnd()
13733 
      oprot.writeFieldEnd()
13734 
    if self.xferBy is not None:
13735 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
13736 
      oprot.writeString(self.xferBy)
13737 
      oprot.writeFieldEnd()
13738 
    if self.xferTxnId is not None:
13739 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
13740 
      oprot.writeString(self.xferTxnId)
13741 
      oprot.writeFieldEnd()
13742 
    if self.xferDate is not None:
13743 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
13744 
      oprot.writeI64(self.xferDate)
13745 
      oprot.writeFieldEnd()
13746 
    oprot.writeFieldStop()
13747 
    oprot.writeStructEnd()
13748 
 
13749 
  def validate(self):
13750 
    return
13751 
 
13752 
 
13753 
  def __repr__(self):
13754 
    L = ['%s=%r' % (key, value)
13755 
      for key, value in self.__dict__.iteritems()]
13756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13757 
 
13758 
  def __eq__(self, other):
13759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13760 
 
13761 
  def __ne__(self, other):
13762 
    return not (self == other)
13763 
 
13764 
class reconcileCodCollection_result:
13765 
  """
13766 
  Attributes:
13767 
   - success
13768 
   - ex
13769 
  """
13770 
 
13771 
  thrift_spec = (
13772 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
13773 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13774 
  )
13775 
 
13776 
  def __init__(self, success=None, ex=None,):
13777 
    self.success = success
13778 
    self.ex = ex
13779 
 
13780 
  def read(self, iprot):
13781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13783 
      return
13784 
    iprot.readStructBegin()
13785 
    while True:
13786 
      (fname, ftype, fid) = iprot.readFieldBegin()
13787 
      if ftype == TType.STOP:
13788 
        break
13789 
      if fid == 0:
13790 
        if ftype == TType.MAP:
13791 
          self.success = {}
4133 chandransh 13792 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
13793 
          for _i226 in xrange(_size222):
13794 
            _key227 = iprot.readString();
13795 
            _val228 = iprot.readString();
13796 
            self.success[_key227] = _val228
3956 chandransh 13797 
          iprot.readMapEnd()
13798 
        else:
13799 
          iprot.skip(ftype)
13800 
      elif fid == 1:
13801 
        if ftype == TType.STRUCT:
13802 
          self.ex = TransactionServiceException()
13803 
          self.ex.read(iprot)
13804 
        else:
13805 
          iprot.skip(ftype)
13806 
      else:
13807 
        iprot.skip(ftype)
13808 
      iprot.readFieldEnd()
13809 
    iprot.readStructEnd()
13810 
 
13811 
  def write(self, oprot):
13812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13814 
      return
13815 
    oprot.writeStructBegin('reconcileCodCollection_result')
13816 
    if self.success is not None:
13817 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13818 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 13819 
      for kiter229,viter230 in self.success.items():
13820 
        oprot.writeString(kiter229)
13821 
        oprot.writeString(viter230)
3956 chandransh 13822 
      oprot.writeMapEnd()
13823 
      oprot.writeFieldEnd()
13824 
    if self.ex is not None:
13825 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13826 
      self.ex.write(oprot)
13827 
      oprot.writeFieldEnd()
13828 
    oprot.writeFieldStop()
13829 
    oprot.writeStructEnd()
13830 
 
13831 
  def validate(self):
13832 
    return
13833 
 
13834 
 
13835 
  def __repr__(self):
13836 
    L = ['%s=%r' % (key, value)
13837 
      for key, value in self.__dict__.iteritems()]
13838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13839 
 
13840 
  def __eq__(self, other):
13841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13842 
 
13843 
  def __ne__(self, other):
13844 
    return not (self == other)
4008 mandeep.dh 13845 
 
13846 
class getTransactionsRequiringExtraProcessing_args:
13847 
  """
13848 
  Attributes:
13849 
   - category
13850 
  """
13851 
 
13852 
  thrift_spec = (
13853 
    None, # 0
13854 
    (1, TType.I32, 'category', None, None, ), # 1
13855 
  )
13856 
 
13857 
  def __init__(self, category=None,):
13858 
    self.category = category
13859 
 
13860 
  def read(self, iprot):
13861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13863 
      return
13864 
    iprot.readStructBegin()
13865 
    while True:
13866 
      (fname, ftype, fid) = iprot.readFieldBegin()
13867 
      if ftype == TType.STOP:
13868 
        break
13869 
      if fid == 1:
13870 
        if ftype == TType.I32:
13871 
          self.category = iprot.readI32();
13872 
        else:
13873 
          iprot.skip(ftype)
13874 
      else:
13875 
        iprot.skip(ftype)
13876 
      iprot.readFieldEnd()
13877 
    iprot.readStructEnd()
13878 
 
13879 
  def write(self, oprot):
13880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13882 
      return
13883 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
13884 
    if self.category is not None:
13885 
      oprot.writeFieldBegin('category', TType.I32, 1)
13886 
      oprot.writeI32(self.category)
13887 
      oprot.writeFieldEnd()
13888 
    oprot.writeFieldStop()
13889 
    oprot.writeStructEnd()
13890 
 
13891 
  def validate(self):
13892 
    return
13893 
 
13894 
 
13895 
  def __repr__(self):
13896 
    L = ['%s=%r' % (key, value)
13897 
      for key, value in self.__dict__.iteritems()]
13898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13899 
 
13900 
  def __eq__(self, other):
13901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13902 
 
13903 
  def __ne__(self, other):
13904 
    return not (self == other)
13905 
 
13906 
class getTransactionsRequiringExtraProcessing_result:
13907 
  """
13908 
  Attributes:
13909 
   - success
13910 
  """
13911 
 
13912 
  thrift_spec = (
13913 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13914 
  )
13915 
 
13916 
  def __init__(self, success=None,):
13917 
    self.success = success
13918 
 
13919 
  def read(self, iprot):
13920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13922 
      return
13923 
    iprot.readStructBegin()
13924 
    while True:
13925 
      (fname, ftype, fid) = iprot.readFieldBegin()
13926 
      if ftype == TType.STOP:
13927 
        break
13928 
      if fid == 0:
13929 
        if ftype == TType.LIST:
13930 
          self.success = []
4133 chandransh 13931 
          (_etype234, _size231) = iprot.readListBegin()
13932 
          for _i235 in xrange(_size231):
13933 
            _elem236 = iprot.readI64();
13934 
            self.success.append(_elem236)
4008 mandeep.dh 13935 
          iprot.readListEnd()
13936 
        else:
13937 
          iprot.skip(ftype)
13938 
      else:
13939 
        iprot.skip(ftype)
13940 
      iprot.readFieldEnd()
13941 
    iprot.readStructEnd()
13942 
 
13943 
  def write(self, oprot):
13944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13946 
      return
13947 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
13948 
    if self.success is not None:
13949 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13950 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 13951 
      for iter237 in self.success:
13952 
        oprot.writeI64(iter237)
4008 mandeep.dh 13953 
      oprot.writeListEnd()
13954 
      oprot.writeFieldEnd()
13955 
    oprot.writeFieldStop()
13956 
    oprot.writeStructEnd()
13957 
 
13958 
  def validate(self):
13959 
    return
13960 
 
13961 
 
13962 
  def __repr__(self):
13963 
    L = ['%s=%r' % (key, value)
13964 
      for key, value in self.__dict__.iteritems()]
13965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13966 
 
13967 
  def __eq__(self, other):
13968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13969 
 
13970 
  def __ne__(self, other):
13971 
    return not (self == other)
13972 
 
13973 
class markTransactionAsProcessed_args:
13974 
  """
13975 
  Attributes:
13976 
   - transactionId
13977 
   - category
13978 
  """
13979 
 
13980 
  thrift_spec = (
13981 
    None, # 0
13982 
    (1, TType.I64, 'transactionId', None, None, ), # 1
13983 
    (2, TType.I32, 'category', None, None, ), # 2
13984 
  )
13985 
 
13986 
  def __init__(self, transactionId=None, category=None,):
13987 
    self.transactionId = transactionId
13988 
    self.category = category
13989 
 
13990 
  def read(self, iprot):
13991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13993 
      return
13994 
    iprot.readStructBegin()
13995 
    while True:
13996 
      (fname, ftype, fid) = iprot.readFieldBegin()
13997 
      if ftype == TType.STOP:
13998 
        break
13999 
      if fid == 1:
14000 
        if ftype == TType.I64:
14001 
          self.transactionId = iprot.readI64();
14002 
        else:
14003 
          iprot.skip(ftype)
14004 
      elif fid == 2:
14005 
        if ftype == TType.I32:
14006 
          self.category = iprot.readI32();
14007 
        else:
14008 
          iprot.skip(ftype)
14009 
      else:
14010 
        iprot.skip(ftype)
14011 
      iprot.readFieldEnd()
14012 
    iprot.readStructEnd()
14013 
 
14014 
  def write(self, oprot):
14015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14017 
      return
14018 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
14019 
    if self.transactionId is not None:
14020 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14021 
      oprot.writeI64(self.transactionId)
14022 
      oprot.writeFieldEnd()
14023 
    if self.category is not None:
14024 
      oprot.writeFieldBegin('category', TType.I32, 2)
14025 
      oprot.writeI32(self.category)
14026 
      oprot.writeFieldEnd()
14027 
    oprot.writeFieldStop()
14028 
    oprot.writeStructEnd()
14029 
 
14030 
  def validate(self):
14031 
    return
14032 
 
14033 
 
14034 
  def __repr__(self):
14035 
    L = ['%s=%r' % (key, value)
14036 
      for key, value in self.__dict__.iteritems()]
14037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14038 
 
14039 
  def __eq__(self, other):
14040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14041 
 
14042 
  def __ne__(self, other):
14043 
    return not (self == other)
14044 
 
14045 
class markTransactionAsProcessed_result:
14046 
 
14047 
  thrift_spec = (
14048 
  )
14049 
 
14050 
  def read(self, iprot):
14051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14053 
      return
14054 
    iprot.readStructBegin()
14055 
    while True:
14056 
      (fname, ftype, fid) = iprot.readFieldBegin()
14057 
      if ftype == TType.STOP:
14058 
        break
14059 
      else:
14060 
        iprot.skip(ftype)
14061 
      iprot.readFieldEnd()
14062 
    iprot.readStructEnd()
14063 
 
14064 
  def write(self, oprot):
14065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14067 
      return
14068 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
14069 
    oprot.writeFieldStop()
14070 
    oprot.writeStructEnd()
14071 
 
14072 
  def validate(self):
14073 
    return
14074 
 
14075 
 
14076 
  def __repr__(self):
14077 
    L = ['%s=%r' % (key, value)
14078 
      for key, value in self.__dict__.iteritems()]
14079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14080 
 
14081 
  def __eq__(self, other):
14082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14083 
 
14084 
  def __ne__(self, other):
14085 
    return not (self == other)
4018 chandransh 14086 
 
14087 
class getItemWiseRiskyOrdersCount_args:
14088 
 
14089 
  thrift_spec = (
14090 
  )
14091 
 
14092 
  def read(self, iprot):
14093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14095 
      return
14096 
    iprot.readStructBegin()
14097 
    while True:
14098 
      (fname, ftype, fid) = iprot.readFieldBegin()
14099 
      if ftype == TType.STOP:
14100 
        break
14101 
      else:
14102 
        iprot.skip(ftype)
14103 
      iprot.readFieldEnd()
14104 
    iprot.readStructEnd()
14105 
 
14106 
  def write(self, oprot):
14107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14109 
      return
14110 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
14111 
    oprot.writeFieldStop()
14112 
    oprot.writeStructEnd()
14113 
 
14114 
  def validate(self):
14115 
    return
14116 
 
14117 
 
14118 
  def __repr__(self):
14119 
    L = ['%s=%r' % (key, value)
14120 
      for key, value in self.__dict__.iteritems()]
14121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14122 
 
14123 
  def __eq__(self, other):
14124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14125 
 
14126 
  def __ne__(self, other):
14127 
    return not (self == other)
14128 
 
14129 
class getItemWiseRiskyOrdersCount_result:
14130 
  """
14131 
  Attributes:
14132 
   - success
14133 
  """
14134 
 
14135 
  thrift_spec = (
14136 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
14137 
  )
14138 
 
14139 
  def __init__(self, success=None,):
14140 
    self.success = success
14141 
 
14142 
  def read(self, iprot):
14143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14145 
      return
14146 
    iprot.readStructBegin()
14147 
    while True:
14148 
      (fname, ftype, fid) = iprot.readFieldBegin()
14149 
      if ftype == TType.STOP:
14150 
        break
14151 
      if fid == 0:
14152 
        if ftype == TType.MAP:
14153 
          self.success = {}
4133 chandransh 14154 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
14155 
          for _i242 in xrange(_size238):
14156 
            _key243 = iprot.readI64();
14157 
            _val244 = iprot.readI64();
14158 
            self.success[_key243] = _val244
4018 chandransh 14159 
          iprot.readMapEnd()
14160 
        else:
14161 
          iprot.skip(ftype)
14162 
      else:
14163 
        iprot.skip(ftype)
14164 
      iprot.readFieldEnd()
14165 
    iprot.readStructEnd()
14166 
 
14167 
  def write(self, oprot):
14168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14170 
      return
14171 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
14172 
    if self.success is not None:
14173 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14174 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 14175 
      for kiter245,viter246 in self.success.items():
14176 
        oprot.writeI64(kiter245)
14177 
        oprot.writeI64(viter246)
4018 chandransh 14178 
      oprot.writeMapEnd()
14179 
      oprot.writeFieldEnd()
14180 
    oprot.writeFieldStop()
14181 
    oprot.writeStructEnd()
14182 
 
14183 
  def validate(self):
14184 
    return
14185 
 
14186 
 
14187 
  def __repr__(self):
14188 
    L = ['%s=%r' % (key, value)
14189 
      for key, value in self.__dict__.iteritems()]
14190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14191 
 
14192 
  def __eq__(self, other):
14193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14194 
 
14195 
  def __ne__(self, other):
14196 
    return not (self == other)
4247 rajveer 14197 
 
4295 varun.gupt 14198 
class getOrdersForItemIds_args:
14199 
  """
14200 
  Attributes:
14201 
   - itemIds
14202 
  """
14203 
 
14204 
  thrift_spec = (
14205 
    None, # 0
14206 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
14207 
  )
14208 
 
14209 
  def __init__(self, itemIds=None,):
14210 
    self.itemIds = itemIds
14211 
 
14212 
  def read(self, iprot):
14213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14215 
      return
14216 
    iprot.readStructBegin()
14217 
    while True:
14218 
      (fname, ftype, fid) = iprot.readFieldBegin()
14219 
      if ftype == TType.STOP:
14220 
        break
14221 
      if fid == 1:
14222 
        if ftype == TType.LIST:
14223 
          self.itemIds = []
14224 
          (_etype250, _size247) = iprot.readListBegin()
14225 
          for _i251 in xrange(_size247):
14226 
            _elem252 = iprot.readI64();
14227 
            self.itemIds.append(_elem252)
14228 
          iprot.readListEnd()
14229 
        else:
14230 
          iprot.skip(ftype)
14231 
      else:
14232 
        iprot.skip(ftype)
14233 
      iprot.readFieldEnd()
14234 
    iprot.readStructEnd()
14235 
 
14236 
  def write(self, oprot):
14237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14239 
      return
14240 
    oprot.writeStructBegin('getOrdersForItemIds_args')
14241 
    if self.itemIds is not None:
14242 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
14243 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
14244 
      for iter253 in self.itemIds:
14245 
        oprot.writeI64(iter253)
14246 
      oprot.writeListEnd()
14247 
      oprot.writeFieldEnd()
14248 
    oprot.writeFieldStop()
14249 
    oprot.writeStructEnd()
14250 
 
14251 
  def validate(self):
14252 
    return
14253 
 
14254 
 
14255 
  def __repr__(self):
14256 
    L = ['%s=%r' % (key, value)
14257 
      for key, value in self.__dict__.iteritems()]
14258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14259 
 
14260 
  def __eq__(self, other):
14261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14262 
 
14263 
  def __ne__(self, other):
14264 
    return not (self == other)
14265 
 
14266 
class getOrdersForItemIds_result:
14267 
  """
14268 
  Attributes:
14269 
   - success
14270 
  """
14271 
 
14272 
  thrift_spec = (
14273 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14274 
  )
14275 
 
14276 
  def __init__(self, success=None,):
14277 
    self.success = success
14278 
 
14279 
  def read(self, iprot):
14280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14282 
      return
14283 
    iprot.readStructBegin()
14284 
    while True:
14285 
      (fname, ftype, fid) = iprot.readFieldBegin()
14286 
      if ftype == TType.STOP:
14287 
        break
14288 
      if fid == 0:
14289 
        if ftype == TType.LIST:
14290 
          self.success = []
14291 
          (_etype257, _size254) = iprot.readListBegin()
14292 
          for _i258 in xrange(_size254):
14293 
            _elem259 = Order()
14294 
            _elem259.read(iprot)
14295 
            self.success.append(_elem259)
14296 
          iprot.readListEnd()
14297 
        else:
14298 
          iprot.skip(ftype)
14299 
      else:
14300 
        iprot.skip(ftype)
14301 
      iprot.readFieldEnd()
14302 
    iprot.readStructEnd()
14303 
 
14304 
  def write(self, oprot):
14305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14307 
      return
14308 
    oprot.writeStructBegin('getOrdersForItemIds_result')
14309 
    if self.success is not None:
14310 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14311 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
14312 
      for iter260 in self.success:
14313 
        iter260.write(oprot)
14314 
      oprot.writeListEnd()
14315 
      oprot.writeFieldEnd()
14316 
    oprot.writeFieldStop()
14317 
    oprot.writeStructEnd()
14318 
 
14319 
  def validate(self):
14320 
    return
14321 
 
14322 
 
14323 
  def __repr__(self):
14324 
    L = ['%s=%r' % (key, value)
14325 
      for key, value in self.__dict__.iteritems()]
14326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14327 
 
14328 
  def __eq__(self, other):
14329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14330 
 
14331 
  def __ne__(self, other):
14332 
    return not (self == other)
14333 
 
4247 rajveer 14334 
class markOrderCancellationRequestReceived_args:
14335 
  """
14336 
  Attributes:
14337 
   - orderId
14338 
  """
14339 
 
14340 
  thrift_spec = (
14341 
    None, # 0
14342 
    (1, TType.I64, 'orderId', None, None, ), # 1
14343 
  )
14344 
 
14345 
  def __init__(self, orderId=None,):
14346 
    self.orderId = orderId
14347 
 
14348 
  def read(self, iprot):
14349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14351 
      return
14352 
    iprot.readStructBegin()
14353 
    while True:
14354 
      (fname, ftype, fid) = iprot.readFieldBegin()
14355 
      if ftype == TType.STOP:
14356 
        break
14357 
      if fid == 1:
14358 
        if ftype == TType.I64:
14359 
          self.orderId = iprot.readI64();
14360 
        else:
14361 
          iprot.skip(ftype)
14362 
      else:
14363 
        iprot.skip(ftype)
14364 
      iprot.readFieldEnd()
14365 
    iprot.readStructEnd()
14366 
 
14367 
  def write(self, oprot):
14368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14370 
      return
14371 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
14372 
    if self.orderId is not None:
14373 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14374 
      oprot.writeI64(self.orderId)
14375 
      oprot.writeFieldEnd()
14376 
    oprot.writeFieldStop()
14377 
    oprot.writeStructEnd()
14378 
 
14379 
  def validate(self):
14380 
    return
14381 
 
14382 
 
14383 
  def __repr__(self):
14384 
    L = ['%s=%r' % (key, value)
14385 
      for key, value in self.__dict__.iteritems()]
14386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14387 
 
14388 
  def __eq__(self, other):
14389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14390 
 
14391 
  def __ne__(self, other):
14392 
    return not (self == other)
14393 
 
14394 
class markOrderCancellationRequestReceived_result:
14395 
  """
14396 
  Attributes:
14397 
   - ex
14398 
  """
14399 
 
14400 
  thrift_spec = (
14401 
    None, # 0
14402 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14403 
  )
14404 
 
14405 
  def __init__(self, ex=None,):
14406 
    self.ex = ex
14407 
 
14408 
  def read(self, iprot):
14409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14411 
      return
14412 
    iprot.readStructBegin()
14413 
    while True:
14414 
      (fname, ftype, fid) = iprot.readFieldBegin()
14415 
      if ftype == TType.STOP:
14416 
        break
14417 
      if fid == 1:
14418 
        if ftype == TType.STRUCT:
14419 
          self.ex = TransactionServiceException()
14420 
          self.ex.read(iprot)
14421 
        else:
14422 
          iprot.skip(ftype)
14423 
      else:
14424 
        iprot.skip(ftype)
14425 
      iprot.readFieldEnd()
14426 
    iprot.readStructEnd()
14427 
 
14428 
  def write(self, oprot):
14429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14431 
      return
14432 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
14433 
    if self.ex is not None:
14434 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14435 
      self.ex.write(oprot)
14436 
      oprot.writeFieldEnd()
14437 
    oprot.writeFieldStop()
14438 
    oprot.writeStructEnd()
14439 
 
14440 
  def validate(self):
14441 
    return
14442 
 
14443 
 
14444 
  def __repr__(self):
14445 
    L = ['%s=%r' % (key, value)
14446 
      for key, value in self.__dict__.iteritems()]
14447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14448 
 
14449 
  def __eq__(self, other):
14450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14451 
 
14452 
  def __ne__(self, other):
14453 
    return not (self == other)
14454 
 
14455 
class markOrderCancellationRequestConfirmed_args:
14456 
  """
14457 
  Attributes:
14458 
   - orderId
14459 
  """
14460 
 
14461 
  thrift_spec = (
14462 
    None, # 0
14463 
    (1, TType.I64, 'orderId', None, None, ), # 1
14464 
  )
14465 
 
14466 
  def __init__(self, orderId=None,):
14467 
    self.orderId = orderId
14468 
 
14469 
  def read(self, iprot):
14470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14472 
      return
14473 
    iprot.readStructBegin()
14474 
    while True:
14475 
      (fname, ftype, fid) = iprot.readFieldBegin()
14476 
      if ftype == TType.STOP:
14477 
        break
14478 
      if fid == 1:
14479 
        if ftype == TType.I64:
14480 
          self.orderId = iprot.readI64();
14481 
        else:
14482 
          iprot.skip(ftype)
14483 
      else:
14484 
        iprot.skip(ftype)
14485 
      iprot.readFieldEnd()
14486 
    iprot.readStructEnd()
14487 
 
14488 
  def write(self, oprot):
14489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14491 
      return
14492 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
14493 
    if self.orderId is not None:
14494 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14495 
      oprot.writeI64(self.orderId)
14496 
      oprot.writeFieldEnd()
14497 
    oprot.writeFieldStop()
14498 
    oprot.writeStructEnd()
14499 
 
14500 
  def validate(self):
14501 
    return
14502 
 
14503 
 
14504 
  def __repr__(self):
14505 
    L = ['%s=%r' % (key, value)
14506 
      for key, value in self.__dict__.iteritems()]
14507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14508 
 
14509 
  def __eq__(self, other):
14510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14511 
 
14512 
  def __ne__(self, other):
14513 
    return not (self == other)
14514 
 
14515 
class markOrderCancellationRequestConfirmed_result:
14516 
  """
14517 
  Attributes:
14518 
   - ex
14519 
  """
14520 
 
14521 
  thrift_spec = (
14522 
    None, # 0
14523 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14524 
  )
14525 
 
14526 
  def __init__(self, ex=None,):
14527 
    self.ex = ex
14528 
 
14529 
  def read(self, iprot):
14530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14532 
      return
14533 
    iprot.readStructBegin()
14534 
    while True:
14535 
      (fname, ftype, fid) = iprot.readFieldBegin()
14536 
      if ftype == TType.STOP:
14537 
        break
14538 
      if fid == 1:
14539 
        if ftype == TType.STRUCT:
14540 
          self.ex = TransactionServiceException()
14541 
          self.ex.read(iprot)
14542 
        else:
14543 
          iprot.skip(ftype)
14544 
      else:
14545 
        iprot.skip(ftype)
14546 
      iprot.readFieldEnd()
14547 
    iprot.readStructEnd()
14548 
 
14549 
  def write(self, oprot):
14550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14552 
      return
14553 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
14554 
    if self.ex is not None:
14555 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14556 
      self.ex.write(oprot)
14557 
      oprot.writeFieldEnd()
14558 
    oprot.writeFieldStop()
14559 
    oprot.writeStructEnd()
14560 
 
14561 
  def validate(self):
14562 
    return
14563 
 
14564 
 
14565 
  def __repr__(self):
14566 
    L = ['%s=%r' % (key, value)
14567 
      for key, value in self.__dict__.iteritems()]
14568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14569 
 
14570 
  def __eq__(self, other):
14571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14572 
 
14573 
  def __ne__(self, other):
14574 
    return not (self == other)
14575 
 
14576 
class markOrderCancellationRequestDenied_args:
14577 
  """
14578 
  Attributes:
14579 
   - orderId
14580 
  """
14581 
 
14582 
  thrift_spec = (
14583 
    None, # 0
14584 
    (1, TType.I64, 'orderId', None, None, ), # 1
14585 
  )
14586 
 
14587 
  def __init__(self, orderId=None,):
14588 
    self.orderId = orderId
14589 
 
14590 
  def read(self, iprot):
14591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14593 
      return
14594 
    iprot.readStructBegin()
14595 
    while True:
14596 
      (fname, ftype, fid) = iprot.readFieldBegin()
14597 
      if ftype == TType.STOP:
14598 
        break
14599 
      if fid == 1:
14600 
        if ftype == TType.I64:
14601 
          self.orderId = iprot.readI64();
14602 
        else:
14603 
          iprot.skip(ftype)
14604 
      else:
14605 
        iprot.skip(ftype)
14606 
      iprot.readFieldEnd()
14607 
    iprot.readStructEnd()
14608 
 
14609 
  def write(self, oprot):
14610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14612 
      return
14613 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
14614 
    if self.orderId is not None:
14615 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14616 
      oprot.writeI64(self.orderId)
14617 
      oprot.writeFieldEnd()
14618 
    oprot.writeFieldStop()
14619 
    oprot.writeStructEnd()
14620 
 
14621 
  def validate(self):
14622 
    return
14623 
 
14624 
 
14625 
  def __repr__(self):
14626 
    L = ['%s=%r' % (key, value)
14627 
      for key, value in self.__dict__.iteritems()]
14628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14629 
 
14630 
  def __eq__(self, other):
14631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14632 
 
14633 
  def __ne__(self, other):
14634 
    return not (self == other)
14635 
 
14636 
class markOrderCancellationRequestDenied_result:
14637 
  """
14638 
  Attributes:
14639 
   - ex
14640 
  """
14641 
 
14642 
  thrift_spec = (
14643 
    None, # 0
14644 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14645 
  )
14646 
 
14647 
  def __init__(self, ex=None,):
14648 
    self.ex = ex
14649 
 
14650 
  def read(self, iprot):
14651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14653 
      return
14654 
    iprot.readStructBegin()
14655 
    while True:
14656 
      (fname, ftype, fid) = iprot.readFieldBegin()
14657 
      if ftype == TType.STOP:
14658 
        break
14659 
      if fid == 1:
14660 
        if ftype == TType.STRUCT:
14661 
          self.ex = TransactionServiceException()
14662 
          self.ex.read(iprot)
14663 
        else:
14664 
          iprot.skip(ftype)
14665 
      else:
14666 
        iprot.skip(ftype)
14667 
      iprot.readFieldEnd()
14668 
    iprot.readStructEnd()
14669 
 
14670 
  def write(self, oprot):
14671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14673 
      return
14674 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
14675 
    if self.ex is not None:
14676 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14677 
      self.ex.write(oprot)
14678 
      oprot.writeFieldEnd()
14679 
    oprot.writeFieldStop()
14680 
    oprot.writeStructEnd()
14681 
 
14682 
  def validate(self):
14683 
    return
14684 
 
14685 
 
14686 
  def __repr__(self):
14687 
    L = ['%s=%r' % (key, value)
14688 
      for key, value in self.__dict__.iteritems()]
14689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14690 
 
14691 
  def __eq__(self, other):
14692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14693 
 
14694 
  def __ne__(self, other):
14695 
    return not (self == other)
14696 
 
4258 rajveer 14697 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 14698 
  """
14699 
  Attributes:
4258 rajveer 14700 
   - transactionId
4247 rajveer 14701 
  """
14702 
 
14703 
  thrift_spec = (
14704 
    None, # 0
4258 rajveer 14705 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 14706 
  )
14707 
 
4258 rajveer 14708 
  def __init__(self, transactionId=None,):
14709 
    self.transactionId = transactionId
4247 rajveer 14710 
 
14711 
  def read(self, iprot):
14712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14714 
      return
14715 
    iprot.readStructBegin()
14716 
    while True:
14717 
      (fname, ftype, fid) = iprot.readFieldBegin()
14718 
      if ftype == TType.STOP:
14719 
        break
14720 
      if fid == 1:
14721 
        if ftype == TType.I64:
4258 rajveer 14722 
          self.transactionId = iprot.readI64();
4247 rajveer 14723 
        else:
14724 
          iprot.skip(ftype)
14725 
      else:
14726 
        iprot.skip(ftype)
14727 
      iprot.readFieldEnd()
14728 
    iprot.readStructEnd()
14729 
 
14730 
  def write(self, oprot):
14731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14733 
      return
4258 rajveer 14734 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
14735 
    if self.transactionId is not None:
14736 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14737 
      oprot.writeI64(self.transactionId)
4247 rajveer 14738 
      oprot.writeFieldEnd()
14739 
    oprot.writeFieldStop()
14740 
    oprot.writeStructEnd()
14741 
 
14742 
  def validate(self):
14743 
    return
14744 
 
14745 
 
14746 
  def __repr__(self):
14747 
    L = ['%s=%r' % (key, value)
14748 
      for key, value in self.__dict__.iteritems()]
14749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14750 
 
14751 
  def __eq__(self, other):
14752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14753 
 
14754 
  def __ne__(self, other):
14755 
    return not (self == other)
14756 
 
4258 rajveer 14757 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 14758 
  """
14759 
  Attributes:
14760 
   - ex
14761 
  """
14762 
 
14763 
  thrift_spec = (
14764 
    None, # 0
14765 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14766 
  )
14767 
 
14768 
  def __init__(self, ex=None,):
14769 
    self.ex = ex
14770 
 
14771 
  def read(self, iprot):
14772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14774 
      return
14775 
    iprot.readStructBegin()
14776 
    while True:
14777 
      (fname, ftype, fid) = iprot.readFieldBegin()
14778 
      if ftype == TType.STOP:
14779 
        break
14780 
      if fid == 1:
14781 
        if ftype == TType.STRUCT:
14782 
          self.ex = TransactionServiceException()
14783 
          self.ex.read(iprot)
14784 
        else:
14785 
          iprot.skip(ftype)
14786 
      else:
14787 
        iprot.skip(ftype)
14788 
      iprot.readFieldEnd()
14789 
    iprot.readStructEnd()
14790 
 
14791 
  def write(self, oprot):
14792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14794 
      return
4258 rajveer 14795 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 14796 
    if self.ex is not None:
14797 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14798 
      self.ex.write(oprot)
14799 
      oprot.writeFieldEnd()
14800 
    oprot.writeFieldStop()
14801 
    oprot.writeStructEnd()
14802 
 
14803 
  def validate(self):
14804 
    return
14805 
 
14806 
 
14807 
  def __repr__(self):
14808 
    L = ['%s=%r' % (key, value)
14809 
      for key, value in self.__dict__.iteritems()]
14810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14811 
 
14812 
  def __eq__(self, other):
14813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14814 
 
14815 
  def __ne__(self, other):
14816 
    return not (self == other)
4259 anupam.sin 14817 
 
14818 
class refundTransaction_args:
14819 
  """
14820 
  Attributes:
14821 
   - transactionId
14822 
   - refundedBy
14823 
   - reason
14824 
  """
14825 
 
14826 
  thrift_spec = (
14827 
    None, # 0
14828 
    (1, TType.I64, 'transactionId', None, None, ), # 1
14829 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
14830 
    (3, TType.STRING, 'reason', None, None, ), # 3
14831 
  )
14832 
 
14833 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
14834 
    self.transactionId = transactionId
14835 
    self.refundedBy = refundedBy
14836 
    self.reason = reason
14837 
 
14838 
  def read(self, iprot):
14839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14841 
      return
14842 
    iprot.readStructBegin()
14843 
    while True:
14844 
      (fname, ftype, fid) = iprot.readFieldBegin()
14845 
      if ftype == TType.STOP:
14846 
        break
14847 
      if fid == 1:
14848 
        if ftype == TType.I64:
14849 
          self.transactionId = iprot.readI64();
14850 
        else:
14851 
          iprot.skip(ftype)
14852 
      elif fid == 2:
14853 
        if ftype == TType.STRING:
14854 
          self.refundedBy = iprot.readString();
14855 
        else:
14856 
          iprot.skip(ftype)
14857 
      elif fid == 3:
14858 
        if ftype == TType.STRING:
14859 
          self.reason = iprot.readString();
14860 
        else:
14861 
          iprot.skip(ftype)
14862 
      else:
14863 
        iprot.skip(ftype)
14864 
      iprot.readFieldEnd()
14865 
    iprot.readStructEnd()
14866 
 
14867 
  def write(self, oprot):
14868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14870 
      return
14871 
    oprot.writeStructBegin('refundTransaction_args')
14872 
    if self.transactionId is not None:
14873 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14874 
      oprot.writeI64(self.transactionId)
14875 
      oprot.writeFieldEnd()
14876 
    if self.refundedBy is not None:
14877 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
14878 
      oprot.writeString(self.refundedBy)
14879 
      oprot.writeFieldEnd()
14880 
    if self.reason is not None:
14881 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14882 
      oprot.writeString(self.reason)
14883 
      oprot.writeFieldEnd()
14884 
    oprot.writeFieldStop()
14885 
    oprot.writeStructEnd()
14886 
 
14887 
  def validate(self):
14888 
    return
14889 
 
14890 
 
14891 
  def __repr__(self):
14892 
    L = ['%s=%r' % (key, value)
14893 
      for key, value in self.__dict__.iteritems()]
14894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14895 
 
14896 
  def __eq__(self, other):
14897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14898 
 
14899 
  def __ne__(self, other):
14900 
    return not (self == other)
14901 
 
14902 
class refundTransaction_result:
14903 
  """
14904 
  Attributes:
14905 
   - ex
14906 
  """
14907 
 
14908 
  thrift_spec = (
14909 
    None, # 0
14910 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14911 
  )
14912 
 
14913 
  def __init__(self, ex=None,):
14914 
    self.ex = ex
14915 
 
14916 
  def read(self, iprot):
14917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14919 
      return
14920 
    iprot.readStructBegin()
14921 
    while True:
14922 
      (fname, ftype, fid) = iprot.readFieldBegin()
14923 
      if ftype == TType.STOP:
14924 
        break
14925 
      if fid == 1:
14926 
        if ftype == TType.STRUCT:
14927 
          self.ex = TransactionServiceException()
14928 
          self.ex.read(iprot)
14929 
        else:
14930 
          iprot.skip(ftype)
14931 
      else:
14932 
        iprot.skip(ftype)
14933 
      iprot.readFieldEnd()
14934 
    iprot.readStructEnd()
14935 
 
14936 
  def write(self, oprot):
14937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14939 
      return
14940 
    oprot.writeStructBegin('refundTransaction_result')
14941 
    if self.ex is not None:
14942 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14943 
      self.ex.write(oprot)
14944 
      oprot.writeFieldEnd()
14945 
    oprot.writeFieldStop()
14946 
    oprot.writeStructEnd()
14947 
 
14948 
  def validate(self):
14949 
    return
14950 
 
14951 
 
14952 
  def __repr__(self):
14953 
    L = ['%s=%r' % (key, value)
14954 
      for key, value in self.__dict__.iteritems()]
14955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14956 
 
14957 
  def __eq__(self, other):
14958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14959 
 
14960 
  def __ne__(self, other):
14961 
    return not (self == other)
4285 rajveer 14962 
 
4324 mandeep.dh 14963 
class updateShipmentAddress_args:
14964 
  """
14965 
  Attributes:
14966 
   - orderId
14967 
   - addressId
14968 
  """
14969 
 
14970 
  thrift_spec = (
14971 
    None, # 0
14972 
    (1, TType.I64, 'orderId', None, None, ), # 1
14973 
    (2, TType.I64, 'addressId', None, None, ), # 2
14974 
  )
14975 
 
14976 
  def __init__(self, orderId=None, addressId=None,):
14977 
    self.orderId = orderId
14978 
    self.addressId = addressId
14979 
 
14980 
  def read(self, iprot):
14981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14983 
      return
14984 
    iprot.readStructBegin()
14985 
    while True:
14986 
      (fname, ftype, fid) = iprot.readFieldBegin()
14987 
      if ftype == TType.STOP:
14988 
        break
14989 
      if fid == 1:
14990 
        if ftype == TType.I64:
14991 
          self.orderId = iprot.readI64();
14992 
        else:
14993 
          iprot.skip(ftype)
14994 
      elif fid == 2:
14995 
        if ftype == TType.I64:
14996 
          self.addressId = iprot.readI64();
14997 
        else:
14998 
          iprot.skip(ftype)
14999 
      else:
15000 
        iprot.skip(ftype)
15001 
      iprot.readFieldEnd()
15002 
    iprot.readStructEnd()
15003 
 
15004 
  def write(self, oprot):
15005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15007 
      return
15008 
    oprot.writeStructBegin('updateShipmentAddress_args')
15009 
    if self.orderId is not None:
15010 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15011 
      oprot.writeI64(self.orderId)
15012 
      oprot.writeFieldEnd()
15013 
    if self.addressId is not None:
15014 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
15015 
      oprot.writeI64(self.addressId)
15016 
      oprot.writeFieldEnd()
15017 
    oprot.writeFieldStop()
15018 
    oprot.writeStructEnd()
15019 
 
15020 
  def validate(self):
15021 
    return
15022 
 
15023 
 
15024 
  def __repr__(self):
15025 
    L = ['%s=%r' % (key, value)
15026 
      for key, value in self.__dict__.iteritems()]
15027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15028 
 
15029 
  def __eq__(self, other):
15030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15031 
 
15032 
  def __ne__(self, other):
15033 
    return not (self == other)
15034 
 
15035 
class updateShipmentAddress_result:
15036 
  """
15037 
  Attributes:
15038 
   - ex
15039 
  """
15040 
 
15041 
  thrift_spec = (
15042 
    None, # 0
15043 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15044 
  )
15045 
 
15046 
  def __init__(self, ex=None,):
15047 
    self.ex = ex
15048 
 
15049 
  def read(self, iprot):
15050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15052 
      return
15053 
    iprot.readStructBegin()
15054 
    while True:
15055 
      (fname, ftype, fid) = iprot.readFieldBegin()
15056 
      if ftype == TType.STOP:
15057 
        break
15058 
      if fid == 1:
15059 
        if ftype == TType.STRUCT:
15060 
          self.ex = TransactionServiceException()
15061 
          self.ex.read(iprot)
15062 
        else:
15063 
          iprot.skip(ftype)
15064 
      else:
15065 
        iprot.skip(ftype)
15066 
      iprot.readFieldEnd()
15067 
    iprot.readStructEnd()
15068 
 
15069 
  def write(self, oprot):
15070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15072 
      return
15073 
    oprot.writeStructBegin('updateShipmentAddress_result')
15074 
    if self.ex is not None:
15075 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15076 
      self.ex.write(oprot)
15077 
      oprot.writeFieldEnd()
15078 
    oprot.writeFieldStop()
15079 
    oprot.writeStructEnd()
15080 
 
15081 
  def validate(self):
15082 
    return
15083 
 
15084 
 
15085 
  def __repr__(self):
15086 
    L = ['%s=%r' % (key, value)
15087 
      for key, value in self.__dict__.iteritems()]
15088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15089 
 
15090 
  def __eq__(self, other):
15091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15092 
 
15093 
  def __ne__(self, other):
15094 
    return not (self == other)
15095 
 
4285 rajveer 15096 
class acceptOrdersForItemId_args:
15097 
  """
15098 
  Attributes:
15099 
   - itemId
15100 
   - inventory
15101 
  """
15102 
 
15103 
  thrift_spec = (
15104 
    None, # 0
15105 
    (1, TType.I64, 'itemId', None, None, ), # 1
15106 
    (2, TType.I64, 'inventory', None, None, ), # 2
15107 
  )
15108 
 
15109 
  def __init__(self, itemId=None, inventory=None,):
15110 
    self.itemId = itemId
15111 
    self.inventory = inventory
15112 
 
15113 
  def read(self, iprot):
15114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15116 
      return
15117 
    iprot.readStructBegin()
15118 
    while True:
15119 
      (fname, ftype, fid) = iprot.readFieldBegin()
15120 
      if ftype == TType.STOP:
15121 
        break
15122 
      if fid == 1:
15123 
        if ftype == TType.I64:
15124 
          self.itemId = iprot.readI64();
15125 
        else:
15126 
          iprot.skip(ftype)
15127 
      elif fid == 2:
15128 
        if ftype == TType.I64:
15129 
          self.inventory = iprot.readI64();
15130 
        else:
15131 
          iprot.skip(ftype)
15132 
      else:
15133 
        iprot.skip(ftype)
15134 
      iprot.readFieldEnd()
15135 
    iprot.readStructEnd()
15136 
 
15137 
  def write(self, oprot):
15138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15140 
      return
15141 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
15142 
    if self.itemId is not None:
15143 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15144 
      oprot.writeI64(self.itemId)
15145 
      oprot.writeFieldEnd()
15146 
    if self.inventory is not None:
15147 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
15148 
      oprot.writeI64(self.inventory)
15149 
      oprot.writeFieldEnd()
15150 
    oprot.writeFieldStop()
15151 
    oprot.writeStructEnd()
15152 
 
15153 
  def validate(self):
15154 
    return
15155 
 
15156 
 
15157 
  def __repr__(self):
15158 
    L = ['%s=%r' % (key, value)
15159 
      for key, value in self.__dict__.iteritems()]
15160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15161 
 
15162 
  def __eq__(self, other):
15163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15164 
 
15165 
  def __ne__(self, other):
15166 
    return not (self == other)
15167 
 
15168 
class acceptOrdersForItemId_result:
15169 
  """
15170 
  Attributes:
15171 
   - success
15172 
   - ex
15173 
  """
15174 
 
15175 
  thrift_spec = (
15176 
    (0, TType.BOOL, 'success', None, None, ), # 0
15177 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15178 
  )
15179 
 
15180 
  def __init__(self, success=None, ex=None,):
15181 
    self.success = success
15182 
    self.ex = ex
15183 
 
15184 
  def read(self, iprot):
15185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15187 
      return
15188 
    iprot.readStructBegin()
15189 
    while True:
15190 
      (fname, ftype, fid) = iprot.readFieldBegin()
15191 
      if ftype == TType.STOP:
15192 
        break
15193 
      if fid == 0:
15194 
        if ftype == TType.BOOL:
15195 
          self.success = iprot.readBool();
15196 
        else:
15197 
          iprot.skip(ftype)
15198 
      elif fid == 1:
15199 
        if ftype == TType.STRUCT:
15200 
          self.ex = TransactionServiceException()
15201 
          self.ex.read(iprot)
15202 
        else:
15203 
          iprot.skip(ftype)
15204 
      else:
15205 
        iprot.skip(ftype)
15206 
      iprot.readFieldEnd()
15207 
    iprot.readStructEnd()
15208 
 
15209 
  def write(self, oprot):
15210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15212 
      return
15213 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
15214 
    if self.success is not None:
15215 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15216 
      oprot.writeBool(self.success)
15217 
      oprot.writeFieldEnd()
15218 
    if self.ex is not None:
15219 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15220 
      self.ex.write(oprot)
15221 
      oprot.writeFieldEnd()
15222 
    oprot.writeFieldStop()
15223 
    oprot.writeStructEnd()
15224 
 
15225 
  def validate(self):
15226 
    return
15227 
 
15228 
 
15229 
  def __repr__(self):
15230 
    L = ['%s=%r' % (key, value)
15231 
      for key, value in self.__dict__.iteritems()]
15232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15233 
 
15234 
  def __eq__(self, other):
15235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15236 
 
15237 
  def __ne__(self, other):
15238 
    return not (self == other)
4303 rajveer 15239 
 
15240 
class markOrdersAsPORaised_args:
15241 
  """
15242 
  Attributes:
15243 
   - vendorId
15244 
   - itemId
15245 
   - quantity
15246 
   - estimate
4369 rajveer 15247 
   - isReminder
4303 rajveer 15248 
  """
15249 
 
15250 
  thrift_spec = (
15251 
    None, # 0
15252 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15253 
    (2, TType.I64, 'itemId', None, None, ), # 2
15254 
    (3, TType.I64, 'quantity', None, None, ), # 3
15255 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15256 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15257 
  )
15258 
 
4369 rajveer 15259 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15260 
    self.vendorId = vendorId
15261 
    self.itemId = itemId
15262 
    self.quantity = quantity
15263 
    self.estimate = estimate
4369 rajveer 15264 
    self.isReminder = isReminder
4303 rajveer 15265 
 
15266 
  def read(self, iprot):
15267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15269 
      return
15270 
    iprot.readStructBegin()
15271 
    while True:
15272 
      (fname, ftype, fid) = iprot.readFieldBegin()
15273 
      if ftype == TType.STOP:
15274 
        break
15275 
      if fid == 1:
15276 
        if ftype == TType.I64:
15277 
          self.vendorId = iprot.readI64();
15278 
        else:
15279 
          iprot.skip(ftype)
15280 
      elif fid == 2:
15281 
        if ftype == TType.I64:
15282 
          self.itemId = iprot.readI64();
15283 
        else:
15284 
          iprot.skip(ftype)
15285 
      elif fid == 3:
15286 
        if ftype == TType.I64:
15287 
          self.quantity = iprot.readI64();
15288 
        else:
15289 
          iprot.skip(ftype)
15290 
      elif fid == 4:
15291 
        if ftype == TType.I64:
15292 
          self.estimate = iprot.readI64();
15293 
        else:
15294 
          iprot.skip(ftype)
4369 rajveer 15295 
      elif fid == 5:
15296 
        if ftype == TType.BOOL:
15297 
          self.isReminder = iprot.readBool();
15298 
        else:
15299 
          iprot.skip(ftype)
4303 rajveer 15300 
      else:
15301 
        iprot.skip(ftype)
15302 
      iprot.readFieldEnd()
15303 
    iprot.readStructEnd()
15304 
 
15305 
  def write(self, oprot):
15306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15308 
      return
15309 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
15310 
    if self.vendorId is not None:
15311 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15312 
      oprot.writeI64(self.vendorId)
15313 
      oprot.writeFieldEnd()
15314 
    if self.itemId is not None:
15315 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15316 
      oprot.writeI64(self.itemId)
15317 
      oprot.writeFieldEnd()
15318 
    if self.quantity is not None:
15319 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15320 
      oprot.writeI64(self.quantity)
15321 
      oprot.writeFieldEnd()
15322 
    if self.estimate is not None:
15323 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15324 
      oprot.writeI64(self.estimate)
15325 
      oprot.writeFieldEnd()
4369 rajveer 15326 
    if self.isReminder is not None:
15327 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15328 
      oprot.writeBool(self.isReminder)
15329 
      oprot.writeFieldEnd()
4303 rajveer 15330 
    oprot.writeFieldStop()
15331 
    oprot.writeStructEnd()
15332 
 
15333 
  def validate(self):
15334 
    return
15335 
 
15336 
 
15337 
  def __repr__(self):
15338 
    L = ['%s=%r' % (key, value)
15339 
      for key, value in self.__dict__.iteritems()]
15340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15341 
 
15342 
  def __eq__(self, other):
15343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15344 
 
15345 
  def __ne__(self, other):
15346 
    return not (self == other)
15347 
 
15348 
class markOrdersAsPORaised_result:
15349 
  """
15350 
  Attributes:
15351 
   - ex
15352 
  """
15353 
 
15354 
  thrift_spec = (
15355 
    None, # 0
15356 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15357 
  )
15358 
 
15359 
  def __init__(self, ex=None,):
15360 
    self.ex = ex
15361 
 
15362 
  def read(self, iprot):
15363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15365 
      return
15366 
    iprot.readStructBegin()
15367 
    while True:
15368 
      (fname, ftype, fid) = iprot.readFieldBegin()
15369 
      if ftype == TType.STOP:
15370 
        break
15371 
      if fid == 1:
15372 
        if ftype == TType.STRUCT:
15373 
          self.ex = TransactionServiceException()
15374 
          self.ex.read(iprot)
15375 
        else:
15376 
          iprot.skip(ftype)
15377 
      else:
15378 
        iprot.skip(ftype)
15379 
      iprot.readFieldEnd()
15380 
    iprot.readStructEnd()
15381 
 
15382 
  def write(self, oprot):
15383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15385 
      return
15386 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
15387 
    if self.ex is not None:
15388 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15389 
      self.ex.write(oprot)
15390 
      oprot.writeFieldEnd()
15391 
    oprot.writeFieldStop()
15392 
    oprot.writeStructEnd()
15393 
 
15394 
  def validate(self):
15395 
    return
15396 
 
15397 
 
15398 
  def __repr__(self):
15399 
    L = ['%s=%r' % (key, value)
15400 
      for key, value in self.__dict__.iteritems()]
15401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15402 
 
15403 
  def __eq__(self, other):
15404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15405 
 
15406 
  def __ne__(self, other):
15407 
    return not (self == other)
15408 
 
15409 
class markOrdersAsReversalInitiated_args:
15410 
  """
15411 
  Attributes:
15412 
   - vendorId
15413 
   - itemId
15414 
   - quantity
15415 
   - estimate
4369 rajveer 15416 
   - isReminder
4303 rajveer 15417 
  """
15418 
 
15419 
  thrift_spec = (
15420 
    None, # 0
15421 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15422 
    (2, TType.I64, 'itemId', None, None, ), # 2
15423 
    (3, TType.I64, 'quantity', None, None, ), # 3
15424 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15425 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15426 
  )
15427 
 
4369 rajveer 15428 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15429 
    self.vendorId = vendorId
15430 
    self.itemId = itemId
15431 
    self.quantity = quantity
15432 
    self.estimate = estimate
4369 rajveer 15433 
    self.isReminder = isReminder
4303 rajveer 15434 
 
15435 
  def read(self, iprot):
15436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15438 
      return
15439 
    iprot.readStructBegin()
15440 
    while True:
15441 
      (fname, ftype, fid) = iprot.readFieldBegin()
15442 
      if ftype == TType.STOP:
15443 
        break
15444 
      if fid == 1:
15445 
        if ftype == TType.I64:
15446 
          self.vendorId = iprot.readI64();
15447 
        else:
15448 
          iprot.skip(ftype)
15449 
      elif fid == 2:
15450 
        if ftype == TType.I64:
15451 
          self.itemId = iprot.readI64();
15452 
        else:
15453 
          iprot.skip(ftype)
15454 
      elif fid == 3:
15455 
        if ftype == TType.I64:
15456 
          self.quantity = iprot.readI64();
15457 
        else:
15458 
          iprot.skip(ftype)
15459 
      elif fid == 4:
15460 
        if ftype == TType.I64:
15461 
          self.estimate = iprot.readI64();
15462 
        else:
15463 
          iprot.skip(ftype)
4369 rajveer 15464 
      elif fid == 5:
15465 
        if ftype == TType.BOOL:
15466 
          self.isReminder = iprot.readBool();
15467 
        else:
15468 
          iprot.skip(ftype)
4303 rajveer 15469 
      else:
15470 
        iprot.skip(ftype)
15471 
      iprot.readFieldEnd()
15472 
    iprot.readStructEnd()
15473 
 
15474 
  def write(self, oprot):
15475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15477 
      return
15478 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
15479 
    if self.vendorId is not None:
15480 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15481 
      oprot.writeI64(self.vendorId)
15482 
      oprot.writeFieldEnd()
15483 
    if self.itemId is not None:
15484 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15485 
      oprot.writeI64(self.itemId)
15486 
      oprot.writeFieldEnd()
15487 
    if self.quantity is not None:
15488 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15489 
      oprot.writeI64(self.quantity)
15490 
      oprot.writeFieldEnd()
15491 
    if self.estimate is not None:
15492 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15493 
      oprot.writeI64(self.estimate)
15494 
      oprot.writeFieldEnd()
4369 rajveer 15495 
    if self.isReminder is not None:
15496 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15497 
      oprot.writeBool(self.isReminder)
15498 
      oprot.writeFieldEnd()
4303 rajveer 15499 
    oprot.writeFieldStop()
15500 
    oprot.writeStructEnd()
15501 
 
15502 
  def validate(self):
15503 
    return
15504 
 
15505 
 
15506 
  def __repr__(self):
15507 
    L = ['%s=%r' % (key, value)
15508 
      for key, value in self.__dict__.iteritems()]
15509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15510 
 
15511 
  def __eq__(self, other):
15512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15513 
 
15514 
  def __ne__(self, other):
15515 
    return not (self == other)
15516 
 
15517 
class markOrdersAsReversalInitiated_result:
15518 
  """
15519 
  Attributes:
15520 
   - ex
15521 
  """
15522 
 
15523 
  thrift_spec = (
15524 
    None, # 0
15525 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15526 
  )
15527 
 
15528 
  def __init__(self, ex=None,):
15529 
    self.ex = ex
15530 
 
15531 
  def read(self, iprot):
15532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15534 
      return
15535 
    iprot.readStructBegin()
15536 
    while True:
15537 
      (fname, ftype, fid) = iprot.readFieldBegin()
15538 
      if ftype == TType.STOP:
15539 
        break
15540 
      if fid == 1:
15541 
        if ftype == TType.STRUCT:
15542 
          self.ex = TransactionServiceException()
15543 
          self.ex.read(iprot)
15544 
        else:
15545 
          iprot.skip(ftype)
15546 
      else:
15547 
        iprot.skip(ftype)
15548 
      iprot.readFieldEnd()
15549 
    iprot.readStructEnd()
15550 
 
15551 
  def write(self, oprot):
15552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15554 
      return
15555 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
15556 
    if self.ex is not None:
15557 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15558 
      self.ex.write(oprot)
15559 
      oprot.writeFieldEnd()
15560 
    oprot.writeFieldStop()
15561 
    oprot.writeStructEnd()
15562 
 
15563 
  def validate(self):
15564 
    return
15565 
 
15566 
 
15567 
  def __repr__(self):
15568 
    L = ['%s=%r' % (key, value)
15569 
      for key, value in self.__dict__.iteritems()]
15570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15571 
 
15572 
  def __eq__(self, other):
15573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15574 
 
15575 
  def __ne__(self, other):
15576 
    return not (self == other)
15577 
 
15578 
class markOrdersAsNotAvailabke_args:
15579 
  """
15580 
  Attributes:
15581 
   - vendorId
15582 
   - itemId
15583 
   - quantity
15584 
   - estimate
4369 rajveer 15585 
   - isReminder
4303 rajveer 15586 
  """
15587 
 
15588 
  thrift_spec = (
15589 
    None, # 0
15590 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15591 
    (2, TType.I64, 'itemId', None, None, ), # 2
15592 
    (3, TType.I64, 'quantity', None, None, ), # 3
15593 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15594 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15595 
  )
15596 
 
4369 rajveer 15597 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15598 
    self.vendorId = vendorId
15599 
    self.itemId = itemId
15600 
    self.quantity = quantity
15601 
    self.estimate = estimate
4369 rajveer 15602 
    self.isReminder = isReminder
4303 rajveer 15603 
 
15604 
  def read(self, iprot):
15605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15607 
      return
15608 
    iprot.readStructBegin()
15609 
    while True:
15610 
      (fname, ftype, fid) = iprot.readFieldBegin()
15611 
      if ftype == TType.STOP:
15612 
        break
15613 
      if fid == 1:
15614 
        if ftype == TType.I64:
15615 
          self.vendorId = iprot.readI64();
15616 
        else:
15617 
          iprot.skip(ftype)
15618 
      elif fid == 2:
15619 
        if ftype == TType.I64:
15620 
          self.itemId = iprot.readI64();
15621 
        else:
15622 
          iprot.skip(ftype)
15623 
      elif fid == 3:
15624 
        if ftype == TType.I64:
15625 
          self.quantity = iprot.readI64();
15626 
        else:
15627 
          iprot.skip(ftype)
15628 
      elif fid == 4:
15629 
        if ftype == TType.I64:
15630 
          self.estimate = iprot.readI64();
15631 
        else:
15632 
          iprot.skip(ftype)
4369 rajveer 15633 
      elif fid == 5:
15634 
        if ftype == TType.BOOL:
15635 
          self.isReminder = iprot.readBool();
15636 
        else:
15637 
          iprot.skip(ftype)
4303 rajveer 15638 
      else:
15639 
        iprot.skip(ftype)
15640 
      iprot.readFieldEnd()
15641 
    iprot.readStructEnd()
15642 
 
15643 
  def write(self, oprot):
15644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15646 
      return
15647 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
15648 
    if self.vendorId is not None:
15649 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15650 
      oprot.writeI64(self.vendorId)
15651 
      oprot.writeFieldEnd()
15652 
    if self.itemId is not None:
15653 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15654 
      oprot.writeI64(self.itemId)
15655 
      oprot.writeFieldEnd()
15656 
    if self.quantity is not None:
15657 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15658 
      oprot.writeI64(self.quantity)
15659 
      oprot.writeFieldEnd()
15660 
    if self.estimate is not None:
15661 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15662 
      oprot.writeI64(self.estimate)
15663 
      oprot.writeFieldEnd()
4369 rajveer 15664 
    if self.isReminder is not None:
15665 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15666 
      oprot.writeBool(self.isReminder)
15667 
      oprot.writeFieldEnd()
4303 rajveer 15668 
    oprot.writeFieldStop()
15669 
    oprot.writeStructEnd()
15670 
 
15671 
  def validate(self):
15672 
    return
15673 
 
15674 
 
15675 
  def __repr__(self):
15676 
    L = ['%s=%r' % (key, value)
15677 
      for key, value in self.__dict__.iteritems()]
15678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15679 
 
15680 
  def __eq__(self, other):
15681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15682 
 
15683 
  def __ne__(self, other):
15684 
    return not (self == other)
15685 
 
15686 
class markOrdersAsNotAvailabke_result:
15687 
  """
15688 
  Attributes:
15689 
   - ex
15690 
  """
15691 
 
15692 
  thrift_spec = (
15693 
    None, # 0
15694 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15695 
  )
15696 
 
15697 
  def __init__(self, ex=None,):
15698 
    self.ex = ex
15699 
 
15700 
  def read(self, iprot):
15701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15703 
      return
15704 
    iprot.readStructBegin()
15705 
    while True:
15706 
      (fname, ftype, fid) = iprot.readFieldBegin()
15707 
      if ftype == TType.STOP:
15708 
        break
15709 
      if fid == 1:
15710 
        if ftype == TType.STRUCT:
15711 
          self.ex = TransactionServiceException()
15712 
          self.ex.read(iprot)
15713 
        else:
15714 
          iprot.skip(ftype)
15715 
      else:
15716 
        iprot.skip(ftype)
15717 
      iprot.readFieldEnd()
15718 
    iprot.readStructEnd()
15719 
 
15720 
  def write(self, oprot):
15721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15723 
      return
15724 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
15725 
    if self.ex is not None:
15726 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15727 
      self.ex.write(oprot)
15728 
      oprot.writeFieldEnd()
15729 
    oprot.writeFieldStop()
15730 
    oprot.writeStructEnd()
15731 
 
15732 
  def validate(self):
15733 
    return
15734 
 
15735 
 
15736 
  def __repr__(self):
15737 
    L = ['%s=%r' % (key, value)
15738 
      for key, value in self.__dict__.iteritems()]
15739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15740 
 
15741 
  def __eq__(self, other):
15742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15743 
 
15744 
  def __ne__(self, other):
15745 
    return not (self == other)
4369 rajveer 15746 
 
15747 
class markOrdersAsTimeout_args:
15748 
  """
15749 
  Attributes:
15750 
   - vendorId
15751 
  """
15752 
 
15753 
  thrift_spec = (
15754 
    None, # 0
15755 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15756 
  )
15757 
 
15758 
  def __init__(self, vendorId=None,):
15759 
    self.vendorId = vendorId
15760 
 
15761 
  def read(self, iprot):
15762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15764 
      return
15765 
    iprot.readStructBegin()
15766 
    while True:
15767 
      (fname, ftype, fid) = iprot.readFieldBegin()
15768 
      if ftype == TType.STOP:
15769 
        break
15770 
      if fid == 1:
15771 
        if ftype == TType.I64:
15772 
          self.vendorId = iprot.readI64();
15773 
        else:
15774 
          iprot.skip(ftype)
15775 
      else:
15776 
        iprot.skip(ftype)
15777 
      iprot.readFieldEnd()
15778 
    iprot.readStructEnd()
15779 
 
15780 
  def write(self, oprot):
15781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15783 
      return
15784 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
15785 
    if self.vendorId is not None:
15786 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15787 
      oprot.writeI64(self.vendorId)
15788 
      oprot.writeFieldEnd()
15789 
    oprot.writeFieldStop()
15790 
    oprot.writeStructEnd()
15791 
 
15792 
  def validate(self):
15793 
    return
15794 
 
15795 
 
15796 
  def __repr__(self):
15797 
    L = ['%s=%r' % (key, value)
15798 
      for key, value in self.__dict__.iteritems()]
15799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15800 
 
15801 
  def __eq__(self, other):
15802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15803 
 
15804 
  def __ne__(self, other):
15805 
    return not (self == other)
15806 
 
15807 
class markOrdersAsTimeout_result:
15808 
  """
15809 
  Attributes:
15810 
   - success
15811 
   - ex
15812 
  """
15813 
 
15814 
  thrift_spec = (
15815 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
15816 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15817 
  )
15818 
 
15819 
  def __init__(self, success=None, ex=None,):
15820 
    self.success = success
15821 
    self.ex = ex
15822 
 
15823 
  def read(self, iprot):
15824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15826 
      return
15827 
    iprot.readStructBegin()
15828 
    while True:
15829 
      (fname, ftype, fid) = iprot.readFieldBegin()
15830 
      if ftype == TType.STOP:
15831 
        break
15832 
      if fid == 0:
15833 
        if ftype == TType.MAP:
15834 
          self.success = {}
15835 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
15836 
          for _i265 in xrange(_size261):
15837 
            _key266 = iprot.readI32();
15838 
            _val267 = TimeoutSummary()
15839 
            _val267.read(iprot)
15840 
            self.success[_key266] = _val267
15841 
          iprot.readMapEnd()
15842 
        else:
15843 
          iprot.skip(ftype)
15844 
      elif fid == 1:
15845 
        if ftype == TType.STRUCT:
15846 
          self.ex = TransactionServiceException()
15847 
          self.ex.read(iprot)
15848 
        else:
15849 
          iprot.skip(ftype)
15850 
      else:
15851 
        iprot.skip(ftype)
15852 
      iprot.readFieldEnd()
15853 
    iprot.readStructEnd()
15854 
 
15855 
  def write(self, oprot):
15856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15858 
      return
15859 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
15860 
    if self.success is not None:
15861 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15862 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
15863 
      for kiter268,viter269 in self.success.items():
15864 
        oprot.writeI32(kiter268)
15865 
        viter269.write(oprot)
15866 
      oprot.writeMapEnd()
15867 
      oprot.writeFieldEnd()
15868 
    if self.ex is not None:
15869 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15870 
      self.ex.write(oprot)
15871 
      oprot.writeFieldEnd()
15872 
    oprot.writeFieldStop()
15873 
    oprot.writeStructEnd()
15874 
 
15875 
  def validate(self):
15876 
    return
15877 
 
15878 
 
15879 
  def __repr__(self):
15880 
    L = ['%s=%r' % (key, value)
15881 
      for key, value in self.__dict__.iteritems()]
15882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15883 
 
15884 
  def __eq__(self, other):
15885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15886 
 
15887 
  def __ne__(self, other):
15888 
    return not (self == other)
4386 anupam.sin 15889 
 
15890 
class getOrderForAwb_args:
15891 
  """
15892 
  Attributes:
15893 
   - awb
15894 
  """
15895 
 
15896 
  thrift_spec = (
15897 
    None, # 0
15898 
    (1, TType.STRING, 'awb', None, None, ), # 1
15899 
  )
15900 
 
15901 
  def __init__(self, awb=None,):
15902 
    self.awb = awb
15903 
 
15904 
  def read(self, iprot):
15905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15907 
      return
15908 
    iprot.readStructBegin()
15909 
    while True:
15910 
      (fname, ftype, fid) = iprot.readFieldBegin()
15911 
      if ftype == TType.STOP:
15912 
        break
15913 
      if fid == 1:
15914 
        if ftype == TType.STRING:
15915 
          self.awb = iprot.readString();
15916 
        else:
15917 
          iprot.skip(ftype)
15918 
      else:
15919 
        iprot.skip(ftype)
15920 
      iprot.readFieldEnd()
15921 
    iprot.readStructEnd()
15922 
 
15923 
  def write(self, oprot):
15924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15926 
      return
15927 
    oprot.writeStructBegin('getOrderForAwb_args')
15928 
    if self.awb is not None:
15929 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
15930 
      oprot.writeString(self.awb)
15931 
      oprot.writeFieldEnd()
15932 
    oprot.writeFieldStop()
15933 
    oprot.writeStructEnd()
15934 
 
15935 
  def validate(self):
15936 
    return
15937 
 
15938 
 
15939 
  def __repr__(self):
15940 
    L = ['%s=%r' % (key, value)
15941 
      for key, value in self.__dict__.iteritems()]
15942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15943 
 
15944 
  def __eq__(self, other):
15945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15946 
 
15947 
  def __ne__(self, other):
15948 
    return not (self == other)
15949 
 
15950 
class getOrderForAwb_result:
15951 
  """
15952 
  Attributes:
15953 
   - success
15954 
   - ex
15955 
  """
15956 
 
15957 
  thrift_spec = (
15958 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
15959 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15960 
  )
15961 
 
15962 
  def __init__(self, success=None, ex=None,):
15963 
    self.success = success
15964 
    self.ex = ex
15965 
 
15966 
  def read(self, iprot):
15967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15969 
      return
15970 
    iprot.readStructBegin()
15971 
    while True:
15972 
      (fname, ftype, fid) = iprot.readFieldBegin()
15973 
      if ftype == TType.STOP:
15974 
        break
15975 
      if fid == 0:
15976 
        if ftype == TType.STRUCT:
15977 
          self.success = Order()
15978 
          self.success.read(iprot)
15979 
        else:
15980 
          iprot.skip(ftype)
15981 
      elif fid == 1:
15982 
        if ftype == TType.STRUCT:
15983 
          self.ex = TransactionServiceException()
15984 
          self.ex.read(iprot)
15985 
        else:
15986 
          iprot.skip(ftype)
15987 
      else:
15988 
        iprot.skip(ftype)
15989 
      iprot.readFieldEnd()
15990 
    iprot.readStructEnd()
15991 
 
15992 
  def write(self, oprot):
15993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15995 
      return
15996 
    oprot.writeStructBegin('getOrderForAwb_result')
15997 
    if self.success is not None:
15998 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15999 
      self.success.write(oprot)
16000 
      oprot.writeFieldEnd()
16001 
    if self.ex is not None:
16002 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16003 
      self.ex.write(oprot)
16004 
      oprot.writeFieldEnd()
16005 
    oprot.writeFieldStop()
16006 
    oprot.writeStructEnd()
16007 
 
16008 
  def validate(self):
16009 
    return
16010 
 
16011 
 
16012 
  def __repr__(self):
16013 
    L = ['%s=%r' % (key, value)
16014 
      for key, value in self.__dict__.iteritems()]
16015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16016 
 
16017 
  def __eq__(self, other):
16018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16019 
 
16020 
  def __ne__(self, other):
16021 
    return not (self == other)