Subversion Repositories SmartDukaan

Rev

Rev 4495 | Rev 4579 | 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 
 
4506 phani.kuma 865 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
866 
    """
867 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 868 
 
4506 phani.kuma 869 
    Parameters:
870 
     - logistics_provider_id
871 
     - order_status
872 
    """
873 
    pass
874 
 
875 
 
3376 rajveer 876 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 877 
  def __init__(self, iprot, oprot=None):
3376 rajveer 878 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 879 
 
880 
  def createTransaction(self, transaction):
881 
    """
882 
    Parameters:
883 
     - transaction
884 
    """
885 
    self.send_createTransaction(transaction)
132 ashish 886 
    return self.recv_createTransaction()
94 ashish 887 
 
888 
  def send_createTransaction(self, transaction):
889 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
890 
    args = createTransaction_args()
891 
    args.transaction = transaction
892 
    args.write(self._oprot)
893 
    self._oprot.writeMessageEnd()
894 
    self._oprot.trans.flush()
895 
 
896 
  def recv_createTransaction(self, ):
897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
898 
    if mtype == TMessageType.EXCEPTION:
899 
      x = TApplicationException()
900 
      x.read(self._iprot)
901 
      self._iprot.readMessageEnd()
902 
      raise x
903 
    result = createTransaction_result()
904 
    result.read(self._iprot)
905 
    self._iprot.readMessageEnd()
3431 rajveer 906 
    if result.success is not None:
132 ashish 907 
      return result.success
3431 rajveer 908 
    if result.ex is not None:
94 ashish 909 
      raise result.ex
132 ashish 910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 911 
 
912 
  def getTransaction(self, id):
913 
    """
914 
    Parameters:
915 
     - id
916 
    """
917 
    self.send_getTransaction(id)
918 
    return self.recv_getTransaction()
919 
 
920 
  def send_getTransaction(self, id):
921 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
922 
    args = getTransaction_args()
923 
    args.id = id
924 
    args.write(self._oprot)
925 
    self._oprot.writeMessageEnd()
926 
    self._oprot.trans.flush()
927 
 
928 
  def recv_getTransaction(self, ):
929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
930 
    if mtype == TMessageType.EXCEPTION:
931 
      x = TApplicationException()
932 
      x.read(self._iprot)
933 
      self._iprot.readMessageEnd()
934 
      raise x
935 
    result = getTransaction_result()
936 
    result.read(self._iprot)
937 
    self._iprot.readMessageEnd()
3431 rajveer 938 
    if result.success is not None:
94 ashish 939 
      return result.success
3431 rajveer 940 
    if result.ex is not None:
94 ashish 941 
      raise result.ex
942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
943 
 
944 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
945 
    """
946 
    Parameters:
947 
     - customerId
948 
     - from_date
949 
     - to_date
950 
     - status
951 
    """
952 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
953 
    return self.recv_getTransactionsForCustomer()
954 
 
955 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
956 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
957 
    args = getTransactionsForCustomer_args()
958 
    args.customerId = customerId
959 
    args.from_date = from_date
960 
    args.to_date = to_date
961 
    args.status = status
962 
    args.write(self._oprot)
963 
    self._oprot.writeMessageEnd()
964 
    self._oprot.trans.flush()
965 
 
966 
  def recv_getTransactionsForCustomer(self, ):
967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
968 
    if mtype == TMessageType.EXCEPTION:
969 
      x = TApplicationException()
970 
      x.read(self._iprot)
971 
      self._iprot.readMessageEnd()
972 
      raise x
973 
    result = getTransactionsForCustomer_result()
974 
    result.read(self._iprot)
975 
    self._iprot.readMessageEnd()
3431 rajveer 976 
    if result.success is not None:
94 ashish 977 
      return result.success
3431 rajveer 978 
    if result.ex is not None:
94 ashish 979 
      raise result.ex
980 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
981 
 
132 ashish 982 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
983 
    """
984 
    Parameters:
985 
     - shoppingCartId
986 
    """
987 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
988 
    return self.recv_getTransactionsForShoppingCartId()
989 
 
990 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
991 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
992 
    args = getTransactionsForShoppingCartId_args()
993 
    args.shoppingCartId = shoppingCartId
994 
    args.write(self._oprot)
995 
    self._oprot.writeMessageEnd()
996 
    self._oprot.trans.flush()
997 
 
998 
  def recv_getTransactionsForShoppingCartId(self, ):
999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1000 
    if mtype == TMessageType.EXCEPTION:
1001 
      x = TApplicationException()
1002 
      x.read(self._iprot)
1003 
      self._iprot.readMessageEnd()
1004 
      raise x
1005 
    result = getTransactionsForShoppingCartId_result()
1006 
    result.read(self._iprot)
1007 
    self._iprot.readMessageEnd()
3431 rajveer 1008 
    if result.success is not None:
132 ashish 1009 
      return result.success
3431 rajveer 1010 
    if result.ex is not None:
132 ashish 1011 
      raise result.ex
1012 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1013 
 
94 ashish 1014 
  def getTransactionStatus(self, transactionId):
1015 
    """
1016 
    Parameters:
1017 
     - transactionId
1018 
    """
1019 
    self.send_getTransactionStatus(transactionId)
1020 
    return self.recv_getTransactionStatus()
1021 
 
1022 
  def send_getTransactionStatus(self, transactionId):
1023 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1024 
    args = getTransactionStatus_args()
1025 
    args.transactionId = transactionId
1026 
    args.write(self._oprot)
1027 
    self._oprot.writeMessageEnd()
1028 
    self._oprot.trans.flush()
1029 
 
1030 
  def recv_getTransactionStatus(self, ):
1031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1032 
    if mtype == TMessageType.EXCEPTION:
1033 
      x = TApplicationException()
1034 
      x.read(self._iprot)
1035 
      self._iprot.readMessageEnd()
1036 
      raise x
1037 
    result = getTransactionStatus_result()
1038 
    result.read(self._iprot)
1039 
    self._iprot.readMessageEnd()
3431 rajveer 1040 
    if result.success is not None:
94 ashish 1041 
      return result.success
3431 rajveer 1042 
    if result.ex is not None:
94 ashish 1043 
      raise result.ex
1044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1045 
 
1046 
  def changeTransactionStatus(self, transactionId, status, description):
1047 
    """
1048 
    Parameters:
1049 
     - transactionId
1050 
     - status
1051 
     - description
1052 
    """
1053 
    self.send_changeTransactionStatus(transactionId, status, description)
1054 
    return self.recv_changeTransactionStatus()
1055 
 
1056 
  def send_changeTransactionStatus(self, transactionId, status, description):
1057 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1058 
    args = changeTransactionStatus_args()
1059 
    args.transactionId = transactionId
1060 
    args.status = status
1061 
    args.description = description
1062 
    args.write(self._oprot)
1063 
    self._oprot.writeMessageEnd()
1064 
    self._oprot.trans.flush()
1065 
 
1066 
  def recv_changeTransactionStatus(self, ):
1067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1068 
    if mtype == TMessageType.EXCEPTION:
1069 
      x = TApplicationException()
1070 
      x.read(self._iprot)
1071 
      self._iprot.readMessageEnd()
1072 
      raise x
1073 
    result = changeTransactionStatus_result()
1074 
    result.read(self._iprot)
1075 
    self._iprot.readMessageEnd()
3431 rajveer 1076 
    if result.success is not None:
94 ashish 1077 
      return result.success
3431 rajveer 1078 
    if result.ex is not None:
94 ashish 1079 
      raise result.ex
1080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1081 
 
1398 varun.gupt 1082 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1083 
    """
1084 
    Parameters:
1085 
     - transactionId
1086 
    """
1398 varun.gupt 1087 
    self.send_enqueueTransactionInfoEmail(transactionId)
1088 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1089 
 
1398 varun.gupt 1090 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1091 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1092 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1093 
    args.transactionId = transactionId
1094 
    args.write(self._oprot)
1095 
    self._oprot.writeMessageEnd()
1096 
    self._oprot.trans.flush()
1097 
 
1398 varun.gupt 1098 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1100 
    if mtype == TMessageType.EXCEPTION:
1101 
      x = TApplicationException()
1102 
      x.read(self._iprot)
1103 
      self._iprot.readMessageEnd()
1104 
      raise x
1398 varun.gupt 1105 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1106 
    result.read(self._iprot)
1107 
    self._iprot.readMessageEnd()
3431 rajveer 1108 
    if result.success is not None:
1382 varun.gupt 1109 
      return result.success
3431 rajveer 1110 
    if result.ex is not None:
1382 varun.gupt 1111 
      raise result.ex
1398 varun.gupt 1112 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1113 
 
483 rajveer 1114 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1115 
    """
1116 
    Parameters:
483 rajveer 1117 
     - status
1118 
     - from_date
1119 
     - to_date
1120 
     - warehouse_id
94 ashish 1121 
    """
483 rajveer 1122 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1123 
    return self.recv_getAllOrders()
94 ashish 1124 
 
483 rajveer 1125 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1126 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1127 
    args = getAllOrders_args()
1128 
    args.status = status
1129 
    args.from_date = from_date
1130 
    args.to_date = to_date
1131 
    args.warehouse_id = warehouse_id
94 ashish 1132 
    args.write(self._oprot)
1133 
    self._oprot.writeMessageEnd()
1134 
    self._oprot.trans.flush()
1135 
 
483 rajveer 1136 
  def recv_getAllOrders(self, ):
94 ashish 1137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1138 
    if mtype == TMessageType.EXCEPTION:
1139 
      x = TApplicationException()
1140 
      x.read(self._iprot)
1141 
      self._iprot.readMessageEnd()
1142 
      raise x
483 rajveer 1143 
    result = getAllOrders_result()
94 ashish 1144 
    result.read(self._iprot)
1145 
    self._iprot.readMessageEnd()
3431 rajveer 1146 
    if result.success is not None:
94 ashish 1147 
      return result.success
3431 rajveer 1148 
    if result.ex is not None:
94 ashish 1149 
      raise result.ex
483 rajveer 1150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1151 
 
4133 chandransh 1152 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1153 
    """
1154 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1155 
    Pass the status as null and the limit as 0 to ignore them.
1156 
 
1157 
    Parameters:
1158 
     - statuses
1159 
     - offset
1160 
     - limit
1161 
     - warehouse_id
1162 
    """
1163 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1164 
    return self.recv_getOrdersInBatch()
1165 
 
1166 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1167 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1168 
    args = getOrdersInBatch_args()
1169 
    args.statuses = statuses
1170 
    args.offset = offset
1171 
    args.limit = limit
1172 
    args.warehouse_id = warehouse_id
1173 
    args.write(self._oprot)
1174 
    self._oprot.writeMessageEnd()
1175 
    self._oprot.trans.flush()
1176 
 
1177 
  def recv_getOrdersInBatch(self, ):
1178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1179 
    if mtype == TMessageType.EXCEPTION:
1180 
      x = TApplicationException()
1181 
      x.read(self._iprot)
1182 
      self._iprot.readMessageEnd()
1183 
      raise x
1184 
    result = getOrdersInBatch_result()
1185 
    result.read(self._iprot)
1186 
    self._iprot.readMessageEnd()
1187 
    if result.success is not None:
1188 
      return result.success
1189 
    if result.ex is not None:
1190 
      raise result.ex
1191 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1192 
 
1193 
  def getOrderCount(self, statuses, warehouseId):
1194 
    """
1195 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1196 
 
1197 
    Parameters:
1198 
     - statuses
1199 
     - warehouseId
1200 
    """
1201 
    self.send_getOrderCount(statuses, warehouseId)
1202 
    return self.recv_getOrderCount()
1203 
 
1204 
  def send_getOrderCount(self, statuses, warehouseId):
1205 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1206 
    args = getOrderCount_args()
1207 
    args.statuses = statuses
1208 
    args.warehouseId = warehouseId
1209 
    args.write(self._oprot)
1210 
    self._oprot.writeMessageEnd()
1211 
    self._oprot.trans.flush()
1212 
 
1213 
  def recv_getOrderCount(self, ):
1214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1215 
    if mtype == TMessageType.EXCEPTION:
1216 
      x = TApplicationException()
1217 
      x.read(self._iprot)
1218 
      self._iprot.readMessageEnd()
1219 
      raise x
1220 
    result = getOrderCount_result()
1221 
    result.read(self._iprot)
1222 
    self._iprot.readMessageEnd()
1223 
    if result.success is not None:
1224 
      return result.success
1225 
    if result.ex is not None:
1226 
      raise result.ex
1227 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1228 
 
999 varun.gupt 1229 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1230 
    """
1132 chandransh 1231 
    Returns orders within a range of their billing dates
3431 rajveer 1232 
 
999 varun.gupt 1233 
    Parameters:
1234 
     - status
1235 
     - start_billing_date
1236 
     - end_billing_date
1237 
     - warehouse_id
1238 
    """
1239 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1240 
    return self.recv_getOrdersByBillingDate()
1241 
 
1242 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1243 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1244 
    args = getOrdersByBillingDate_args()
1245 
    args.status = status
1246 
    args.start_billing_date = start_billing_date
1247 
    args.end_billing_date = end_billing_date
1248 
    args.warehouse_id = warehouse_id
1249 
    args.write(self._oprot)
1250 
    self._oprot.writeMessageEnd()
1251 
    self._oprot.trans.flush()
1252 
 
1253 
  def recv_getOrdersByBillingDate(self, ):
1254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1255 
    if mtype == TMessageType.EXCEPTION:
1256 
      x = TApplicationException()
1257 
      x.read(self._iprot)
1258 
      self._iprot.readMessageEnd()
1259 
      raise x
1260 
    result = getOrdersByBillingDate_result()
1261 
    result.read(self._iprot)
1262 
    self._iprot.readMessageEnd()
3431 rajveer 1263 
    if result.success is not None:
999 varun.gupt 1264 
      return result.success
3431 rajveer 1265 
    if result.ex is not None:
999 varun.gupt 1266 
      raise result.ex
1267 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1268 
 
3451 chandransh 1269 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1270 
    """
1271 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1272 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1273 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1274 
 
3427 chandransh 1275 
    Parameters:
1276 
     - fromShippingDate
1277 
     - toShippingDate
1278 
     - providerId
1279 
     - warehouseId
3451 chandransh 1280 
     - cod
3427 chandransh 1281 
    """
3451 chandransh 1282 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1283 
    return self.recv_getOrdersByShippingDate()
1284 
 
3451 chandransh 1285 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1286 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1287 
    args = getOrdersByShippingDate_args()
1288 
    args.fromShippingDate = fromShippingDate
1289 
    args.toShippingDate = toShippingDate
1290 
    args.providerId = providerId
1291 
    args.warehouseId = warehouseId
3451 chandransh 1292 
    args.cod = cod
3427 chandransh 1293 
    args.write(self._oprot)
1294 
    self._oprot.writeMessageEnd()
1295 
    self._oprot.trans.flush()
1296 
 
1297 
  def recv_getOrdersByShippingDate(self, ):
1298 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1299 
    if mtype == TMessageType.EXCEPTION:
1300 
      x = TApplicationException()
1301 
      x.read(self._iprot)
1302 
      self._iprot.readMessageEnd()
1303 
      raise x
1304 
    result = getOrdersByShippingDate_result()
1305 
    result.read(self._iprot)
1306 
    self._iprot.readMessageEnd()
3431 rajveer 1307 
    if result.success is not None:
3427 chandransh 1308 
      return result.success
3431 rajveer 1309 
    if result.ex is not None:
3427 chandransh 1310 
      raise result.ex
1311 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1312 
 
1382 varun.gupt 1313 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1314 
    """
1315 
    Returns order ids for orders which can be returned
3431 rajveer 1316 
 
1382 varun.gupt 1317 
    Parameters:
1318 
     - customer_id
1319 
     - limit
1320 
    """
1321 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1322 
    return self.recv_getReturnableOrdersForCustomer()
1323 
 
1324 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1325 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1326 
    args = getReturnableOrdersForCustomer_args()
1327 
    args.customer_id = customer_id
1328 
    args.limit = limit
1329 
    args.write(self._oprot)
1330 
    self._oprot.writeMessageEnd()
1331 
    self._oprot.trans.flush()
1332 
 
1333 
  def recv_getReturnableOrdersForCustomer(self, ):
1334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1335 
    if mtype == TMessageType.EXCEPTION:
1336 
      x = TApplicationException()
1337 
      x.read(self._iprot)
1338 
      self._iprot.readMessageEnd()
1339 
      raise x
1340 
    result = getReturnableOrdersForCustomer_result()
1341 
    result.read(self._iprot)
1342 
    self._iprot.readMessageEnd()
3431 rajveer 1343 
    if result.success is not None:
1382 varun.gupt 1344 
      return result.success
3431 rajveer 1345 
    if result.ex is not None:
1382 varun.gupt 1346 
      raise result.ex
1347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1348 
 
1349 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1350 
    """
1351 
    Returns order ids for orders which can be cancelled
3431 rajveer 1352 
 
1382 varun.gupt 1353 
    Parameters:
1354 
     - customer_id
1355 
     - limit
1356 
    """
1357 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1358 
    return self.recv_getCancellableOrdersForCustomer()
1359 
 
1360 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1361 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1362 
    args = getCancellableOrdersForCustomer_args()
1363 
    args.customer_id = customer_id
1364 
    args.limit = limit
1365 
    args.write(self._oprot)
1366 
    self._oprot.writeMessageEnd()
1367 
    self._oprot.trans.flush()
1368 
 
1369 
  def recv_getCancellableOrdersForCustomer(self, ):
1370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1371 
    if mtype == TMessageType.EXCEPTION:
1372 
      x = TApplicationException()
1373 
      x.read(self._iprot)
1374 
      self._iprot.readMessageEnd()
1375 
      raise x
1376 
    result = getCancellableOrdersForCustomer_result()
1377 
    result.read(self._iprot)
1378 
    self._iprot.readMessageEnd()
3431 rajveer 1379 
    if result.success is not None:
1382 varun.gupt 1380 
      return result.success
3431 rajveer 1381 
    if result.ex is not None:
1382 varun.gupt 1382 
      raise result.ex
1383 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1384 
 
483 rajveer 1385 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1386 
    """
1387 
    Parameters:
483 rajveer 1388 
     - orderId
1389 
     - status
1390 
     - description
94 ashish 1391 
    """
483 rajveer 1392 
    self.send_changeOrderStatus(orderId, status, description)
1393 
    return self.recv_changeOrderStatus()
94 ashish 1394 
 
483 rajveer 1395 
  def send_changeOrderStatus(self, orderId, status, description):
1396 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1397 
    args = changeOrderStatus_args()
1398 
    args.orderId = orderId
1399 
    args.status = status
1400 
    args.description = description
94 ashish 1401 
    args.write(self._oprot)
1402 
    self._oprot.writeMessageEnd()
1403 
    self._oprot.trans.flush()
1404 
 
483 rajveer 1405 
  def recv_changeOrderStatus(self, ):
94 ashish 1406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1407 
    if mtype == TMessageType.EXCEPTION:
1408 
      x = TApplicationException()
1409 
      x.read(self._iprot)
1410 
      self._iprot.readMessageEnd()
1411 
      raise x
483 rajveer 1412 
    result = changeOrderStatus_result()
94 ashish 1413 
    result.read(self._iprot)
1414 
    self._iprot.readMessageEnd()
3431 rajveer 1415 
    if result.success is not None:
94 ashish 1416 
      return result.success
3431 rajveer 1417 
    if result.ex is not None:
94 ashish 1418 
      raise result.ex
483 rajveer 1419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1420 
 
1528 ankur.sing 1421 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1422 
    """
1528 ankur.sing 1423 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1424 
    only user who owns the transaction can view its order details.
3431 rajveer 1425 
 
94 ashish 1426 
    Parameters:
1427 
     - transactionId
1528 ankur.sing 1428 
     - customerId
94 ashish 1429 
    """
1528 ankur.sing 1430 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1431 
    return self.recv_getOrdersForTransaction()
94 ashish 1432 
 
1528 ankur.sing 1433 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1434 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1435 
    args = getOrdersForTransaction_args()
94 ashish 1436 
    args.transactionId = transactionId
1528 ankur.sing 1437 
    args.customerId = customerId
94 ashish 1438 
    args.write(self._oprot)
1439 
    self._oprot.writeMessageEnd()
1440 
    self._oprot.trans.flush()
1441 
 
483 rajveer 1442 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1443 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1444 
    if mtype == TMessageType.EXCEPTION:
1445 
      x = TApplicationException()
1446 
      x.read(self._iprot)
1447 
      self._iprot.readMessageEnd()
1448 
      raise x
483 rajveer 1449 
    result = getOrdersForTransaction_result()
94 ashish 1450 
    result.read(self._iprot)
1451 
    self._iprot.readMessageEnd()
3431 rajveer 1452 
    if result.success is not None:
94 ashish 1453 
      return result.success
3431 rajveer 1454 
    if result.ex is not None:
94 ashish 1455 
      raise result.ex
483 rajveer 1456 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1457 
 
3014 chandransh 1458 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1459 
    """
3014 chandransh 1460 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1461 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1462 
 
94 ashish 1463 
    Parameters:
483 rajveer 1464 
     - customerId
1465 
     - from_date
1466 
     - to_date
3014 chandransh 1467 
     - statuses
94 ashish 1468 
    """
3014 chandransh 1469 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1470 
    return self.recv_getOrdersForCustomer()
94 ashish 1471 
 
3014 chandransh 1472 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1473 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1474 
    args = getOrdersForCustomer_args()
1475 
    args.customerId = customerId
1476 
    args.from_date = from_date
1477 
    args.to_date = to_date
3014 chandransh 1478 
    args.statuses = statuses
94 ashish 1479 
    args.write(self._oprot)
1480 
    self._oprot.writeMessageEnd()
1481 
    self._oprot.trans.flush()
1482 
 
483 rajveer 1483 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1485 
    if mtype == TMessageType.EXCEPTION:
1486 
      x = TApplicationException()
1487 
      x.read(self._iprot)
1488 
      self._iprot.readMessageEnd()
1489 
      raise x
483 rajveer 1490 
    result = getOrdersForCustomer_result()
94 ashish 1491 
    result.read(self._iprot)
1492 
    self._iprot.readMessageEnd()
3431 rajveer 1493 
    if result.success is not None:
94 ashish 1494 
      return result.success
3431 rajveer 1495 
    if result.ex is not None:
94 ashish 1496 
      raise result.ex
483 rajveer 1497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1498 
 
483 rajveer 1499 
  def createOrder(self, order):
94 ashish 1500 
    """
1501 
    Parameters:
483 rajveer 1502 
     - order
94 ashish 1503 
    """
483 rajveer 1504 
    self.send_createOrder(order)
1505 
    return self.recv_createOrder()
94 ashish 1506 
 
483 rajveer 1507 
  def send_createOrder(self, order):
1508 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1509 
    args = createOrder_args()
1510 
    args.order = order
94 ashish 1511 
    args.write(self._oprot)
1512 
    self._oprot.writeMessageEnd()
1513 
    self._oprot.trans.flush()
1514 
 
483 rajveer 1515 
  def recv_createOrder(self, ):
94 ashish 1516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1517 
    if mtype == TMessageType.EXCEPTION:
1518 
      x = TApplicationException()
1519 
      x.read(self._iprot)
1520 
      self._iprot.readMessageEnd()
1521 
      raise x
483 rajveer 1522 
    result = createOrder_result()
94 ashish 1523 
    result.read(self._iprot)
1524 
    self._iprot.readMessageEnd()
3431 rajveer 1525 
    if result.success is not None:
94 ashish 1526 
      return result.success
3431 rajveer 1527 
    if result.ex is not None:
94 ashish 1528 
      raise result.ex
483 rajveer 1529 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1530 
 
483 rajveer 1531 
  def getOrder(self, id):
94 ashish 1532 
    """
1533 
    Parameters:
483 rajveer 1534 
     - id
94 ashish 1535 
    """
483 rajveer 1536 
    self.send_getOrder(id)
1537 
    return self.recv_getOrder()
94 ashish 1538 
 
483 rajveer 1539 
  def send_getOrder(self, id):
1540 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1541 
    args = getOrder_args()
1542 
    args.id = id
94 ashish 1543 
    args.write(self._oprot)
1544 
    self._oprot.writeMessageEnd()
1545 
    self._oprot.trans.flush()
1546 
 
483 rajveer 1547 
  def recv_getOrder(self, ):
94 ashish 1548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1549 
    if mtype == TMessageType.EXCEPTION:
1550 
      x = TApplicationException()
1551 
      x.read(self._iprot)
1552 
      self._iprot.readMessageEnd()
1553 
      raise x
483 rajveer 1554 
    result = getOrder_result()
94 ashish 1555 
    result.read(self._iprot)
1556 
    self._iprot.readMessageEnd()
3431 rajveer 1557 
    if result.success is not None:
94 ashish 1558 
      return result.success
3431 rajveer 1559 
    if result.ex is not None:
94 ashish 1560 
      raise result.ex
483 rajveer 1561 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1562 
 
483 rajveer 1563 
  def getLineItemsForOrder(self, orderId):
94 ashish 1564 
    """
1565 
    Parameters:
483 rajveer 1566 
     - orderId
94 ashish 1567 
    """
483 rajveer 1568 
    self.send_getLineItemsForOrder(orderId)
1569 
    return self.recv_getLineItemsForOrder()
94 ashish 1570 
 
483 rajveer 1571 
  def send_getLineItemsForOrder(self, orderId):
1572 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1573 
    args = getLineItemsForOrder_args()
1574 
    args.orderId = orderId
94 ashish 1575 
    args.write(self._oprot)
1576 
    self._oprot.writeMessageEnd()
1577 
    self._oprot.trans.flush()
1578 
 
483 rajveer 1579 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1581 
    if mtype == TMessageType.EXCEPTION:
1582 
      x = TApplicationException()
1583 
      x.read(self._iprot)
1584 
      self._iprot.readMessageEnd()
1585 
      raise x
483 rajveer 1586 
    result = getLineItemsForOrder_result()
94 ashish 1587 
    result.read(self._iprot)
1588 
    self._iprot.readMessageEnd()
3431 rajveer 1589 
    if result.success is not None:
94 ashish 1590 
      return result.success
3431 rajveer 1591 
    if result.ex is not None:
94 ashish 1592 
      raise result.ex
483 rajveer 1593 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1594 
 
1528 ankur.sing 1595 
  def getOrderForCustomer(self, orderId, customerId):
1596 
    """
1597 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1598 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1599 
 
1528 ankur.sing 1600 
    Parameters:
1601 
     - orderId
1602 
     - customerId
1603 
    """
1604 
    self.send_getOrderForCustomer(orderId, customerId)
1605 
    return self.recv_getOrderForCustomer()
1606 
 
1607 
  def send_getOrderForCustomer(self, orderId, customerId):
1608 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1609 
    args = getOrderForCustomer_args()
1610 
    args.orderId = orderId
1611 
    args.customerId = customerId
1612 
    args.write(self._oprot)
1613 
    self._oprot.writeMessageEnd()
1614 
    self._oprot.trans.flush()
1615 
 
1616 
  def recv_getOrderForCustomer(self, ):
1617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1618 
    if mtype == TMessageType.EXCEPTION:
1619 
      x = TApplicationException()
1620 
      x.read(self._iprot)
1621 
      self._iprot.readMessageEnd()
1622 
      raise x
1623 
    result = getOrderForCustomer_result()
1624 
    result.read(self._iprot)
1625 
    self._iprot.readMessageEnd()
3431 rajveer 1626 
    if result.success is not None:
1528 ankur.sing 1627 
      return result.success
3431 rajveer 1628 
    if result.ex is not None:
1528 ankur.sing 1629 
      raise result.ex
1630 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1631 
 
4444 rajveer 1632 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1633 
    """
1634 
    Parameters:
4394 rajveer 1635 
     - type
4444 rajveer 1636 
     - warehouseId
4394 rajveer 1637 
     - status
1638 
     - timestamp
3064 chandransh 1639 
    """
4444 rajveer 1640 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1641 
    return self.recv_getAlerts()
1642 
 
4444 rajveer 1643 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1644 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1645 
    args = getAlerts_args()
4394 rajveer 1646 
    args.type = type
4444 rajveer 1647 
    args.warehouseId = warehouseId
4394 rajveer 1648 
    args.status = status
1649 
    args.timestamp = timestamp
3064 chandransh 1650 
    args.write(self._oprot)
1651 
    self._oprot.writeMessageEnd()
1652 
    self._oprot.trans.flush()
1653 
 
1654 
  def recv_getAlerts(self, ):
1655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1656 
    if mtype == TMessageType.EXCEPTION:
1657 
      x = TApplicationException()
1658 
      x.read(self._iprot)
1659 
      self._iprot.readMessageEnd()
1660 
      raise x
1661 
    result = getAlerts_result()
1662 
    result.read(self._iprot)
1663 
    self._iprot.readMessageEnd()
3431 rajveer 1664 
    if result.success is not None:
3064 chandransh 1665 
      return result.success
1666 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1667 
 
4444 rajveer 1668 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1669 
    """
1670 
    Parameters:
1671 
     - type
4444 rajveer 1672 
     - warehouseId
4394 rajveer 1673 
     - description
3064 chandransh 1674 
    """
4444 rajveer 1675 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1676 
    self.recv_addAlert()
3064 chandransh 1677 
 
4444 rajveer 1678 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1679 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1680 
    args = addAlert_args()
3064 chandransh 1681 
    args.type = type
4444 rajveer 1682 
    args.warehouseId = warehouseId
4394 rajveer 1683 
    args.description = description
3064 chandransh 1684 
    args.write(self._oprot)
1685 
    self._oprot.writeMessageEnd()
1686 
    self._oprot.trans.flush()
1687 
 
4394 rajveer 1688 
  def recv_addAlert(self, ):
3064 chandransh 1689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1690 
    if mtype == TMessageType.EXCEPTION:
1691 
      x = TApplicationException()
1692 
      x.read(self._iprot)
1693 
      self._iprot.readMessageEnd()
1694 
      raise x
4394 rajveer 1695 
    result = addAlert_result()
3064 chandransh 1696 
    result.read(self._iprot)
1697 
    self._iprot.readMessageEnd()
1698 
    return
1699 
 
4444 rajveer 1700 
  def markAlertsAsSeen(self, warehouseId):
1701 
    """
1702 
    Parameters:
1703 
     - warehouseId
1704 
    """
1705 
    self.send_markAlertsAsSeen(warehouseId)
1706 
    self.recv_markAlertsAsSeen()
1707 
 
1708 
  def send_markAlertsAsSeen(self, warehouseId):
1709 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1710 
    args = markAlertsAsSeen_args()
1711 
    args.warehouseId = warehouseId
1712 
    args.write(self._oprot)
1713 
    self._oprot.writeMessageEnd()
1714 
    self._oprot.trans.flush()
1715 
 
1716 
  def recv_markAlertsAsSeen(self, ):
1717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1718 
    if mtype == TMessageType.EXCEPTION:
1719 
      x = TApplicationException()
1720 
      x.read(self._iprot)
1721 
      self._iprot.readMessageEnd()
1722 
      raise x
1723 
    result = markAlertsAsSeen_result()
1724 
    result.read(self._iprot)
1725 
    self._iprot.readMessageEnd()
1726 
    return
1727 
 
3064 chandransh 1728 
  def getValidOrderCount(self, ):
1729 
    """
1730 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1731 
    """
1732 
    self.send_getValidOrderCount()
1733 
    return self.recv_getValidOrderCount()
1734 
 
1735 
  def send_getValidOrderCount(self, ):
1736 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1737 
    args = getValidOrderCount_args()
1738 
    args.write(self._oprot)
1739 
    self._oprot.writeMessageEnd()
1740 
    self._oprot.trans.flush()
1741 
 
1742 
  def recv_getValidOrderCount(self, ):
1743 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1744 
    if mtype == TMessageType.EXCEPTION:
1745 
      x = TApplicationException()
1746 
      x.read(self._iprot)
1747 
      self._iprot.readMessageEnd()
1748 
      raise x
1749 
    result = getValidOrderCount_result()
1750 
    result.read(self._iprot)
1751 
    self._iprot.readMessageEnd()
3431 rajveer 1752 
    if result.success is not None:
3064 chandransh 1753 
      return result.success
1754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1755 
 
1756 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1757 
    """
1758 
    Returns the number of distinct customers who have done successful transactions
1759 
    """
1760 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1761 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1762 
 
1763 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1764 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1765 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1766 
    args.write(self._oprot)
1767 
    self._oprot.writeMessageEnd()
1768 
    self._oprot.trans.flush()
1769 
 
1770 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1772 
    if mtype == TMessageType.EXCEPTION:
1773 
      x = TApplicationException()
1774 
      x.read(self._iprot)
1775 
      self._iprot.readMessageEnd()
1776 
      raise x
1777 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1778 
    result.read(self._iprot)
1779 
    self._iprot.readMessageEnd()
3431 rajveer 1780 
    if result.success is not None:
3064 chandransh 1781 
      return result.success
1782 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1783 
 
1784 
  def getValidOrdersAmountRange(self, ):
1785 
    """
1786 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1787 
    List contains two values, first minimum amount and second maximum amount.
1788 
    """
1789 
    self.send_getValidOrdersAmountRange()
1790 
    return self.recv_getValidOrdersAmountRange()
1791 
 
1792 
  def send_getValidOrdersAmountRange(self, ):
1793 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1794 
    args = getValidOrdersAmountRange_args()
1795 
    args.write(self._oprot)
1796 
    self._oprot.writeMessageEnd()
1797 
    self._oprot.trans.flush()
1798 
 
1799 
  def recv_getValidOrdersAmountRange(self, ):
1800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1801 
    if mtype == TMessageType.EXCEPTION:
1802 
      x = TApplicationException()
1803 
      x.read(self._iprot)
1804 
      self._iprot.readMessageEnd()
1805 
      raise x
1806 
    result = getValidOrdersAmountRange_result()
1807 
    result.read(self._iprot)
1808 
    self._iprot.readMessageEnd()
3431 rajveer 1809 
    if result.success is not None:
3064 chandransh 1810 
      return result.success
1811 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1812 
 
1813 
  def getValidOrders(self, limit):
1814 
    """
1815 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1816 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1817 
 
3064 chandransh 1818 
    Parameters:
1819 
     - limit
1820 
    """
1821 
    self.send_getValidOrders(limit)
1822 
    return self.recv_getValidOrders()
1823 
 
1824 
  def send_getValidOrders(self, limit):
1825 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1826 
    args = getValidOrders_args()
1827 
    args.limit = limit
1828 
    args.write(self._oprot)
1829 
    self._oprot.writeMessageEnd()
1830 
    self._oprot.trans.flush()
1831 
 
1832 
  def recv_getValidOrders(self, ):
1833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1834 
    if mtype == TMessageType.EXCEPTION:
1835 
      x = TApplicationException()
1836 
      x.read(self._iprot)
1837 
      self._iprot.readMessageEnd()
1838 
      raise x
1839 
    result = getValidOrders_result()
1840 
    result.read(self._iprot)
1841 
    self._iprot.readMessageEnd()
3431 rajveer 1842 
    if result.success is not None:
3064 chandransh 1843 
      return result.success
1844 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1845 
 
1220 chandransh 1846 
  def batchOrders(self, warehouseId):
1847 
    """
1848 
    Create a batch of all the pending orders for the given warehouse.
1849 
    The returned list is orderd by created_timestamp.
1850 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1851 
 
1220 chandransh 1852 
    Parameters:
1853 
     - warehouseId
1854 
    """
1855 
    self.send_batchOrders(warehouseId)
1856 
    return self.recv_batchOrders()
1857 
 
1858 
  def send_batchOrders(self, warehouseId):
1859 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1860 
    args = batchOrders_args()
1861 
    args.warehouseId = warehouseId
1862 
    args.write(self._oprot)
1863 
    self._oprot.writeMessageEnd()
1864 
    self._oprot.trans.flush()
1865 
 
1866 
  def recv_batchOrders(self, ):
1867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1868 
    if mtype == TMessageType.EXCEPTION:
1869 
      x = TApplicationException()
1870 
      x.read(self._iprot)
1871 
      self._iprot.readMessageEnd()
1872 
      raise x
1873 
    result = batchOrders_result()
1874 
    result.read(self._iprot)
1875 
    self._iprot.readMessageEnd()
3431 rajveer 1876 
    if result.success is not None:
1220 chandransh 1877 
      return result.success
3431 rajveer 1878 
    if result.ex is not None:
1220 chandransh 1879 
      raise result.ex
1880 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1881 
 
1208 chandransh 1882 
  def markOrderAsOutOfStock(self, orderId):
1883 
    """
1884 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1885 
 
1208 chandransh 1886 
    Parameters:
1887 
     - orderId
1888 
    """
1889 
    self.send_markOrderAsOutOfStock(orderId)
1890 
    return self.recv_markOrderAsOutOfStock()
1891 
 
1892 
  def send_markOrderAsOutOfStock(self, orderId):
1893 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1894 
    args = markOrderAsOutOfStock_args()
1895 
    args.orderId = orderId
1896 
    args.write(self._oprot)
1897 
    self._oprot.writeMessageEnd()
1898 
    self._oprot.trans.flush()
1899 
 
1900 
  def recv_markOrderAsOutOfStock(self, ):
1901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1902 
    if mtype == TMessageType.EXCEPTION:
1903 
      x = TApplicationException()
1904 
      x.read(self._iprot)
1905 
      self._iprot.readMessageEnd()
1906 
      raise x
1907 
    result = markOrderAsOutOfStock_result()
1908 
    result.read(self._iprot)
1909 
    self._iprot.readMessageEnd()
3431 rajveer 1910 
    if result.success is not None:
1208 chandransh 1911 
      return result.success
3431 rajveer 1912 
    if result.ex is not None:
1208 chandransh 1913 
      raise result.ex
1914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1915 
 
3064 chandransh 1916 
  def verifyOrder(self, orderId):
759 chandransh 1917 
    """
3064 chandransh 1918 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1919 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1920 
    used for all other orders as well.
1921 
    Throws an exception if no such order exists.
3431 rajveer 1922 
 
759 chandransh 1923 
    Parameters:
3064 chandransh 1924 
     - orderId
759 chandransh 1925 
    """
3064 chandransh 1926 
    self.send_verifyOrder(orderId)
1927 
    return self.recv_verifyOrder()
759 chandransh 1928 
 
3064 chandransh 1929 
  def send_verifyOrder(self, orderId):
1930 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1931 
    args = verifyOrder_args()
1932 
    args.orderId = orderId
759 chandransh 1933 
    args.write(self._oprot)
1934 
    self._oprot.writeMessageEnd()
1935 
    self._oprot.trans.flush()
1936 
 
3064 chandransh 1937 
  def recv_verifyOrder(self, ):
759 chandransh 1938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1939 
    if mtype == TMessageType.EXCEPTION:
1940 
      x = TApplicationException()
1941 
      x.read(self._iprot)
1942 
      self._iprot.readMessageEnd()
1943 
      raise x
3064 chandransh 1944 
    result = verifyOrder_result()
759 chandransh 1945 
    result.read(self._iprot)
1946 
    self._iprot.readMessageEnd()
3431 rajveer 1947 
    if result.success is not None:
759 chandransh 1948 
      return result.success
3431 rajveer 1949 
    if result.ex is not None:
759 chandransh 1950 
      raise result.ex
3064 chandransh 1951 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1952 
 
3064 chandransh 1953 
  def acceptOrder(self, orderId):
1113 chandransh 1954 
    """
3064 chandransh 1955 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1956 
    given order is not a COD order, it also captures the payment if the same has
1957 
    not been captured.
1958 
    Throws an exception if no such order exists.
3431 rajveer 1959 
 
1113 chandransh 1960 
    Parameters:
3064 chandransh 1961 
     - orderId
1113 chandransh 1962 
    """
3064 chandransh 1963 
    self.send_acceptOrder(orderId)
1964 
    return self.recv_acceptOrder()
1113 chandransh 1965 
 
3064 chandransh 1966 
  def send_acceptOrder(self, orderId):
1967 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1968 
    args = acceptOrder_args()
1969 
    args.orderId = orderId
1113 chandransh 1970 
    args.write(self._oprot)
1971 
    self._oprot.writeMessageEnd()
1972 
    self._oprot.trans.flush()
1973 
 
3064 chandransh 1974 
  def recv_acceptOrder(self, ):
1113 chandransh 1975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1976 
    if mtype == TMessageType.EXCEPTION:
1977 
      x = TApplicationException()
1978 
      x.read(self._iprot)
1979 
      self._iprot.readMessageEnd()
1980 
      raise x
3064 chandransh 1981 
    result = acceptOrder_result()
1113 chandransh 1982 
    result.read(self._iprot)
1983 
    self._iprot.readMessageEnd()
3431 rajveer 1984 
    if result.success is not None:
1113 chandransh 1985 
      return result.success
3431 rajveer 1986 
    if result.ex is not None:
1113 chandransh 1987 
      raise result.ex
3064 chandransh 1988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1989 
 
4283 anupam.sin 1990 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 1991 
    """
3064 chandransh 1992 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 1993 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1994 
    the IMEI no. if a -1 is supplied.
1995 
    Also, it generates an invoice number for the order, marks the order as
1996 
    BILLED and sets the billing timestamp.
1997 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1998 
 
1135 chandransh 1999 
    Parameters:
3064 chandransh 2000 
     - orderId
2001 
     - invoice_number
4283 anupam.sin 2002 
     - imeiNumber
2003 
     - itemNumber
3064 chandransh 2004 
     - billed_by
4264 rajveer 2005 
     - jacketNumber
4283 anupam.sin 2006 
     - billingType
2007 
     - vendorId
1135 chandransh 2008 
    """
4283 anupam.sin 2009 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 2010 
    return self.recv_addBillingDetails()
1135 chandransh 2011 
 
4283 anupam.sin 2012 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 2013 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2014 
    args = addBillingDetails_args()
2015 
    args.orderId = orderId
2016 
    args.invoice_number = invoice_number
4283 anupam.sin 2017 
    args.imeiNumber = imeiNumber
2018 
    args.itemNumber = itemNumber
3064 chandransh 2019 
    args.billed_by = billed_by
4264 rajveer 2020 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2021 
    args.billingType = billingType
2022 
    args.vendorId = vendorId
1135 chandransh 2023 
    args.write(self._oprot)
2024 
    self._oprot.writeMessageEnd()
2025 
    self._oprot.trans.flush()
2026 
 
3064 chandransh 2027 
  def recv_addBillingDetails(self, ):
1135 chandransh 2028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2029 
    if mtype == TMessageType.EXCEPTION:
2030 
      x = TApplicationException()
2031 
      x.read(self._iprot)
2032 
      self._iprot.readMessageEnd()
2033 
      raise x
3064 chandransh 2034 
    result = addBillingDetails_result()
1135 chandransh 2035 
    result.read(self._iprot)
2036 
    self._iprot.readMessageEnd()
3431 rajveer 2037 
    if result.success is not None:
3064 chandransh 2038 
      return result.success
3431 rajveer 2039 
    if result.ex is not None:
1135 chandransh 2040 
      raise result.ex
3064 chandransh 2041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2042 
 
3064 chandransh 2043 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2044 
    """
3064 chandransh 2045 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2046 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2047 
 
1408 ankur.sing 2048 
    Parameters:
3064 chandransh 2049 
     - warehouseId
1408 ankur.sing 2050 
     - providerId
3064 chandransh 2051 
     - cod
1408 ankur.sing 2052 
    """
3064 chandransh 2053 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2054 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2055 
 
3064 chandransh 2056 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2057 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2058 
    args = markOrdersAsManifested_args()
2059 
    args.warehouseId = warehouseId
1408 ankur.sing 2060 
    args.providerId = providerId
3064 chandransh 2061 
    args.cod = cod
1408 ankur.sing 2062 
    args.write(self._oprot)
2063 
    self._oprot.writeMessageEnd()
2064 
    self._oprot.trans.flush()
2065 
 
3064 chandransh 2066 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2068 
    if mtype == TMessageType.EXCEPTION:
2069 
      x = TApplicationException()
2070 
      x.read(self._iprot)
2071 
      self._iprot.readMessageEnd()
2072 
      raise x
3064 chandransh 2073 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2074 
    result.read(self._iprot)
2075 
    self._iprot.readMessageEnd()
3431 rajveer 2076 
    if result.success is not None:
1408 ankur.sing 2077 
      return result.success
3431 rajveer 2078 
    if result.ex is not None:
3064 chandransh 2079 
      raise result.ex
2080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2081 
 
4410 rajveer 2082 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2083 
    """
2084 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2085 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2086 
 
2087 
    Parameters:
2088 
     - warehouseId
2089 
     - providerId
2090 
     - cod
2091 
    """
2092 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2093 
    return self.recv_markOrdersAsShippedFromWarehouse()
2094 
 
2095 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2096 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2097 
    args = markOrdersAsShippedFromWarehouse_args()
2098 
    args.warehouseId = warehouseId
2099 
    args.providerId = providerId
2100 
    args.cod = cod
2101 
    args.write(self._oprot)
2102 
    self._oprot.writeMessageEnd()
2103 
    self._oprot.trans.flush()
2104 
 
2105 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2107 
    if mtype == TMessageType.EXCEPTION:
2108 
      x = TApplicationException()
2109 
      x.read(self._iprot)
2110 
      self._iprot.readMessageEnd()
2111 
      raise x
2112 
    result = markOrdersAsShippedFromWarehouse_result()
2113 
    result.read(self._iprot)
2114 
    self._iprot.readMessageEnd()
2115 
    if result.success is not None:
2116 
      return result.success
2117 
    if result.ex is not None:
2118 
      raise result.ex
2119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2120 
 
3064 chandransh 2121 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2122 
    """
3064 chandransh 2123 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2124 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2125 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2126 
 
94 ashish 2127 
    Parameters:
3064 chandransh 2128 
     - providerId
2129 
     - pickupDetails
304 ashish 2130 
    """
3064 chandransh 2131 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2132 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2133 
 
3064 chandransh 2134 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2135 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2136 
    args = markOrdersAsPickedUp_args()
2137 
    args.providerId = providerId
2138 
    args.pickupDetails = pickupDetails
304 ashish 2139 
    args.write(self._oprot)
2140 
    self._oprot.writeMessageEnd()
2141 
    self._oprot.trans.flush()
2142 
 
3064 chandransh 2143 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2145 
    if mtype == TMessageType.EXCEPTION:
2146 
      x = TApplicationException()
2147 
      x.read(self._iprot)
2148 
      self._iprot.readMessageEnd()
2149 
      raise x
3064 chandransh 2150 
    result = markOrdersAsPickedUp_result()
304 ashish 2151 
    result.read(self._iprot)
2152 
    self._iprot.readMessageEnd()
3431 rajveer 2153 
    if result.success is not None:
304 ashish 2154 
      return result.success
3431 rajveer 2155 
    if result.ex is not None:
3064 chandransh 2156 
      raise result.ex
2157 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2158 
 
3064 chandransh 2159 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2160 
    """
3064 chandransh 2161 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2162 
    the name of the receiver.
2163 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2164 
 
304 ashish 2165 
    Parameters:
3064 chandransh 2166 
     - providerId
2167 
     - deliveredOrders
304 ashish 2168 
    """
3064 chandransh 2169 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2170 
    self.recv_markOrdersAsDelivered()
304 ashish 2171 
 
3064 chandransh 2172 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2173 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2174 
    args = markOrdersAsDelivered_args()
2175 
    args.providerId = providerId
2176 
    args.deliveredOrders = deliveredOrders
304 ashish 2177 
    args.write(self._oprot)
2178 
    self._oprot.writeMessageEnd()
2179 
    self._oprot.trans.flush()
2180 
 
3064 chandransh 2181 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2182 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2183 
    if mtype == TMessageType.EXCEPTION:
2184 
      x = TApplicationException()
2185 
      x.read(self._iprot)
2186 
      self._iprot.readMessageEnd()
2187 
      raise x
3064 chandransh 2188 
    result = markOrdersAsDelivered_result()
304 ashish 2189 
    result.read(self._iprot)
2190 
    self._iprot.readMessageEnd()
3431 rajveer 2191 
    if result.ex is not None:
3064 chandransh 2192 
      raise result.ex
304 ashish 2193 
    return
2194 
 
3064 chandransh 2195 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2196 
    """
3064 chandransh 2197 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2198 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2199 
 
3064 chandransh 2200 
    Parameters:
2201 
     - providerId
2202 
     - returnedOrders
1596 ankur.sing 2203 
    """
3064 chandransh 2204 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2205 
    self.recv_markOrdersAsFailed()
304 ashish 2206 
 
3064 chandransh 2207 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2208 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2209 
    args = markOrdersAsFailed_args()
2210 
    args.providerId = providerId
2211 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2212 
    args.write(self._oprot)
2213 
    self._oprot.writeMessageEnd()
2214 
    self._oprot.trans.flush()
2215 
 
3064 chandransh 2216 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2218 
    if mtype == TMessageType.EXCEPTION:
2219 
      x = TApplicationException()
2220 
      x.read(self._iprot)
2221 
      self._iprot.readMessageEnd()
2222 
      raise x
3064 chandransh 2223 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2224 
    result.read(self._iprot)
2225 
    self._iprot.readMessageEnd()
3431 rajveer 2226 
    if result.ex is not None:
3064 chandransh 2227 
      raise result.ex
2228 
    return
1596 ankur.sing 2229 
 
3064 chandransh 2230 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2231 
    """
3064 chandransh 2232 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2233 
 
3064 chandransh 2234 
    Parameters:
2235 
     - providerId
2236 
     - undeliveredOrders
1627 ankur.sing 2237 
    """
3064 chandransh 2238 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2239 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2240 
 
3064 chandransh 2241 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2242 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2243 
    args = updateNonDeliveryReason_args()
2244 
    args.providerId = providerId
2245 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2246 
    args.write(self._oprot)
2247 
    self._oprot.writeMessageEnd()
2248 
    self._oprot.trans.flush()
2249 
 
3064 chandransh 2250 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2252 
    if mtype == TMessageType.EXCEPTION:
2253 
      x = TApplicationException()
2254 
      x.read(self._iprot)
2255 
      self._iprot.readMessageEnd()
2256 
      raise x
3064 chandransh 2257 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2258 
    result.read(self._iprot)
2259 
    self._iprot.readMessageEnd()
3431 rajveer 2260 
    if result.ex is not None:
3064 chandransh 2261 
      raise result.ex
2262 
    return
1627 ankur.sing 2263 
 
3064 chandransh 2264 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2265 
    """
3064 chandransh 2266 
    Returns the list of orders whose delivery time has passed but have not been
2267 
    delivered yet for the given provider and warehouse. To get a complete list of
2268 
    undelivered orders, pass them as -1.
2269 
    Returns an empty list if no such orders exist.
3431 rajveer 2270 
 
1886 ankur.sing 2271 
    Parameters:
3064 chandransh 2272 
     - providerId
2273 
     - warehouseId
1886 ankur.sing 2274 
    """
3064 chandransh 2275 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2276 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2277 
 
3064 chandransh 2278 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2279 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2280 
    args = getUndeliveredOrders_args()
2281 
    args.providerId = providerId
2282 
    args.warehouseId = warehouseId
1886 ankur.sing 2283 
    args.write(self._oprot)
2284 
    self._oprot.writeMessageEnd()
2285 
    self._oprot.trans.flush()
2286 
 
3064 chandransh 2287 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2289 
    if mtype == TMessageType.EXCEPTION:
2290 
      x = TApplicationException()
2291 
      x.read(self._iprot)
2292 
      self._iprot.readMessageEnd()
2293 
      raise x
3064 chandransh 2294 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2295 
    result.read(self._iprot)
2296 
    self._iprot.readMessageEnd()
3431 rajveer 2297 
    if result.success is not None:
1886 ankur.sing 2298 
      return result.success
3064 chandransh 2299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2300 
 
2536 chandransh 2301 
  def toggleDOAFlag(self, orderId):
2302 
    """
2303 
    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.
2304 
    Returns the final flag status.
2305 
    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 2306 
 
2536 chandransh 2307 
    Parameters:
2308 
     - orderId
2309 
    """
2310 
    self.send_toggleDOAFlag(orderId)
2311 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2312 
 
2536 chandransh 2313 
  def send_toggleDOAFlag(self, orderId):
2314 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2315 
    args = toggleDOAFlag_args()
2316 
    args.orderId = orderId
2317 
    args.write(self._oprot)
2318 
    self._oprot.writeMessageEnd()
2319 
    self._oprot.trans.flush()
2320 
 
2321 
  def recv_toggleDOAFlag(self, ):
2322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2323 
    if mtype == TMessageType.EXCEPTION:
2324 
      x = TApplicationException()
2325 
      x.read(self._iprot)
2326 
      self._iprot.readMessageEnd()
2327 
      raise x
2328 
    result = toggleDOAFlag_result()
2329 
    result.read(self._iprot)
2330 
    self._iprot.readMessageEnd()
3431 rajveer 2331 
    if result.success is not None:
2536 chandransh 2332 
      return result.success
3431 rajveer 2333 
    if result.ex is not None:
2536 chandransh 2334 
      raise result.ex
2335 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2336 
 
4454 rajveer 2337 
  def markOrderDoaRequestReceived(self, orderId):
2338 
    """
2339 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2340 
 
2341 
    Parameters:
2342 
     - orderId
2343 
    """
2344 
    self.send_markOrderDoaRequestReceived(orderId)
2345 
    return self.recv_markOrderDoaRequestReceived()
2346 
 
2347 
  def send_markOrderDoaRequestReceived(self, orderId):
2348 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2349 
    args = markOrderDoaRequestReceived_args()
2350 
    args.orderId = orderId
2351 
    args.write(self._oprot)
2352 
    self._oprot.writeMessageEnd()
2353 
    self._oprot.trans.flush()
2354 
 
2355 
  def recv_markOrderDoaRequestReceived(self, ):
2356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2357 
    if mtype == TMessageType.EXCEPTION:
2358 
      x = TApplicationException()
2359 
      x.read(self._iprot)
2360 
      self._iprot.readMessageEnd()
2361 
      raise x
2362 
    result = markOrderDoaRequestReceived_result()
2363 
    result.read(self._iprot)
2364 
    self._iprot.readMessageEnd()
2365 
    if result.success is not None:
2366 
      return result.success
2367 
    if result.ex is not None:
2368 
      raise result.ex
2369 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2370 
 
2371 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2372 
    """
2373 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2374 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2375 
 
2376 
    Parameters:
2377 
     - orderId
2378 
     - isAuthorized
2379 
    """
2380 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2381 
    return self.recv_markOrderDoaRequestAuthorized()
2382 
 
2383 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2384 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2385 
    args = markOrderDoaRequestAuthorized_args()
2386 
    args.orderId = orderId
2387 
    args.isAuthorized = isAuthorized
2388 
    args.write(self._oprot)
2389 
    self._oprot.writeMessageEnd()
2390 
    self._oprot.trans.flush()
2391 
 
2392 
  def recv_markOrderDoaRequestAuthorized(self, ):
2393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2394 
    if mtype == TMessageType.EXCEPTION:
2395 
      x = TApplicationException()
2396 
      x.read(self._iprot)
2397 
      self._iprot.readMessageEnd()
2398 
      raise x
2399 
    result = markOrderDoaRequestAuthorized_result()
2400 
    result.read(self._iprot)
2401 
    self._iprot.readMessageEnd()
2402 
    if result.success is not None:
2403 
      return result.success
2404 
    if result.ex is not None:
2405 
      raise result.ex
2406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2407 
 
4488 rajveer 2408 
  def markOrderReturnRequestReceived(self, orderId):
2409 
    """
2410 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2411 
 
2412 
    Parameters:
2413 
     - orderId
2414 
    """
2415 
    self.send_markOrderReturnRequestReceived(orderId)
2416 
    return self.recv_markOrderReturnRequestReceived()
2417 
 
2418 
  def send_markOrderReturnRequestReceived(self, orderId):
2419 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2420 
    args = markOrderReturnRequestReceived_args()
2421 
    args.orderId = orderId
2422 
    args.write(self._oprot)
2423 
    self._oprot.writeMessageEnd()
2424 
    self._oprot.trans.flush()
2425 
 
2426 
  def recv_markOrderReturnRequestReceived(self, ):
2427 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2428 
    if mtype == TMessageType.EXCEPTION:
2429 
      x = TApplicationException()
2430 
      x.read(self._iprot)
2431 
      self._iprot.readMessageEnd()
2432 
      raise x
2433 
    result = markOrderReturnRequestReceived_result()
2434 
    result.read(self._iprot)
2435 
    self._iprot.readMessageEnd()
2436 
    if result.success is not None:
2437 
      return result.success
2438 
    if result.ex is not None:
2439 
      raise result.ex
2440 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2441 
 
2442 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2443 
    """
2444 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2445 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2446 
 
2447 
    Parameters:
2448 
     - orderId
2449 
     - isAuthorized
2450 
    """
2451 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2452 
    return self.recv_markOrderReturnRequestAuthorized()
2453 
 
2454 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2455 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2456 
    args = markOrderReturnRequestAuthorized_args()
2457 
    args.orderId = orderId
2458 
    args.isAuthorized = isAuthorized
2459 
    args.write(self._oprot)
2460 
    self._oprot.writeMessageEnd()
2461 
    self._oprot.trans.flush()
2462 
 
2463 
  def recv_markOrderReturnRequestAuthorized(self, ):
2464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2465 
    if mtype == TMessageType.EXCEPTION:
2466 
      x = TApplicationException()
2467 
      x.read(self._iprot)
2468 
      self._iprot.readMessageEnd()
2469 
      raise x
2470 
    result = markOrderReturnRequestAuthorized_result()
2471 
    result.read(self._iprot)
2472 
    self._iprot.readMessageEnd()
2473 
    if result.success is not None:
2474 
      return result.success
2475 
    if result.ex is not None:
2476 
      raise result.ex
2477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2478 
 
2536 chandransh 2479 
  def requestPickupNumber(self, orderId):
2480 
    """
2481 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2482 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2483 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2484 
    For any other status, it returns false.
2485 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2486 
 
2536 chandransh 2487 
    Parameters:
2488 
     - orderId
2489 
    """
2490 
    self.send_requestPickupNumber(orderId)
2491 
    return self.recv_requestPickupNumber()
2492 
 
2493 
  def send_requestPickupNumber(self, orderId):
2494 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2495 
    args = requestPickupNumber_args()
2496 
    args.orderId = orderId
2497 
    args.write(self._oprot)
2498 
    self._oprot.writeMessageEnd()
2499 
    self._oprot.trans.flush()
2500 
 
2501 
  def recv_requestPickupNumber(self, ):
2502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2503 
    if mtype == TMessageType.EXCEPTION:
2504 
      x = TApplicationException()
2505 
      x.read(self._iprot)
2506 
      self._iprot.readMessageEnd()
2507 
      raise x
2508 
    result = requestPickupNumber_result()
2509 
    result.read(self._iprot)
2510 
    self._iprot.readMessageEnd()
3431 rajveer 2511 
    if result.success is not None:
2536 chandransh 2512 
      return result.success
3431 rajveer 2513 
    if result.ex is not None:
2536 chandransh 2514 
      raise result.ex
2515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2516 
 
2517 
  def authorizePickup(self, orderId, pickupNumber):
2518 
    """
4452 rajveer 2519 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2520 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2521 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2522 
    	3. Returns true
2591 chandransh 2523 
    If the order is in any other status, it returns false.
2536 chandransh 2524 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2525 
 
2536 chandransh 2526 
    Parameters:
2527 
     - orderId
2528 
     - pickupNumber
2529 
    """
2530 
    self.send_authorizePickup(orderId, pickupNumber)
2531 
    return self.recv_authorizePickup()
2532 
 
2533 
  def send_authorizePickup(self, orderId, pickupNumber):
2534 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2535 
    args = authorizePickup_args()
2536 
    args.orderId = orderId
2537 
    args.pickupNumber = pickupNumber
2538 
    args.write(self._oprot)
2539 
    self._oprot.writeMessageEnd()
2540 
    self._oprot.trans.flush()
2541 
 
2542 
  def recv_authorizePickup(self, ):
2543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2544 
    if mtype == TMessageType.EXCEPTION:
2545 
      x = TApplicationException()
2546 
      x.read(self._iprot)
2547 
      self._iprot.readMessageEnd()
2548 
      raise x
2549 
    result = authorizePickup_result()
2550 
    result.read(self._iprot)
2551 
    self._iprot.readMessageEnd()
3431 rajveer 2552 
    if result.success is not None:
2536 chandransh 2553 
      return result.success
3431 rajveer 2554 
    if result.ex is not None:
2536 chandransh 2555 
      raise result.ex
2556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2557 
 
2764 chandransh 2558 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2559 
    """
2560 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2561 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2562 
 
2764 chandransh 2563 
    Parameters:
2564 
     - providerId
2565 
     - pickupDetails
2566 
    """
2567 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2568 
    return self.recv_markDoasAsPickedUp()
2569 
 
2570 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2571 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2572 
    args = markDoasAsPickedUp_args()
2573 
    args.providerId = providerId
2574 
    args.pickupDetails = pickupDetails
2575 
    args.write(self._oprot)
2576 
    self._oprot.writeMessageEnd()
2577 
    self._oprot.trans.flush()
2578 
 
2579 
  def recv_markDoasAsPickedUp(self, ):
2580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2581 
    if mtype == TMessageType.EXCEPTION:
2582 
      x = TApplicationException()
2583 
      x.read(self._iprot)
2584 
      self._iprot.readMessageEnd()
2585 
      raise x
2586 
    result = markDoasAsPickedUp_result()
2587 
    result.read(self._iprot)
2588 
    self._iprot.readMessageEnd()
3431 rajveer 2589 
    if result.success is not None:
2764 chandransh 2590 
      return result.success
2591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2592 
 
4479 rajveer 2593 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2594 
    """
4452 rajveer 2595 
    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 2596 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2597 
    If the order is in any other state, it returns false.
2598 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2599 
 
2591 chandransh 2600 
    Parameters:
2601 
     - orderId
4479 rajveer 2602 
     - receiveCondition
2591 chandransh 2603 
    """
4479 rajveer 2604 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2605 
    return self.recv_receiveReturn()
2536 chandransh 2606 
 
4479 rajveer 2607 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2608 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2609 
    args = receiveReturn_args()
2591 chandransh 2610 
    args.orderId = orderId
4479 rajveer 2611 
    args.receiveCondition = receiveCondition
2591 chandransh 2612 
    args.write(self._oprot)
2613 
    self._oprot.writeMessageEnd()
2614 
    self._oprot.trans.flush()
2615 
 
2616 chandransh 2616 
  def recv_receiveReturn(self, ):
2591 chandransh 2617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2618 
    if mtype == TMessageType.EXCEPTION:
2619 
      x = TApplicationException()
2620 
      x.read(self._iprot)
2621 
      self._iprot.readMessageEnd()
2622 
      raise x
2616 chandransh 2623 
    result = receiveReturn_result()
2591 chandransh 2624 
    result.read(self._iprot)
2625 
    self._iprot.readMessageEnd()
3431 rajveer 2626 
    if result.success is not None:
2591 chandransh 2627 
      return result.success
3431 rajveer 2628 
    if result.ex is not None:
2591 chandransh 2629 
      raise result.ex
2616 chandransh 2630 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2631 
 
2632 
  def validateDoa(self, orderId, isValid):
2633 
    """
4452 rajveer 2634 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2635 
    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 2636 
    If the order is in any other state, it returns false.
2637 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2638 
 
2591 chandransh 2639 
    Parameters:
2640 
     - orderId
2641 
     - isValid
2642 
    """
2643 
    self.send_validateDoa(orderId, isValid)
2644 
    return self.recv_validateDoa()
2645 
 
2646 
  def send_validateDoa(self, orderId, isValid):
2647 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2648 
    args = validateDoa_args()
2649 
    args.orderId = orderId
2650 
    args.isValid = isValid
2651 
    args.write(self._oprot)
2652 
    self._oprot.writeMessageEnd()
2653 
    self._oprot.trans.flush()
2654 
 
2655 
  def recv_validateDoa(self, ):
2656 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2657 
    if mtype == TMessageType.EXCEPTION:
2658 
      x = TApplicationException()
2659 
      x.read(self._iprot)
2660 
      self._iprot.readMessageEnd()
2661 
      raise x
2662 
    result = validateDoa_result()
2663 
    result.read(self._iprot)
2664 
    self._iprot.readMessageEnd()
3431 rajveer 2665 
    if result.success is not None:
2591 chandransh 2666 
      return result.success
3431 rajveer 2667 
    if result.ex is not None:
2591 chandransh 2668 
      raise result.ex
2669 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2670 
 
4495 rajveer 2671 
  def validateReturnProduct(self, orderId, isUsable):
2672 
    """
2673 
    Parameters:
2674 
     - orderId
2675 
     - isUsable
2676 
    """
2677 
    self.send_validateReturnProduct(orderId, isUsable)
2678 
    return self.recv_validateReturnProduct()
2679 
 
2680 
  def send_validateReturnProduct(self, orderId, isUsable):
2681 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2682 
    args = validateReturnProduct_args()
2683 
    args.orderId = orderId
2684 
    args.isUsable = isUsable
2685 
    args.write(self._oprot)
2686 
    self._oprot.writeMessageEnd()
2687 
    self._oprot.trans.flush()
2688 
 
2689 
  def recv_validateReturnProduct(self, ):
2690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2691 
    if mtype == TMessageType.EXCEPTION:
2692 
      x = TApplicationException()
2693 
      x.read(self._iprot)
2694 
      self._iprot.readMessageEnd()
2695 
      raise x
2696 
    result = validateReturnProduct_result()
2697 
    result.read(self._iprot)
2698 
    self._iprot.readMessageEnd()
2699 
    if result.success is not None:
2700 
      return result.success
2701 
    if result.ex is not None:
2702 
      raise result.ex
2703 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2704 
 
2616 chandransh 2705 
  def reshipOrder(self, orderId):
2706 
    """
4484 rajveer 2707 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2708 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2709 
    	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 2710 
 
2711 
    If the order is in DOA_CERT_VALID state, it does the following:
2712 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2713 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2714 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2715 
 
2616 chandransh 2716 
    Returns the id of the newly created order.
3431 rajveer 2717 
 
2616 chandransh 2718 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2719 
 
2616 chandransh 2720 
    Parameters:
2721 
     - orderId
2722 
    """
2723 
    self.send_reshipOrder(orderId)
2724 
    return self.recv_reshipOrder()
2591 chandransh 2725 
 
2616 chandransh 2726 
  def send_reshipOrder(self, orderId):
2727 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2728 
    args = reshipOrder_args()
2729 
    args.orderId = orderId
2730 
    args.write(self._oprot)
2731 
    self._oprot.writeMessageEnd()
2732 
    self._oprot.trans.flush()
2733 
 
2734 
  def recv_reshipOrder(self, ):
2735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2736 
    if mtype == TMessageType.EXCEPTION:
2737 
      x = TApplicationException()
2738 
      x.read(self._iprot)
2739 
      self._iprot.readMessageEnd()
2740 
      raise x
2741 
    result = reshipOrder_result()
2742 
    result.read(self._iprot)
2743 
    self._iprot.readMessageEnd()
3431 rajveer 2744 
    if result.success is not None:
2616 chandransh 2745 
      return result.success
3431 rajveer 2746 
    if result.ex is not None:
2616 chandransh 2747 
      raise result.ex
2748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2749 
 
3226 chandransh 2750 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2751 
    """
4484 rajveer 2752 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2753 
    	1. Creates a refund request for batch processing.
2754 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 2755 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2756 
 
2616 chandransh 2757 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2758 
    	1. Creates a refund request for batch processing.
3226 chandransh 2759 
    	2. Cancels the reservation of the item in the warehouse.
2760 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2761 
 
3226 chandransh 2762 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2763 
    	1. Cancels the reservation of the item in the warehouse.
2764 
    	2. Marks the current order as CANCELED.
2765 
 
2766 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2767 
 
2616 chandransh 2768 
    Returns True if it is successful, False otherwise.
3431 rajveer 2769 
 
2616 chandransh 2770 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2771 
 
2616 chandransh 2772 
    Parameters:
2773 
     - orderId
3226 chandransh 2774 
     - refundedBy
2775 
     - reason
2616 chandransh 2776 
    """
3226 chandransh 2777 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2778 
    return self.recv_refundOrder()
2779 
 
3226 chandransh 2780 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2781 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2782 
    args = refundOrder_args()
2783 
    args.orderId = orderId
3226 chandransh 2784 
    args.refundedBy = refundedBy
2785 
    args.reason = reason
2616 chandransh 2786 
    args.write(self._oprot)
2787 
    self._oprot.writeMessageEnd()
2788 
    self._oprot.trans.flush()
2789 
 
2790 
  def recv_refundOrder(self, ):
2791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2792 
    if mtype == TMessageType.EXCEPTION:
2793 
      x = TApplicationException()
2794 
      x.read(self._iprot)
2795 
      self._iprot.readMessageEnd()
2796 
      raise x
2797 
    result = refundOrder_result()
2798 
    result.read(self._iprot)
2799 
    self._iprot.readMessageEnd()
3431 rajveer 2800 
    if result.success is not None:
2616 chandransh 2801 
      return result.success
3431 rajveer 2802 
    if result.ex is not None:
2616 chandransh 2803 
      raise result.ex
2804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2805 
 
2690 chandransh 2806 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2807 
    """
2808 
    Get all return orders created between the from and to dates for the given warehouse.
2809 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2810 
 
2690 chandransh 2811 
    Parameters:
2812 
     - warehouseId
2813 
     - fromDate
2814 
     - toDate
2815 
    """
2816 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2817 
    return self.recv_getReturnOrders()
2616 chandransh 2818 
 
2690 chandransh 2819 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2820 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2821 
    args = getReturnOrders_args()
2822 
    args.warehouseId = warehouseId
2823 
    args.fromDate = fromDate
2824 
    args.toDate = toDate
2825 
    args.write(self._oprot)
2826 
    self._oprot.writeMessageEnd()
2827 
    self._oprot.trans.flush()
2828 
 
2829 
  def recv_getReturnOrders(self, ):
2830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2831 
    if mtype == TMessageType.EXCEPTION:
2832 
      x = TApplicationException()
2833 
      x.read(self._iprot)
2834 
      self._iprot.readMessageEnd()
2835 
      raise x
2836 
    result = getReturnOrders_result()
2837 
    result.read(self._iprot)
2838 
    self._iprot.readMessageEnd()
3431 rajveer 2839 
    if result.success is not None:
2690 chandransh 2840 
      return result.success
2841 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2842 
 
2700 chandransh 2843 
  def getReturnOrder(self, id):
2844 
    """
2845 
    Returns the ReturnOrder corresponding to the given id.
2846 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2847 
 
2700 chandransh 2848 
    Parameters:
2849 
     - id
2850 
    """
2851 
    self.send_getReturnOrder(id)
2852 
    return self.recv_getReturnOrder()
2853 
 
2854 
  def send_getReturnOrder(self, id):
2855 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2856 
    args = getReturnOrder_args()
2857 
    args.id = id
2858 
    args.write(self._oprot)
2859 
    self._oprot.writeMessageEnd()
2860 
    self._oprot.trans.flush()
2861 
 
2862 
  def recv_getReturnOrder(self, ):
2863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2864 
    if mtype == TMessageType.EXCEPTION:
2865 
      x = TApplicationException()
2866 
      x.read(self._iprot)
2867 
      self._iprot.readMessageEnd()
2868 
      raise x
2869 
    result = getReturnOrder_result()
2870 
    result.read(self._iprot)
2871 
    self._iprot.readMessageEnd()
3431 rajveer 2872 
    if result.success is not None:
2700 chandransh 2873 
      return result.success
3431 rajveer 2874 
    if result.ex is not None:
2700 chandransh 2875 
      raise result.ex
2876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2877 
 
2690 chandransh 2878 
  def processReturn(self, returnOrderId):
2879 
    """
2880 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2881 
 
2690 chandransh 2882 
    Parameters:
2883 
     - returnOrderId
2884 
    """
2885 
    self.send_processReturn(returnOrderId)
2886 
    self.recv_processReturn()
2887 
 
2888 
  def send_processReturn(self, returnOrderId):
2889 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2890 
    args = processReturn_args()
2891 
    args.returnOrderId = returnOrderId
2892 
    args.write(self._oprot)
2893 
    self._oprot.writeMessageEnd()
2894 
    self._oprot.trans.flush()
2895 
 
2896 
  def recv_processReturn(self, ):
2897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2898 
    if mtype == TMessageType.EXCEPTION:
2899 
      x = TApplicationException()
2900 
      x.read(self._iprot)
2901 
      self._iprot.readMessageEnd()
2902 
      raise x
2903 
    result = processReturn_result()
2904 
    result.read(self._iprot)
2905 
    self._iprot.readMessageEnd()
3431 rajveer 2906 
    if result.ex is not None:
2690 chandransh 2907 
      raise result.ex
2908 
    return
2909 
 
2819 chandransh 2910 
  def createPurchaseOrder(self, warehouseId):
2911 
    """
2912 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2913 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2914 
 
2819 chandransh 2915 
    Parameters:
2916 
     - warehouseId
2917 
    """
2918 
    self.send_createPurchaseOrder(warehouseId)
2919 
    return self.recv_createPurchaseOrder()
2690 chandransh 2920 
 
2819 chandransh 2921 
  def send_createPurchaseOrder(self, warehouseId):
2922 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2923 
    args = createPurchaseOrder_args()
2924 
    args.warehouseId = warehouseId
2925 
    args.write(self._oprot)
2926 
    self._oprot.writeMessageEnd()
2927 
    self._oprot.trans.flush()
2928 
 
2929 
  def recv_createPurchaseOrder(self, ):
2930 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2931 
    if mtype == TMessageType.EXCEPTION:
2932 
      x = TApplicationException()
2933 
      x.read(self._iprot)
2934 
      self._iprot.readMessageEnd()
2935 
      raise x
2936 
    result = createPurchaseOrder_result()
2937 
    result.read(self._iprot)
2938 
    self._iprot.readMessageEnd()
3431 rajveer 2939 
    if result.success is not None:
2819 chandransh 2940 
      return result.success
3431 rajveer 2941 
    if result.ex is not None:
2819 chandransh 2942 
      raise result.ex
2943 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2944 
 
3451 chandransh 2945 
  def updateWeight(self, orderId, weight):
2946 
    """
2947 
    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 2948 
 
3451 chandransh 2949 
    Parameters:
2950 
     - orderId
2951 
     - weight
2952 
    """
2953 
    self.send_updateWeight(orderId, weight)
2954 
    return self.recv_updateWeight()
2955 
 
2956 
  def send_updateWeight(self, orderId, weight):
2957 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2958 
    args = updateWeight_args()
2959 
    args.orderId = orderId
2960 
    args.weight = weight
2961 
    args.write(self._oprot)
2962 
    self._oprot.writeMessageEnd()
2963 
    self._oprot.trans.flush()
2964 
 
2965 
  def recv_updateWeight(self, ):
2966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2967 
    if mtype == TMessageType.EXCEPTION:
2968 
      x = TApplicationException()
2969 
      x.read(self._iprot)
2970 
      self._iprot.readMessageEnd()
2971 
      raise x
2972 
    result = updateWeight_result()
2973 
    result.read(self._iprot)
2974 
    self._iprot.readMessageEnd()
2975 
    if result.success is not None:
2976 
      return result.success
2977 
    if result.ex is not None:
2978 
      raise result.ex
2979 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2980 
 
3469 chandransh 2981 
  def changeItem(self, orderId, itemId):
2982 
    """
2983 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2984 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2985 
 
3469 chandransh 2986 
    Parameters:
2987 
     - orderId
2988 
     - itemId
2989 
    """
2990 
    self.send_changeItem(orderId, itemId)
2991 
    return self.recv_changeItem()
2992 
 
2993 
  def send_changeItem(self, orderId, itemId):
2994 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2995 
    args = changeItem_args()
2996 
    args.orderId = orderId
2997 
    args.itemId = itemId
2998 
    args.write(self._oprot)
2999 
    self._oprot.writeMessageEnd()
3000 
    self._oprot.trans.flush()
3001 
 
3002 
  def recv_changeItem(self, ):
3003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3004 
    if mtype == TMessageType.EXCEPTION:
3005 
      x = TApplicationException()
3006 
      x.read(self._iprot)
3007 
      self._iprot.readMessageEnd()
3008 
      raise x
3009 
    result = changeItem_result()
3010 
    result.read(self._iprot)
3011 
    self._iprot.readMessageEnd()
3012 
    if result.success is not None:
3013 
      return result.success
3014 
    if result.ex is not None:
3015 
      raise result.ex
3016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3017 
 
3018 
  def shiftToWarehouse(self, orderId, warehouseId):
3019 
    """
3020 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3021 
 
3022 
    Parameters:
3023 
     - orderId
3024 
     - warehouseId
3025 
    """
3026 
    self.send_shiftToWarehouse(orderId, warehouseId)
3027 
    return self.recv_shiftToWarehouse()
3028 
 
3029 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3030 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3031 
    args = shiftToWarehouse_args()
3032 
    args.orderId = orderId
3033 
    args.warehouseId = warehouseId
3034 
    args.write(self._oprot)
3035 
    self._oprot.writeMessageEnd()
3036 
    self._oprot.trans.flush()
3037 
 
3038 
  def recv_shiftToWarehouse(self, ):
3039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3040 
    if mtype == TMessageType.EXCEPTION:
3041 
      x = TApplicationException()
3042 
      x.read(self._iprot)
3043 
      self._iprot.readMessageEnd()
3044 
      raise x
3045 
    result = shiftToWarehouse_result()
3046 
    result.read(self._iprot)
3047 
    self._iprot.readMessageEnd()
3048 
    if result.success is not None:
3049 
      return result.success
3050 
    if result.ex is not None:
3051 
      raise result.ex
3052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3053 
 
3986 chandransh 3054 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3055 
    """
3056 
    Adds the given delay reason to the given order.
3986 chandransh 3057 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3058 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3059 
 
3553 chandransh 3060 
    Parameters:
3061 
     - orderId
3062 
     - delayReason
3986 chandransh 3063 
     - furtherDelay
3553 chandransh 3064 
    """
3986 chandransh 3065 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 3066 
    return self.recv_addDelayReason()
3067 
 
3986 chandransh 3068 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3069 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3070 
    args = addDelayReason_args()
3071 
    args.orderId = orderId
3072 
    args.delayReason = delayReason
3986 chandransh 3073 
    args.furtherDelay = furtherDelay
3553 chandransh 3074 
    args.write(self._oprot)
3075 
    self._oprot.writeMessageEnd()
3076 
    self._oprot.trans.flush()
3077 
 
3078 
  def recv_addDelayReason(self, ):
3079 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3080 
    if mtype == TMessageType.EXCEPTION:
3081 
      x = TApplicationException()
3082 
      x.read(self._iprot)
3083 
      self._iprot.readMessageEnd()
3084 
      raise x
3085 
    result = addDelayReason_result()
3086 
    result.read(self._iprot)
3087 
    self._iprot.readMessageEnd()
3088 
    if result.success is not None:
3089 
      return result.success
3090 
    if result.ex is not None:
3091 
      raise result.ex
3092 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3093 
 
3956 chandransh 3094 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3095 
    """
3096 
    Marks the COD orders with given AWB nos. as having been processed.
3097 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3098 
 
3956 chandransh 3099 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3100 
    1. There is no order corresponding to an AWB number.
3101 
    2. The captured amount for a payment exceeds the total payment.
3102 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3103 
 
3104 
    Parameters:
3105 
     - collectedAmountMap
3106 
     - xferBy
3107 
     - xferTxnId
3108 
     - xferDate
3109 
    """
3110 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3111 
    return self.recv_reconcileCodCollection()
3112 
 
3113 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3114 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3115 
    args = reconcileCodCollection_args()
3116 
    args.collectedAmountMap = collectedAmountMap
3117 
    args.xferBy = xferBy
3118 
    args.xferTxnId = xferTxnId
3119 
    args.xferDate = xferDate
3120 
    args.write(self._oprot)
3121 
    self._oprot.writeMessageEnd()
3122 
    self._oprot.trans.flush()
3123 
 
3124 
  def recv_reconcileCodCollection(self, ):
3125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3126 
    if mtype == TMessageType.EXCEPTION:
3127 
      x = TApplicationException()
3128 
      x.read(self._iprot)
3129 
      self._iprot.readMessageEnd()
3130 
      raise x
3131 
    result = reconcileCodCollection_result()
3132 
    result.read(self._iprot)
3133 
    self._iprot.readMessageEnd()
3134 
    if result.success is not None:
3135 
      return result.success
3136 
    if result.ex is not None:
3137 
      raise result.ex
3138 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3139 
 
4008 mandeep.dh 3140 
  def getTransactionsRequiringExtraProcessing(self, category):
3141 
    """
4065 mandeep.dh 3142 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3143 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3144 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3145 
 
4008 mandeep.dh 3146 
    Parameters:
3147 
     - category
3148 
    """
3149 
    self.send_getTransactionsRequiringExtraProcessing(category)
3150 
    return self.recv_getTransactionsRequiringExtraProcessing()
3151 
 
3152 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3153 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3154 
    args = getTransactionsRequiringExtraProcessing_args()
3155 
    args.category = category
3156 
    args.write(self._oprot)
3157 
    self._oprot.writeMessageEnd()
3158 
    self._oprot.trans.flush()
3159 
 
3160 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3161 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3162 
    if mtype == TMessageType.EXCEPTION:
3163 
      x = TApplicationException()
3164 
      x.read(self._iprot)
3165 
      self._iprot.readMessageEnd()
3166 
      raise x
3167 
    result = getTransactionsRequiringExtraProcessing_result()
3168 
    result.read(self._iprot)
3169 
    self._iprot.readMessageEnd()
3170 
    if result.success is not None:
3171 
      return result.success
3172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3173 
 
3174 
  def markTransactionAsProcessed(self, transactionId, category):
3175 
    """
3176 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3177 
    It essentially deletes the transaction id record for a particular
3178 
    processing type category (if present) from DB.
3179 
    This is currently used by CRM application.
4008 mandeep.dh 3180 
 
3181 
    Parameters:
3182 
     - transactionId
3183 
     - category
3184 
    """
3185 
    self.send_markTransactionAsProcessed(transactionId, category)
3186 
    self.recv_markTransactionAsProcessed()
3187 
 
3188 
  def send_markTransactionAsProcessed(self, transactionId, category):
3189 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3190 
    args = markTransactionAsProcessed_args()
3191 
    args.transactionId = transactionId
3192 
    args.category = category
3193 
    args.write(self._oprot)
3194 
    self._oprot.writeMessageEnd()
3195 
    self._oprot.trans.flush()
3196 
 
3197 
  def recv_markTransactionAsProcessed(self, ):
3198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3199 
    if mtype == TMessageType.EXCEPTION:
3200 
      x = TApplicationException()
3201 
      x.read(self._iprot)
3202 
      self._iprot.readMessageEnd()
3203 
      raise x
3204 
    result = markTransactionAsProcessed_result()
3205 
    result.read(self._iprot)
3206 
    self._iprot.readMessageEnd()
3207 
    return
3208 
 
4018 chandransh 3209 
  def getItemWiseRiskyOrdersCount(self, ):
3210 
    """
3211 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3212 
    is defined as one whose shipping date is about to expire.
3213 
    """
3214 
    self.send_getItemWiseRiskyOrdersCount()
3215 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3216 
 
4018 chandransh 3217 
  def send_getItemWiseRiskyOrdersCount(self, ):
3218 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3219 
    args = getItemWiseRiskyOrdersCount_args()
3220 
    args.write(self._oprot)
3221 
    self._oprot.writeMessageEnd()
3222 
    self._oprot.trans.flush()
3223 
 
3224 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3226 
    if mtype == TMessageType.EXCEPTION:
3227 
      x = TApplicationException()
3228 
      x.read(self._iprot)
3229 
      self._iprot.readMessageEnd()
3230 
      raise x
3231 
    result = getItemWiseRiskyOrdersCount_result()
3232 
    result.read(self._iprot)
3233 
    self._iprot.readMessageEnd()
3234 
    if result.success is not None:
3235 
      return result.success
3236 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3237 
 
4295 varun.gupt 3238 
  def getOrdersForItemIds(self, itemIds):
3239 
    """
3240 
    Returns a list of all orders which have items with given id
3241 
 
3242 
    Parameters:
3243 
     - itemIds
3244 
    """
3245 
    self.send_getOrdersForItemIds(itemIds)
3246 
    return self.recv_getOrdersForItemIds()
3247 
 
3248 
  def send_getOrdersForItemIds(self, itemIds):
3249 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3250 
    args = getOrdersForItemIds_args()
3251 
    args.itemIds = itemIds
3252 
    args.write(self._oprot)
3253 
    self._oprot.writeMessageEnd()
3254 
    self._oprot.trans.flush()
3255 
 
3256 
  def recv_getOrdersForItemIds(self, ):
3257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3258 
    if mtype == TMessageType.EXCEPTION:
3259 
      x = TApplicationException()
3260 
      x.read(self._iprot)
3261 
      self._iprot.readMessageEnd()
3262 
      raise x
3263 
    result = getOrdersForItemIds_result()
3264 
    result.read(self._iprot)
3265 
    self._iprot.readMessageEnd()
3266 
    if result.success is not None:
3267 
      return result.success
3268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3269 
 
4247 rajveer 3270 
  def markOrderCancellationRequestReceived(self, orderId):
3271 
    """
3272 
    Mark order as cancellation request received. If customer sends request of cancellation of
3273 
    a particular order, this method will be called. It will just change status of the order
3274 
    depending on its current status. It also records the previous status, so that we can move
3275 
    back to that status if cancellation request is denied.
4018 chandransh 3276 
 
4247 rajveer 3277 
    Parameters:
3278 
     - orderId
3279 
    """
3280 
    self.send_markOrderCancellationRequestReceived(orderId)
3281 
    self.recv_markOrderCancellationRequestReceived()
3282 
 
3283 
  def send_markOrderCancellationRequestReceived(self, orderId):
3284 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3285 
    args = markOrderCancellationRequestReceived_args()
3286 
    args.orderId = orderId
3287 
    args.write(self._oprot)
3288 
    self._oprot.writeMessageEnd()
3289 
    self._oprot.trans.flush()
3290 
 
3291 
  def recv_markOrderCancellationRequestReceived(self, ):
3292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3293 
    if mtype == TMessageType.EXCEPTION:
3294 
      x = TApplicationException()
3295 
      x.read(self._iprot)
3296 
      self._iprot.readMessageEnd()
3297 
      raise x
3298 
    result = markOrderCancellationRequestReceived_result()
3299 
    result.read(self._iprot)
3300 
    self._iprot.readMessageEnd()
3301 
    if result.ex is not None:
3302 
      raise result.ex
3303 
    return
3304 
 
3305 
  def markOrderCancellationRequestConfirmed(self, orderId):
3306 
    """
3307 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3308 
    cancellation request confirmed. After this OM will be able to cancel the order.
3309 
 
3310 
    Parameters:
3311 
     - orderId
3312 
    """
3313 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3314 
    self.recv_markOrderCancellationRequestConfirmed()
3315 
 
3316 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3317 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3318 
    args = markOrderCancellationRequestConfirmed_args()
3319 
    args.orderId = orderId
3320 
    args.write(self._oprot)
3321 
    self._oprot.writeMessageEnd()
3322 
    self._oprot.trans.flush()
3323 
 
3324 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3326 
    if mtype == TMessageType.EXCEPTION:
3327 
      x = TApplicationException()
3328 
      x.read(self._iprot)
3329 
      self._iprot.readMessageEnd()
3330 
      raise x
3331 
    result = markOrderCancellationRequestConfirmed_result()
3332 
    result.read(self._iprot)
3333 
    self._iprot.readMessageEnd()
3334 
    if result.ex is not None:
3335 
      raise result.ex
3336 
    return
3337 
 
3338 
  def markOrderCancellationRequestDenied(self, orderId):
3339 
    """
3340 
    If we decide to not to cancel order, we will move the order ro previous status.
3341 
 
3342 
    Parameters:
3343 
     - orderId
3344 
    """
3345 
    self.send_markOrderCancellationRequestDenied(orderId)
3346 
    self.recv_markOrderCancellationRequestDenied()
3347 
 
3348 
  def send_markOrderCancellationRequestDenied(self, orderId):
3349 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3350 
    args = markOrderCancellationRequestDenied_args()
3351 
    args.orderId = orderId
3352 
    args.write(self._oprot)
3353 
    self._oprot.writeMessageEnd()
3354 
    self._oprot.trans.flush()
3355 
 
3356 
  def recv_markOrderCancellationRequestDenied(self, ):
3357 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3358 
    if mtype == TMessageType.EXCEPTION:
3359 
      x = TApplicationException()
3360 
      x.read(self._iprot)
3361 
      self._iprot.readMessageEnd()
3362 
      raise x
3363 
    result = markOrderCancellationRequestDenied_result()
3364 
    result.read(self._iprot)
3365 
    self._iprot.readMessageEnd()
3366 
    if result.ex is not None:
3367 
      raise result.ex
3368 
    return
3369 
 
4258 rajveer 3370 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3371 
    """
4258 rajveer 3372 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3373 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3374 
 
3375 
    Parameters:
4258 rajveer 3376 
     - transactionId
4247 rajveer 3377 
    """
4258 rajveer 3378 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3379 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3380 
 
4258 rajveer 3381 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3382 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3383 
    args = markTransactionAsPaymentFlagRemoved_args()
3384 
    args.transactionId = transactionId
4247 rajveer 3385 
    args.write(self._oprot)
3386 
    self._oprot.writeMessageEnd()
3387 
    self._oprot.trans.flush()
3388 
 
4258 rajveer 3389 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3391 
    if mtype == TMessageType.EXCEPTION:
3392 
      x = TApplicationException()
3393 
      x.read(self._iprot)
3394 
      self._iprot.readMessageEnd()
3395 
      raise x
4258 rajveer 3396 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3397 
    result.read(self._iprot)
3398 
    self._iprot.readMessageEnd()
3399 
    if result.ex is not None:
3400 
      raise result.ex
3401 
    return
3402 
 
4259 anupam.sin 3403 
  def refundTransaction(self, transactionId, refundedBy, reason):
3404 
    """
3405 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3406 
    need to be cancelled
4247 rajveer 3407 
 
4259 anupam.sin 3408 
    Parameters:
3409 
     - transactionId
3410 
     - refundedBy
3411 
     - reason
3412 
    """
3413 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3414 
    self.recv_refundTransaction()
3415 
 
3416 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3417 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3418 
    args = refundTransaction_args()
3419 
    args.transactionId = transactionId
3420 
    args.refundedBy = refundedBy
3421 
    args.reason = reason
3422 
    args.write(self._oprot)
3423 
    self._oprot.writeMessageEnd()
3424 
    self._oprot.trans.flush()
3425 
 
3426 
  def recv_refundTransaction(self, ):
3427 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3428 
    if mtype == TMessageType.EXCEPTION:
3429 
      x = TApplicationException()
3430 
      x.read(self._iprot)
3431 
      self._iprot.readMessageEnd()
3432 
      raise x
3433 
    result = refundTransaction_result()
3434 
    result.read(self._iprot)
3435 
    self._iprot.readMessageEnd()
3436 
    if result.ex is not None:
3437 
      raise result.ex
3438 
    return
3439 
 
4324 mandeep.dh 3440 
  def updateShipmentAddress(self, orderId, addressId):
3441 
    """
3442 
    Updates shipment address of an order. Delivery and shipping date estimates
3443 
    etc. are also updated here.
3444 
 
3445 
    Throws TransactionServiceException in case address change is not
3446 
    possible due to certain reasons such as new pincode in address is
3447 
    not serviceable etc.
3448 
 
3449 
    Parameters:
3450 
     - orderId
3451 
     - addressId
3452 
    """
3453 
    self.send_updateShipmentAddress(orderId, addressId)
3454 
    self.recv_updateShipmentAddress()
3455 
 
3456 
  def send_updateShipmentAddress(self, orderId, addressId):
3457 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3458 
    args = updateShipmentAddress_args()
3459 
    args.orderId = orderId
3460 
    args.addressId = addressId
3461 
    args.write(self._oprot)
3462 
    self._oprot.writeMessageEnd()
3463 
    self._oprot.trans.flush()
3464 
 
3465 
  def recv_updateShipmentAddress(self, ):
3466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3467 
    if mtype == TMessageType.EXCEPTION:
3468 
      x = TApplicationException()
3469 
      x.read(self._iprot)
3470 
      self._iprot.readMessageEnd()
3471 
      raise x
3472 
    result = updateShipmentAddress_result()
3473 
    result.read(self._iprot)
3474 
    self._iprot.readMessageEnd()
3475 
    if result.ex is not None:
3476 
      raise result.ex
3477 
    return
3478 
 
4285 rajveer 3479 
  def acceptOrdersForItemId(self, itemId, inventory):
3480 
    """
3481 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3482 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3483 
 
4285 rajveer 3484 
    Parameters:
3485 
     - itemId
3486 
     - inventory
3487 
    """
3488 
    self.send_acceptOrdersForItemId(itemId, inventory)
3489 
    return self.recv_acceptOrdersForItemId()
3490 
 
3491 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3492 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3493 
    args = acceptOrdersForItemId_args()
3494 
    args.itemId = itemId
3495 
    args.inventory = inventory
3496 
    args.write(self._oprot)
3497 
    self._oprot.writeMessageEnd()
3498 
    self._oprot.trans.flush()
3499 
 
3500 
  def recv_acceptOrdersForItemId(self, ):
3501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3502 
    if mtype == TMessageType.EXCEPTION:
3503 
      x = TApplicationException()
3504 
      x.read(self._iprot)
3505 
      self._iprot.readMessageEnd()
3506 
      raise x
3507 
    result = acceptOrdersForItemId_result()
3508 
    result.read(self._iprot)
3509 
    self._iprot.readMessageEnd()
3510 
    if result.success is not None:
3511 
      return result.success
3512 
    if result.ex is not None:
3513 
      raise result.ex
3514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3515 
 
4369 rajveer 3516 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3517 
    """
3518 
    Parameters:
3519 
     - vendorId
3520 
     - itemId
3521 
     - quantity
3522 
     - estimate
4369 rajveer 3523 
     - isReminder
4303 rajveer 3524 
    """
4369 rajveer 3525 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3526 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3527 
 
4369 rajveer 3528 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3529 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3530 
    args = markOrdersAsPORaised_args()
3531 
    args.vendorId = vendorId
3532 
    args.itemId = itemId
3533 
    args.quantity = quantity
3534 
    args.estimate = estimate
4369 rajveer 3535 
    args.isReminder = isReminder
4303 rajveer 3536 
    args.write(self._oprot)
3537 
    self._oprot.writeMessageEnd()
3538 
    self._oprot.trans.flush()
3539 
 
3540 
  def recv_markOrdersAsPORaised(self, ):
3541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3542 
    if mtype == TMessageType.EXCEPTION:
3543 
      x = TApplicationException()
3544 
      x.read(self._iprot)
3545 
      self._iprot.readMessageEnd()
3546 
      raise x
3547 
    result = markOrdersAsPORaised_result()
3548 
    result.read(self._iprot)
3549 
    self._iprot.readMessageEnd()
3550 
    if result.ex is not None:
3551 
      raise result.ex
3552 
    return
3553 
 
4369 rajveer 3554 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3555 
    """
3556 
    Parameters:
3557 
     - vendorId
3558 
     - itemId
3559 
     - quantity
3560 
     - estimate
4369 rajveer 3561 
     - isReminder
4303 rajveer 3562 
    """
4369 rajveer 3563 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3564 
    self.recv_markOrdersAsReversalInitiated()
3565 
 
4369 rajveer 3566 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3567 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3568 
    args = markOrdersAsReversalInitiated_args()
3569 
    args.vendorId = vendorId
3570 
    args.itemId = itemId
3571 
    args.quantity = quantity
3572 
    args.estimate = estimate
4369 rajveer 3573 
    args.isReminder = isReminder
4303 rajveer 3574 
    args.write(self._oprot)
3575 
    self._oprot.writeMessageEnd()
3576 
    self._oprot.trans.flush()
3577 
 
3578 
  def recv_markOrdersAsReversalInitiated(self, ):
3579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3580 
    if mtype == TMessageType.EXCEPTION:
3581 
      x = TApplicationException()
3582 
      x.read(self._iprot)
3583 
      self._iprot.readMessageEnd()
3584 
      raise x
3585 
    result = markOrdersAsReversalInitiated_result()
3586 
    result.read(self._iprot)
3587 
    self._iprot.readMessageEnd()
3588 
    if result.ex is not None:
3589 
      raise result.ex
3590 
    return
3591 
 
4369 rajveer 3592 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3593 
    """
3594 
    Parameters:
3595 
     - vendorId
3596 
     - itemId
3597 
     - quantity
3598 
     - estimate
4369 rajveer 3599 
     - isReminder
4303 rajveer 3600 
    """
4369 rajveer 3601 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3602 
    self.recv_markOrdersAsNotAvailabke()
3603 
 
4369 rajveer 3604 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3605 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3606 
    args = markOrdersAsNotAvailabke_args()
3607 
    args.vendorId = vendorId
3608 
    args.itemId = itemId
3609 
    args.quantity = quantity
3610 
    args.estimate = estimate
4369 rajveer 3611 
    args.isReminder = isReminder
4303 rajveer 3612 
    args.write(self._oprot)
3613 
    self._oprot.writeMessageEnd()
3614 
    self._oprot.trans.flush()
3615 
 
3616 
  def recv_markOrdersAsNotAvailabke(self, ):
3617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3618 
    if mtype == TMessageType.EXCEPTION:
3619 
      x = TApplicationException()
3620 
      x.read(self._iprot)
3621 
      self._iprot.readMessageEnd()
3622 
      raise x
3623 
    result = markOrdersAsNotAvailabke_result()
3624 
    result.read(self._iprot)
3625 
    self._iprot.readMessageEnd()
3626 
    if result.ex is not None:
3627 
      raise result.ex
3628 
    return
3629 
 
4369 rajveer 3630 
  def markOrdersAsTimeout(self, vendorId):
3631 
    """
3632 
    Parameters:
3633 
     - vendorId
3634 
    """
3635 
    self.send_markOrdersAsTimeout(vendorId)
3636 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3637 
 
4369 rajveer 3638 
  def send_markOrdersAsTimeout(self, vendorId):
3639 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3640 
    args = markOrdersAsTimeout_args()
3641 
    args.vendorId = vendorId
3642 
    args.write(self._oprot)
3643 
    self._oprot.writeMessageEnd()
3644 
    self._oprot.trans.flush()
3645 
 
3646 
  def recv_markOrdersAsTimeout(self, ):
3647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3648 
    if mtype == TMessageType.EXCEPTION:
3649 
      x = TApplicationException()
3650 
      x.read(self._iprot)
3651 
      self._iprot.readMessageEnd()
3652 
      raise x
3653 
    result = markOrdersAsTimeout_result()
3654 
    result.read(self._iprot)
3655 
    self._iprot.readMessageEnd()
3656 
    if result.success is not None:
3657 
      return result.success
3658 
    if result.ex is not None:
3659 
      raise result.ex
3660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3661 
 
4386 anupam.sin 3662 
  def getOrderForAwb(self, awb):
3663 
    """
3664 
    Returns the order corresponding to an AWB number
4369 rajveer 3665 
 
4386 anupam.sin 3666 
    Parameters:
3667 
     - awb
3668 
    """
3669 
    self.send_getOrderForAwb(awb)
3670 
    return self.recv_getOrderForAwb()
3671 
 
3672 
  def send_getOrderForAwb(self, awb):
3673 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3674 
    args = getOrderForAwb_args()
3675 
    args.awb = awb
3676 
    args.write(self._oprot)
3677 
    self._oprot.writeMessageEnd()
3678 
    self._oprot.trans.flush()
3679 
 
3680 
  def recv_getOrderForAwb(self, ):
3681 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3682 
    if mtype == TMessageType.EXCEPTION:
3683 
      x = TApplicationException()
3684 
      x.read(self._iprot)
3685 
      self._iprot.readMessageEnd()
3686 
      raise x
3687 
    result = getOrderForAwb_result()
3688 
    result.read(self._iprot)
3689 
    self._iprot.readMessageEnd()
3690 
    if result.success is not None:
3691 
      return result.success
3692 
    if result.ex is not None:
3693 
      raise result.ex
3694 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3695 
 
4506 phani.kuma 3696 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3697 
    """
3698 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3699 
 
4506 phani.kuma 3700 
    Parameters:
3701 
     - logistics_provider_id
3702 
     - order_status
3703 
    """
3704 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
3705 
    return self.recv_getOrdersForProviderForStatus()
3706 
 
3707 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3708 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
3709 
    args = getOrdersForProviderForStatus_args()
3710 
    args.logistics_provider_id = logistics_provider_id
3711 
    args.order_status = order_status
3712 
    args.write(self._oprot)
3713 
    self._oprot.writeMessageEnd()
3714 
    self._oprot.trans.flush()
3715 
 
3716 
  def recv_getOrdersForProviderForStatus(self, ):
3717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3718 
    if mtype == TMessageType.EXCEPTION:
3719 
      x = TApplicationException()
3720 
      x.read(self._iprot)
3721 
      self._iprot.readMessageEnd()
3722 
      raise x
3723 
    result = getOrdersForProviderForStatus_result()
3724 
    result.read(self._iprot)
3725 
    self._iprot.readMessageEnd()
3726 
    if result.success is not None:
3727 
      return result.success
3728 
    if result.ex is not None:
3729 
      raise result.ex
3730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
3731 
 
3732 
 
3376 rajveer 3733 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3734 
  def __init__(self, handler):
3376 rajveer 3735 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3736 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3737 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3738 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3739 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3740 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3741 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3742 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3743 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3744 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3745 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3746 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3747 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3748 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3749 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3750 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3751 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3752 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3753 
    self._processMap["createOrder"] = Processor.process_createOrder
3754 
    self._processMap["getOrder"] = Processor.process_getOrder
3755 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3756 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3757 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 3758 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 3759 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 3760 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3761 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3762 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3763 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3764 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3765 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3766 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3767 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3768 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
759 chandransh 3769 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 3770 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 3771 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3772 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3773 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3774 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3775 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3776 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4454 rajveer 3777 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
3778 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 3779 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
3780 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 3781 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3782 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3783 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3784 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3785 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 3786 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 3787 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3788 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3789 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3790 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3791 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3792 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3793 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3794 
    self._processMap["changeItem"] = Processor.process_changeItem
3795 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3796 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3797 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3798 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3799 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3800 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 3801 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 3802 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3803 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3804 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3805 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3806 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 3807 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 3808 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 3809 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
3810 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
3811 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 3812 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4386 anupam.sin 3813 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 3814 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
94 ashish 3815 
 
3816 
  def process(self, iprot, oprot):
3817 
    (name, type, seqid) = iprot.readMessageBegin()
3818 
    if name not in self._processMap:
3819 
      iprot.skip(TType.STRUCT)
3820 
      iprot.readMessageEnd()
3821 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3822 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3823 
      x.write(oprot)
3824 
      oprot.writeMessageEnd()
3825 
      oprot.trans.flush()
3826 
      return
3827 
    else:
3828 
      self._processMap[name](self, seqid, iprot, oprot)
3829 
    return True
3830 
 
3831 
  def process_createTransaction(self, seqid, iprot, oprot):
3832 
    args = createTransaction_args()
3833 
    args.read(iprot)
3834 
    iprot.readMessageEnd()
3835 
    result = createTransaction_result()
3836 
    try:
132 ashish 3837 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3838 
    except TransactionServiceException, ex:
3839 
      result.ex = ex
3840 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3841 
    result.write(oprot)
3842 
    oprot.writeMessageEnd()
3843 
    oprot.trans.flush()
3844 
 
3845 
  def process_getTransaction(self, seqid, iprot, oprot):
3846 
    args = getTransaction_args()
3847 
    args.read(iprot)
3848 
    iprot.readMessageEnd()
3849 
    result = getTransaction_result()
3850 
    try:
3851 
      result.success = self._handler.getTransaction(args.id)
3852 
    except TransactionServiceException, ex:
3853 
      result.ex = ex
3854 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3855 
    result.write(oprot)
3856 
    oprot.writeMessageEnd()
3857 
    oprot.trans.flush()
3858 
 
3859 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3860 
    args = getTransactionsForCustomer_args()
3861 
    args.read(iprot)
3862 
    iprot.readMessageEnd()
3863 
    result = getTransactionsForCustomer_result()
3864 
    try:
3865 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3866 
    except TransactionServiceException, ex:
3867 
      result.ex = ex
3868 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3869 
    result.write(oprot)
3870 
    oprot.writeMessageEnd()
3871 
    oprot.trans.flush()
3872 
 
132 ashish 3873 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3874 
    args = getTransactionsForShoppingCartId_args()
3875 
    args.read(iprot)
3876 
    iprot.readMessageEnd()
3877 
    result = getTransactionsForShoppingCartId_result()
3878 
    try:
3879 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3880 
    except TransactionServiceException, ex:
3881 
      result.ex = ex
3882 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3883 
    result.write(oprot)
3884 
    oprot.writeMessageEnd()
3885 
    oprot.trans.flush()
3886 
 
94 ashish 3887 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3888 
    args = getTransactionStatus_args()
3889 
    args.read(iprot)
3890 
    iprot.readMessageEnd()
3891 
    result = getTransactionStatus_result()
3892 
    try:
3893 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3894 
    except TransactionServiceException, ex:
3895 
      result.ex = ex
3896 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3897 
    result.write(oprot)
3898 
    oprot.writeMessageEnd()
3899 
    oprot.trans.flush()
3900 
 
3901 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3902 
    args = changeTransactionStatus_args()
3903 
    args.read(iprot)
3904 
    iprot.readMessageEnd()
3905 
    result = changeTransactionStatus_result()
3906 
    try:
3907 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3908 
    except TransactionServiceException, ex:
3909 
      result.ex = ex
3910 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3911 
    result.write(oprot)
3912 
    oprot.writeMessageEnd()
3913 
    oprot.trans.flush()
3914 
 
1398 varun.gupt 3915 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3916 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3917 
    args.read(iprot)
3918 
    iprot.readMessageEnd()
1398 varun.gupt 3919 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3920 
    try:
1398 varun.gupt 3921 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3922 
    except TransactionServiceException, ex:
3923 
      result.ex = ex
1398 varun.gupt 3924 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3925 
    result.write(oprot)
3926 
    oprot.writeMessageEnd()
3927 
    oprot.trans.flush()
3928 
 
483 rajveer 3929 
  def process_getAllOrders(self, seqid, iprot, oprot):
3930 
    args = getAllOrders_args()
94 ashish 3931 
    args.read(iprot)
3932 
    iprot.readMessageEnd()
483 rajveer 3933 
    result = getAllOrders_result()
94 ashish 3934 
    try:
483 rajveer 3935 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3936 
    except TransactionServiceException, ex:
3937 
      result.ex = ex
483 rajveer 3938 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3939 
    result.write(oprot)
3940 
    oprot.writeMessageEnd()
3941 
    oprot.trans.flush()
3942 
 
4133 chandransh 3943 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3944 
    args = getOrdersInBatch_args()
3945 
    args.read(iprot)
3946 
    iprot.readMessageEnd()
3947 
    result = getOrdersInBatch_result()
3948 
    try:
3949 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3950 
    except TransactionServiceException, ex:
3951 
      result.ex = ex
3952 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3953 
    result.write(oprot)
3954 
    oprot.writeMessageEnd()
3955 
    oprot.trans.flush()
3956 
 
3957 
  def process_getOrderCount(self, seqid, iprot, oprot):
3958 
    args = getOrderCount_args()
3959 
    args.read(iprot)
3960 
    iprot.readMessageEnd()
3961 
    result = getOrderCount_result()
3962 
    try:
3963 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3964 
    except TransactionServiceException, ex:
3965 
      result.ex = ex
3966 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3967 
    result.write(oprot)
3968 
    oprot.writeMessageEnd()
3969 
    oprot.trans.flush()
3970 
 
999 varun.gupt 3971 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3972 
    args = getOrdersByBillingDate_args()
3973 
    args.read(iprot)
3974 
    iprot.readMessageEnd()
3975 
    result = getOrdersByBillingDate_result()
3976 
    try:
3977 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3978 
    except TransactionServiceException, ex:
3979 
      result.ex = ex
3980 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3981 
    result.write(oprot)
3982 
    oprot.writeMessageEnd()
3983 
    oprot.trans.flush()
3984 
 
3427 chandransh 3985 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3986 
    args = getOrdersByShippingDate_args()
3987 
    args.read(iprot)
3988 
    iprot.readMessageEnd()
3989 
    result = getOrdersByShippingDate_result()
3990 
    try:
3451 chandransh 3991 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3992 
    except TransactionServiceException, ex:
3993 
      result.ex = ex
3994 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3995 
    result.write(oprot)
3996 
    oprot.writeMessageEnd()
3997 
    oprot.trans.flush()
3998 
 
1382 varun.gupt 3999 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4000 
    args = getReturnableOrdersForCustomer_args()
4001 
    args.read(iprot)
4002 
    iprot.readMessageEnd()
4003 
    result = getReturnableOrdersForCustomer_result()
4004 
    try:
4005 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4006 
    except TransactionServiceException, ex:
4007 
      result.ex = ex
4008 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4009 
    result.write(oprot)
4010 
    oprot.writeMessageEnd()
4011 
    oprot.trans.flush()
4012 
 
4013 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4014 
    args = getCancellableOrdersForCustomer_args()
4015 
    args.read(iprot)
4016 
    iprot.readMessageEnd()
4017 
    result = getCancellableOrdersForCustomer_result()
4018 
    try:
4019 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4020 
    except TransactionServiceException, ex:
4021 
      result.ex = ex
4022 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4023 
    result.write(oprot)
4024 
    oprot.writeMessageEnd()
4025 
    oprot.trans.flush()
4026 
 
483 rajveer 4027 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4028 
    args = changeOrderStatus_args()
94 ashish 4029 
    args.read(iprot)
4030 
    iprot.readMessageEnd()
483 rajveer 4031 
    result = changeOrderStatus_result()
94 ashish 4032 
    try:
483 rajveer 4033 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4034 
    except TransactionServiceException, ex:
4035 
      result.ex = ex
483 rajveer 4036 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4037 
    result.write(oprot)
4038 
    oprot.writeMessageEnd()
4039 
    oprot.trans.flush()
4040 
 
483 rajveer 4041 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4042 
    args = getOrdersForTransaction_args()
94 ashish 4043 
    args.read(iprot)
4044 
    iprot.readMessageEnd()
483 rajveer 4045 
    result = getOrdersForTransaction_result()
94 ashish 4046 
    try:
1528 ankur.sing 4047 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4048 
    except TransactionServiceException, ex:
4049 
      result.ex = ex
483 rajveer 4050 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4051 
    result.write(oprot)
4052 
    oprot.writeMessageEnd()
4053 
    oprot.trans.flush()
4054 
 
483 rajveer 4055 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4056 
    args = getOrdersForCustomer_args()
94 ashish 4057 
    args.read(iprot)
4058 
    iprot.readMessageEnd()
483 rajveer 4059 
    result = getOrdersForCustomer_result()
94 ashish 4060 
    try:
3014 chandransh 4061 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4062 
    except TransactionServiceException, ex:
4063 
      result.ex = ex
483 rajveer 4064 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4065 
    result.write(oprot)
4066 
    oprot.writeMessageEnd()
4067 
    oprot.trans.flush()
4068 
 
483 rajveer 4069 
  def process_createOrder(self, seqid, iprot, oprot):
4070 
    args = createOrder_args()
94 ashish 4071 
    args.read(iprot)
4072 
    iprot.readMessageEnd()
483 rajveer 4073 
    result = createOrder_result()
94 ashish 4074 
    try:
483 rajveer 4075 
      result.success = self._handler.createOrder(args.order)
94 ashish 4076 
    except TransactionServiceException, ex:
4077 
      result.ex = ex
483 rajveer 4078 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4079 
    result.write(oprot)
4080 
    oprot.writeMessageEnd()
4081 
    oprot.trans.flush()
4082 
 
483 rajveer 4083 
  def process_getOrder(self, seqid, iprot, oprot):
4084 
    args = getOrder_args()
94 ashish 4085 
    args.read(iprot)
4086 
    iprot.readMessageEnd()
483 rajveer 4087 
    result = getOrder_result()
94 ashish 4088 
    try:
483 rajveer 4089 
      result.success = self._handler.getOrder(args.id)
94 ashish 4090 
    except TransactionServiceException, ex:
4091 
      result.ex = ex
483 rajveer 4092 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4093 
    result.write(oprot)
4094 
    oprot.writeMessageEnd()
4095 
    oprot.trans.flush()
4096 
 
483 rajveer 4097 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4098 
    args = getLineItemsForOrder_args()
94 ashish 4099 
    args.read(iprot)
4100 
    iprot.readMessageEnd()
483 rajveer 4101 
    result = getLineItemsForOrder_result()
94 ashish 4102 
    try:
483 rajveer 4103 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4104 
    except TransactionServiceException, ex:
4105 
      result.ex = ex
483 rajveer 4106 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4107 
    result.write(oprot)
4108 
    oprot.writeMessageEnd()
4109 
    oprot.trans.flush()
4110 
 
1528 ankur.sing 4111 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4112 
    args = getOrderForCustomer_args()
4113 
    args.read(iprot)
4114 
    iprot.readMessageEnd()
4115 
    result = getOrderForCustomer_result()
4116 
    try:
4117 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4118 
    except TransactionServiceException, ex:
4119 
      result.ex = ex
4120 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4121 
    result.write(oprot)
4122 
    oprot.writeMessageEnd()
4123 
    oprot.trans.flush()
4124 
 
3064 chandransh 4125 
  def process_getAlerts(self, seqid, iprot, oprot):
4126 
    args = getAlerts_args()
4127 
    args.read(iprot)
4128 
    iprot.readMessageEnd()
4129 
    result = getAlerts_result()
4444 rajveer 4130 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4131 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4132 
    result.write(oprot)
4133 
    oprot.writeMessageEnd()
4134 
    oprot.trans.flush()
4135 
 
4394 rajveer 4136 
  def process_addAlert(self, seqid, iprot, oprot):
4137 
    args = addAlert_args()
3064 chandransh 4138 
    args.read(iprot)
4139 
    iprot.readMessageEnd()
4394 rajveer 4140 
    result = addAlert_result()
4444 rajveer 4141 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4142 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4143 
    result.write(oprot)
4144 
    oprot.writeMessageEnd()
4145 
    oprot.trans.flush()
4146 
 
4444 rajveer 4147 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4148 
    args = markAlertsAsSeen_args()
4149 
    args.read(iprot)
4150 
    iprot.readMessageEnd()
4151 
    result = markAlertsAsSeen_result()
4152 
    self._handler.markAlertsAsSeen(args.warehouseId)
4153 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4154 
    result.write(oprot)
4155 
    oprot.writeMessageEnd()
4156 
    oprot.trans.flush()
4157 
 
3064 chandransh 4158 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4159 
    args = getValidOrderCount_args()
4160 
    args.read(iprot)
4161 
    iprot.readMessageEnd()
4162 
    result = getValidOrderCount_result()
4163 
    result.success = self._handler.getValidOrderCount()
4164 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4165 
    result.write(oprot)
4166 
    oprot.writeMessageEnd()
4167 
    oprot.trans.flush()
4168 
 
4169 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4170 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4171 
    args.read(iprot)
4172 
    iprot.readMessageEnd()
4173 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4174 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4175 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4176 
    result.write(oprot)
4177 
    oprot.writeMessageEnd()
4178 
    oprot.trans.flush()
4179 
 
4180 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4181 
    args = getValidOrdersAmountRange_args()
4182 
    args.read(iprot)
4183 
    iprot.readMessageEnd()
4184 
    result = getValidOrdersAmountRange_result()
4185 
    result.success = self._handler.getValidOrdersAmountRange()
4186 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4187 
    result.write(oprot)
4188 
    oprot.writeMessageEnd()
4189 
    oprot.trans.flush()
4190 
 
4191 
  def process_getValidOrders(self, seqid, iprot, oprot):
4192 
    args = getValidOrders_args()
4193 
    args.read(iprot)
4194 
    iprot.readMessageEnd()
4195 
    result = getValidOrders_result()
4196 
    result.success = self._handler.getValidOrders(args.limit)
4197 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4198 
    result.write(oprot)
4199 
    oprot.writeMessageEnd()
4200 
    oprot.trans.flush()
4201 
 
1220 chandransh 4202 
  def process_batchOrders(self, seqid, iprot, oprot):
4203 
    args = batchOrders_args()
4204 
    args.read(iprot)
4205 
    iprot.readMessageEnd()
4206 
    result = batchOrders_result()
4207 
    try:
4208 
      result.success = self._handler.batchOrders(args.warehouseId)
4209 
    except TransactionServiceException, ex:
4210 
      result.ex = ex
4211 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4212 
    result.write(oprot)
4213 
    oprot.writeMessageEnd()
4214 
    oprot.trans.flush()
4215 
 
1208 chandransh 4216 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4217 
    args = markOrderAsOutOfStock_args()
4218 
    args.read(iprot)
4219 
    iprot.readMessageEnd()
4220 
    result = markOrderAsOutOfStock_result()
4221 
    try:
4222 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4223 
    except TransactionServiceException, ex:
4224 
      result.ex = ex
4225 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4226 
    result.write(oprot)
4227 
    oprot.writeMessageEnd()
4228 
    oprot.trans.flush()
4229 
 
3064 chandransh 4230 
  def process_verifyOrder(self, seqid, iprot, oprot):
4231 
    args = verifyOrder_args()
759 chandransh 4232 
    args.read(iprot)
4233 
    iprot.readMessageEnd()
3064 chandransh 4234 
    result = verifyOrder_result()
759 chandransh 4235 
    try:
3064 chandransh 4236 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4237 
    except TransactionServiceException, ex:
4238 
      result.ex = ex
3064 chandransh 4239 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4240 
    result.write(oprot)
4241 
    oprot.writeMessageEnd()
4242 
    oprot.trans.flush()
4243 
 
3064 chandransh 4244 
  def process_acceptOrder(self, seqid, iprot, oprot):
4245 
    args = acceptOrder_args()
1113 chandransh 4246 
    args.read(iprot)
4247 
    iprot.readMessageEnd()
3064 chandransh 4248 
    result = acceptOrder_result()
1113 chandransh 4249 
    try:
3064 chandransh 4250 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4251 
    except TransactionServiceException, ex:
4252 
      result.ex = ex
3064 chandransh 4253 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4254 
    result.write(oprot)
4255 
    oprot.writeMessageEnd()
4256 
    oprot.trans.flush()
4257 
 
3064 chandransh 4258 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4259 
    args = addBillingDetails_args()
1135 chandransh 4260 
    args.read(iprot)
4261 
    iprot.readMessageEnd()
3064 chandransh 4262 
    result = addBillingDetails_result()
1135 chandransh 4263 
    try:
4283 anupam.sin 4264 
      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 4265 
    except TransactionServiceException, ex:
4266 
      result.ex = ex
3064 chandransh 4267 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4268 
    result.write(oprot)
4269 
    oprot.writeMessageEnd()
4270 
    oprot.trans.flush()
4271 
 
3064 chandransh 4272 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4273 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4274 
    args.read(iprot)
4275 
    iprot.readMessageEnd()
3064 chandransh 4276 
    result = markOrdersAsManifested_result()
4277 
    try:
4278 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4279 
    except TransactionServiceException, ex:
4280 
      result.ex = ex
4281 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4282 
    result.write(oprot)
4283 
    oprot.writeMessageEnd()
4284 
    oprot.trans.flush()
4285 
 
4410 rajveer 4286 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4287 
    args = markOrdersAsShippedFromWarehouse_args()
4288 
    args.read(iprot)
4289 
    iprot.readMessageEnd()
4290 
    result = markOrdersAsShippedFromWarehouse_result()
4291 
    try:
4292 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4293 
    except TransactionServiceException, ex:
4294 
      result.ex = ex
4295 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4296 
    result.write(oprot)
4297 
    oprot.writeMessageEnd()
4298 
    oprot.trans.flush()
4299 
 
3064 chandransh 4300 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4301 
    args = markOrdersAsPickedUp_args()
304 ashish 4302 
    args.read(iprot)
4303 
    iprot.readMessageEnd()
3064 chandransh 4304 
    result = markOrdersAsPickedUp_result()
4305 
    try:
4306 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4307 
    except TransactionServiceException, ex:
4308 
      result.ex = ex
4309 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4310 
    result.write(oprot)
4311 
    oprot.writeMessageEnd()
4312 
    oprot.trans.flush()
94 ashish 4313 
 
3064 chandransh 4314 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4315 
    args = markOrdersAsDelivered_args()
304 ashish 4316 
    args.read(iprot)
4317 
    iprot.readMessageEnd()
3064 chandransh 4318 
    result = markOrdersAsDelivered_result()
4319 
    try:
4320 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4321 
    except TransactionServiceException, ex:
4322 
      result.ex = ex
4323 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4324 
    result.write(oprot)
4325 
    oprot.writeMessageEnd()
4326 
    oprot.trans.flush()
4327 
 
3064 chandransh 4328 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4329 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4330 
    args.read(iprot)
4331 
    iprot.readMessageEnd()
3064 chandransh 4332 
    result = markOrdersAsFailed_result()
4333 
    try:
4334 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4335 
    except TransactionServiceException, ex:
4336 
      result.ex = ex
4337 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4338 
    result.write(oprot)
4339 
    oprot.writeMessageEnd()
4340 
    oprot.trans.flush()
304 ashish 4341 
 
3064 chandransh 4342 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4343 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4344 
    args.read(iprot)
4345 
    iprot.readMessageEnd()
3064 chandransh 4346 
    result = updateNonDeliveryReason_result()
4347 
    try:
4348 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
4349 
    except TransactionServiceException, ex:
4350 
      result.ex = ex
4351 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4352 
    result.write(oprot)
4353 
    oprot.writeMessageEnd()
4354 
    oprot.trans.flush()
1596 ankur.sing 4355 
 
3064 chandransh 4356 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4357 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4358 
    args.read(iprot)
4359 
    iprot.readMessageEnd()
3064 chandransh 4360 
    result = getUndeliveredOrders_result()
4361 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4362 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4363 
    result.write(oprot)
4364 
    oprot.writeMessageEnd()
4365 
    oprot.trans.flush()
4366 
 
2536 chandransh 4367 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4368 
    args = toggleDOAFlag_args()
4369 
    args.read(iprot)
4370 
    iprot.readMessageEnd()
4371 
    result = toggleDOAFlag_result()
4372 
    try:
4373 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4374 
    except TransactionServiceException, ex:
4375 
      result.ex = ex
4376 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4377 
    result.write(oprot)
4378 
    oprot.writeMessageEnd()
4379 
    oprot.trans.flush()
1886 ankur.sing 4380 
 
4454 rajveer 4381 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
4382 
    args = markOrderDoaRequestReceived_args()
4383 
    args.read(iprot)
4384 
    iprot.readMessageEnd()
4385 
    result = markOrderDoaRequestReceived_result()
4386 
    try:
4387 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
4388 
    except TransactionServiceException, ex:
4389 
      result.ex = ex
4390 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
4391 
    result.write(oprot)
4392 
    oprot.writeMessageEnd()
4393 
    oprot.trans.flush()
4394 
 
4395 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
4396 
    args = markOrderDoaRequestAuthorized_args()
4397 
    args.read(iprot)
4398 
    iprot.readMessageEnd()
4399 
    result = markOrderDoaRequestAuthorized_result()
4400 
    try:
4401 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
4402 
    except TransactionServiceException, ex:
4403 
      result.ex = ex
4404 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
4405 
    result.write(oprot)
4406 
    oprot.writeMessageEnd()
4407 
    oprot.trans.flush()
4408 
 
4488 rajveer 4409 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
4410 
    args = markOrderReturnRequestReceived_args()
4411 
    args.read(iprot)
4412 
    iprot.readMessageEnd()
4413 
    result = markOrderReturnRequestReceived_result()
4414 
    try:
4415 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
4416 
    except TransactionServiceException, ex:
4417 
      result.ex = ex
4418 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
4419 
    result.write(oprot)
4420 
    oprot.writeMessageEnd()
4421 
    oprot.trans.flush()
4422 
 
4423 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
4424 
    args = markOrderReturnRequestAuthorized_args()
4425 
    args.read(iprot)
4426 
    iprot.readMessageEnd()
4427 
    result = markOrderReturnRequestAuthorized_result()
4428 
    try:
4429 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
4430 
    except TransactionServiceException, ex:
4431 
      result.ex = ex
4432 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
4433 
    result.write(oprot)
4434 
    oprot.writeMessageEnd()
4435 
    oprot.trans.flush()
4436 
 
2536 chandransh 4437 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
4438 
    args = requestPickupNumber_args()
4439 
    args.read(iprot)
4440 
    iprot.readMessageEnd()
4441 
    result = requestPickupNumber_result()
4442 
    try:
4443 
      result.success = self._handler.requestPickupNumber(args.orderId)
4444 
    except TransactionServiceException, ex:
4445 
      result.ex = ex
4446 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
4447 
    result.write(oprot)
4448 
    oprot.writeMessageEnd()
4449 
    oprot.trans.flush()
4450 
 
4451 
  def process_authorizePickup(self, seqid, iprot, oprot):
4452 
    args = authorizePickup_args()
4453 
    args.read(iprot)
4454 
    iprot.readMessageEnd()
4455 
    result = authorizePickup_result()
4456 
    try:
4457 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
4458 
    except TransactionServiceException, ex:
4459 
      result.ex = ex
4460 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4461 
    result.write(oprot)
4462 
    oprot.writeMessageEnd()
4463 
    oprot.trans.flush()
4464 
 
2764 chandransh 4465 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4466 
    args = markDoasAsPickedUp_args()
4467 
    args.read(iprot)
4468 
    iprot.readMessageEnd()
4469 
    result = markDoasAsPickedUp_result()
4470 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4471 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4472 
    result.write(oprot)
4473 
    oprot.writeMessageEnd()
4474 
    oprot.trans.flush()
4475 
 
2616 chandransh 4476 
  def process_receiveReturn(self, seqid, iprot, oprot):
4477 
    args = receiveReturn_args()
2591 chandransh 4478 
    args.read(iprot)
4479 
    iprot.readMessageEnd()
2616 chandransh 4480 
    result = receiveReturn_result()
2591 chandransh 4481 
    try:
4479 rajveer 4482 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 4483 
    except TransactionServiceException, ex:
4484 
      result.ex = ex
2616 chandransh 4485 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4486 
    result.write(oprot)
4487 
    oprot.writeMessageEnd()
4488 
    oprot.trans.flush()
2536 chandransh 4489 
 
2591 chandransh 4490 
  def process_validateDoa(self, seqid, iprot, oprot):
4491 
    args = validateDoa_args()
4492 
    args.read(iprot)
4493 
    iprot.readMessageEnd()
4494 
    result = validateDoa_result()
4495 
    try:
4496 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4497 
    except TransactionServiceException, ex:
4498 
      result.ex = ex
4499 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4500 
    result.write(oprot)
4501 
    oprot.writeMessageEnd()
4502 
    oprot.trans.flush()
4503 
 
4495 rajveer 4504 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
4505 
    args = validateReturnProduct_args()
4506 
    args.read(iprot)
4507 
    iprot.readMessageEnd()
4508 
    result = validateReturnProduct_result()
4509 
    try:
4510 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
4511 
    except TransactionServiceException, ex:
4512 
      result.ex = ex
4513 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
4514 
    result.write(oprot)
4515 
    oprot.writeMessageEnd()
4516 
    oprot.trans.flush()
4517 
 
2616 chandransh 4518 
  def process_reshipOrder(self, seqid, iprot, oprot):
4519 
    args = reshipOrder_args()
4520 
    args.read(iprot)
4521 
    iprot.readMessageEnd()
4522 
    result = reshipOrder_result()
4523 
    try:
4524 
      result.success = self._handler.reshipOrder(args.orderId)
4525 
    except TransactionServiceException, ex:
4526 
      result.ex = ex
4527 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4528 
    result.write(oprot)
4529 
    oprot.writeMessageEnd()
4530 
    oprot.trans.flush()
2591 chandransh 4531 
 
2616 chandransh 4532 
  def process_refundOrder(self, seqid, iprot, oprot):
4533 
    args = refundOrder_args()
4534 
    args.read(iprot)
4535 
    iprot.readMessageEnd()
4536 
    result = refundOrder_result()
4537 
    try:
3226 chandransh 4538 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4539 
    except TransactionServiceException, ex:
4540 
      result.ex = ex
4541 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4542 
    result.write(oprot)
4543 
    oprot.writeMessageEnd()
4544 
    oprot.trans.flush()
4545 
 
2690 chandransh 4546 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4547 
    args = getReturnOrders_args()
4548 
    args.read(iprot)
4549 
    iprot.readMessageEnd()
4550 
    result = getReturnOrders_result()
4551 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4552 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4553 
    result.write(oprot)
4554 
    oprot.writeMessageEnd()
4555 
    oprot.trans.flush()
2616 chandransh 4556 
 
2700 chandransh 4557 
  def process_getReturnOrder(self, seqid, iprot, oprot):
4558 
    args = getReturnOrder_args()
4559 
    args.read(iprot)
4560 
    iprot.readMessageEnd()
4561 
    result = getReturnOrder_result()
4562 
    try:
4563 
      result.success = self._handler.getReturnOrder(args.id)
4564 
    except TransactionServiceException, ex:
4565 
      result.ex = ex
4566 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
4567 
    result.write(oprot)
4568 
    oprot.writeMessageEnd()
4569 
    oprot.trans.flush()
4570 
 
2690 chandransh 4571 
  def process_processReturn(self, seqid, iprot, oprot):
4572 
    args = processReturn_args()
4573 
    args.read(iprot)
4574 
    iprot.readMessageEnd()
4575 
    result = processReturn_result()
4576 
    try:
4577 
      self._handler.processReturn(args.returnOrderId)
4578 
    except TransactionServiceException, ex:
4579 
      result.ex = ex
4580 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
4581 
    result.write(oprot)
4582 
    oprot.writeMessageEnd()
4583 
    oprot.trans.flush()
4584 
 
2819 chandransh 4585 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
4586 
    args = createPurchaseOrder_args()
4587 
    args.read(iprot)
4588 
    iprot.readMessageEnd()
4589 
    result = createPurchaseOrder_result()
4590 
    try:
4591 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
4592 
    except TransactionServiceException, ex:
4593 
      result.ex = ex
4594 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
4595 
    result.write(oprot)
4596 
    oprot.writeMessageEnd()
4597 
    oprot.trans.flush()
2690 chandransh 4598 
 
3451 chandransh 4599 
  def process_updateWeight(self, seqid, iprot, oprot):
4600 
    args = updateWeight_args()
4601 
    args.read(iprot)
4602 
    iprot.readMessageEnd()
4603 
    result = updateWeight_result()
4604 
    try:
4605 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
4606 
    except TransactionServiceException, ex:
4607 
      result.ex = ex
4608 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
4609 
    result.write(oprot)
4610 
    oprot.writeMessageEnd()
4611 
    oprot.trans.flush()
2819 chandransh 4612 
 
3469 chandransh 4613 
  def process_changeItem(self, seqid, iprot, oprot):
4614 
    args = changeItem_args()
4615 
    args.read(iprot)
4616 
    iprot.readMessageEnd()
4617 
    result = changeItem_result()
4618 
    try:
4619 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
4620 
    except TransactionServiceException, ex:
4621 
      result.ex = ex
4622 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
4623 
    result.write(oprot)
4624 
    oprot.writeMessageEnd()
4625 
    oprot.trans.flush()
3451 chandransh 4626 
 
3469 chandransh 4627 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
4628 
    args = shiftToWarehouse_args()
4629 
    args.read(iprot)
4630 
    iprot.readMessageEnd()
4631 
    result = shiftToWarehouse_result()
4632 
    try:
4633 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
4634 
    except TransactionServiceException, ex:
4635 
      result.ex = ex
4636 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
4637 
    result.write(oprot)
4638 
    oprot.writeMessageEnd()
4639 
    oprot.trans.flush()
4640 
 
3553 chandransh 4641 
  def process_addDelayReason(self, seqid, iprot, oprot):
4642 
    args = addDelayReason_args()
4643 
    args.read(iprot)
4644 
    iprot.readMessageEnd()
4645 
    result = addDelayReason_result()
4646 
    try:
3986 chandransh 4647 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 4648 
    except TransactionServiceException, ex:
4649 
      result.ex = ex
4650 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
4651 
    result.write(oprot)
4652 
    oprot.writeMessageEnd()
4653 
    oprot.trans.flush()
3469 chandransh 4654 
 
3956 chandransh 4655 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
4656 
    args = reconcileCodCollection_args()
4657 
    args.read(iprot)
4658 
    iprot.readMessageEnd()
4659 
    result = reconcileCodCollection_result()
4660 
    try:
4661 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
4662 
    except TransactionServiceException, ex:
4663 
      result.ex = ex
4664 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
4665 
    result.write(oprot)
4666 
    oprot.writeMessageEnd()
4667 
    oprot.trans.flush()
3553 chandransh 4668 
 
4008 mandeep.dh 4669 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
4670 
    args = getTransactionsRequiringExtraProcessing_args()
4671 
    args.read(iprot)
4672 
    iprot.readMessageEnd()
4673 
    result = getTransactionsRequiringExtraProcessing_result()
4674 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
4675 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
4676 
    result.write(oprot)
4677 
    oprot.writeMessageEnd()
4678 
    oprot.trans.flush()
3956 chandransh 4679 
 
4008 mandeep.dh 4680 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
4681 
    args = markTransactionAsProcessed_args()
4682 
    args.read(iprot)
4683 
    iprot.readMessageEnd()
4684 
    result = markTransactionAsProcessed_result()
4685 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
4686 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
4687 
    result.write(oprot)
4688 
    oprot.writeMessageEnd()
4689 
    oprot.trans.flush()
4690 
 
4018 chandransh 4691 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
4692 
    args = getItemWiseRiskyOrdersCount_args()
4693 
    args.read(iprot)
4694 
    iprot.readMessageEnd()
4695 
    result = getItemWiseRiskyOrdersCount_result()
4696 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
4697 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
4698 
    result.write(oprot)
4699 
    oprot.writeMessageEnd()
4700 
    oprot.trans.flush()
4008 mandeep.dh 4701 
 
4295 varun.gupt 4702 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
4703 
    args = getOrdersForItemIds_args()
4704 
    args.read(iprot)
4705 
    iprot.readMessageEnd()
4706 
    result = getOrdersForItemIds_result()
4707 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
4708 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
4709 
    result.write(oprot)
4710 
    oprot.writeMessageEnd()
4711 
    oprot.trans.flush()
4712 
 
4247 rajveer 4713 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
4714 
    args = markOrderCancellationRequestReceived_args()
4715 
    args.read(iprot)
4716 
    iprot.readMessageEnd()
4717 
    result = markOrderCancellationRequestReceived_result()
4718 
    try:
4719 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
4720 
    except TransactionServiceException, ex:
4721 
      result.ex = ex
4722 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
4723 
    result.write(oprot)
4724 
    oprot.writeMessageEnd()
4725 
    oprot.trans.flush()
4018 chandransh 4726 
 
4247 rajveer 4727 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
4728 
    args = markOrderCancellationRequestConfirmed_args()
4729 
    args.read(iprot)
4730 
    iprot.readMessageEnd()
4731 
    result = markOrderCancellationRequestConfirmed_result()
4732 
    try:
4733 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
4734 
    except TransactionServiceException, ex:
4735 
      result.ex = ex
4736 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
4737 
    result.write(oprot)
4738 
    oprot.writeMessageEnd()
4739 
    oprot.trans.flush()
4740 
 
4741 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4742 
    args = markOrderCancellationRequestDenied_args()
4743 
    args.read(iprot)
4744 
    iprot.readMessageEnd()
4745 
    result = markOrderCancellationRequestDenied_result()
4746 
    try:
4747 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4748 
    except TransactionServiceException, ex:
4749 
      result.ex = ex
4750 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4751 
    result.write(oprot)
4752 
    oprot.writeMessageEnd()
4753 
    oprot.trans.flush()
4754 
 
4258 rajveer 4755 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4756 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4757 
    args.read(iprot)
4758 
    iprot.readMessageEnd()
4258 rajveer 4759 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4760 
    try:
4258 rajveer 4761 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4762 
    except TransactionServiceException, ex:
4763 
      result.ex = ex
4258 rajveer 4764 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4765 
    result.write(oprot)
4766 
    oprot.writeMessageEnd()
4767 
    oprot.trans.flush()
4768 
 
4259 anupam.sin 4769 
  def process_refundTransaction(self, seqid, iprot, oprot):
4770 
    args = refundTransaction_args()
4771 
    args.read(iprot)
4772 
    iprot.readMessageEnd()
4773 
    result = refundTransaction_result()
4774 
    try:
4775 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4776 
    except TransactionServiceException, ex:
4777 
      result.ex = ex
4778 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4779 
    result.write(oprot)
4780 
    oprot.writeMessageEnd()
4781 
    oprot.trans.flush()
4247 rajveer 4782 
 
4324 mandeep.dh 4783 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
4784 
    args = updateShipmentAddress_args()
4785 
    args.read(iprot)
4786 
    iprot.readMessageEnd()
4787 
    result = updateShipmentAddress_result()
4788 
    try:
4789 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
4790 
    except TransactionServiceException, ex:
4791 
      result.ex = ex
4792 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
4793 
    result.write(oprot)
4794 
    oprot.writeMessageEnd()
4795 
    oprot.trans.flush()
4796 
 
4285 rajveer 4797 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
4798 
    args = acceptOrdersForItemId_args()
4799 
    args.read(iprot)
4800 
    iprot.readMessageEnd()
4801 
    result = acceptOrdersForItemId_result()
4802 
    try:
4803 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
4804 
    except TransactionServiceException, ex:
4805 
      result.ex = ex
4806 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
4807 
    result.write(oprot)
4808 
    oprot.writeMessageEnd()
4809 
    oprot.trans.flush()
4259 anupam.sin 4810 
 
4303 rajveer 4811 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
4812 
    args = markOrdersAsPORaised_args()
4813 
    args.read(iprot)
4814 
    iprot.readMessageEnd()
4815 
    result = markOrdersAsPORaised_result()
4816 
    try:
4369 rajveer 4817 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4818 
    except TransactionServiceException, ex:
4819 
      result.ex = ex
4820 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
4821 
    result.write(oprot)
4822 
    oprot.writeMessageEnd()
4823 
    oprot.trans.flush()
4285 rajveer 4824 
 
4303 rajveer 4825 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
4826 
    args = markOrdersAsReversalInitiated_args()
4827 
    args.read(iprot)
4828 
    iprot.readMessageEnd()
4829 
    result = markOrdersAsReversalInitiated_result()
4830 
    try:
4369 rajveer 4831 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4832 
    except TransactionServiceException, ex:
4833 
      result.ex = ex
4834 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
4835 
    result.write(oprot)
4836 
    oprot.writeMessageEnd()
4837 
    oprot.trans.flush()
4838 
 
4839 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
4840 
    args = markOrdersAsNotAvailabke_args()
4841 
    args.read(iprot)
4842 
    iprot.readMessageEnd()
4843 
    result = markOrdersAsNotAvailabke_result()
4844 
    try:
4369 rajveer 4845 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4846 
    except TransactionServiceException, ex:
4847 
      result.ex = ex
4848 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
4849 
    result.write(oprot)
4850 
    oprot.writeMessageEnd()
4851 
    oprot.trans.flush()
4852 
 
4369 rajveer 4853 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
4854 
    args = markOrdersAsTimeout_args()
4855 
    args.read(iprot)
4856 
    iprot.readMessageEnd()
4857 
    result = markOrdersAsTimeout_result()
4858 
    try:
4859 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
4860 
    except TransactionServiceException, ex:
4861 
      result.ex = ex
4862 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
4863 
    result.write(oprot)
4864 
    oprot.writeMessageEnd()
4865 
    oprot.trans.flush()
4303 rajveer 4866 
 
4386 anupam.sin 4867 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
4868 
    args = getOrderForAwb_args()
4869 
    args.read(iprot)
4870 
    iprot.readMessageEnd()
4871 
    result = getOrderForAwb_result()
4872 
    try:
4873 
      result.success = self._handler.getOrderForAwb(args.awb)
4874 
    except TransactionServiceException, ex:
4875 
      result.ex = ex
4876 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
4877 
    result.write(oprot)
4878 
    oprot.writeMessageEnd()
4879 
    oprot.trans.flush()
4369 rajveer 4880 
 
4506 phani.kuma 4881 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
4882 
    args = getOrdersForProviderForStatus_args()
4883 
    args.read(iprot)
4884 
    iprot.readMessageEnd()
4885 
    result = getOrdersForProviderForStatus_result()
4886 
    try:
4887 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
4888 
    except TransactionServiceException, ex:
4889 
      result.ex = ex
4890 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
4891 
    result.write(oprot)
4892 
    oprot.writeMessageEnd()
4893 
    oprot.trans.flush()
4386 anupam.sin 4894 
 
4506 phani.kuma 4895 
 
94 ashish 4896 
# HELPER FUNCTIONS AND STRUCTURES
4897 
 
4898 
class createTransaction_args:
4899 
  """
4900 
  Attributes:
4901 
   - transaction
4902 
  """
4903 
 
4904 
  thrift_spec = (
4905 
    None, # 0
4906 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4907 
  )
4908 
 
4909 
  def __init__(self, transaction=None,):
4910 
    self.transaction = transaction
4911 
 
4912 
  def read(self, iprot):
4913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4915 
      return
4916 
    iprot.readStructBegin()
4917 
    while True:
4918 
      (fname, ftype, fid) = iprot.readFieldBegin()
4919 
      if ftype == TType.STOP:
4920 
        break
4921 
      if fid == 1:
4922 
        if ftype == TType.STRUCT:
4923 
          self.transaction = Transaction()
4924 
          self.transaction.read(iprot)
4925 
        else:
4926 
          iprot.skip(ftype)
4927 
      else:
4928 
        iprot.skip(ftype)
4929 
      iprot.readFieldEnd()
4930 
    iprot.readStructEnd()
4931 
 
4932 
  def write(self, oprot):
4933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4935 
      return
4936 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4937 
    if self.transaction is not None:
94 ashish 4938 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4939 
      self.transaction.write(oprot)
4940 
      oprot.writeFieldEnd()
4941 
    oprot.writeFieldStop()
4942 
    oprot.writeStructEnd()
4943 
 
3431 rajveer 4944 
  def validate(self):
4945 
    return
4946 
 
4947 
 
94 ashish 4948 
  def __repr__(self):
4949 
    L = ['%s=%r' % (key, value)
4950 
      for key, value in self.__dict__.iteritems()]
4951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4952 
 
4953 
  def __eq__(self, other):
4954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4955 
 
4956 
  def __ne__(self, other):
4957 
    return not (self == other)
4958 
 
4959 
class createTransaction_result:
4960 
  """
4961 
  Attributes:
132 ashish 4962 
   - success
94 ashish 4963 
   - ex
4964 
  """
4965 
 
4966 
  thrift_spec = (
132 ashish 4967 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4968 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4969 
  )
4970 
 
132 ashish 4971 
  def __init__(self, success=None, ex=None,):
4972 
    self.success = success
94 ashish 4973 
    self.ex = ex
4974 
 
4975 
  def read(self, iprot):
4976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4978 
      return
4979 
    iprot.readStructBegin()
4980 
    while True:
4981 
      (fname, ftype, fid) = iprot.readFieldBegin()
4982 
      if ftype == TType.STOP:
4983 
        break
132 ashish 4984 
      if fid == 0:
4985 
        if ftype == TType.I64:
4986 
          self.success = iprot.readI64();
4987 
        else:
4988 
          iprot.skip(ftype)
4989 
      elif fid == 1:
94 ashish 4990 
        if ftype == TType.STRUCT:
4991 
          self.ex = TransactionServiceException()
4992 
          self.ex.read(iprot)
4993 
        else:
4994 
          iprot.skip(ftype)
4995 
      else:
4996 
        iprot.skip(ftype)
4997 
      iprot.readFieldEnd()
4998 
    iprot.readStructEnd()
4999 
 
5000 
  def write(self, oprot):
5001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5003 
      return
5004 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5005 
    if self.success is not None:
132 ashish 5006 
      oprot.writeFieldBegin('success', TType.I64, 0)
5007 
      oprot.writeI64(self.success)
5008 
      oprot.writeFieldEnd()
3431 rajveer 5009 
    if self.ex is not None:
94 ashish 5010 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5011 
      self.ex.write(oprot)
5012 
      oprot.writeFieldEnd()
5013 
    oprot.writeFieldStop()
5014 
    oprot.writeStructEnd()
5015 
 
3431 rajveer 5016 
  def validate(self):
5017 
    return
5018 
 
5019 
 
94 ashish 5020 
  def __repr__(self):
5021 
    L = ['%s=%r' % (key, value)
5022 
      for key, value in self.__dict__.iteritems()]
5023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5024 
 
5025 
  def __eq__(self, other):
5026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5027 
 
5028 
  def __ne__(self, other):
5029 
    return not (self == other)
5030 
 
5031 
class getTransaction_args:
5032 
  """
5033 
  Attributes:
5034 
   - id
5035 
  """
5036 
 
5037 
  thrift_spec = (
5038 
    None, # 0
5039 
    (1, TType.I64, 'id', None, None, ), # 1
5040 
  )
5041 
 
5042 
  def __init__(self, id=None,):
5043 
    self.id = id
5044 
 
5045 
  def read(self, iprot):
5046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5048 
      return
5049 
    iprot.readStructBegin()
5050 
    while True:
5051 
      (fname, ftype, fid) = iprot.readFieldBegin()
5052 
      if ftype == TType.STOP:
5053 
        break
5054 
      if fid == 1:
5055 
        if ftype == TType.I64:
5056 
          self.id = iprot.readI64();
5057 
        else:
5058 
          iprot.skip(ftype)
5059 
      else:
5060 
        iprot.skip(ftype)
5061 
      iprot.readFieldEnd()
5062 
    iprot.readStructEnd()
5063 
 
5064 
  def write(self, oprot):
5065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5067 
      return
5068 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 5069 
    if self.id is not None:
94 ashish 5070 
      oprot.writeFieldBegin('id', TType.I64, 1)
5071 
      oprot.writeI64(self.id)
5072 
      oprot.writeFieldEnd()
5073 
    oprot.writeFieldStop()
5074 
    oprot.writeStructEnd()
5075 
 
3431 rajveer 5076 
  def validate(self):
5077 
    return
5078 
 
5079 
 
94 ashish 5080 
  def __repr__(self):
5081 
    L = ['%s=%r' % (key, value)
5082 
      for key, value in self.__dict__.iteritems()]
5083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5084 
 
5085 
  def __eq__(self, other):
5086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5087 
 
5088 
  def __ne__(self, other):
5089 
    return not (self == other)
5090 
 
5091 
class getTransaction_result:
5092 
  """
5093 
  Attributes:
5094 
   - success
5095 
   - ex
5096 
  """
5097 
 
5098 
  thrift_spec = (
5099 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
5100 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5101 
  )
5102 
 
5103 
  def __init__(self, success=None, ex=None,):
5104 
    self.success = success
5105 
    self.ex = ex
5106 
 
5107 
  def read(self, iprot):
5108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5110 
      return
5111 
    iprot.readStructBegin()
5112 
    while True:
5113 
      (fname, ftype, fid) = iprot.readFieldBegin()
5114 
      if ftype == TType.STOP:
5115 
        break
5116 
      if fid == 0:
5117 
        if ftype == TType.STRUCT:
5118 
          self.success = Transaction()
5119 
          self.success.read(iprot)
5120 
        else:
5121 
          iprot.skip(ftype)
5122 
      elif fid == 1:
5123 
        if ftype == TType.STRUCT:
5124 
          self.ex = TransactionServiceException()
5125 
          self.ex.read(iprot)
5126 
        else:
5127 
          iprot.skip(ftype)
5128 
      else:
5129 
        iprot.skip(ftype)
5130 
      iprot.readFieldEnd()
5131 
    iprot.readStructEnd()
5132 
 
5133 
  def write(self, oprot):
5134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5136 
      return
5137 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 5138 
    if self.success is not None:
94 ashish 5139 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5140 
      self.success.write(oprot)
5141 
      oprot.writeFieldEnd()
3431 rajveer 5142 
    if self.ex is not None:
94 ashish 5143 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5144 
      self.ex.write(oprot)
5145 
      oprot.writeFieldEnd()
5146 
    oprot.writeFieldStop()
5147 
    oprot.writeStructEnd()
5148 
 
3431 rajveer 5149 
  def validate(self):
5150 
    return
5151 
 
5152 
 
94 ashish 5153 
  def __repr__(self):
5154 
    L = ['%s=%r' % (key, value)
5155 
      for key, value in self.__dict__.iteritems()]
5156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5157 
 
5158 
  def __eq__(self, other):
5159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5160 
 
5161 
  def __ne__(self, other):
5162 
    return not (self == other)
5163 
 
5164 
class getTransactionsForCustomer_args:
5165 
  """
5166 
  Attributes:
5167 
   - customerId
5168 
   - from_date
5169 
   - to_date
5170 
   - status
5171 
  """
5172 
 
5173 
  thrift_spec = (
5174 
    None, # 0
5175 
    (1, TType.I64, 'customerId', None, None, ), # 1
5176 
    (2, TType.I64, 'from_date', None, None, ), # 2
5177 
    (3, TType.I64, 'to_date', None, None, ), # 3
5178 
    (4, TType.I32, 'status', None, None, ), # 4
5179 
  )
5180 
 
5181 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
5182 
    self.customerId = customerId
5183 
    self.from_date = from_date
5184 
    self.to_date = to_date
5185 
    self.status = status
5186 
 
5187 
  def read(self, iprot):
5188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5190 
      return
5191 
    iprot.readStructBegin()
5192 
    while True:
5193 
      (fname, ftype, fid) = iprot.readFieldBegin()
5194 
      if ftype == TType.STOP:
5195 
        break
5196 
      if fid == 1:
5197 
        if ftype == TType.I64:
5198 
          self.customerId = iprot.readI64();
5199 
        else:
5200 
          iprot.skip(ftype)
5201 
      elif fid == 2:
5202 
        if ftype == TType.I64:
5203 
          self.from_date = iprot.readI64();
5204 
        else:
5205 
          iprot.skip(ftype)
5206 
      elif fid == 3:
5207 
        if ftype == TType.I64:
5208 
          self.to_date = iprot.readI64();
5209 
        else:
5210 
          iprot.skip(ftype)
5211 
      elif fid == 4:
5212 
        if ftype == TType.I32:
5213 
          self.status = iprot.readI32();
5214 
        else:
5215 
          iprot.skip(ftype)
5216 
      else:
5217 
        iprot.skip(ftype)
5218 
      iprot.readFieldEnd()
5219 
    iprot.readStructEnd()
5220 
 
5221 
  def write(self, oprot):
5222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5224 
      return
5225 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 5226 
    if self.customerId is not None:
94 ashish 5227 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5228 
      oprot.writeI64(self.customerId)
5229 
      oprot.writeFieldEnd()
3431 rajveer 5230 
    if self.from_date is not None:
94 ashish 5231 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5232 
      oprot.writeI64(self.from_date)
5233 
      oprot.writeFieldEnd()
3431 rajveer 5234 
    if self.to_date is not None:
94 ashish 5235 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5236 
      oprot.writeI64(self.to_date)
5237 
      oprot.writeFieldEnd()
3431 rajveer 5238 
    if self.status is not None:
94 ashish 5239 
      oprot.writeFieldBegin('status', TType.I32, 4)
5240 
      oprot.writeI32(self.status)
5241 
      oprot.writeFieldEnd()
5242 
    oprot.writeFieldStop()
5243 
    oprot.writeStructEnd()
5244 
 
3431 rajveer 5245 
  def validate(self):
5246 
    return
5247 
 
5248 
 
94 ashish 5249 
  def __repr__(self):
5250 
    L = ['%s=%r' % (key, value)
5251 
      for key, value in self.__dict__.iteritems()]
5252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5253 
 
5254 
  def __eq__(self, other):
5255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5256 
 
5257 
  def __ne__(self, other):
5258 
    return not (self == other)
5259 
 
5260 
class getTransactionsForCustomer_result:
5261 
  """
5262 
  Attributes:
5263 
   - success
5264 
   - ex
5265 
  """
5266 
 
5267 
  thrift_spec = (
5268 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5269 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5270 
  )
5271 
 
5272 
  def __init__(self, success=None, ex=None,):
5273 
    self.success = success
5274 
    self.ex = ex
5275 
 
5276 
  def read(self, iprot):
5277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5279 
      return
5280 
    iprot.readStructBegin()
5281 
    while True:
5282 
      (fname, ftype, fid) = iprot.readFieldBegin()
5283 
      if ftype == TType.STOP:
5284 
        break
5285 
      if fid == 0:
5286 
        if ftype == TType.LIST:
5287 
          self.success = []
685 chandransh 5288 
          (_etype17, _size14) = iprot.readListBegin()
5289 
          for _i18 in xrange(_size14):
5290 
            _elem19 = Transaction()
5291 
            _elem19.read(iprot)
5292 
            self.success.append(_elem19)
94 ashish 5293 
          iprot.readListEnd()
5294 
        else:
5295 
          iprot.skip(ftype)
5296 
      elif fid == 1:
5297 
        if ftype == TType.STRUCT:
5298 
          self.ex = TransactionServiceException()
5299 
          self.ex.read(iprot)
5300 
        else:
5301 
          iprot.skip(ftype)
5302 
      else:
5303 
        iprot.skip(ftype)
5304 
      iprot.readFieldEnd()
5305 
    iprot.readStructEnd()
5306 
 
5307 
  def write(self, oprot):
5308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5310 
      return
5311 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 5312 
    if self.success is not None:
94 ashish 5313 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5314 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5315 
      for iter20 in self.success:
5316 
        iter20.write(oprot)
94 ashish 5317 
      oprot.writeListEnd()
5318 
      oprot.writeFieldEnd()
3431 rajveer 5319 
    if self.ex is not None:
94 ashish 5320 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5321 
      self.ex.write(oprot)
5322 
      oprot.writeFieldEnd()
5323 
    oprot.writeFieldStop()
5324 
    oprot.writeStructEnd()
5325 
 
3431 rajveer 5326 
  def validate(self):
5327 
    return
5328 
 
5329 
 
94 ashish 5330 
  def __repr__(self):
5331 
    L = ['%s=%r' % (key, value)
5332 
      for key, value in self.__dict__.iteritems()]
5333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5334 
 
5335 
  def __eq__(self, other):
5336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5337 
 
5338 
  def __ne__(self, other):
5339 
    return not (self == other)
5340 
 
132 ashish 5341 
class getTransactionsForShoppingCartId_args:
5342 
  """
5343 
  Attributes:
5344 
   - shoppingCartId
5345 
  """
5346 
 
5347 
  thrift_spec = (
5348 
    None, # 0
5349 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
5350 
  )
5351 
 
5352 
  def __init__(self, shoppingCartId=None,):
5353 
    self.shoppingCartId = shoppingCartId
5354 
 
5355 
  def read(self, iprot):
5356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5358 
      return
5359 
    iprot.readStructBegin()
5360 
    while True:
5361 
      (fname, ftype, fid) = iprot.readFieldBegin()
5362 
      if ftype == TType.STOP:
5363 
        break
5364 
      if fid == 1:
5365 
        if ftype == TType.I64:
5366 
          self.shoppingCartId = iprot.readI64();
5367 
        else:
5368 
          iprot.skip(ftype)
5369 
      else:
5370 
        iprot.skip(ftype)
5371 
      iprot.readFieldEnd()
5372 
    iprot.readStructEnd()
5373 
 
5374 
  def write(self, oprot):
5375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5377 
      return
5378 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 5379 
    if self.shoppingCartId is not None:
132 ashish 5380 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
5381 
      oprot.writeI64(self.shoppingCartId)
5382 
      oprot.writeFieldEnd()
5383 
    oprot.writeFieldStop()
5384 
    oprot.writeStructEnd()
5385 
 
3431 rajveer 5386 
  def validate(self):
5387 
    return
5388 
 
5389 
 
132 ashish 5390 
  def __repr__(self):
5391 
    L = ['%s=%r' % (key, value)
5392 
      for key, value in self.__dict__.iteritems()]
5393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5394 
 
5395 
  def __eq__(self, other):
5396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5397 
 
5398 
  def __ne__(self, other):
5399 
    return not (self == other)
5400 
 
5401 
class getTransactionsForShoppingCartId_result:
5402 
  """
5403 
  Attributes:
5404 
   - success
5405 
   - ex
5406 
  """
5407 
 
5408 
  thrift_spec = (
5409 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5410 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5411 
  )
5412 
 
5413 
  def __init__(self, success=None, ex=None,):
5414 
    self.success = success
5415 
    self.ex = ex
5416 
 
5417 
  def read(self, iprot):
5418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5420 
      return
5421 
    iprot.readStructBegin()
5422 
    while True:
5423 
      (fname, ftype, fid) = iprot.readFieldBegin()
5424 
      if ftype == TType.STOP:
5425 
        break
5426 
      if fid == 0:
5427 
        if ftype == TType.LIST:
5428 
          self.success = []
685 chandransh 5429 
          (_etype24, _size21) = iprot.readListBegin()
5430 
          for _i25 in xrange(_size21):
5431 
            _elem26 = Transaction()
5432 
            _elem26.read(iprot)
5433 
            self.success.append(_elem26)
132 ashish 5434 
          iprot.readListEnd()
5435 
        else:
5436 
          iprot.skip(ftype)
5437 
      elif fid == 1:
5438 
        if ftype == TType.STRUCT:
5439 
          self.ex = TransactionServiceException()
5440 
          self.ex.read(iprot)
5441 
        else:
5442 
          iprot.skip(ftype)
5443 
      else:
5444 
        iprot.skip(ftype)
5445 
      iprot.readFieldEnd()
5446 
    iprot.readStructEnd()
5447 
 
5448 
  def write(self, oprot):
5449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5451 
      return
5452 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 5453 
    if self.success is not None:
132 ashish 5454 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5455 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5456 
      for iter27 in self.success:
5457 
        iter27.write(oprot)
132 ashish 5458 
      oprot.writeListEnd()
5459 
      oprot.writeFieldEnd()
3431 rajveer 5460 
    if self.ex is not None:
132 ashish 5461 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5462 
      self.ex.write(oprot)
5463 
      oprot.writeFieldEnd()
5464 
    oprot.writeFieldStop()
5465 
    oprot.writeStructEnd()
5466 
 
3431 rajveer 5467 
  def validate(self):
5468 
    return
5469 
 
5470 
 
132 ashish 5471 
  def __repr__(self):
5472 
    L = ['%s=%r' % (key, value)
5473 
      for key, value in self.__dict__.iteritems()]
5474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5475 
 
5476 
  def __eq__(self, other):
5477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5478 
 
5479 
  def __ne__(self, other):
5480 
    return not (self == other)
5481 
 
94 ashish 5482 
class getTransactionStatus_args:
5483 
  """
5484 
  Attributes:
5485 
   - transactionId
5486 
  """
5487 
 
5488 
  thrift_spec = (
5489 
    None, # 0
5490 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5491 
  )
5492 
 
5493 
  def __init__(self, transactionId=None,):
5494 
    self.transactionId = transactionId
5495 
 
5496 
  def read(self, iprot):
5497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5499 
      return
5500 
    iprot.readStructBegin()
5501 
    while True:
5502 
      (fname, ftype, fid) = iprot.readFieldBegin()
5503 
      if ftype == TType.STOP:
5504 
        break
5505 
      if fid == 1:
5506 
        if ftype == TType.I64:
5507 
          self.transactionId = iprot.readI64();
5508 
        else:
5509 
          iprot.skip(ftype)
5510 
      else:
5511 
        iprot.skip(ftype)
5512 
      iprot.readFieldEnd()
5513 
    iprot.readStructEnd()
5514 
 
5515 
  def write(self, oprot):
5516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5518 
      return
5519 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 5520 
    if self.transactionId is not None:
94 ashish 5521 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5522 
      oprot.writeI64(self.transactionId)
5523 
      oprot.writeFieldEnd()
5524 
    oprot.writeFieldStop()
5525 
    oprot.writeStructEnd()
5526 
 
3431 rajveer 5527 
  def validate(self):
5528 
    return
5529 
 
5530 
 
94 ashish 5531 
  def __repr__(self):
5532 
    L = ['%s=%r' % (key, value)
5533 
      for key, value in self.__dict__.iteritems()]
5534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5535 
 
5536 
  def __eq__(self, other):
5537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5538 
 
5539 
  def __ne__(self, other):
5540 
    return not (self == other)
5541 
 
5542 
class getTransactionStatus_result:
5543 
  """
5544 
  Attributes:
5545 
   - success
5546 
   - ex
5547 
  """
5548 
 
5549 
  thrift_spec = (
5550 
    (0, TType.I32, 'success', None, None, ), # 0
5551 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5552 
  )
5553 
 
5554 
  def __init__(self, success=None, ex=None,):
5555 
    self.success = success
5556 
    self.ex = ex
5557 
 
5558 
  def read(self, iprot):
5559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5561 
      return
5562 
    iprot.readStructBegin()
5563 
    while True:
5564 
      (fname, ftype, fid) = iprot.readFieldBegin()
5565 
      if ftype == TType.STOP:
5566 
        break
5567 
      if fid == 0:
5568 
        if ftype == TType.I32:
5569 
          self.success = iprot.readI32();
5570 
        else:
5571 
          iprot.skip(ftype)
5572 
      elif fid == 1:
5573 
        if ftype == TType.STRUCT:
5574 
          self.ex = TransactionServiceException()
5575 
          self.ex.read(iprot)
5576 
        else:
5577 
          iprot.skip(ftype)
5578 
      else:
5579 
        iprot.skip(ftype)
5580 
      iprot.readFieldEnd()
5581 
    iprot.readStructEnd()
5582 
 
5583 
  def write(self, oprot):
5584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5586 
      return
5587 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 5588 
    if self.success is not None:
94 ashish 5589 
      oprot.writeFieldBegin('success', TType.I32, 0)
5590 
      oprot.writeI32(self.success)
5591 
      oprot.writeFieldEnd()
3431 rajveer 5592 
    if self.ex is not None:
94 ashish 5593 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5594 
      self.ex.write(oprot)
5595 
      oprot.writeFieldEnd()
5596 
    oprot.writeFieldStop()
5597 
    oprot.writeStructEnd()
5598 
 
3431 rajveer 5599 
  def validate(self):
5600 
    return
5601 
 
5602 
 
94 ashish 5603 
  def __repr__(self):
5604 
    L = ['%s=%r' % (key, value)
5605 
      for key, value in self.__dict__.iteritems()]
5606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5607 
 
5608 
  def __eq__(self, other):
5609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5610 
 
5611 
  def __ne__(self, other):
5612 
    return not (self == other)
5613 
 
5614 
class changeTransactionStatus_args:
5615 
  """
5616 
  Attributes:
5617 
   - transactionId
5618 
   - status
5619 
   - description
5620 
  """
5621 
 
5622 
  thrift_spec = (
5623 
    None, # 0
5624 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5625 
    (2, TType.I32, 'status', None, None, ), # 2
5626 
    (3, TType.STRING, 'description', None, None, ), # 3
5627 
  )
5628 
 
5629 
  def __init__(self, transactionId=None, status=None, description=None,):
5630 
    self.transactionId = transactionId
5631 
    self.status = status
5632 
    self.description = description
5633 
 
5634 
  def read(self, iprot):
5635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5637 
      return
5638 
    iprot.readStructBegin()
5639 
    while True:
5640 
      (fname, ftype, fid) = iprot.readFieldBegin()
5641 
      if ftype == TType.STOP:
5642 
        break
5643 
      if fid == 1:
5644 
        if ftype == TType.I64:
5645 
          self.transactionId = iprot.readI64();
5646 
        else:
5647 
          iprot.skip(ftype)
5648 
      elif fid == 2:
5649 
        if ftype == TType.I32:
5650 
          self.status = iprot.readI32();
5651 
        else:
5652 
          iprot.skip(ftype)
5653 
      elif fid == 3:
5654 
        if ftype == TType.STRING:
5655 
          self.description = iprot.readString();
5656 
        else:
5657 
          iprot.skip(ftype)
5658 
      else:
5659 
        iprot.skip(ftype)
5660 
      iprot.readFieldEnd()
5661 
    iprot.readStructEnd()
5662 
 
5663 
  def write(self, oprot):
5664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5666 
      return
5667 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 5668 
    if self.transactionId is not None:
94 ashish 5669 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5670 
      oprot.writeI64(self.transactionId)
5671 
      oprot.writeFieldEnd()
3431 rajveer 5672 
    if self.status is not None:
94 ashish 5673 
      oprot.writeFieldBegin('status', TType.I32, 2)
5674 
      oprot.writeI32(self.status)
5675 
      oprot.writeFieldEnd()
3431 rajveer 5676 
    if self.description is not None:
94 ashish 5677 
      oprot.writeFieldBegin('description', TType.STRING, 3)
5678 
      oprot.writeString(self.description)
5679 
      oprot.writeFieldEnd()
5680 
    oprot.writeFieldStop()
5681 
    oprot.writeStructEnd()
5682 
 
3431 rajveer 5683 
  def validate(self):
5684 
    return
5685 
 
5686 
 
94 ashish 5687 
  def __repr__(self):
5688 
    L = ['%s=%r' % (key, value)
5689 
      for key, value in self.__dict__.iteritems()]
5690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5691 
 
5692 
  def __eq__(self, other):
5693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5694 
 
5695 
  def __ne__(self, other):
5696 
    return not (self == other)
5697 
 
5698 
class changeTransactionStatus_result:
5699 
  """
5700 
  Attributes:
5701 
   - success
5702 
   - ex
5703 
  """
5704 
 
5705 
  thrift_spec = (
5706 
    (0, TType.BOOL, 'success', None, None, ), # 0
5707 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5708 
  )
5709 
 
5710 
  def __init__(self, success=None, ex=None,):
5711 
    self.success = success
5712 
    self.ex = ex
5713 
 
5714 
  def read(self, iprot):
5715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5717 
      return
5718 
    iprot.readStructBegin()
5719 
    while True:
5720 
      (fname, ftype, fid) = iprot.readFieldBegin()
5721 
      if ftype == TType.STOP:
5722 
        break
5723 
      if fid == 0:
5724 
        if ftype == TType.BOOL:
5725 
          self.success = iprot.readBool();
5726 
        else:
5727 
          iprot.skip(ftype)
5728 
      elif fid == 1:
5729 
        if ftype == TType.STRUCT:
5730 
          self.ex = TransactionServiceException()
5731 
          self.ex.read(iprot)
5732 
        else:
5733 
          iprot.skip(ftype)
5734 
      else:
5735 
        iprot.skip(ftype)
5736 
      iprot.readFieldEnd()
5737 
    iprot.readStructEnd()
5738 
 
5739 
  def write(self, oprot):
5740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5742 
      return
5743 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 5744 
    if self.success is not None:
94 ashish 5745 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5746 
      oprot.writeBool(self.success)
5747 
      oprot.writeFieldEnd()
3431 rajveer 5748 
    if self.ex is not None:
94 ashish 5749 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5750 
      self.ex.write(oprot)
5751 
      oprot.writeFieldEnd()
5752 
    oprot.writeFieldStop()
5753 
    oprot.writeStructEnd()
5754 
 
3431 rajveer 5755 
  def validate(self):
5756 
    return
5757 
 
5758 
 
94 ashish 5759 
  def __repr__(self):
5760 
    L = ['%s=%r' % (key, value)
5761 
      for key, value in self.__dict__.iteritems()]
5762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5763 
 
5764 
  def __eq__(self, other):
5765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5766 
 
5767 
  def __ne__(self, other):
5768 
    return not (self == other)
5769 
 
1398 varun.gupt 5770 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 5771 
  """
5772 
  Attributes:
5773 
   - transactionId
5774 
  """
5775 
 
5776 
  thrift_spec = (
5777 
    None, # 0
5778 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5779 
  )
5780 
 
5781 
  def __init__(self, transactionId=None,):
5782 
    self.transactionId = transactionId
5783 
 
5784 
  def read(self, iprot):
5785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5787 
      return
5788 
    iprot.readStructBegin()
5789 
    while True:
5790 
      (fname, ftype, fid) = iprot.readFieldBegin()
5791 
      if ftype == TType.STOP:
5792 
        break
5793 
      if fid == 1:
5794 
        if ftype == TType.I64:
5795 
          self.transactionId = iprot.readI64();
5796 
        else:
5797 
          iprot.skip(ftype)
5798 
      else:
5799 
        iprot.skip(ftype)
5800 
      iprot.readFieldEnd()
5801 
    iprot.readStructEnd()
5802 
 
5803 
  def write(self, oprot):
5804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5806 
      return
1398 varun.gupt 5807 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 5808 
    if self.transactionId is not None:
1382 varun.gupt 5809 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5810 
      oprot.writeI64(self.transactionId)
5811 
      oprot.writeFieldEnd()
5812 
    oprot.writeFieldStop()
5813 
    oprot.writeStructEnd()
5814 
 
3431 rajveer 5815 
  def validate(self):
5816 
    return
5817 
 
5818 
 
1382 varun.gupt 5819 
  def __repr__(self):
5820 
    L = ['%s=%r' % (key, value)
5821 
      for key, value in self.__dict__.iteritems()]
5822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5823 
 
5824 
  def __eq__(self, other):
5825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5826 
 
5827 
  def __ne__(self, other):
5828 
    return not (self == other)
5829 
 
1398 varun.gupt 5830 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 5831 
  """
5832 
  Attributes:
5833 
   - success
5834 
   - ex
5835 
  """
5836 
 
5837 
  thrift_spec = (
5838 
    (0, TType.BOOL, 'success', None, None, ), # 0
5839 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5840 
  )
5841 
 
5842 
  def __init__(self, success=None, ex=None,):
5843 
    self.success = success
5844 
    self.ex = ex
5845 
 
5846 
  def read(self, iprot):
5847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5849 
      return
5850 
    iprot.readStructBegin()
5851 
    while True:
5852 
      (fname, ftype, fid) = iprot.readFieldBegin()
5853 
      if ftype == TType.STOP:
5854 
        break
5855 
      if fid == 0:
5856 
        if ftype == TType.BOOL:
5857 
          self.success = iprot.readBool();
5858 
        else:
5859 
          iprot.skip(ftype)
5860 
      elif fid == 1:
5861 
        if ftype == TType.STRUCT:
5862 
          self.ex = TransactionServiceException()
5863 
          self.ex.read(iprot)
5864 
        else:
5865 
          iprot.skip(ftype)
5866 
      else:
5867 
        iprot.skip(ftype)
5868 
      iprot.readFieldEnd()
5869 
    iprot.readStructEnd()
5870 
 
5871 
  def write(self, oprot):
5872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5874 
      return
1398 varun.gupt 5875 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5876 
    if self.success is not None:
1382 varun.gupt 5877 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5878 
      oprot.writeBool(self.success)
5879 
      oprot.writeFieldEnd()
3431 rajveer 5880 
    if self.ex is not None:
1382 varun.gupt 5881 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5882 
      self.ex.write(oprot)
5883 
      oprot.writeFieldEnd()
5884 
    oprot.writeFieldStop()
5885 
    oprot.writeStructEnd()
5886 
 
3431 rajveer 5887 
  def validate(self):
5888 
    return
5889 
 
5890 
 
1382 varun.gupt 5891 
  def __repr__(self):
5892 
    L = ['%s=%r' % (key, value)
5893 
      for key, value in self.__dict__.iteritems()]
5894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5895 
 
5896 
  def __eq__(self, other):
5897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5898 
 
5899 
  def __ne__(self, other):
5900 
    return not (self == other)
5901 
 
483 rajveer 5902 
class getAllOrders_args:
94 ashish 5903 
  """
5904 
  Attributes:
483 rajveer 5905 
   - status
5906 
   - from_date
5907 
   - to_date
5908 
   - warehouse_id
94 ashish 5909 
  """
5910 
 
5911 
  thrift_spec = (
5912 
    None, # 0
483 rajveer 5913 
    (1, TType.I32, 'status', None, None, ), # 1
5914 
    (2, TType.I64, 'from_date', None, None, ), # 2
5915 
    (3, TType.I64, 'to_date', None, None, ), # 3
5916 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5917 
  )
5918 
 
483 rajveer 5919 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5920 
    self.status = status
5921 
    self.from_date = from_date
5922 
    self.to_date = to_date
5923 
    self.warehouse_id = warehouse_id
94 ashish 5924 
 
5925 
  def read(self, iprot):
5926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5928 
      return
5929 
    iprot.readStructBegin()
5930 
    while True:
5931 
      (fname, ftype, fid) = iprot.readFieldBegin()
5932 
      if ftype == TType.STOP:
5933 
        break
5934 
      if fid == 1:
483 rajveer 5935 
        if ftype == TType.I32:
5936 
          self.status = iprot.readI32();
94 ashish 5937 
        else:
5938 
          iprot.skip(ftype)
483 rajveer 5939 
      elif fid == 2:
5940 
        if ftype == TType.I64:
5941 
          self.from_date = iprot.readI64();
94 ashish 5942 
        else:
5943 
          iprot.skip(ftype)
483 rajveer 5944 
      elif fid == 3:
5945 
        if ftype == TType.I64:
5946 
          self.to_date = iprot.readI64();
94 ashish 5947 
        else:
5948 
          iprot.skip(ftype)
483 rajveer 5949 
      elif fid == 4:
94 ashish 5950 
        if ftype == TType.I64:
483 rajveer 5951 
          self.warehouse_id = iprot.readI64();
94 ashish 5952 
        else:
5953 
          iprot.skip(ftype)
5954 
      else:
5955 
        iprot.skip(ftype)
5956 
      iprot.readFieldEnd()
5957 
    iprot.readStructEnd()
5958 
 
5959 
  def write(self, oprot):
5960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5962 
      return
483 rajveer 5963 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5964 
    if self.status is not None:
483 rajveer 5965 
      oprot.writeFieldBegin('status', TType.I32, 1)
5966 
      oprot.writeI32(self.status)
94 ashish 5967 
      oprot.writeFieldEnd()
3431 rajveer 5968 
    if self.from_date is not None:
483 rajveer 5969 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5970 
      oprot.writeI64(self.from_date)
94 ashish 5971 
      oprot.writeFieldEnd()
3431 rajveer 5972 
    if self.to_date is not None:
483 rajveer 5973 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5974 
      oprot.writeI64(self.to_date)
94 ashish 5975 
      oprot.writeFieldEnd()
3431 rajveer 5976 
    if self.warehouse_id is not None:
483 rajveer 5977 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5978 
      oprot.writeI64(self.warehouse_id)
94 ashish 5979 
      oprot.writeFieldEnd()
5980 
    oprot.writeFieldStop()
5981 
    oprot.writeStructEnd()
5982 
 
3431 rajveer 5983 
  def validate(self):
5984 
    return
5985 
 
5986 
 
94 ashish 5987 
  def __repr__(self):
5988 
    L = ['%s=%r' % (key, value)
5989 
      for key, value in self.__dict__.iteritems()]
5990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5991 
 
5992 
  def __eq__(self, other):
5993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5994 
 
5995 
  def __ne__(self, other):
5996 
    return not (self == other)
5997 
 
483 rajveer 5998 
class getAllOrders_result:
94 ashish 5999 
  """
6000 
  Attributes:
6001 
   - success
6002 
   - ex
6003 
  """
6004 
 
6005 
  thrift_spec = (
483 rajveer 6006 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6007 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6008 
  )
6009 
 
6010 
  def __init__(self, success=None, ex=None,):
6011 
    self.success = success
6012 
    self.ex = ex
6013 
 
6014 
  def read(self, iprot):
6015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6017 
      return
6018 
    iprot.readStructBegin()
6019 
    while True:
6020 
      (fname, ftype, fid) = iprot.readFieldBegin()
6021 
      if ftype == TType.STOP:
6022 
        break
6023 
      if fid == 0:
483 rajveer 6024 
        if ftype == TType.LIST:
6025 
          self.success = []
685 chandransh 6026 
          (_etype31, _size28) = iprot.readListBegin()
6027 
          for _i32 in xrange(_size28):
6028 
            _elem33 = Order()
6029 
            _elem33.read(iprot)
6030 
            self.success.append(_elem33)
483 rajveer 6031 
          iprot.readListEnd()
94 ashish 6032 
        else:
6033 
          iprot.skip(ftype)
6034 
      elif fid == 1:
6035 
        if ftype == TType.STRUCT:
6036 
          self.ex = TransactionServiceException()
6037 
          self.ex.read(iprot)
6038 
        else:
6039 
          iprot.skip(ftype)
6040 
      else:
6041 
        iprot.skip(ftype)
6042 
      iprot.readFieldEnd()
6043 
    iprot.readStructEnd()
6044 
 
6045 
  def write(self, oprot):
6046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6048 
      return
483 rajveer 6049 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 6050 
    if self.success is not None:
483 rajveer 6051 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6052 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6053 
      for iter34 in self.success:
6054 
        iter34.write(oprot)
483 rajveer 6055 
      oprot.writeListEnd()
94 ashish 6056 
      oprot.writeFieldEnd()
3431 rajveer 6057 
    if self.ex is not None:
94 ashish 6058 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6059 
      self.ex.write(oprot)
6060 
      oprot.writeFieldEnd()
6061 
    oprot.writeFieldStop()
6062 
    oprot.writeStructEnd()
6063 
 
3431 rajveer 6064 
  def validate(self):
6065 
    return
6066 
 
6067 
 
94 ashish 6068 
  def __repr__(self):
6069 
    L = ['%s=%r' % (key, value)
6070 
      for key, value in self.__dict__.iteritems()]
6071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6072 
 
6073 
  def __eq__(self, other):
6074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6075 
 
6076 
  def __ne__(self, other):
6077 
    return not (self == other)
6078 
 
4133 chandransh 6079 
class getOrdersInBatch_args:
6080 
  """
6081 
  Attributes:
6082 
   - statuses
6083 
   - offset
6084 
   - limit
6085 
   - warehouse_id
6086 
  """
6087 
 
6088 
  thrift_spec = (
6089 
    None, # 0
6090 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6091 
    (2, TType.I64, 'offset', None, None, ), # 2
6092 
    (3, TType.I64, 'limit', None, None, ), # 3
6093 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6094 
  )
6095 
 
6096 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
6097 
    self.statuses = statuses
6098 
    self.offset = offset
6099 
    self.limit = limit
6100 
    self.warehouse_id = warehouse_id
6101 
 
6102 
  def read(self, iprot):
6103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6105 
      return
6106 
    iprot.readStructBegin()
6107 
    while True:
6108 
      (fname, ftype, fid) = iprot.readFieldBegin()
6109 
      if ftype == TType.STOP:
6110 
        break
6111 
      if fid == 1:
6112 
        if ftype == TType.LIST:
6113 
          self.statuses = []
6114 
          (_etype38, _size35) = iprot.readListBegin()
6115 
          for _i39 in xrange(_size35):
6116 
            _elem40 = iprot.readI32();
6117 
            self.statuses.append(_elem40)
6118 
          iprot.readListEnd()
6119 
        else:
6120 
          iprot.skip(ftype)
6121 
      elif fid == 2:
6122 
        if ftype == TType.I64:
6123 
          self.offset = iprot.readI64();
6124 
        else:
6125 
          iprot.skip(ftype)
6126 
      elif fid == 3:
6127 
        if ftype == TType.I64:
6128 
          self.limit = iprot.readI64();
6129 
        else:
6130 
          iprot.skip(ftype)
6131 
      elif fid == 4:
6132 
        if ftype == TType.I64:
6133 
          self.warehouse_id = iprot.readI64();
6134 
        else:
6135 
          iprot.skip(ftype)
6136 
      else:
6137 
        iprot.skip(ftype)
6138 
      iprot.readFieldEnd()
6139 
    iprot.readStructEnd()
6140 
 
6141 
  def write(self, oprot):
6142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6144 
      return
6145 
    oprot.writeStructBegin('getOrdersInBatch_args')
6146 
    if self.statuses is not None:
6147 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6148 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6149 
      for iter41 in self.statuses:
6150 
        oprot.writeI32(iter41)
6151 
      oprot.writeListEnd()
6152 
      oprot.writeFieldEnd()
6153 
    if self.offset is not None:
6154 
      oprot.writeFieldBegin('offset', TType.I64, 2)
6155 
      oprot.writeI64(self.offset)
6156 
      oprot.writeFieldEnd()
6157 
    if self.limit is not None:
6158 
      oprot.writeFieldBegin('limit', TType.I64, 3)
6159 
      oprot.writeI64(self.limit)
6160 
      oprot.writeFieldEnd()
6161 
    if self.warehouse_id is not None:
6162 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6163 
      oprot.writeI64(self.warehouse_id)
6164 
      oprot.writeFieldEnd()
6165 
    oprot.writeFieldStop()
6166 
    oprot.writeStructEnd()
6167 
 
6168 
  def validate(self):
6169 
    return
6170 
 
6171 
 
6172 
  def __repr__(self):
6173 
    L = ['%s=%r' % (key, value)
6174 
      for key, value in self.__dict__.iteritems()]
6175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6176 
 
6177 
  def __eq__(self, other):
6178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6179 
 
6180 
  def __ne__(self, other):
6181 
    return not (self == other)
6182 
 
6183 
class getOrdersInBatch_result:
6184 
  """
6185 
  Attributes:
6186 
   - success
6187 
   - ex
6188 
  """
6189 
 
6190 
  thrift_spec = (
6191 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6192 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6193 
  )
6194 
 
6195 
  def __init__(self, success=None, ex=None,):
6196 
    self.success = success
6197 
    self.ex = ex
6198 
 
6199 
  def read(self, iprot):
6200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6202 
      return
6203 
    iprot.readStructBegin()
6204 
    while True:
6205 
      (fname, ftype, fid) = iprot.readFieldBegin()
6206 
      if ftype == TType.STOP:
6207 
        break
6208 
      if fid == 0:
6209 
        if ftype == TType.LIST:
6210 
          self.success = []
6211 
          (_etype45, _size42) = iprot.readListBegin()
6212 
          for _i46 in xrange(_size42):
6213 
            _elem47 = Order()
6214 
            _elem47.read(iprot)
6215 
            self.success.append(_elem47)
6216 
          iprot.readListEnd()
6217 
        else:
6218 
          iprot.skip(ftype)
6219 
      elif fid == 1:
6220 
        if ftype == TType.STRUCT:
6221 
          self.ex = TransactionServiceException()
6222 
          self.ex.read(iprot)
6223 
        else:
6224 
          iprot.skip(ftype)
6225 
      else:
6226 
        iprot.skip(ftype)
6227 
      iprot.readFieldEnd()
6228 
    iprot.readStructEnd()
6229 
 
6230 
  def write(self, oprot):
6231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6233 
      return
6234 
    oprot.writeStructBegin('getOrdersInBatch_result')
6235 
    if self.success is not None:
6236 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6237 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6238 
      for iter48 in self.success:
6239 
        iter48.write(oprot)
6240 
      oprot.writeListEnd()
6241 
      oprot.writeFieldEnd()
6242 
    if self.ex is not None:
6243 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6244 
      self.ex.write(oprot)
6245 
      oprot.writeFieldEnd()
6246 
    oprot.writeFieldStop()
6247 
    oprot.writeStructEnd()
6248 
 
6249 
  def validate(self):
6250 
    return
6251 
 
6252 
 
6253 
  def __repr__(self):
6254 
    L = ['%s=%r' % (key, value)
6255 
      for key, value in self.__dict__.iteritems()]
6256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6257 
 
6258 
  def __eq__(self, other):
6259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6260 
 
6261 
  def __ne__(self, other):
6262 
    return not (self == other)
6263 
 
6264 
class getOrderCount_args:
6265 
  """
6266 
  Attributes:
6267 
   - statuses
6268 
   - warehouseId
6269 
  """
6270 
 
6271 
  thrift_spec = (
6272 
    None, # 0
6273 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6274 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6275 
  )
6276 
 
6277 
  def __init__(self, statuses=None, warehouseId=None,):
6278 
    self.statuses = statuses
6279 
    self.warehouseId = warehouseId
6280 
 
6281 
  def read(self, iprot):
6282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6284 
      return
6285 
    iprot.readStructBegin()
6286 
    while True:
6287 
      (fname, ftype, fid) = iprot.readFieldBegin()
6288 
      if ftype == TType.STOP:
6289 
        break
6290 
      if fid == 1:
6291 
        if ftype == TType.LIST:
6292 
          self.statuses = []
6293 
          (_etype52, _size49) = iprot.readListBegin()
6294 
          for _i53 in xrange(_size49):
6295 
            _elem54 = iprot.readI32();
6296 
            self.statuses.append(_elem54)
6297 
          iprot.readListEnd()
6298 
        else:
6299 
          iprot.skip(ftype)
6300 
      elif fid == 2:
6301 
        if ftype == TType.I64:
6302 
          self.warehouseId = iprot.readI64();
6303 
        else:
6304 
          iprot.skip(ftype)
6305 
      else:
6306 
        iprot.skip(ftype)
6307 
      iprot.readFieldEnd()
6308 
    iprot.readStructEnd()
6309 
 
6310 
  def write(self, oprot):
6311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6313 
      return
6314 
    oprot.writeStructBegin('getOrderCount_args')
6315 
    if self.statuses is not None:
6316 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6317 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6318 
      for iter55 in self.statuses:
6319 
        oprot.writeI32(iter55)
6320 
      oprot.writeListEnd()
6321 
      oprot.writeFieldEnd()
6322 
    if self.warehouseId is not None:
6323 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6324 
      oprot.writeI64(self.warehouseId)
6325 
      oprot.writeFieldEnd()
6326 
    oprot.writeFieldStop()
6327 
    oprot.writeStructEnd()
6328 
 
6329 
  def validate(self):
6330 
    return
6331 
 
6332 
 
6333 
  def __repr__(self):
6334 
    L = ['%s=%r' % (key, value)
6335 
      for key, value in self.__dict__.iteritems()]
6336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6337 
 
6338 
  def __eq__(self, other):
6339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6340 
 
6341 
  def __ne__(self, other):
6342 
    return not (self == other)
6343 
 
6344 
class getOrderCount_result:
6345 
  """
6346 
  Attributes:
6347 
   - success
6348 
   - ex
6349 
  """
6350 
 
6351 
  thrift_spec = (
6352 
    (0, TType.I32, 'success', None, None, ), # 0
6353 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6354 
  )
6355 
 
6356 
  def __init__(self, success=None, ex=None,):
6357 
    self.success = success
6358 
    self.ex = ex
6359 
 
6360 
  def read(self, iprot):
6361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6363 
      return
6364 
    iprot.readStructBegin()
6365 
    while True:
6366 
      (fname, ftype, fid) = iprot.readFieldBegin()
6367 
      if ftype == TType.STOP:
6368 
        break
6369 
      if fid == 0:
6370 
        if ftype == TType.I32:
6371 
          self.success = iprot.readI32();
6372 
        else:
6373 
          iprot.skip(ftype)
6374 
      elif fid == 1:
6375 
        if ftype == TType.STRUCT:
6376 
          self.ex = TransactionServiceException()
6377 
          self.ex.read(iprot)
6378 
        else:
6379 
          iprot.skip(ftype)
6380 
      else:
6381 
        iprot.skip(ftype)
6382 
      iprot.readFieldEnd()
6383 
    iprot.readStructEnd()
6384 
 
6385 
  def write(self, oprot):
6386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6388 
      return
6389 
    oprot.writeStructBegin('getOrderCount_result')
6390 
    if self.success is not None:
6391 
      oprot.writeFieldBegin('success', TType.I32, 0)
6392 
      oprot.writeI32(self.success)
6393 
      oprot.writeFieldEnd()
6394 
    if self.ex is not None:
6395 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6396 
      self.ex.write(oprot)
6397 
      oprot.writeFieldEnd()
6398 
    oprot.writeFieldStop()
6399 
    oprot.writeStructEnd()
6400 
 
6401 
  def validate(self):
6402 
    return
6403 
 
6404 
 
6405 
  def __repr__(self):
6406 
    L = ['%s=%r' % (key, value)
6407 
      for key, value in self.__dict__.iteritems()]
6408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6409 
 
6410 
  def __eq__(self, other):
6411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6412 
 
6413 
  def __ne__(self, other):
6414 
    return not (self == other)
6415 
 
999 varun.gupt 6416 
class getOrdersByBillingDate_args:
6417 
  """
6418 
  Attributes:
6419 
   - status
6420 
   - start_billing_date
6421 
   - end_billing_date
6422 
   - warehouse_id
6423 
  """
6424 
 
6425 
  thrift_spec = (
6426 
    None, # 0
6427 
    (1, TType.I32, 'status', None, None, ), # 1
6428 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
6429 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
6430 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6431 
  )
6432 
 
6433 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
6434 
    self.status = status
6435 
    self.start_billing_date = start_billing_date
6436 
    self.end_billing_date = end_billing_date
6437 
    self.warehouse_id = warehouse_id
6438 
 
6439 
  def read(self, iprot):
6440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6442 
      return
6443 
    iprot.readStructBegin()
6444 
    while True:
6445 
      (fname, ftype, fid) = iprot.readFieldBegin()
6446 
      if ftype == TType.STOP:
6447 
        break
6448 
      if fid == 1:
6449 
        if ftype == TType.I32:
6450 
          self.status = iprot.readI32();
6451 
        else:
6452 
          iprot.skip(ftype)
6453 
      elif fid == 2:
6454 
        if ftype == TType.I64:
6455 
          self.start_billing_date = iprot.readI64();
6456 
        else:
6457 
          iprot.skip(ftype)
6458 
      elif fid == 3:
6459 
        if ftype == TType.I64:
6460 
          self.end_billing_date = iprot.readI64();
6461 
        else:
6462 
          iprot.skip(ftype)
6463 
      elif fid == 4:
6464 
        if ftype == TType.I64:
6465 
          self.warehouse_id = iprot.readI64();
6466 
        else:
6467 
          iprot.skip(ftype)
6468 
      else:
6469 
        iprot.skip(ftype)
6470 
      iprot.readFieldEnd()
6471 
    iprot.readStructEnd()
6472 
 
6473 
  def write(self, oprot):
6474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6476 
      return
6477 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 6478 
    if self.status is not None:
999 varun.gupt 6479 
      oprot.writeFieldBegin('status', TType.I32, 1)
6480 
      oprot.writeI32(self.status)
6481 
      oprot.writeFieldEnd()
3431 rajveer 6482 
    if self.start_billing_date is not None:
999 varun.gupt 6483 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
6484 
      oprot.writeI64(self.start_billing_date)
6485 
      oprot.writeFieldEnd()
3431 rajveer 6486 
    if self.end_billing_date is not None:
999 varun.gupt 6487 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
6488 
      oprot.writeI64(self.end_billing_date)
6489 
      oprot.writeFieldEnd()
3431 rajveer 6490 
    if self.warehouse_id is not None:
999 varun.gupt 6491 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6492 
      oprot.writeI64(self.warehouse_id)
6493 
      oprot.writeFieldEnd()
6494 
    oprot.writeFieldStop()
6495 
    oprot.writeStructEnd()
6496 
 
3431 rajveer 6497 
  def validate(self):
6498 
    return
6499 
 
6500 
 
999 varun.gupt 6501 
  def __repr__(self):
6502 
    L = ['%s=%r' % (key, value)
6503 
      for key, value in self.__dict__.iteritems()]
6504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6505 
 
6506 
  def __eq__(self, other):
6507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6508 
 
6509 
  def __ne__(self, other):
6510 
    return not (self == other)
6511 
 
6512 
class getOrdersByBillingDate_result:
6513 
  """
6514 
  Attributes:
6515 
   - success
6516 
   - ex
6517 
  """
6518 
 
6519 
  thrift_spec = (
6520 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6521 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6522 
  )
6523 
 
6524 
  def __init__(self, success=None, ex=None,):
6525 
    self.success = success
6526 
    self.ex = ex
6527 
 
6528 
  def read(self, iprot):
6529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6531 
      return
6532 
    iprot.readStructBegin()
6533 
    while True:
6534 
      (fname, ftype, fid) = iprot.readFieldBegin()
6535 
      if ftype == TType.STOP:
6536 
        break
6537 
      if fid == 0:
6538 
        if ftype == TType.LIST:
6539 
          self.success = []
4133 chandransh 6540 
          (_etype59, _size56) = iprot.readListBegin()
6541 
          for _i60 in xrange(_size56):
6542 
            _elem61 = Order()
6543 
            _elem61.read(iprot)
6544 
            self.success.append(_elem61)
999 varun.gupt 6545 
          iprot.readListEnd()
6546 
        else:
6547 
          iprot.skip(ftype)
6548 
      elif fid == 1:
6549 
        if ftype == TType.STRUCT:
6550 
          self.ex = TransactionServiceException()
6551 
          self.ex.read(iprot)
6552 
        else:
6553 
          iprot.skip(ftype)
6554 
      else:
6555 
        iprot.skip(ftype)
6556 
      iprot.readFieldEnd()
6557 
    iprot.readStructEnd()
6558 
 
6559 
  def write(self, oprot):
6560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6562 
      return
6563 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 6564 
    if self.success is not None:
999 varun.gupt 6565 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6566 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6567 
      for iter62 in self.success:
6568 
        iter62.write(oprot)
999 varun.gupt 6569 
      oprot.writeListEnd()
6570 
      oprot.writeFieldEnd()
3431 rajveer 6571 
    if self.ex is not None:
999 varun.gupt 6572 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6573 
      self.ex.write(oprot)
6574 
      oprot.writeFieldEnd()
6575 
    oprot.writeFieldStop()
6576 
    oprot.writeStructEnd()
6577 
 
3431 rajveer 6578 
  def validate(self):
6579 
    return
6580 
 
6581 
 
999 varun.gupt 6582 
  def __repr__(self):
6583 
    L = ['%s=%r' % (key, value)
6584 
      for key, value in self.__dict__.iteritems()]
6585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6586 
 
6587 
  def __eq__(self, other):
6588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6589 
 
6590 
  def __ne__(self, other):
6591 
    return not (self == other)
6592 
 
3427 chandransh 6593 
class getOrdersByShippingDate_args:
6594 
  """
6595 
  Attributes:
6596 
   - fromShippingDate
6597 
   - toShippingDate
6598 
   - providerId
6599 
   - warehouseId
3451 chandransh 6600 
   - cod
3427 chandransh 6601 
  """
6602 
 
6603 
  thrift_spec = (
6604 
    None, # 0
6605 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
6606 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
6607 
    (3, TType.I64, 'providerId', None, None, ), # 3
6608 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 6609 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 6610 
  )
6611 
 
3451 chandransh 6612 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 6613 
    self.fromShippingDate = fromShippingDate
6614 
    self.toShippingDate = toShippingDate
6615 
    self.providerId = providerId
6616 
    self.warehouseId = warehouseId
3451 chandransh 6617 
    self.cod = cod
3427 chandransh 6618 
 
6619 
  def read(self, iprot):
6620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6622 
      return
6623 
    iprot.readStructBegin()
6624 
    while True:
6625 
      (fname, ftype, fid) = iprot.readFieldBegin()
6626 
      if ftype == TType.STOP:
6627 
        break
6628 
      if fid == 1:
6629 
        if ftype == TType.I64:
6630 
          self.fromShippingDate = iprot.readI64();
6631 
        else:
6632 
          iprot.skip(ftype)
6633 
      elif fid == 2:
6634 
        if ftype == TType.I64:
6635 
          self.toShippingDate = iprot.readI64();
6636 
        else:
6637 
          iprot.skip(ftype)
6638 
      elif fid == 3:
6639 
        if ftype == TType.I64:
6640 
          self.providerId = iprot.readI64();
6641 
        else:
6642 
          iprot.skip(ftype)
6643 
      elif fid == 4:
6644 
        if ftype == TType.I64:
6645 
          self.warehouseId = iprot.readI64();
6646 
        else:
6647 
          iprot.skip(ftype)
3451 chandransh 6648 
      elif fid == 5:
6649 
        if ftype == TType.BOOL:
6650 
          self.cod = iprot.readBool();
6651 
        else:
6652 
          iprot.skip(ftype)
3427 chandransh 6653 
      else:
6654 
        iprot.skip(ftype)
6655 
      iprot.readFieldEnd()
6656 
    iprot.readStructEnd()
6657 
 
6658 
  def write(self, oprot):
6659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6661 
      return
6662 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 6663 
    if self.fromShippingDate is not None:
3427 chandransh 6664 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
6665 
      oprot.writeI64(self.fromShippingDate)
6666 
      oprot.writeFieldEnd()
3431 rajveer 6667 
    if self.toShippingDate is not None:
3427 chandransh 6668 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
6669 
      oprot.writeI64(self.toShippingDate)
6670 
      oprot.writeFieldEnd()
3431 rajveer 6671 
    if self.providerId is not None:
3427 chandransh 6672 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
6673 
      oprot.writeI64(self.providerId)
6674 
      oprot.writeFieldEnd()
3431 rajveer 6675 
    if self.warehouseId is not None:
3427 chandransh 6676 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
6677 
      oprot.writeI64(self.warehouseId)
6678 
      oprot.writeFieldEnd()
3451 chandransh 6679 
    if self.cod is not None:
6680 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
6681 
      oprot.writeBool(self.cod)
6682 
      oprot.writeFieldEnd()
3427 chandransh 6683 
    oprot.writeFieldStop()
6684 
    oprot.writeStructEnd()
6685 
 
3431 rajveer 6686 
  def validate(self):
6687 
    return
6688 
 
6689 
 
3427 chandransh 6690 
  def __repr__(self):
6691 
    L = ['%s=%r' % (key, value)
6692 
      for key, value in self.__dict__.iteritems()]
6693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6694 
 
6695 
  def __eq__(self, other):
6696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6697 
 
6698 
  def __ne__(self, other):
6699 
    return not (self == other)
6700 
 
6701 
class getOrdersByShippingDate_result:
6702 
  """
6703 
  Attributes:
6704 
   - success
6705 
   - ex
6706 
  """
6707 
 
6708 
  thrift_spec = (
6709 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6710 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6711 
  )
6712 
 
6713 
  def __init__(self, success=None, ex=None,):
6714 
    self.success = success
6715 
    self.ex = ex
6716 
 
6717 
  def read(self, iprot):
6718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6720 
      return
6721 
    iprot.readStructBegin()
6722 
    while True:
6723 
      (fname, ftype, fid) = iprot.readFieldBegin()
6724 
      if ftype == TType.STOP:
6725 
        break
6726 
      if fid == 0:
6727 
        if ftype == TType.LIST:
6728 
          self.success = []
4133 chandransh 6729 
          (_etype66, _size63) = iprot.readListBegin()
6730 
          for _i67 in xrange(_size63):
6731 
            _elem68 = Order()
6732 
            _elem68.read(iprot)
6733 
            self.success.append(_elem68)
3427 chandransh 6734 
          iprot.readListEnd()
6735 
        else:
6736 
          iprot.skip(ftype)
6737 
      elif fid == 1:
6738 
        if ftype == TType.STRUCT:
6739 
          self.ex = TransactionServiceException()
6740 
          self.ex.read(iprot)
6741 
        else:
6742 
          iprot.skip(ftype)
6743 
      else:
6744 
        iprot.skip(ftype)
6745 
      iprot.readFieldEnd()
6746 
    iprot.readStructEnd()
6747 
 
6748 
  def write(self, oprot):
6749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6751 
      return
6752 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 6753 
    if self.success is not None:
3427 chandransh 6754 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6755 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6756 
      for iter69 in self.success:
6757 
        iter69.write(oprot)
3427 chandransh 6758 
      oprot.writeListEnd()
6759 
      oprot.writeFieldEnd()
3431 rajveer 6760 
    if self.ex is not None:
3427 chandransh 6761 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6762 
      self.ex.write(oprot)
6763 
      oprot.writeFieldEnd()
6764 
    oprot.writeFieldStop()
6765 
    oprot.writeStructEnd()
6766 
 
3431 rajveer 6767 
  def validate(self):
6768 
    return
6769 
 
6770 
 
3427 chandransh 6771 
  def __repr__(self):
6772 
    L = ['%s=%r' % (key, value)
6773 
      for key, value in self.__dict__.iteritems()]
6774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6775 
 
6776 
  def __eq__(self, other):
6777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6778 
 
6779 
  def __ne__(self, other):
6780 
    return not (self == other)
6781 
 
1382 varun.gupt 6782 
class getReturnableOrdersForCustomer_args:
6783 
  """
6784 
  Attributes:
6785 
   - customer_id
6786 
   - limit
6787 
  """
6788 
 
6789 
  thrift_spec = (
6790 
    None, # 0
6791 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6792 
    (2, TType.I64, 'limit', None, None, ), # 2
6793 
  )
6794 
 
6795 
  def __init__(self, customer_id=None, limit=None,):
6796 
    self.customer_id = customer_id
6797 
    self.limit = limit
6798 
 
6799 
  def read(self, iprot):
6800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6802 
      return
6803 
    iprot.readStructBegin()
6804 
    while True:
6805 
      (fname, ftype, fid) = iprot.readFieldBegin()
6806 
      if ftype == TType.STOP:
6807 
        break
6808 
      if fid == 1:
6809 
        if ftype == TType.I64:
6810 
          self.customer_id = iprot.readI64();
6811 
        else:
6812 
          iprot.skip(ftype)
6813 
      elif fid == 2:
6814 
        if ftype == TType.I64:
6815 
          self.limit = iprot.readI64();
6816 
        else:
6817 
          iprot.skip(ftype)
6818 
      else:
6819 
        iprot.skip(ftype)
6820 
      iprot.readFieldEnd()
6821 
    iprot.readStructEnd()
6822 
 
6823 
  def write(self, oprot):
6824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6826 
      return
6827 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 6828 
    if self.customer_id is not None:
1382 varun.gupt 6829 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6830 
      oprot.writeI64(self.customer_id)
6831 
      oprot.writeFieldEnd()
3431 rajveer 6832 
    if self.limit is not None:
1382 varun.gupt 6833 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6834 
      oprot.writeI64(self.limit)
6835 
      oprot.writeFieldEnd()
6836 
    oprot.writeFieldStop()
6837 
    oprot.writeStructEnd()
6838 
 
3431 rajveer 6839 
  def validate(self):
6840 
    return
6841 
 
6842 
 
1382 varun.gupt 6843 
  def __repr__(self):
6844 
    L = ['%s=%r' % (key, value)
6845 
      for key, value in self.__dict__.iteritems()]
6846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6847 
 
6848 
  def __eq__(self, other):
6849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6850 
 
6851 
  def __ne__(self, other):
6852 
    return not (self == other)
6853 
 
6854 
class getReturnableOrdersForCustomer_result:
6855 
  """
6856 
  Attributes:
6857 
   - success
6858 
   - ex
6859 
  """
6860 
 
6861 
  thrift_spec = (
6862 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6863 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6864 
  )
6865 
 
6866 
  def __init__(self, success=None, ex=None,):
6867 
    self.success = success
6868 
    self.ex = ex
6869 
 
6870 
  def read(self, iprot):
6871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6873 
      return
6874 
    iprot.readStructBegin()
6875 
    while True:
6876 
      (fname, ftype, fid) = iprot.readFieldBegin()
6877 
      if ftype == TType.STOP:
6878 
        break
6879 
      if fid == 0:
6880 
        if ftype == TType.LIST:
6881 
          self.success = []
4133 chandransh 6882 
          (_etype73, _size70) = iprot.readListBegin()
6883 
          for _i74 in xrange(_size70):
6884 
            _elem75 = iprot.readI64();
6885 
            self.success.append(_elem75)
1382 varun.gupt 6886 
          iprot.readListEnd()
6887 
        else:
6888 
          iprot.skip(ftype)
6889 
      elif fid == 1:
6890 
        if ftype == TType.STRUCT:
6891 
          self.ex = TransactionServiceException()
6892 
          self.ex.read(iprot)
6893 
        else:
6894 
          iprot.skip(ftype)
6895 
      else:
6896 
        iprot.skip(ftype)
6897 
      iprot.readFieldEnd()
6898 
    iprot.readStructEnd()
6899 
 
6900 
  def write(self, oprot):
6901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6903 
      return
6904 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6905 
    if self.success is not None:
1382 varun.gupt 6906 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6907 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6908 
      for iter76 in self.success:
6909 
        oprot.writeI64(iter76)
1382 varun.gupt 6910 
      oprot.writeListEnd()
6911 
      oprot.writeFieldEnd()
3431 rajveer 6912 
    if self.ex is not None:
1382 varun.gupt 6913 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6914 
      self.ex.write(oprot)
6915 
      oprot.writeFieldEnd()
6916 
    oprot.writeFieldStop()
6917 
    oprot.writeStructEnd()
6918 
 
3431 rajveer 6919 
  def validate(self):
6920 
    return
6921 
 
6922 
 
1382 varun.gupt 6923 
  def __repr__(self):
6924 
    L = ['%s=%r' % (key, value)
6925 
      for key, value in self.__dict__.iteritems()]
6926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6927 
 
6928 
  def __eq__(self, other):
6929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6930 
 
6931 
  def __ne__(self, other):
6932 
    return not (self == other)
6933 
 
6934 
class getCancellableOrdersForCustomer_args:
6935 
  """
6936 
  Attributes:
6937 
   - customer_id
6938 
   - limit
6939 
  """
6940 
 
6941 
  thrift_spec = (
6942 
    None, # 0
6943 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6944 
    (2, TType.I64, 'limit', None, None, ), # 2
6945 
  )
6946 
 
6947 
  def __init__(self, customer_id=None, limit=None,):
6948 
    self.customer_id = customer_id
6949 
    self.limit = limit
6950 
 
6951 
  def read(self, iprot):
6952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6954 
      return
6955 
    iprot.readStructBegin()
6956 
    while True:
6957 
      (fname, ftype, fid) = iprot.readFieldBegin()
6958 
      if ftype == TType.STOP:
6959 
        break
6960 
      if fid == 1:
6961 
        if ftype == TType.I64:
6962 
          self.customer_id = iprot.readI64();
6963 
        else:
6964 
          iprot.skip(ftype)
6965 
      elif fid == 2:
6966 
        if ftype == TType.I64:
6967 
          self.limit = iprot.readI64();
6968 
        else:
6969 
          iprot.skip(ftype)
6970 
      else:
6971 
        iprot.skip(ftype)
6972 
      iprot.readFieldEnd()
6973 
    iprot.readStructEnd()
6974 
 
6975 
  def write(self, oprot):
6976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6978 
      return
6979 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6980 
    if self.customer_id is not None:
1382 varun.gupt 6981 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6982 
      oprot.writeI64(self.customer_id)
6983 
      oprot.writeFieldEnd()
3431 rajveer 6984 
    if self.limit is not None:
1382 varun.gupt 6985 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6986 
      oprot.writeI64(self.limit)
6987 
      oprot.writeFieldEnd()
6988 
    oprot.writeFieldStop()
6989 
    oprot.writeStructEnd()
6990 
 
3431 rajveer 6991 
  def validate(self):
6992 
    return
6993 
 
6994 
 
1382 varun.gupt 6995 
  def __repr__(self):
6996 
    L = ['%s=%r' % (key, value)
6997 
      for key, value in self.__dict__.iteritems()]
6998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6999 
 
7000 
  def __eq__(self, other):
7001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7002 
 
7003 
  def __ne__(self, other):
7004 
    return not (self == other)
7005 
 
7006 
class getCancellableOrdersForCustomer_result:
7007 
  """
7008 
  Attributes:
7009 
   - success
7010 
   - ex
7011 
  """
7012 
 
7013 
  thrift_spec = (
7014 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7015 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7016 
  )
7017 
 
7018 
  def __init__(self, success=None, ex=None,):
7019 
    self.success = success
7020 
    self.ex = ex
7021 
 
7022 
  def read(self, iprot):
7023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7025 
      return
7026 
    iprot.readStructBegin()
7027 
    while True:
7028 
      (fname, ftype, fid) = iprot.readFieldBegin()
7029 
      if ftype == TType.STOP:
7030 
        break
7031 
      if fid == 0:
7032 
        if ftype == TType.LIST:
7033 
          self.success = []
4133 chandransh 7034 
          (_etype80, _size77) = iprot.readListBegin()
7035 
          for _i81 in xrange(_size77):
7036 
            _elem82 = iprot.readI64();
7037 
            self.success.append(_elem82)
1382 varun.gupt 7038 
          iprot.readListEnd()
7039 
        else:
7040 
          iprot.skip(ftype)
7041 
      elif fid == 1:
7042 
        if ftype == TType.STRUCT:
7043 
          self.ex = TransactionServiceException()
7044 
          self.ex.read(iprot)
7045 
        else:
7046 
          iprot.skip(ftype)
7047 
      else:
7048 
        iprot.skip(ftype)
7049 
      iprot.readFieldEnd()
7050 
    iprot.readStructEnd()
7051 
 
7052 
  def write(self, oprot):
7053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7055 
      return
7056 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 7057 
    if self.success is not None:
1382 varun.gupt 7058 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7059 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7060 
      for iter83 in self.success:
7061 
        oprot.writeI64(iter83)
1382 varun.gupt 7062 
      oprot.writeListEnd()
7063 
      oprot.writeFieldEnd()
3431 rajveer 7064 
    if self.ex is not None:
1382 varun.gupt 7065 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7066 
      self.ex.write(oprot)
7067 
      oprot.writeFieldEnd()
7068 
    oprot.writeFieldStop()
7069 
    oprot.writeStructEnd()
7070 
 
3431 rajveer 7071 
  def validate(self):
7072 
    return
7073 
 
7074 
 
1382 varun.gupt 7075 
  def __repr__(self):
7076 
    L = ['%s=%r' % (key, value)
7077 
      for key, value in self.__dict__.iteritems()]
7078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7079 
 
7080 
  def __eq__(self, other):
7081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7082 
 
7083 
  def __ne__(self, other):
7084 
    return not (self == other)
7085 
 
483 rajveer 7086 
class changeOrderStatus_args:
94 ashish 7087 
  """
7088 
  Attributes:
483 rajveer 7089 
   - orderId
7090 
   - status
7091 
   - description
94 ashish 7092 
  """
7093 
 
7094 
  thrift_spec = (
7095 
    None, # 0
483 rajveer 7096 
    (1, TType.I64, 'orderId', None, None, ), # 1
7097 
    (2, TType.I32, 'status', None, None, ), # 2
7098 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 7099 
  )
7100 
 
483 rajveer 7101 
  def __init__(self, orderId=None, status=None, description=None,):
7102 
    self.orderId = orderId
7103 
    self.status = status
7104 
    self.description = description
94 ashish 7105 
 
7106 
  def read(self, iprot):
7107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7109 
      return
7110 
    iprot.readStructBegin()
7111 
    while True:
7112 
      (fname, ftype, fid) = iprot.readFieldBegin()
7113 
      if ftype == TType.STOP:
7114 
        break
7115 
      if fid == 1:
7116 
        if ftype == TType.I64:
483 rajveer 7117 
          self.orderId = iprot.readI64();
94 ashish 7118 
        else:
7119 
          iprot.skip(ftype)
7120 
      elif fid == 2:
483 rajveer 7121 
        if ftype == TType.I32:
7122 
          self.status = iprot.readI32();
94 ashish 7123 
        else:
7124 
          iprot.skip(ftype)
483 rajveer 7125 
      elif fid == 3:
7126 
        if ftype == TType.STRING:
7127 
          self.description = iprot.readString();
7128 
        else:
7129 
          iprot.skip(ftype)
94 ashish 7130 
      else:
7131 
        iprot.skip(ftype)
7132 
      iprot.readFieldEnd()
7133 
    iprot.readStructEnd()
7134 
 
7135 
  def write(self, oprot):
7136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7138 
      return
483 rajveer 7139 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 7140 
    if self.orderId is not None:
483 rajveer 7141 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7142 
      oprot.writeI64(self.orderId)
94 ashish 7143 
      oprot.writeFieldEnd()
3431 rajveer 7144 
    if self.status is not None:
483 rajveer 7145 
      oprot.writeFieldBegin('status', TType.I32, 2)
7146 
      oprot.writeI32(self.status)
94 ashish 7147 
      oprot.writeFieldEnd()
3431 rajveer 7148 
    if self.description is not None:
483 rajveer 7149 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7150 
      oprot.writeString(self.description)
7151 
      oprot.writeFieldEnd()
94 ashish 7152 
    oprot.writeFieldStop()
7153 
    oprot.writeStructEnd()
7154 
 
3431 rajveer 7155 
  def validate(self):
7156 
    return
7157 
 
7158 
 
94 ashish 7159 
  def __repr__(self):
7160 
    L = ['%s=%r' % (key, value)
7161 
      for key, value in self.__dict__.iteritems()]
7162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7163 
 
7164 
  def __eq__(self, other):
7165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7166 
 
7167 
  def __ne__(self, other):
7168 
    return not (self == other)
7169 
 
483 rajveer 7170 
class changeOrderStatus_result:
94 ashish 7171 
  """
7172 
  Attributes:
7173 
   - success
7174 
   - ex
7175 
  """
7176 
 
7177 
  thrift_spec = (
7178 
    (0, TType.BOOL, 'success', None, None, ), # 0
7179 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7180 
  )
7181 
 
7182 
  def __init__(self, success=None, ex=None,):
7183 
    self.success = success
7184 
    self.ex = ex
7185 
 
7186 
  def read(self, iprot):
7187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7189 
      return
7190 
    iprot.readStructBegin()
7191 
    while True:
7192 
      (fname, ftype, fid) = iprot.readFieldBegin()
7193 
      if ftype == TType.STOP:
7194 
        break
7195 
      if fid == 0:
7196 
        if ftype == TType.BOOL:
7197 
          self.success = iprot.readBool();
7198 
        else:
7199 
          iprot.skip(ftype)
7200 
      elif fid == 1:
7201 
        if ftype == TType.STRUCT:
7202 
          self.ex = TransactionServiceException()
7203 
          self.ex.read(iprot)
7204 
        else:
7205 
          iprot.skip(ftype)
7206 
      else:
7207 
        iprot.skip(ftype)
7208 
      iprot.readFieldEnd()
7209 
    iprot.readStructEnd()
7210 
 
7211 
  def write(self, oprot):
7212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7214 
      return
483 rajveer 7215 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 7216 
    if self.success is not None:
94 ashish 7217 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7218 
      oprot.writeBool(self.success)
7219 
      oprot.writeFieldEnd()
3431 rajveer 7220 
    if self.ex is not None:
94 ashish 7221 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7222 
      self.ex.write(oprot)
7223 
      oprot.writeFieldEnd()
7224 
    oprot.writeFieldStop()
7225 
    oprot.writeStructEnd()
7226 
 
3431 rajveer 7227 
  def validate(self):
7228 
    return
7229 
 
7230 
 
94 ashish 7231 
  def __repr__(self):
7232 
    L = ['%s=%r' % (key, value)
7233 
      for key, value in self.__dict__.iteritems()]
7234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7235 
 
7236 
  def __eq__(self, other):
7237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7238 
 
7239 
  def __ne__(self, other):
7240 
    return not (self == other)
7241 
 
3064 chandransh 7242 
class getOrdersForTransaction_args:
494 rajveer 7243 
  """
7244 
  Attributes:
3064 chandransh 7245 
   - transactionId
7246 
   - customerId
494 rajveer 7247 
  """
7248 
 
7249 
  thrift_spec = (
7250 
    None, # 0
3064 chandransh 7251 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7252 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 7253 
  )
7254 
 
3064 chandransh 7255 
  def __init__(self, transactionId=None, customerId=None,):
7256 
    self.transactionId = transactionId
7257 
    self.customerId = customerId
494 rajveer 7258 
 
7259 
  def read(self, iprot):
7260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7262 
      return
7263 
    iprot.readStructBegin()
7264 
    while True:
7265 
      (fname, ftype, fid) = iprot.readFieldBegin()
7266 
      if ftype == TType.STOP:
7267 
        break
7268 
      if fid == 1:
7269 
        if ftype == TType.I64:
3064 chandransh 7270 
          self.transactionId = iprot.readI64();
494 rajveer 7271 
        else:
7272 
          iprot.skip(ftype)
7273 
      elif fid == 2:
3064 chandransh 7274 
        if ftype == TType.I64:
7275 
          self.customerId = iprot.readI64();
494 rajveer 7276 
        else:
7277 
          iprot.skip(ftype)
7278 
      else:
7279 
        iprot.skip(ftype)
7280 
      iprot.readFieldEnd()
7281 
    iprot.readStructEnd()
7282 
 
7283 
  def write(self, oprot):
7284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7286 
      return
3064 chandransh 7287 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 7288 
    if self.transactionId is not None:
3064 chandransh 7289 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7290 
      oprot.writeI64(self.transactionId)
494 rajveer 7291 
      oprot.writeFieldEnd()
3431 rajveer 7292 
    if self.customerId is not None:
3064 chandransh 7293 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
7294 
      oprot.writeI64(self.customerId)
494 rajveer 7295 
      oprot.writeFieldEnd()
7296 
    oprot.writeFieldStop()
7297 
    oprot.writeStructEnd()
7298 
 
3431 rajveer 7299 
  def validate(self):
7300 
    return
7301 
 
7302 
 
494 rajveer 7303 
  def __repr__(self):
7304 
    L = ['%s=%r' % (key, value)
7305 
      for key, value in self.__dict__.iteritems()]
7306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7307 
 
7308 
  def __eq__(self, other):
7309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7310 
 
7311 
  def __ne__(self, other):
7312 
    return not (self == other)
7313 
 
3064 chandransh 7314 
class getOrdersForTransaction_result:
494 rajveer 7315 
  """
7316 
  Attributes:
7317 
   - success
7318 
   - ex
7319 
  """
7320 
 
7321 
  thrift_spec = (
3064 chandransh 7322 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 7323 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7324 
  )
7325 
 
7326 
  def __init__(self, success=None, ex=None,):
7327 
    self.success = success
7328 
    self.ex = ex
7329 
 
7330 
  def read(self, iprot):
7331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7333 
      return
7334 
    iprot.readStructBegin()
7335 
    while True:
7336 
      (fname, ftype, fid) = iprot.readFieldBegin()
7337 
      if ftype == TType.STOP:
7338 
        break
7339 
      if fid == 0:
3064 chandransh 7340 
        if ftype == TType.LIST:
7341 
          self.success = []
4133 chandransh 7342 
          (_etype87, _size84) = iprot.readListBegin()
7343 
          for _i88 in xrange(_size84):
7344 
            _elem89 = Order()
7345 
            _elem89.read(iprot)
7346 
            self.success.append(_elem89)
3064 chandransh 7347 
          iprot.readListEnd()
494 rajveer 7348 
        else:
7349 
          iprot.skip(ftype)
7350 
      elif fid == 1:
7351 
        if ftype == TType.STRUCT:
7352 
          self.ex = TransactionServiceException()
7353 
          self.ex.read(iprot)
7354 
        else:
7355 
          iprot.skip(ftype)
7356 
      else:
7357 
        iprot.skip(ftype)
7358 
      iprot.readFieldEnd()
7359 
    iprot.readStructEnd()
7360 
 
7361 
  def write(self, oprot):
7362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7364 
      return
3064 chandransh 7365 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 7366 
    if self.success is not None:
3064 chandransh 7367 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7368 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7369 
      for iter90 in self.success:
7370 
        iter90.write(oprot)
3064 chandransh 7371 
      oprot.writeListEnd()
494 rajveer 7372 
      oprot.writeFieldEnd()
3431 rajveer 7373 
    if self.ex is not None:
494 rajveer 7374 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7375 
      self.ex.write(oprot)
7376 
      oprot.writeFieldEnd()
7377 
    oprot.writeFieldStop()
7378 
    oprot.writeStructEnd()
7379 
 
3431 rajveer 7380 
  def validate(self):
7381 
    return
7382 
 
7383 
 
494 rajveer 7384 
  def __repr__(self):
7385 
    L = ['%s=%r' % (key, value)
7386 
      for key, value in self.__dict__.iteritems()]
7387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7388 
 
7389 
  def __eq__(self, other):
7390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7391 
 
7392 
  def __ne__(self, other):
7393 
    return not (self == other)
7394 
 
3064 chandransh 7395 
class getOrdersForCustomer_args:
1149 chandransh 7396 
  """
7397 
  Attributes:
3064 chandransh 7398 
   - customerId
7399 
   - from_date
7400 
   - to_date
7401 
   - statuses
1149 chandransh 7402 
  """
7403 
 
7404 
  thrift_spec = (
7405 
    None, # 0
3064 chandransh 7406 
    (1, TType.I64, 'customerId', None, None, ), # 1
7407 
    (2, TType.I64, 'from_date', None, None, ), # 2
7408 
    (3, TType.I64, 'to_date', None, None, ), # 3
7409 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 7410 
  )
7411 
 
3064 chandransh 7412 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
7413 
    self.customerId = customerId
7414 
    self.from_date = from_date
7415 
    self.to_date = to_date
7416 
    self.statuses = statuses
1149 chandransh 7417 
 
7418 
  def read(self, iprot):
7419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7421 
      return
7422 
    iprot.readStructBegin()
7423 
    while True:
7424 
      (fname, ftype, fid) = iprot.readFieldBegin()
7425 
      if ftype == TType.STOP:
7426 
        break
7427 
      if fid == 1:
7428 
        if ftype == TType.I64:
3064 chandransh 7429 
          self.customerId = iprot.readI64();
1149 chandransh 7430 
        else:
7431 
          iprot.skip(ftype)
7432 
      elif fid == 2:
7433 
        if ftype == TType.I64:
3064 chandransh 7434 
          self.from_date = iprot.readI64();
1149 chandransh 7435 
        else:
7436 
          iprot.skip(ftype)
2783 chandransh 7437 
      elif fid == 3:
7438 
        if ftype == TType.I64:
3064 chandransh 7439 
          self.to_date = iprot.readI64();
2783 chandransh 7440 
        else:
7441 
          iprot.skip(ftype)
7442 
      elif fid == 4:
3064 chandransh 7443 
        if ftype == TType.LIST:
7444 
          self.statuses = []
4133 chandransh 7445 
          (_etype94, _size91) = iprot.readListBegin()
7446 
          for _i95 in xrange(_size91):
7447 
            _elem96 = iprot.readI32();
7448 
            self.statuses.append(_elem96)
3064 chandransh 7449 
          iprot.readListEnd()
2783 chandransh 7450 
        else:
7451 
          iprot.skip(ftype)
1149 chandransh 7452 
      else:
7453 
        iprot.skip(ftype)
7454 
      iprot.readFieldEnd()
7455 
    iprot.readStructEnd()
7456 
 
7457 
  def write(self, oprot):
7458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7460 
      return
3064 chandransh 7461 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 7462 
    if self.customerId is not None:
3064 chandransh 7463 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7464 
      oprot.writeI64(self.customerId)
1149 chandransh 7465 
      oprot.writeFieldEnd()
3431 rajveer 7466 
    if self.from_date is not None:
3064 chandransh 7467 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7468 
      oprot.writeI64(self.from_date)
1149 chandransh 7469 
      oprot.writeFieldEnd()
3431 rajveer 7470 
    if self.to_date is not None:
3064 chandransh 7471 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7472 
      oprot.writeI64(self.to_date)
2783 chandransh 7473 
      oprot.writeFieldEnd()
3431 rajveer 7474 
    if self.statuses is not None:
3064 chandransh 7475 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
7476 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 7477 
      for iter97 in self.statuses:
7478 
        oprot.writeI32(iter97)
3064 chandransh 7479 
      oprot.writeListEnd()
2783 chandransh 7480 
      oprot.writeFieldEnd()
1149 chandransh 7481 
    oprot.writeFieldStop()
7482 
    oprot.writeStructEnd()
7483 
 
3431 rajveer 7484 
  def validate(self):
7485 
    return
7486 
 
7487 
 
1149 chandransh 7488 
  def __repr__(self):
7489 
    L = ['%s=%r' % (key, value)
7490 
      for key, value in self.__dict__.iteritems()]
7491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7492 
 
7493 
  def __eq__(self, other):
7494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7495 
 
7496 
  def __ne__(self, other):
7497 
    return not (self == other)
7498 
 
3064 chandransh 7499 
class getOrdersForCustomer_result:
1149 chandransh 7500 
  """
7501 
  Attributes:
7502 
   - success
7503 
   - ex
7504 
  """
7505 
 
7506 
  thrift_spec = (
3064 chandransh 7507 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 7508 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7509 
  )
7510 
 
7511 
  def __init__(self, success=None, ex=None,):
7512 
    self.success = success
7513 
    self.ex = ex
7514 
 
7515 
  def read(self, iprot):
7516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7518 
      return
7519 
    iprot.readStructBegin()
7520 
    while True:
7521 
      (fname, ftype, fid) = iprot.readFieldBegin()
7522 
      if ftype == TType.STOP:
7523 
        break
7524 
      if fid == 0:
3064 chandransh 7525 
        if ftype == TType.LIST:
7526 
          self.success = []
4133 chandransh 7527 
          (_etype101, _size98) = iprot.readListBegin()
7528 
          for _i102 in xrange(_size98):
7529 
            _elem103 = Order()
7530 
            _elem103.read(iprot)
7531 
            self.success.append(_elem103)
3064 chandransh 7532 
          iprot.readListEnd()
1149 chandransh 7533 
        else:
7534 
          iprot.skip(ftype)
7535 
      elif fid == 1:
7536 
        if ftype == TType.STRUCT:
7537 
          self.ex = TransactionServiceException()
7538 
          self.ex.read(iprot)
7539 
        else:
7540 
          iprot.skip(ftype)
7541 
      else:
7542 
        iprot.skip(ftype)
7543 
      iprot.readFieldEnd()
7544 
    iprot.readStructEnd()
7545 
 
7546 
  def write(self, oprot):
7547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7549 
      return
3064 chandransh 7550 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 7551 
    if self.success is not None:
3064 chandransh 7552 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7553 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7554 
      for iter104 in self.success:
7555 
        iter104.write(oprot)
3064 chandransh 7556 
      oprot.writeListEnd()
1149 chandransh 7557 
      oprot.writeFieldEnd()
3431 rajveer 7558 
    if self.ex is not None:
1149 chandransh 7559 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7560 
      self.ex.write(oprot)
7561 
      oprot.writeFieldEnd()
7562 
    oprot.writeFieldStop()
7563 
    oprot.writeStructEnd()
7564 
 
3431 rajveer 7565 
  def validate(self):
7566 
    return
7567 
 
7568 
 
1149 chandransh 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_args:
921 rajveer 7581 
  """
7582 
  Attributes:
3064 chandransh 7583 
   - order
921 rajveer 7584 
  """
7585 
 
7586 
  thrift_spec = (
7587 
    None, # 0
3064 chandransh 7588 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 7589 
  )
7590 
 
3064 chandransh 7591 
  def __init__(self, order=None,):
7592 
    self.order = order
921 rajveer 7593 
 
7594 
  def read(self, iprot):
7595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7597 
      return
7598 
    iprot.readStructBegin()
7599 
    while True:
7600 
      (fname, ftype, fid) = iprot.readFieldBegin()
7601 
      if ftype == TType.STOP:
7602 
        break
7603 
      if fid == 1:
3064 chandransh 7604 
        if ftype == TType.STRUCT:
7605 
          self.order = Order()
7606 
          self.order.read(iprot)
921 rajveer 7607 
        else:
7608 
          iprot.skip(ftype)
7609 
      else:
7610 
        iprot.skip(ftype)
7611 
      iprot.readFieldEnd()
7612 
    iprot.readStructEnd()
7613 
 
7614 
  def write(self, oprot):
7615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7617 
      return
3064 chandransh 7618 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 7619 
    if self.order is not None:
3064 chandransh 7620 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
7621 
      self.order.write(oprot)
921 rajveer 7622 
      oprot.writeFieldEnd()
7623 
    oprot.writeFieldStop()
7624 
    oprot.writeStructEnd()
7625 
 
3431 rajveer 7626 
  def validate(self):
7627 
    return
7628 
 
7629 
 
921 rajveer 7630 
  def __repr__(self):
7631 
    L = ['%s=%r' % (key, value)
7632 
      for key, value in self.__dict__.iteritems()]
7633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7634 
 
7635 
  def __eq__(self, other):
7636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7637 
 
7638 
  def __ne__(self, other):
7639 
    return not (self == other)
7640 
 
3064 chandransh 7641 
class createOrder_result:
921 rajveer 7642 
  """
7643 
  Attributes:
7644 
   - success
7645 
   - ex
7646 
  """
7647 
 
7648 
  thrift_spec = (
3064 chandransh 7649 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 7650 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7651 
  )
7652 
 
7653 
  def __init__(self, success=None, ex=None,):
7654 
    self.success = success
7655 
    self.ex = ex
7656 
 
7657 
  def read(self, iprot):
7658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7660 
      return
7661 
    iprot.readStructBegin()
7662 
    while True:
7663 
      (fname, ftype, fid) = iprot.readFieldBegin()
7664 
      if ftype == TType.STOP:
7665 
        break
7666 
      if fid == 0:
3064 chandransh 7667 
        if ftype == TType.I64:
7668 
          self.success = iprot.readI64();
921 rajveer 7669 
        else:
7670 
          iprot.skip(ftype)
7671 
      elif fid == 1:
7672 
        if ftype == TType.STRUCT:
7673 
          self.ex = TransactionServiceException()
7674 
          self.ex.read(iprot)
7675 
        else:
7676 
          iprot.skip(ftype)
7677 
      else:
7678 
        iprot.skip(ftype)
7679 
      iprot.readFieldEnd()
7680 
    iprot.readStructEnd()
7681 
 
7682 
  def write(self, oprot):
7683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7685 
      return
3064 chandransh 7686 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 7687 
    if self.success is not None:
3064 chandransh 7688 
      oprot.writeFieldBegin('success', TType.I64, 0)
7689 
      oprot.writeI64(self.success)
921 rajveer 7690 
      oprot.writeFieldEnd()
3431 rajveer 7691 
    if self.ex is not None:
921 rajveer 7692 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7693 
      self.ex.write(oprot)
7694 
      oprot.writeFieldEnd()
7695 
    oprot.writeFieldStop()
7696 
    oprot.writeStructEnd()
7697 
 
3431 rajveer 7698 
  def validate(self):
7699 
    return
7700 
 
7701 
 
921 rajveer 7702 
  def __repr__(self):
7703 
    L = ['%s=%r' % (key, value)
7704 
      for key, value in self.__dict__.iteritems()]
7705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7706 
 
7707 
  def __eq__(self, other):
7708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7709 
 
7710 
  def __ne__(self, other):
7711 
    return not (self == other)
7712 
 
3064 chandransh 7713 
class getOrder_args:
921 rajveer 7714 
  """
7715 
  Attributes:
3064 chandransh 7716 
   - id
921 rajveer 7717 
  """
7718 
 
7719 
  thrift_spec = (
7720 
    None, # 0
3064 chandransh 7721 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 7722 
  )
7723 
 
3064 chandransh 7724 
  def __init__(self, id=None,):
7725 
    self.id = id
921 rajveer 7726 
 
7727 
  def read(self, iprot):
7728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7730 
      return
7731 
    iprot.readStructBegin()
7732 
    while True:
7733 
      (fname, ftype, fid) = iprot.readFieldBegin()
7734 
      if ftype == TType.STOP:
7735 
        break
7736 
      if fid == 1:
7737 
        if ftype == TType.I64:
3064 chandransh 7738 
          self.id = iprot.readI64();
921 rajveer 7739 
        else:
7740 
          iprot.skip(ftype)
7741 
      else:
7742 
        iprot.skip(ftype)
7743 
      iprot.readFieldEnd()
7744 
    iprot.readStructEnd()
7745 
 
7746 
  def write(self, oprot):
7747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7749 
      return
3064 chandransh 7750 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 7751 
    if self.id is not None:
3064 chandransh 7752 
      oprot.writeFieldBegin('id', TType.I64, 1)
7753 
      oprot.writeI64(self.id)
921 rajveer 7754 
      oprot.writeFieldEnd()
7755 
    oprot.writeFieldStop()
7756 
    oprot.writeStructEnd()
7757 
 
3431 rajveer 7758 
  def validate(self):
7759 
    return
7760 
 
7761 
 
921 rajveer 7762 
  def __repr__(self):
7763 
    L = ['%s=%r' % (key, value)
7764 
      for key, value in self.__dict__.iteritems()]
7765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7766 
 
7767 
  def __eq__(self, other):
7768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7769 
 
7770 
  def __ne__(self, other):
7771 
    return not (self == other)
7772 
 
3064 chandransh 7773 
class getOrder_result:
921 rajveer 7774 
  """
7775 
  Attributes:
7776 
   - success
7777 
   - ex
7778 
  """
7779 
 
7780 
  thrift_spec = (
3064 chandransh 7781 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 7782 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7783 
  )
7784 
 
7785 
  def __init__(self, success=None, ex=None,):
7786 
    self.success = success
7787 
    self.ex = ex
7788 
 
7789 
  def read(self, iprot):
7790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7792 
      return
7793 
    iprot.readStructBegin()
7794 
    while True:
7795 
      (fname, ftype, fid) = iprot.readFieldBegin()
7796 
      if ftype == TType.STOP:
7797 
        break
7798 
      if fid == 0:
3064 chandransh 7799 
        if ftype == TType.STRUCT:
7800 
          self.success = Order()
7801 
          self.success.read(iprot)
921 rajveer 7802 
        else:
7803 
          iprot.skip(ftype)
7804 
      elif fid == 1:
7805 
        if ftype == TType.STRUCT:
7806 
          self.ex = TransactionServiceException()
7807 
          self.ex.read(iprot)
7808 
        else:
7809 
          iprot.skip(ftype)
7810 
      else:
7811 
        iprot.skip(ftype)
7812 
      iprot.readFieldEnd()
7813 
    iprot.readStructEnd()
7814 
 
7815 
  def write(self, oprot):
7816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7818 
      return
3064 chandransh 7819 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 7820 
    if self.success is not None:
3064 chandransh 7821 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7822 
      self.success.write(oprot)
921 rajveer 7823 
      oprot.writeFieldEnd()
3431 rajveer 7824 
    if self.ex is not None:
921 rajveer 7825 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7826 
      self.ex.write(oprot)
7827 
      oprot.writeFieldEnd()
7828 
    oprot.writeFieldStop()
7829 
    oprot.writeStructEnd()
7830 
 
3431 rajveer 7831 
  def validate(self):
7832 
    return
7833 
 
7834 
 
921 rajveer 7835 
  def __repr__(self):
7836 
    L = ['%s=%r' % (key, value)
7837 
      for key, value in self.__dict__.iteritems()]
7838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7839 
 
7840 
  def __eq__(self, other):
7841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7842 
 
7843 
  def __ne__(self, other):
7844 
    return not (self == other)
7845 
 
3064 chandransh 7846 
class getLineItemsForOrder_args:
94 ashish 7847 
  """
7848 
  Attributes:
3064 chandransh 7849 
   - orderId
94 ashish 7850 
  """
7851 
 
7852 
  thrift_spec = (
7853 
    None, # 0
3064 chandransh 7854 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7855 
  )
7856 
 
3064 chandransh 7857 
  def __init__(self, orderId=None,):
7858 
    self.orderId = orderId
94 ashish 7859 
 
7860 
  def read(self, iprot):
7861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7863 
      return
7864 
    iprot.readStructBegin()
7865 
    while True:
7866 
      (fname, ftype, fid) = iprot.readFieldBegin()
7867 
      if ftype == TType.STOP:
7868 
        break
7869 
      if fid == 1:
7870 
        if ftype == TType.I64:
3064 chandransh 7871 
          self.orderId = iprot.readI64();
94 ashish 7872 
        else:
7873 
          iprot.skip(ftype)
7874 
      else:
7875 
        iprot.skip(ftype)
7876 
      iprot.readFieldEnd()
7877 
    iprot.readStructEnd()
7878 
 
7879 
  def write(self, oprot):
7880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7882 
      return
3064 chandransh 7883 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7884 
    if self.orderId is not None:
3064 chandransh 7885 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7886 
      oprot.writeI64(self.orderId)
94 ashish 7887 
      oprot.writeFieldEnd()
7888 
    oprot.writeFieldStop()
7889 
    oprot.writeStructEnd()
7890 
 
3431 rajveer 7891 
  def validate(self):
7892 
    return
7893 
 
7894 
 
94 ashish 7895 
  def __repr__(self):
7896 
    L = ['%s=%r' % (key, value)
7897 
      for key, value in self.__dict__.iteritems()]
7898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7899 
 
7900 
  def __eq__(self, other):
7901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7902 
 
7903 
  def __ne__(self, other):
7904 
    return not (self == other)
7905 
 
3064 chandransh 7906 
class getLineItemsForOrder_result:
94 ashish 7907 
  """
7908 
  Attributes:
7909 
   - success
7910 
   - ex
7911 
  """
7912 
 
7913 
  thrift_spec = (
3064 chandransh 7914 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7915 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7916 
  )
7917 
 
7918 
  def __init__(self, success=None, ex=None,):
7919 
    self.success = success
7920 
    self.ex = ex
7921 
 
7922 
  def read(self, iprot):
7923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7925 
      return
7926 
    iprot.readStructBegin()
7927 
    while True:
7928 
      (fname, ftype, fid) = iprot.readFieldBegin()
7929 
      if ftype == TType.STOP:
7930 
        break
7931 
      if fid == 0:
483 rajveer 7932 
        if ftype == TType.LIST:
7933 
          self.success = []
4133 chandransh 7934 
          (_etype108, _size105) = iprot.readListBegin()
7935 
          for _i109 in xrange(_size105):
7936 
            _elem110 = LineItem()
7937 
            _elem110.read(iprot)
7938 
            self.success.append(_elem110)
483 rajveer 7939 
          iprot.readListEnd()
94 ashish 7940 
        else:
7941 
          iprot.skip(ftype)
7942 
      elif fid == 1:
7943 
        if ftype == TType.STRUCT:
7944 
          self.ex = TransactionServiceException()
7945 
          self.ex.read(iprot)
7946 
        else:
7947 
          iprot.skip(ftype)
7948 
      else:
7949 
        iprot.skip(ftype)
7950 
      iprot.readFieldEnd()
7951 
    iprot.readStructEnd()
7952 
 
7953 
  def write(self, oprot):
7954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7956 
      return
3064 chandransh 7957 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7958 
    if self.success is not None:
483 rajveer 7959 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7960 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7961 
      for iter111 in self.success:
7962 
        iter111.write(oprot)
483 rajveer 7963 
      oprot.writeListEnd()
94 ashish 7964 
      oprot.writeFieldEnd()
3431 rajveer 7965 
    if self.ex is not None:
94 ashish 7966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7967 
      self.ex.write(oprot)
7968 
      oprot.writeFieldEnd()
7969 
    oprot.writeFieldStop()
7970 
    oprot.writeStructEnd()
7971 
 
3431 rajveer 7972 
  def validate(self):
7973 
    return
7974 
 
7975 
 
94 ashish 7976 
  def __repr__(self):
7977 
    L = ['%s=%r' % (key, value)
7978 
      for key, value in self.__dict__.iteritems()]
7979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7980 
 
7981 
  def __eq__(self, other):
7982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7983 
 
7984 
  def __ne__(self, other):
7985 
    return not (self == other)
7986 
 
3064 chandransh 7987 
class getOrderForCustomer_args:
94 ashish 7988 
  """
7989 
  Attributes:
3064 chandransh 7990 
   - orderId
483 rajveer 7991 
   - customerId
94 ashish 7992 
  """
7993 
 
7994 
  thrift_spec = (
7995 
    None, # 0
3064 chandransh 7996 
    (1, TType.I64, 'orderId', None, None, ), # 1
7997 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7998 
  )
7999 
 
3064 chandransh 8000 
  def __init__(self, orderId=None, customerId=None,):
8001 
    self.orderId = orderId
483 rajveer 8002 
    self.customerId = customerId
94 ashish 8003 
 
8004 
  def read(self, iprot):
8005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8007 
      return
8008 
    iprot.readStructBegin()
8009 
    while True:
8010 
      (fname, ftype, fid) = iprot.readFieldBegin()
8011 
      if ftype == TType.STOP:
8012 
        break
8013 
      if fid == 1:
8014 
        if ftype == TType.I64:
3064 chandransh 8015 
          self.orderId = iprot.readI64();
94 ashish 8016 
        else:
8017 
          iprot.skip(ftype)
8018 
      elif fid == 2:
8019 
        if ftype == TType.I64:
3064 chandransh 8020 
          self.customerId = iprot.readI64();
94 ashish 8021 
        else:
8022 
          iprot.skip(ftype)
8023 
      else:
8024 
        iprot.skip(ftype)
8025 
      iprot.readFieldEnd()
8026 
    iprot.readStructEnd()
8027 
 
8028 
  def write(self, oprot):
8029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8031 
      return
3064 chandransh 8032 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 8033 
    if self.orderId is not None:
3064 chandransh 8034 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8035 
      oprot.writeI64(self.orderId)
8036 
      oprot.writeFieldEnd()
3431 rajveer 8037 
    if self.customerId is not None:
3064 chandransh 8038 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 8039 
      oprot.writeI64(self.customerId)
94 ashish 8040 
      oprot.writeFieldEnd()
8041 
    oprot.writeFieldStop()
8042 
    oprot.writeStructEnd()
8043 
 
3431 rajveer 8044 
  def validate(self):
8045 
    return
8046 
 
8047 
 
94 ashish 8048 
  def __repr__(self):
8049 
    L = ['%s=%r' % (key, value)
8050 
      for key, value in self.__dict__.iteritems()]
8051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8052 
 
8053 
  def __eq__(self, other):
8054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8055 
 
8056 
  def __ne__(self, other):
8057 
    return not (self == other)
8058 
 
3064 chandransh 8059 
class getOrderForCustomer_result:
94 ashish 8060 
  """
8061 
  Attributes:
8062 
   - success
8063 
   - ex
8064 
  """
8065 
 
8066 
  thrift_spec = (
3064 chandransh 8067 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 8068 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8069 
  )
8070 
 
8071 
  def __init__(self, success=None, ex=None,):
8072 
    self.success = success
8073 
    self.ex = ex
8074 
 
8075 
  def read(self, iprot):
8076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8078 
      return
8079 
    iprot.readStructBegin()
8080 
    while True:
8081 
      (fname, ftype, fid) = iprot.readFieldBegin()
8082 
      if ftype == TType.STOP:
8083 
        break
8084 
      if fid == 0:
3064 chandransh 8085 
        if ftype == TType.STRUCT:
8086 
          self.success = Order()
8087 
          self.success.read(iprot)
94 ashish 8088 
        else:
8089 
          iprot.skip(ftype)
8090 
      elif fid == 1:
8091 
        if ftype == TType.STRUCT:
8092 
          self.ex = TransactionServiceException()
8093 
          self.ex.read(iprot)
8094 
        else:
8095 
          iprot.skip(ftype)
8096 
      else:
8097 
        iprot.skip(ftype)
8098 
      iprot.readFieldEnd()
8099 
    iprot.readStructEnd()
8100 
 
8101 
  def write(self, oprot):
8102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8104 
      return
3064 chandransh 8105 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 8106 
    if self.success is not None:
3064 chandransh 8107 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8108 
      self.success.write(oprot)
94 ashish 8109 
      oprot.writeFieldEnd()
3431 rajveer 8110 
    if self.ex is not None:
94 ashish 8111 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8112 
      self.ex.write(oprot)
8113 
      oprot.writeFieldEnd()
8114 
    oprot.writeFieldStop()
8115 
    oprot.writeStructEnd()
8116 
 
3431 rajveer 8117 
  def validate(self):
8118 
    return
8119 
 
8120 
 
94 ashish 8121 
  def __repr__(self):
8122 
    L = ['%s=%r' % (key, value)
8123 
      for key, value in self.__dict__.iteritems()]
8124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8125 
 
8126 
  def __eq__(self, other):
8127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8128 
 
8129 
  def __ne__(self, other):
8130 
    return not (self == other)
8131 
 
3064 chandransh 8132 
class getAlerts_args:
94 ashish 8133 
  """
8134 
  Attributes:
4394 rajveer 8135 
   - type
4444 rajveer 8136 
   - warehouseId
4394 rajveer 8137 
   - status
8138 
   - timestamp
94 ashish 8139 
  """
8140 
 
8141 
  thrift_spec = (
8142 
    None, # 0
4394 rajveer 8143 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8144 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8145 
    (3, TType.I64, 'status', None, None, ), # 3
8146 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 8147 
  )
8148 
 
4444 rajveer 8149 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 8150 
    self.type = type
4444 rajveer 8151 
    self.warehouseId = warehouseId
4394 rajveer 8152 
    self.status = status
8153 
    self.timestamp = timestamp
94 ashish 8154 
 
8155 
  def read(self, iprot):
8156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8158 
      return
8159 
    iprot.readStructBegin()
8160 
    while True:
8161 
      (fname, ftype, fid) = iprot.readFieldBegin()
8162 
      if ftype == TType.STOP:
8163 
        break
8164 
      if fid == 1:
3064 chandransh 8165 
        if ftype == TType.I64:
4394 rajveer 8166 
          self.type = iprot.readI64();
94 ashish 8167 
        else:
8168 
          iprot.skip(ftype)
3064 chandransh 8169 
      elif fid == 2:
4394 rajveer 8170 
        if ftype == TType.I64:
4444 rajveer 8171 
          self.warehouseId = iprot.readI64();
3064 chandransh 8172 
        else:
8173 
          iprot.skip(ftype)
4394 rajveer 8174 
      elif fid == 3:
8175 
        if ftype == TType.I64:
4444 rajveer 8176 
          self.status = iprot.readI64();
8177 
        else:
8178 
          iprot.skip(ftype)
8179 
      elif fid == 4:
8180 
        if ftype == TType.I64:
4394 rajveer 8181 
          self.timestamp = iprot.readI64();
8182 
        else:
8183 
          iprot.skip(ftype)
94 ashish 8184 
      else:
8185 
        iprot.skip(ftype)
8186 
      iprot.readFieldEnd()
8187 
    iprot.readStructEnd()
8188 
 
8189 
  def write(self, oprot):
8190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8192 
      return
3064 chandransh 8193 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 8194 
    if self.type is not None:
8195 
      oprot.writeFieldBegin('type', TType.I64, 1)
8196 
      oprot.writeI64(self.type)
94 ashish 8197 
      oprot.writeFieldEnd()
4444 rajveer 8198 
    if self.warehouseId is not None:
8199 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8200 
      oprot.writeI64(self.warehouseId)
8201 
      oprot.writeFieldEnd()
4394 rajveer 8202 
    if self.status is not None:
4444 rajveer 8203 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 8204 
      oprot.writeI64(self.status)
3064 chandransh 8205 
      oprot.writeFieldEnd()
4394 rajveer 8206 
    if self.timestamp is not None:
4444 rajveer 8207 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 8208 
      oprot.writeI64(self.timestamp)
8209 
      oprot.writeFieldEnd()
94 ashish 8210 
    oprot.writeFieldStop()
8211 
    oprot.writeStructEnd()
8212 
 
3431 rajveer 8213 
  def validate(self):
8214 
    return
8215 
 
8216 
 
94 ashish 8217 
  def __repr__(self):
8218 
    L = ['%s=%r' % (key, value)
8219 
      for key, value in self.__dict__.iteritems()]
8220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8221 
 
8222 
  def __eq__(self, other):
8223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8224 
 
8225 
  def __ne__(self, other):
8226 
    return not (self == other)
8227 
 
3064 chandransh 8228 
class getAlerts_result:
94 ashish 8229 
  """
8230 
  Attributes:
8231 
   - success
8232 
  """
8233 
 
8234 
  thrift_spec = (
3064 chandransh 8235 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 8236 
  )
8237 
 
3064 chandransh 8238 
  def __init__(self, success=None,):
94 ashish 8239 
    self.success = success
8240 
 
8241 
  def read(self, iprot):
8242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8244 
      return
8245 
    iprot.readStructBegin()
8246 
    while True:
8247 
      (fname, ftype, fid) = iprot.readFieldBegin()
8248 
      if ftype == TType.STOP:
8249 
        break
8250 
      if fid == 0:
3064 chandransh 8251 
        if ftype == TType.LIST:
8252 
          self.success = []
4133 chandransh 8253 
          (_etype115, _size112) = iprot.readListBegin()
8254 
          for _i116 in xrange(_size112):
8255 
            _elem117 = Alert()
8256 
            _elem117.read(iprot)
8257 
            self.success.append(_elem117)
3064 chandransh 8258 
          iprot.readListEnd()
94 ashish 8259 
        else:
8260 
          iprot.skip(ftype)
8261 
      else:
8262 
        iprot.skip(ftype)
8263 
      iprot.readFieldEnd()
8264 
    iprot.readStructEnd()
8265 
 
8266 
  def write(self, oprot):
8267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8269 
      return
3064 chandransh 8270 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 8271 
    if self.success is not None:
3064 chandransh 8272 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8273 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8274 
      for iter118 in self.success:
8275 
        iter118.write(oprot)
3064 chandransh 8276 
      oprot.writeListEnd()
94 ashish 8277 
      oprot.writeFieldEnd()
8278 
    oprot.writeFieldStop()
8279 
    oprot.writeStructEnd()
8280 
 
3431 rajveer 8281 
  def validate(self):
8282 
    return
8283 
 
8284 
 
94 ashish 8285 
  def __repr__(self):
8286 
    L = ['%s=%r' % (key, value)
8287 
      for key, value in self.__dict__.iteritems()]
8288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8289 
 
8290 
  def __eq__(self, other):
8291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8292 
 
8293 
  def __ne__(self, other):
8294 
    return not (self == other)
8295 
 
4394 rajveer 8296 
class addAlert_args:
94 ashish 8297 
  """
8298 
  Attributes:
3064 chandransh 8299 
   - type
4444 rajveer 8300 
   - warehouseId
4394 rajveer 8301 
   - description
94 ashish 8302 
  """
8303 
 
8304 
  thrift_spec = (
8305 
    None, # 0
4394 rajveer 8306 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8307 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8308 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8309 
  )
8310 
 
4444 rajveer 8311 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 8312 
    self.type = type
4444 rajveer 8313 
    self.warehouseId = warehouseId
4394 rajveer 8314 
    self.description = description
94 ashish 8315 
 
8316 
  def read(self, iprot):
8317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8319 
      return
8320 
    iprot.readStructBegin()
8321 
    while True:
8322 
      (fname, ftype, fid) = iprot.readFieldBegin()
8323 
      if ftype == TType.STOP:
8324 
        break
8325 
      if fid == 1:
8326 
        if ftype == TType.I64:
4394 rajveer 8327 
          self.type = iprot.readI64();
94 ashish 8328 
        else:
8329 
          iprot.skip(ftype)
3064 chandransh 8330 
      elif fid == 2:
4444 rajveer 8331 
        if ftype == TType.I64:
8332 
          self.warehouseId = iprot.readI64();
8333 
        else:
8334 
          iprot.skip(ftype)
8335 
      elif fid == 3:
3064 chandransh 8336 
        if ftype == TType.STRING:
4394 rajveer 8337 
          self.description = iprot.readString();
3064 chandransh 8338 
        else:
8339 
          iprot.skip(ftype)
94 ashish 8340 
      else:
8341 
        iprot.skip(ftype)
8342 
      iprot.readFieldEnd()
8343 
    iprot.readStructEnd()
8344 
 
8345 
  def write(self, oprot):
8346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8348 
      return
4394 rajveer 8349 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 8350 
    if self.type is not None:
4394 rajveer 8351 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 8352 
      oprot.writeI64(self.type)
8353 
      oprot.writeFieldEnd()
4444 rajveer 8354 
    if self.warehouseId is not None:
8355 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8356 
      oprot.writeI64(self.warehouseId)
8357 
      oprot.writeFieldEnd()
4394 rajveer 8358 
    if self.description is not None:
4444 rajveer 8359 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 8360 
      oprot.writeString(self.description)
3064 chandransh 8361 
      oprot.writeFieldEnd()
94 ashish 8362 
    oprot.writeFieldStop()
8363 
    oprot.writeStructEnd()
8364 
 
3431 rajveer 8365 
  def validate(self):
8366 
    return
8367 
 
8368 
 
94 ashish 8369 
  def __repr__(self):
8370 
    L = ['%s=%r' % (key, value)
8371 
      for key, value in self.__dict__.iteritems()]
8372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8373 
 
8374 
  def __eq__(self, other):
8375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8376 
 
8377 
  def __ne__(self, other):
8378 
    return not (self == other)
8379 
 
4394 rajveer 8380 
class addAlert_result:
3064 chandransh 8381 
 
8382 
  thrift_spec = (
8383 
  )
8384 
 
8385 
  def read(self, iprot):
8386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8388 
      return
8389 
    iprot.readStructBegin()
8390 
    while True:
8391 
      (fname, ftype, fid) = iprot.readFieldBegin()
8392 
      if ftype == TType.STOP:
8393 
        break
8394 
      else:
8395 
        iprot.skip(ftype)
8396 
      iprot.readFieldEnd()
8397 
    iprot.readStructEnd()
8398 
 
8399 
  def write(self, oprot):
8400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8402 
      return
4394 rajveer 8403 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 8404 
    oprot.writeFieldStop()
8405 
    oprot.writeStructEnd()
8406 
 
3431 rajveer 8407 
  def validate(self):
8408 
    return
8409 
 
8410 
 
3064 chandransh 8411 
  def __repr__(self):
8412 
    L = ['%s=%r' % (key, value)
8413 
      for key, value in self.__dict__.iteritems()]
8414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8415 
 
8416 
  def __eq__(self, other):
8417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8418 
 
8419 
  def __ne__(self, other):
8420 
    return not (self == other)
8421 
 
4444 rajveer 8422 
class markAlertsAsSeen_args:
8423 
  """
8424 
  Attributes:
8425 
   - warehouseId
8426 
  """
8427 
 
8428 
  thrift_spec = (
8429 
    None, # 0
8430 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8431 
  )
8432 
 
8433 
  def __init__(self, warehouseId=None,):
8434 
    self.warehouseId = warehouseId
8435 
 
8436 
  def read(self, iprot):
8437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8439 
      return
8440 
    iprot.readStructBegin()
8441 
    while True:
8442 
      (fname, ftype, fid) = iprot.readFieldBegin()
8443 
      if ftype == TType.STOP:
8444 
        break
8445 
      if fid == 1:
8446 
        if ftype == TType.I64:
8447 
          self.warehouseId = iprot.readI64();
8448 
        else:
8449 
          iprot.skip(ftype)
8450 
      else:
8451 
        iprot.skip(ftype)
8452 
      iprot.readFieldEnd()
8453 
    iprot.readStructEnd()
8454 
 
8455 
  def write(self, oprot):
8456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8458 
      return
8459 
    oprot.writeStructBegin('markAlertsAsSeen_args')
8460 
    if self.warehouseId is not None:
8461 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8462 
      oprot.writeI64(self.warehouseId)
8463 
      oprot.writeFieldEnd()
8464 
    oprot.writeFieldStop()
8465 
    oprot.writeStructEnd()
8466 
 
8467 
  def validate(self):
8468 
    return
8469 
 
8470 
 
8471 
  def __repr__(self):
8472 
    L = ['%s=%r' % (key, value)
8473 
      for key, value in self.__dict__.iteritems()]
8474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8475 
 
8476 
  def __eq__(self, other):
8477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8478 
 
8479 
  def __ne__(self, other):
8480 
    return not (self == other)
8481 
 
8482 
class markAlertsAsSeen_result:
8483 
 
8484 
  thrift_spec = (
8485 
  )
8486 
 
8487 
  def read(self, iprot):
8488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8490 
      return
8491 
    iprot.readStructBegin()
8492 
    while True:
8493 
      (fname, ftype, fid) = iprot.readFieldBegin()
8494 
      if ftype == TType.STOP:
8495 
        break
8496 
      else:
8497 
        iprot.skip(ftype)
8498 
      iprot.readFieldEnd()
8499 
    iprot.readStructEnd()
8500 
 
8501 
  def write(self, oprot):
8502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8504 
      return
8505 
    oprot.writeStructBegin('markAlertsAsSeen_result')
8506 
    oprot.writeFieldStop()
8507 
    oprot.writeStructEnd()
8508 
 
8509 
  def validate(self):
8510 
    return
8511 
 
8512 
 
8513 
  def __repr__(self):
8514 
    L = ['%s=%r' % (key, value)
8515 
      for key, value in self.__dict__.iteritems()]
8516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8517 
 
8518 
  def __eq__(self, other):
8519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8520 
 
8521 
  def __ne__(self, other):
8522 
    return not (self == other)
8523 
 
3064 chandransh 8524 
class getValidOrderCount_args:
8525 
 
8526 
  thrift_spec = (
8527 
  )
8528 
 
8529 
  def read(self, iprot):
8530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8532 
      return
8533 
    iprot.readStructBegin()
8534 
    while True:
8535 
      (fname, ftype, fid) = iprot.readFieldBegin()
8536 
      if ftype == TType.STOP:
8537 
        break
8538 
      else:
8539 
        iprot.skip(ftype)
8540 
      iprot.readFieldEnd()
8541 
    iprot.readStructEnd()
8542 
 
8543 
  def write(self, oprot):
8544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8546 
      return
8547 
    oprot.writeStructBegin('getValidOrderCount_args')
8548 
    oprot.writeFieldStop()
8549 
    oprot.writeStructEnd()
8550 
 
3431 rajveer 8551 
  def validate(self):
8552 
    return
8553 
 
8554 
 
3064 chandransh 8555 
  def __repr__(self):
8556 
    L = ['%s=%r' % (key, value)
8557 
      for key, value in self.__dict__.iteritems()]
8558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8559 
 
8560 
  def __eq__(self, other):
8561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8562 
 
8563 
  def __ne__(self, other):
8564 
    return not (self == other)
8565 
 
8566 
class getValidOrderCount_result:
94 ashish 8567 
  """
8568 
  Attributes:
8569 
   - success
8570 
  """
8571 
 
8572 
  thrift_spec = (
3064 chandransh 8573 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8574 
  )
8575 
 
3064 chandransh 8576 
  def __init__(self, success=None,):
94 ashish 8577 
    self.success = success
8578 
 
8579 
  def read(self, iprot):
8580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8582 
      return
8583 
    iprot.readStructBegin()
8584 
    while True:
8585 
      (fname, ftype, fid) = iprot.readFieldBegin()
8586 
      if ftype == TType.STOP:
8587 
        break
8588 
      if fid == 0:
3064 chandransh 8589 
        if ftype == TType.I64:
8590 
          self.success = iprot.readI64();
94 ashish 8591 
        else:
8592 
          iprot.skip(ftype)
8593 
      else:
8594 
        iprot.skip(ftype)
8595 
      iprot.readFieldEnd()
8596 
    iprot.readStructEnd()
8597 
 
8598 
  def write(self, oprot):
8599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8601 
      return
3064 chandransh 8602 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 8603 
    if self.success is not None:
3064 chandransh 8604 
      oprot.writeFieldBegin('success', TType.I64, 0)
8605 
      oprot.writeI64(self.success)
94 ashish 8606 
      oprot.writeFieldEnd()
8607 
    oprot.writeFieldStop()
8608 
    oprot.writeStructEnd()
8609 
 
3431 rajveer 8610 
  def validate(self):
8611 
    return
8612 
 
8613 
 
94 ashish 8614 
  def __repr__(self):
8615 
    L = ['%s=%r' % (key, value)
8616 
      for key, value in self.__dict__.iteritems()]
8617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8618 
 
8619 
  def __eq__(self, other):
8620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8621 
 
8622 
  def __ne__(self, other):
8623 
    return not (self == other)
8624 
 
3064 chandransh 8625 
class getNoOfCustomersWithSuccessfulTransaction_args:
8626 
 
8627 
  thrift_spec = (
8628 
  )
8629 
 
8630 
  def read(self, iprot):
8631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8633 
      return
8634 
    iprot.readStructBegin()
8635 
    while True:
8636 
      (fname, ftype, fid) = iprot.readFieldBegin()
8637 
      if ftype == TType.STOP:
8638 
        break
8639 
      else:
8640 
        iprot.skip(ftype)
8641 
      iprot.readFieldEnd()
8642 
    iprot.readStructEnd()
8643 
 
8644 
  def write(self, oprot):
8645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8647 
      return
8648 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
8649 
    oprot.writeFieldStop()
8650 
    oprot.writeStructEnd()
8651 
 
3431 rajveer 8652 
  def validate(self):
8653 
    return
8654 
 
8655 
 
3064 chandransh 8656 
  def __repr__(self):
8657 
    L = ['%s=%r' % (key, value)
8658 
      for key, value in self.__dict__.iteritems()]
8659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8660 
 
8661 
  def __eq__(self, other):
8662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8663 
 
8664 
  def __ne__(self, other):
8665 
    return not (self == other)
8666 
 
8667 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 8668 
  """
8669 
  Attributes:
3064 chandransh 8670 
   - success
94 ashish 8671 
  """
8672 
 
8673 
  thrift_spec = (
3064 chandransh 8674 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8675 
  )
8676 
 
3064 chandransh 8677 
  def __init__(self, success=None,):
8678 
    self.success = success
94 ashish 8679 
 
8680 
  def read(self, iprot):
8681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8683 
      return
8684 
    iprot.readStructBegin()
8685 
    while True:
8686 
      (fname, ftype, fid) = iprot.readFieldBegin()
8687 
      if ftype == TType.STOP:
8688 
        break
3064 chandransh 8689 
      if fid == 0:
94 ashish 8690 
        if ftype == TType.I64:
3064 chandransh 8691 
          self.success = iprot.readI64();
94 ashish 8692 
        else:
8693 
          iprot.skip(ftype)
8694 
      else:
8695 
        iprot.skip(ftype)
8696 
      iprot.readFieldEnd()
8697 
    iprot.readStructEnd()
8698 
 
8699 
  def write(self, oprot):
8700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8702 
      return
3064 chandransh 8703 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 8704 
    if self.success is not None:
3064 chandransh 8705 
      oprot.writeFieldBegin('success', TType.I64, 0)
8706 
      oprot.writeI64(self.success)
94 ashish 8707 
      oprot.writeFieldEnd()
8708 
    oprot.writeFieldStop()
8709 
    oprot.writeStructEnd()
8710 
 
3431 rajveer 8711 
  def validate(self):
8712 
    return
8713 
 
8714 
 
94 ashish 8715 
  def __repr__(self):
8716 
    L = ['%s=%r' % (key, value)
8717 
      for key, value in self.__dict__.iteritems()]
8718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8719 
 
8720 
  def __eq__(self, other):
8721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8722 
 
8723 
  def __ne__(self, other):
8724 
    return not (self == other)
8725 
 
3064 chandransh 8726 
class getValidOrdersAmountRange_args:
8727 
 
8728 
  thrift_spec = (
8729 
  )
8730 
 
8731 
  def read(self, iprot):
8732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8734 
      return
8735 
    iprot.readStructBegin()
8736 
    while True:
8737 
      (fname, ftype, fid) = iprot.readFieldBegin()
8738 
      if ftype == TType.STOP:
8739 
        break
8740 
      else:
8741 
        iprot.skip(ftype)
8742 
      iprot.readFieldEnd()
8743 
    iprot.readStructEnd()
8744 
 
8745 
  def write(self, oprot):
8746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8748 
      return
8749 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
8750 
    oprot.writeFieldStop()
8751 
    oprot.writeStructEnd()
8752 
 
3431 rajveer 8753 
  def validate(self):
8754 
    return
8755 
 
8756 
 
3064 chandransh 8757 
  def __repr__(self):
8758 
    L = ['%s=%r' % (key, value)
8759 
      for key, value in self.__dict__.iteritems()]
8760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8761 
 
8762 
  def __eq__(self, other):
8763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8764 
 
8765 
  def __ne__(self, other):
8766 
    return not (self == other)
8767 
 
8768 
class getValidOrdersAmountRange_result:
94 ashish 8769 
  """
8770 
  Attributes:
8771 
   - success
8772 
  """
8773 
 
8774 
  thrift_spec = (
3064 chandransh 8775 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 8776 
  )
8777 
 
3064 chandransh 8778 
  def __init__(self, success=None,):
94 ashish 8779 
    self.success = success
8780 
 
8781 
  def read(self, iprot):
8782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8784 
      return
8785 
    iprot.readStructBegin()
8786 
    while True:
8787 
      (fname, ftype, fid) = iprot.readFieldBegin()
8788 
      if ftype == TType.STOP:
8789 
        break
8790 
      if fid == 0:
483 rajveer 8791 
        if ftype == TType.LIST:
8792 
          self.success = []
4133 chandransh 8793 
          (_etype122, _size119) = iprot.readListBegin()
8794 
          for _i123 in xrange(_size119):
8795 
            _elem124 = iprot.readDouble();
8796 
            self.success.append(_elem124)
483 rajveer 8797 
          iprot.readListEnd()
94 ashish 8798 
        else:
8799 
          iprot.skip(ftype)
8800 
      else:
8801 
        iprot.skip(ftype)
8802 
      iprot.readFieldEnd()
8803 
    iprot.readStructEnd()
8804 
 
8805 
  def write(self, oprot):
8806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8808 
      return
3064 chandransh 8809 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 8810 
    if self.success is not None:
483 rajveer 8811 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 8812 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 8813 
      for iter125 in self.success:
8814 
        oprot.writeDouble(iter125)
483 rajveer 8815 
      oprot.writeListEnd()
94 ashish 8816 
      oprot.writeFieldEnd()
8817 
    oprot.writeFieldStop()
8818 
    oprot.writeStructEnd()
8819 
 
3431 rajveer 8820 
  def validate(self):
8821 
    return
8822 
 
8823 
 
94 ashish 8824 
  def __repr__(self):
8825 
    L = ['%s=%r' % (key, value)
8826 
      for key, value in self.__dict__.iteritems()]
8827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8828 
 
8829 
  def __eq__(self, other):
8830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8831 
 
8832 
  def __ne__(self, other):
8833 
    return not (self == other)
8834 
 
3064 chandransh 8835 
class getValidOrders_args:
1528 ankur.sing 8836 
  """
8837 
  Attributes:
3064 chandransh 8838 
   - limit
1528 ankur.sing 8839 
  """
8840 
 
8841 
  thrift_spec = (
8842 
    None, # 0
3064 chandransh 8843 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 8844 
  )
8845 
 
3064 chandransh 8846 
  def __init__(self, limit=None,):
8847 
    self.limit = limit
1528 ankur.sing 8848 
 
8849 
  def read(self, iprot):
8850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8852 
      return
8853 
    iprot.readStructBegin()
8854 
    while True:
8855 
      (fname, ftype, fid) = iprot.readFieldBegin()
8856 
      if ftype == TType.STOP:
8857 
        break
8858 
      if fid == 1:
8859 
        if ftype == TType.I64:
3064 chandransh 8860 
          self.limit = iprot.readI64();
1528 ankur.sing 8861 
        else:
8862 
          iprot.skip(ftype)
8863 
      else:
8864 
        iprot.skip(ftype)
8865 
      iprot.readFieldEnd()
8866 
    iprot.readStructEnd()
8867 
 
8868 
  def write(self, oprot):
8869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8871 
      return
3064 chandransh 8872 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 8873 
    if self.limit is not None:
3064 chandransh 8874 
      oprot.writeFieldBegin('limit', TType.I64, 1)
8875 
      oprot.writeI64(self.limit)
1528 ankur.sing 8876 
      oprot.writeFieldEnd()
8877 
    oprot.writeFieldStop()
8878 
    oprot.writeStructEnd()
8879 
 
3431 rajveer 8880 
  def validate(self):
8881 
    return
8882 
 
8883 
 
1528 ankur.sing 8884 
  def __repr__(self):
8885 
    L = ['%s=%r' % (key, value)
8886 
      for key, value in self.__dict__.iteritems()]
8887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8888 
 
8889 
  def __eq__(self, other):
8890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8891 
 
8892 
  def __ne__(self, other):
8893 
    return not (self == other)
8894 
 
3064 chandransh 8895 
class getValidOrders_result:
1528 ankur.sing 8896 
  """
8897 
  Attributes:
8898 
   - success
8899 
  """
8900 
 
8901 
  thrift_spec = (
3064 chandransh 8902 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 8903 
  )
8904 
 
3064 chandransh 8905 
  def __init__(self, success=None,):
1528 ankur.sing 8906 
    self.success = success
8907 
 
8908 
  def read(self, iprot):
8909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8911 
      return
8912 
    iprot.readStructBegin()
8913 
    while True:
8914 
      (fname, ftype, fid) = iprot.readFieldBegin()
8915 
      if ftype == TType.STOP:
8916 
        break
8917 
      if fid == 0:
3064 chandransh 8918 
        if ftype == TType.LIST:
8919 
          self.success = []
4133 chandransh 8920 
          (_etype129, _size126) = iprot.readListBegin()
8921 
          for _i130 in xrange(_size126):
8922 
            _elem131 = Order()
8923 
            _elem131.read(iprot)
8924 
            self.success.append(_elem131)
3064 chandransh 8925 
          iprot.readListEnd()
1528 ankur.sing 8926 
        else:
8927 
          iprot.skip(ftype)
8928 
      else:
8929 
        iprot.skip(ftype)
8930 
      iprot.readFieldEnd()
8931 
    iprot.readStructEnd()
8932 
 
8933 
  def write(self, oprot):
8934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8936 
      return
3064 chandransh 8937 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 8938 
    if self.success is not None:
3064 chandransh 8939 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8940 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8941 
      for iter132 in self.success:
8942 
        iter132.write(oprot)
3064 chandransh 8943 
      oprot.writeListEnd()
1528 ankur.sing 8944 
      oprot.writeFieldEnd()
8945 
    oprot.writeFieldStop()
8946 
    oprot.writeStructEnd()
8947 
 
3431 rajveer 8948 
  def validate(self):
8949 
    return
8950 
 
8951 
 
1528 ankur.sing 8952 
  def __repr__(self):
8953 
    L = ['%s=%r' % (key, value)
8954 
      for key, value in self.__dict__.iteritems()]
8955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8956 
 
8957 
  def __eq__(self, other):
8958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8959 
 
8960 
  def __ne__(self, other):
8961 
    return not (self == other)
8962 
 
1220 chandransh 8963 
class batchOrders_args:
8964 
  """
8965 
  Attributes:
8966 
   - warehouseId
8967 
  """
8968 
 
8969 
  thrift_spec = (
8970 
    None, # 0
8971 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8972 
  )
8973 
 
8974 
  def __init__(self, warehouseId=None,):
8975 
    self.warehouseId = warehouseId
8976 
 
8977 
  def read(self, iprot):
8978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8980 
      return
8981 
    iprot.readStructBegin()
8982 
    while True:
8983 
      (fname, ftype, fid) = iprot.readFieldBegin()
8984 
      if ftype == TType.STOP:
8985 
        break
8986 
      if fid == 1:
8987 
        if ftype == TType.I64:
8988 
          self.warehouseId = iprot.readI64();
8989 
        else:
8990 
          iprot.skip(ftype)
8991 
      else:
8992 
        iprot.skip(ftype)
8993 
      iprot.readFieldEnd()
8994 
    iprot.readStructEnd()
8995 
 
8996 
  def write(self, oprot):
8997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8999 
      return
9000 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9001 
    if self.warehouseId is not None:
1220 chandransh 9002 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9003 
      oprot.writeI64(self.warehouseId)
9004 
      oprot.writeFieldEnd()
9005 
    oprot.writeFieldStop()
9006 
    oprot.writeStructEnd()
9007 
 
3431 rajveer 9008 
  def validate(self):
9009 
    return
9010 
 
9011 
 
1220 chandransh 9012 
  def __repr__(self):
9013 
    L = ['%s=%r' % (key, value)
9014 
      for key, value in self.__dict__.iteritems()]
9015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9016 
 
9017 
  def __eq__(self, other):
9018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9019 
 
9020 
  def __ne__(self, other):
9021 
    return not (self == other)
9022 
 
9023 
class batchOrders_result:
9024 
  """
9025 
  Attributes:
9026 
   - success
9027 
   - ex
9028 
  """
9029 
 
9030 
  thrift_spec = (
9031 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9032 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9033 
  )
9034 
 
9035 
  def __init__(self, success=None, ex=None,):
9036 
    self.success = success
9037 
    self.ex = ex
9038 
 
9039 
  def read(self, iprot):
9040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9042 
      return
9043 
    iprot.readStructBegin()
9044 
    while True:
9045 
      (fname, ftype, fid) = iprot.readFieldBegin()
9046 
      if ftype == TType.STOP:
9047 
        break
9048 
      if fid == 0:
9049 
        if ftype == TType.LIST:
9050 
          self.success = []
4133 chandransh 9051 
          (_etype136, _size133) = iprot.readListBegin()
9052 
          for _i137 in xrange(_size133):
9053 
            _elem138 = Order()
9054 
            _elem138.read(iprot)
9055 
            self.success.append(_elem138)
1220 chandransh 9056 
          iprot.readListEnd()
9057 
        else:
9058 
          iprot.skip(ftype)
9059 
      elif fid == 1:
9060 
        if ftype == TType.STRUCT:
9061 
          self.ex = TransactionServiceException()
9062 
          self.ex.read(iprot)
9063 
        else:
9064 
          iprot.skip(ftype)
9065 
      else:
9066 
        iprot.skip(ftype)
9067 
      iprot.readFieldEnd()
9068 
    iprot.readStructEnd()
9069 
 
9070 
  def write(self, oprot):
9071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9073 
      return
9074 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 9075 
    if self.success is not None:
1220 chandransh 9076 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9077 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9078 
      for iter139 in self.success:
9079 
        iter139.write(oprot)
1220 chandransh 9080 
      oprot.writeListEnd()
9081 
      oprot.writeFieldEnd()
3431 rajveer 9082 
    if self.ex is not None:
1220 chandransh 9083 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9084 
      self.ex.write(oprot)
9085 
      oprot.writeFieldEnd()
9086 
    oprot.writeFieldStop()
9087 
    oprot.writeStructEnd()
9088 
 
3431 rajveer 9089 
  def validate(self):
9090 
    return
9091 
 
9092 
 
1220 chandransh 9093 
  def __repr__(self):
9094 
    L = ['%s=%r' % (key, value)
9095 
      for key, value in self.__dict__.iteritems()]
9096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9097 
 
9098 
  def __eq__(self, other):
9099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9100 
 
9101 
  def __ne__(self, other):
9102 
    return not (self == other)
9103 
 
1208 chandransh 9104 
class markOrderAsOutOfStock_args:
9105 
  """
9106 
  Attributes:
9107 
   - orderId
9108 
  """
9109 
 
9110 
  thrift_spec = (
9111 
    None, # 0
9112 
    (1, TType.I64, 'orderId', None, None, ), # 1
9113 
  )
9114 
 
9115 
  def __init__(self, orderId=None,):
9116 
    self.orderId = orderId
9117 
 
9118 
  def read(self, iprot):
9119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9121 
      return
9122 
    iprot.readStructBegin()
9123 
    while True:
9124 
      (fname, ftype, fid) = iprot.readFieldBegin()
9125 
      if ftype == TType.STOP:
9126 
        break
9127 
      if fid == 1:
9128 
        if ftype == TType.I64:
9129 
          self.orderId = iprot.readI64();
9130 
        else:
9131 
          iprot.skip(ftype)
9132 
      else:
9133 
        iprot.skip(ftype)
9134 
      iprot.readFieldEnd()
9135 
    iprot.readStructEnd()
9136 
 
9137 
  def write(self, oprot):
9138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9140 
      return
9141 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 9142 
    if self.orderId is not None:
1208 chandransh 9143 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9144 
      oprot.writeI64(self.orderId)
9145 
      oprot.writeFieldEnd()
9146 
    oprot.writeFieldStop()
9147 
    oprot.writeStructEnd()
9148 
 
3431 rajveer 9149 
  def validate(self):
9150 
    return
9151 
 
9152 
 
1208 chandransh 9153 
  def __repr__(self):
9154 
    L = ['%s=%r' % (key, value)
9155 
      for key, value in self.__dict__.iteritems()]
9156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9157 
 
9158 
  def __eq__(self, other):
9159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9160 
 
9161 
  def __ne__(self, other):
9162 
    return not (self == other)
9163 
 
9164 
class markOrderAsOutOfStock_result:
9165 
  """
9166 
  Attributes:
9167 
   - success
9168 
   - ex
9169 
  """
9170 
 
9171 
  thrift_spec = (
9172 
    (0, TType.BOOL, 'success', None, None, ), # 0
9173 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9174 
  )
9175 
 
9176 
  def __init__(self, success=None, ex=None,):
9177 
    self.success = success
9178 
    self.ex = ex
9179 
 
9180 
  def read(self, iprot):
9181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9183 
      return
9184 
    iprot.readStructBegin()
9185 
    while True:
9186 
      (fname, ftype, fid) = iprot.readFieldBegin()
9187 
      if ftype == TType.STOP:
9188 
        break
9189 
      if fid == 0:
9190 
        if ftype == TType.BOOL:
9191 
          self.success = iprot.readBool();
9192 
        else:
9193 
          iprot.skip(ftype)
9194 
      elif fid == 1:
9195 
        if ftype == TType.STRUCT:
9196 
          self.ex = TransactionServiceException()
9197 
          self.ex.read(iprot)
9198 
        else:
9199 
          iprot.skip(ftype)
9200 
      else:
9201 
        iprot.skip(ftype)
9202 
      iprot.readFieldEnd()
9203 
    iprot.readStructEnd()
9204 
 
9205 
  def write(self, oprot):
9206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9208 
      return
9209 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 9210 
    if self.success is not None:
1208 chandransh 9211 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9212 
      oprot.writeBool(self.success)
9213 
      oprot.writeFieldEnd()
3431 rajveer 9214 
    if self.ex is not None:
1208 chandransh 9215 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9216 
      self.ex.write(oprot)
9217 
      oprot.writeFieldEnd()
9218 
    oprot.writeFieldStop()
9219 
    oprot.writeStructEnd()
9220 
 
3431 rajveer 9221 
  def validate(self):
9222 
    return
9223 
 
9224 
 
1208 chandransh 9225 
  def __repr__(self):
9226 
    L = ['%s=%r' % (key, value)
9227 
      for key, value in self.__dict__.iteritems()]
9228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9229 
 
9230 
  def __eq__(self, other):
9231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9232 
 
9233 
  def __ne__(self, other):
9234 
    return not (self == other)
9235 
 
3064 chandransh 9236 
class verifyOrder_args:
759 chandransh 9237 
  """
9238 
  Attributes:
3064 chandransh 9239 
   - orderId
759 chandransh 9240 
  """
9241 
 
9242 
  thrift_spec = (
9243 
    None, # 0
3064 chandransh 9244 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 9245 
  )
9246 
 
3064 chandransh 9247 
  def __init__(self, orderId=None,):
9248 
    self.orderId = orderId
759 chandransh 9249 
 
9250 
  def read(self, iprot):
9251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9253 
      return
9254 
    iprot.readStructBegin()
9255 
    while True:
9256 
      (fname, ftype, fid) = iprot.readFieldBegin()
9257 
      if ftype == TType.STOP:
9258 
        break
9259 
      if fid == 1:
9260 
        if ftype == TType.I64:
3064 chandransh 9261 
          self.orderId = iprot.readI64();
759 chandransh 9262 
        else:
9263 
          iprot.skip(ftype)
9264 
      else:
9265 
        iprot.skip(ftype)
9266 
      iprot.readFieldEnd()
9267 
    iprot.readStructEnd()
9268 
 
9269 
  def write(self, oprot):
9270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9272 
      return
3064 chandransh 9273 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 9274 
    if self.orderId is not None:
3064 chandransh 9275 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9276 
      oprot.writeI64(self.orderId)
759 chandransh 9277 
      oprot.writeFieldEnd()
9278 
    oprot.writeFieldStop()
9279 
    oprot.writeStructEnd()
9280 
 
3431 rajveer 9281 
  def validate(self):
9282 
    return
9283 
 
9284 
 
759 chandransh 9285 
  def __repr__(self):
9286 
    L = ['%s=%r' % (key, value)
9287 
      for key, value in self.__dict__.iteritems()]
9288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9289 
 
9290 
  def __eq__(self, other):
9291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9292 
 
9293 
  def __ne__(self, other):
9294 
    return not (self == other)
9295 
 
3064 chandransh 9296 
class verifyOrder_result:
759 chandransh 9297 
  """
9298 
  Attributes:
9299 
   - success
9300 
   - ex
9301 
  """
9302 
 
9303 
  thrift_spec = (
9304 
    (0, TType.BOOL, 'success', None, None, ), # 0
9305 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9306 
  )
9307 
 
9308 
  def __init__(self, success=None, ex=None,):
9309 
    self.success = success
9310 
    self.ex = ex
9311 
 
9312 
  def read(self, iprot):
9313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9315 
      return
9316 
    iprot.readStructBegin()
9317 
    while True:
9318 
      (fname, ftype, fid) = iprot.readFieldBegin()
9319 
      if ftype == TType.STOP:
9320 
        break
9321 
      if fid == 0:
9322 
        if ftype == TType.BOOL:
9323 
          self.success = iprot.readBool();
9324 
        else:
9325 
          iprot.skip(ftype)
9326 
      elif fid == 1:
9327 
        if ftype == TType.STRUCT:
9328 
          self.ex = TransactionServiceException()
9329 
          self.ex.read(iprot)
9330 
        else:
9331 
          iprot.skip(ftype)
9332 
      else:
9333 
        iprot.skip(ftype)
9334 
      iprot.readFieldEnd()
9335 
    iprot.readStructEnd()
9336 
 
9337 
  def write(self, oprot):
9338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9340 
      return
3064 chandransh 9341 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 9342 
    if self.success is not None:
759 chandransh 9343 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9344 
      oprot.writeBool(self.success)
9345 
      oprot.writeFieldEnd()
3431 rajveer 9346 
    if self.ex is not None:
759 chandransh 9347 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9348 
      self.ex.write(oprot)
9349 
      oprot.writeFieldEnd()
9350 
    oprot.writeFieldStop()
9351 
    oprot.writeStructEnd()
9352 
 
3431 rajveer 9353 
  def validate(self):
9354 
    return
9355 
 
9356 
 
759 chandransh 9357 
  def __repr__(self):
9358 
    L = ['%s=%r' % (key, value)
9359 
      for key, value in self.__dict__.iteritems()]
9360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9361 
 
9362 
  def __eq__(self, other):
9363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9364 
 
9365 
  def __ne__(self, other):
9366 
    return not (self == other)
9367 
 
3064 chandransh 9368 
class acceptOrder_args:
1113 chandransh 9369 
  """
9370 
  Attributes:
3064 chandransh 9371 
   - orderId
1113 chandransh 9372 
  """
9373 
 
9374 
  thrift_spec = (
9375 
    None, # 0
3064 chandransh 9376 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 9377 
  )
9378 
 
3064 chandransh 9379 
  def __init__(self, orderId=None,):
9380 
    self.orderId = orderId
1113 chandransh 9381 
 
9382 
  def read(self, iprot):
9383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9385 
      return
9386 
    iprot.readStructBegin()
9387 
    while True:
9388 
      (fname, ftype, fid) = iprot.readFieldBegin()
9389 
      if ftype == TType.STOP:
9390 
        break
9391 
      if fid == 1:
9392 
        if ftype == TType.I64:
3064 chandransh 9393 
          self.orderId = iprot.readI64();
1113 chandransh 9394 
        else:
9395 
          iprot.skip(ftype)
9396 
      else:
9397 
        iprot.skip(ftype)
9398 
      iprot.readFieldEnd()
9399 
    iprot.readStructEnd()
9400 
 
9401 
  def write(self, oprot):
9402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9404 
      return
3064 chandransh 9405 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 9406 
    if self.orderId is not None:
3064 chandransh 9407 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9408 
      oprot.writeI64(self.orderId)
1113 chandransh 9409 
      oprot.writeFieldEnd()
9410 
    oprot.writeFieldStop()
9411 
    oprot.writeStructEnd()
9412 
 
3431 rajveer 9413 
  def validate(self):
9414 
    return
9415 
 
9416 
 
1113 chandransh 9417 
  def __repr__(self):
9418 
    L = ['%s=%r' % (key, value)
9419 
      for key, value in self.__dict__.iteritems()]
9420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9421 
 
9422 
  def __eq__(self, other):
9423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9424 
 
9425 
  def __ne__(self, other):
9426 
    return not (self == other)
9427 
 
3064 chandransh 9428 
class acceptOrder_result:
1113 chandransh 9429 
  """
9430 
  Attributes:
9431 
   - success
9432 
   - ex
9433 
  """
9434 
 
9435 
  thrift_spec = (
3064 chandransh 9436 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 9437 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9438 
  )
9439 
 
9440 
  def __init__(self, success=None, ex=None,):
9441 
    self.success = success
9442 
    self.ex = ex
9443 
 
9444 
  def read(self, iprot):
9445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9447 
      return
9448 
    iprot.readStructBegin()
9449 
    while True:
9450 
      (fname, ftype, fid) = iprot.readFieldBegin()
9451 
      if ftype == TType.STOP:
9452 
        break
9453 
      if fid == 0:
3064 chandransh 9454 
        if ftype == TType.BOOL:
9455 
          self.success = iprot.readBool();
1113 chandransh 9456 
        else:
9457 
          iprot.skip(ftype)
9458 
      elif fid == 1:
9459 
        if ftype == TType.STRUCT:
9460 
          self.ex = TransactionServiceException()
9461 
          self.ex.read(iprot)
9462 
        else:
9463 
          iprot.skip(ftype)
9464 
      else:
9465 
        iprot.skip(ftype)
9466 
      iprot.readFieldEnd()
9467 
    iprot.readStructEnd()
9468 
 
9469 
  def write(self, oprot):
9470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9472 
      return
3064 chandransh 9473 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 9474 
    if self.success is not None:
3064 chandransh 9475 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9476 
      oprot.writeBool(self.success)
1113 chandransh 9477 
      oprot.writeFieldEnd()
3431 rajveer 9478 
    if self.ex is not None:
1113 chandransh 9479 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9480 
      self.ex.write(oprot)
9481 
      oprot.writeFieldEnd()
9482 
    oprot.writeFieldStop()
9483 
    oprot.writeStructEnd()
9484 
 
3431 rajveer 9485 
  def validate(self):
9486 
    return
9487 
 
9488 
 
1113 chandransh 9489 
  def __repr__(self):
9490 
    L = ['%s=%r' % (key, value)
9491 
      for key, value in self.__dict__.iteritems()]
9492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9493 
 
9494 
  def __eq__(self, other):
9495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9496 
 
9497 
  def __ne__(self, other):
9498 
    return not (self == other)
9499 
 
3064 chandransh 9500 
class addBillingDetails_args:
1135 chandransh 9501 
  """
9502 
  Attributes:
3064 chandransh 9503 
   - orderId
9504 
   - invoice_number
4283 anupam.sin 9505 
   - imeiNumber
9506 
   - itemNumber
3064 chandransh 9507 
   - billed_by
4264 rajveer 9508 
   - jacketNumber
4283 anupam.sin 9509 
   - billingType
9510 
   - vendorId
1135 chandransh 9511 
  """
9512 
 
9513 
  thrift_spec = (
9514 
    None, # 0
3064 chandransh 9515 
    (1, TType.I64, 'orderId', None, None, ), # 1
9516 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 9517 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
9518 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
9519 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
9520 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
9521 
    (7, TType.I64, 'billingType', None, None, ), # 7
9522 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 9523 
  )
9524 
 
4283 anupam.sin 9525 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 9526 
    self.orderId = orderId
9527 
    self.invoice_number = invoice_number
4283 anupam.sin 9528 
    self.imeiNumber = imeiNumber
9529 
    self.itemNumber = itemNumber
3064 chandransh 9530 
    self.billed_by = billed_by
4264 rajveer 9531 
    self.jacketNumber = jacketNumber
4283 anupam.sin 9532 
    self.billingType = billingType
9533 
    self.vendorId = vendorId
1135 chandransh 9534 
 
9535 
  def read(self, iprot):
9536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9538 
      return
9539 
    iprot.readStructBegin()
9540 
    while True:
9541 
      (fname, ftype, fid) = iprot.readFieldBegin()
9542 
      if ftype == TType.STOP:
9543 
        break
9544 
      if fid == 1:
9545 
        if ftype == TType.I64:
3064 chandransh 9546 
          self.orderId = iprot.readI64();
1135 chandransh 9547 
        else:
9548 
          iprot.skip(ftype)
9549 
      elif fid == 2:
3064 chandransh 9550 
        if ftype == TType.STRING:
9551 
          self.invoice_number = iprot.readString();
1135 chandransh 9552 
        else:
9553 
          iprot.skip(ftype)
3064 chandransh 9554 
      elif fid == 3:
4264 rajveer 9555 
        if ftype == TType.I64:
3064 chandransh 9556 
          self.imeiNumber = iprot.readI64();
9557 
        else:
9558 
          iprot.skip(ftype)
9559 
      elif fid == 4:
9560 
        if ftype == TType.STRING:
9561 
          self.itemNumber = iprot.readString();
9562 
        else:
9563 
          iprot.skip(ftype)
9564 
      elif fid == 5:
9565 
        if ftype == TType.STRING:
4283 anupam.sin 9566 
          self.billed_by = iprot.readString();
3064 chandransh 9567 
        else:
9568 
          iprot.skip(ftype)
9569 
      elif fid == 6:
9570 
        if ftype == TType.I64:
4283 anupam.sin 9571 
          self.jacketNumber = iprot.readI64();
9572 
        else:
9573 
          iprot.skip(ftype)
9574 
      elif fid == 7:
9575 
        if ftype == TType.I64:
3064 chandransh 9576 
          self.billingType = iprot.readI64();
9577 
        else:
9578 
          iprot.skip(ftype)
4283 anupam.sin 9579 
      elif fid == 8:
9580 
        if ftype == TType.I64:
9581 
          self.vendorId = iprot.readI64();
9582 
        else:
9583 
          iprot.skip(ftype)
1246 chandransh 9584 
      else:
9585 
        iprot.skip(ftype)
9586 
      iprot.readFieldEnd()
9587 
    iprot.readStructEnd()
9588 
 
9589 
  def write(self, oprot):
9590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9592 
      return
4283 anupam.sin 9593 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 9594 
    if self.orderId is not None:
3064 chandransh 9595 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9596 
      oprot.writeI64(self.orderId)
1246 chandransh 9597 
      oprot.writeFieldEnd()
4283 anupam.sin 9598 
    if self.invoice_number is not None:
9599 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
9600 
      oprot.writeString(self.invoice_number)
1246 chandransh 9601 
      oprot.writeFieldEnd()
3431 rajveer 9602 
    if self.imeiNumber is not None:
3064 chandransh 9603 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
9604 
      oprot.writeI64(self.imeiNumber)
9605 
      oprot.writeFieldEnd()
3431 rajveer 9606 
    if self.itemNumber is not None:
3064 chandransh 9607 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
9608 
      oprot.writeString(self.itemNumber)
9609 
      oprot.writeFieldEnd()
4283 anupam.sin 9610 
    if self.billed_by is not None:
9611 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
9612 
      oprot.writeString(self.billed_by)
3064 chandransh 9613 
      oprot.writeFieldEnd()
4283 anupam.sin 9614 
    if self.jacketNumber is not None:
9615 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
9616 
      oprot.writeI64(self.jacketNumber)
9617 
      oprot.writeFieldEnd()
3431 rajveer 9618 
    if self.billingType is not None:
4283 anupam.sin 9619 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 9620 
      oprot.writeI64(self.billingType)
9621 
      oprot.writeFieldEnd()
4283 anupam.sin 9622 
    if self.vendorId is not None:
9623 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
9624 
      oprot.writeI64(self.vendorId)
9625 
      oprot.writeFieldEnd()
1246 chandransh 9626 
    oprot.writeFieldStop()
9627 
    oprot.writeStructEnd()
9628 
 
3431 rajveer 9629 
  def validate(self):
9630 
    return
9631 
 
9632 
 
1246 chandransh 9633 
  def __repr__(self):
9634 
    L = ['%s=%r' % (key, value)
9635 
      for key, value in self.__dict__.iteritems()]
9636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9637 
 
9638 
  def __eq__(self, other):
9639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9640 
 
9641 
  def __ne__(self, other):
9642 
    return not (self == other)
9643 
 
4283 anupam.sin 9644 
class addBillingDetails_result:
1246 chandransh 9645 
  """
9646 
  Attributes:
3064 chandransh 9647 
   - success
1246 chandransh 9648 
   - ex
9649 
  """
9650 
 
9651 
  thrift_spec = (
3064 chandransh 9652 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 9653 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9654 
  )
9655 
 
3064 chandransh 9656 
  def __init__(self, success=None, ex=None,):
9657 
    self.success = success
1246 chandransh 9658 
    self.ex = ex
9659 
 
9660 
  def read(self, iprot):
9661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9663 
      return
9664 
    iprot.readStructBegin()
9665 
    while True:
9666 
      (fname, ftype, fid) = iprot.readFieldBegin()
9667 
      if ftype == TType.STOP:
9668 
        break
3064 chandransh 9669 
      if fid == 0:
9670 
        if ftype == TType.BOOL:
9671 
          self.success = iprot.readBool();
9672 
        else:
9673 
          iprot.skip(ftype)
9674 
      elif fid == 1:
1246 chandransh 9675 
        if ftype == TType.STRUCT:
9676 
          self.ex = TransactionServiceException()
9677 
          self.ex.read(iprot)
9678 
        else:
9679 
          iprot.skip(ftype)
9680 
      else:
9681 
        iprot.skip(ftype)
9682 
      iprot.readFieldEnd()
9683 
    iprot.readStructEnd()
9684 
 
9685 
  def write(self, oprot):
9686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9688 
      return
4283 anupam.sin 9689 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 9690 
    if self.success is not None:
3064 chandransh 9691 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9692 
      oprot.writeBool(self.success)
9693 
      oprot.writeFieldEnd()
3431 rajveer 9694 
    if self.ex is not None:
1246 chandransh 9695 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9696 
      self.ex.write(oprot)
9697 
      oprot.writeFieldEnd()
9698 
    oprot.writeFieldStop()
9699 
    oprot.writeStructEnd()
9700 
 
3431 rajveer 9701 
  def validate(self):
9702 
    return
9703 
 
9704 
 
1246 chandransh 9705 
  def __repr__(self):
9706 
    L = ['%s=%r' % (key, value)
9707 
      for key, value in self.__dict__.iteritems()]
9708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9709 
 
9710 
  def __eq__(self, other):
9711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9712 
 
9713 
  def __ne__(self, other):
9714 
    return not (self == other)
9715 
 
3064 chandransh 9716 
class markOrdersAsManifested_args:
1408 ankur.sing 9717 
  """
9718 
  Attributes:
3064 chandransh 9719 
   - warehouseId
1408 ankur.sing 9720 
   - providerId
3064 chandransh 9721 
   - cod
1408 ankur.sing 9722 
  """
9723 
 
9724 
  thrift_spec = (
9725 
    None, # 0
3064 chandransh 9726 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9727 
    (2, TType.I64, 'providerId', None, None, ), # 2
9728 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 9729 
  )
9730 
 
3064 chandransh 9731 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9732 
    self.warehouseId = warehouseId
1408 ankur.sing 9733 
    self.providerId = providerId
3064 chandransh 9734 
    self.cod = cod
1408 ankur.sing 9735 
 
9736 
  def read(self, iprot):
9737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9739 
      return
9740 
    iprot.readStructBegin()
9741 
    while True:
9742 
      (fname, ftype, fid) = iprot.readFieldBegin()
9743 
      if ftype == TType.STOP:
9744 
        break
9745 
      if fid == 1:
9746 
        if ftype == TType.I64:
3064 chandransh 9747 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 9748 
        else:
9749 
          iprot.skip(ftype)
9750 
      elif fid == 2:
9751 
        if ftype == TType.I64:
3064 chandransh 9752 
          self.providerId = iprot.readI64();
1408 ankur.sing 9753 
        else:
9754 
          iprot.skip(ftype)
3064 chandransh 9755 
      elif fid == 3:
9756 
        if ftype == TType.BOOL:
9757 
          self.cod = iprot.readBool();
9758 
        else:
9759 
          iprot.skip(ftype)
1408 ankur.sing 9760 
      else:
9761 
        iprot.skip(ftype)
9762 
      iprot.readFieldEnd()
9763 
    iprot.readStructEnd()
9764 
 
9765 
  def write(self, oprot):
9766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9768 
      return
3064 chandransh 9769 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 9770 
    if self.warehouseId is not None:
3064 chandransh 9771 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9772 
      oprot.writeI64(self.warehouseId)
9773 
      oprot.writeFieldEnd()
3431 rajveer 9774 
    if self.providerId is not None:
3064 chandransh 9775 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9776 
      oprot.writeI64(self.providerId)
9777 
      oprot.writeFieldEnd()
3431 rajveer 9778 
    if self.cod is not None:
3064 chandransh 9779 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9780 
      oprot.writeBool(self.cod)
1408 ankur.sing 9781 
      oprot.writeFieldEnd()
9782 
    oprot.writeFieldStop()
9783 
    oprot.writeStructEnd()
9784 
 
3431 rajveer 9785 
  def validate(self):
9786 
    return
9787 
 
9788 
 
1408 ankur.sing 9789 
  def __repr__(self):
9790 
    L = ['%s=%r' % (key, value)
9791 
      for key, value in self.__dict__.iteritems()]
9792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9793 
 
9794 
  def __eq__(self, other):
9795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9796 
 
9797 
  def __ne__(self, other):
9798 
    return not (self == other)
9799 
 
3064 chandransh 9800 
class markOrdersAsManifested_result:
1408 ankur.sing 9801 
  """
9802 
  Attributes:
9803 
   - success
3064 chandransh 9804 
   - ex
1408 ankur.sing 9805 
  """
9806 
 
9807 
  thrift_spec = (
3064 chandransh 9808 
    (0, TType.BOOL, 'success', None, None, ), # 0
9809 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 9810 
  )
9811 
 
3064 chandransh 9812 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 9813 
    self.success = success
3064 chandransh 9814 
    self.ex = ex
1408 ankur.sing 9815 
 
9816 
  def read(self, iprot):
9817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9819 
      return
9820 
    iprot.readStructBegin()
9821 
    while True:
9822 
      (fname, ftype, fid) = iprot.readFieldBegin()
9823 
      if ftype == TType.STOP:
9824 
        break
9825 
      if fid == 0:
3064 chandransh 9826 
        if ftype == TType.BOOL:
9827 
          self.success = iprot.readBool();
1408 ankur.sing 9828 
        else:
9829 
          iprot.skip(ftype)
3064 chandransh 9830 
      elif fid == 1:
9831 
        if ftype == TType.STRUCT:
9832 
          self.ex = TransactionServiceException()
9833 
          self.ex.read(iprot)
9834 
        else:
9835 
          iprot.skip(ftype)
1408 ankur.sing 9836 
      else:
9837 
        iprot.skip(ftype)
9838 
      iprot.readFieldEnd()
9839 
    iprot.readStructEnd()
9840 
 
9841 
  def write(self, oprot):
9842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9844 
      return
3064 chandransh 9845 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 9846 
    if self.success is not None:
3064 chandransh 9847 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9848 
      oprot.writeBool(self.success)
1408 ankur.sing 9849 
      oprot.writeFieldEnd()
3431 rajveer 9850 
    if self.ex is not None:
3064 chandransh 9851 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9852 
      self.ex.write(oprot)
9853 
      oprot.writeFieldEnd()
1408 ankur.sing 9854 
    oprot.writeFieldStop()
9855 
    oprot.writeStructEnd()
9856 
 
3431 rajveer 9857 
  def validate(self):
9858 
    return
9859 
 
9860 
 
1408 ankur.sing 9861 
  def __repr__(self):
9862 
    L = ['%s=%r' % (key, value)
9863 
      for key, value in self.__dict__.iteritems()]
9864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9865 
 
9866 
  def __eq__(self, other):
9867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9868 
 
9869 
  def __ne__(self, other):
9870 
    return not (self == other)
9871 
 
4410 rajveer 9872 
class markOrdersAsShippedFromWarehouse_args:
9873 
  """
9874 
  Attributes:
9875 
   - warehouseId
9876 
   - providerId
9877 
   - cod
9878 
  """
9879 
 
9880 
  thrift_spec = (
9881 
    None, # 0
9882 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9883 
    (2, TType.I64, 'providerId', None, None, ), # 2
9884 
    (3, TType.BOOL, 'cod', None, None, ), # 3
9885 
  )
9886 
 
9887 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9888 
    self.warehouseId = warehouseId
9889 
    self.providerId = providerId
9890 
    self.cod = cod
9891 
 
9892 
  def read(self, iprot):
9893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9895 
      return
9896 
    iprot.readStructBegin()
9897 
    while True:
9898 
      (fname, ftype, fid) = iprot.readFieldBegin()
9899 
      if ftype == TType.STOP:
9900 
        break
9901 
      if fid == 1:
9902 
        if ftype == TType.I64:
9903 
          self.warehouseId = iprot.readI64();
9904 
        else:
9905 
          iprot.skip(ftype)
9906 
      elif fid == 2:
9907 
        if ftype == TType.I64:
9908 
          self.providerId = iprot.readI64();
9909 
        else:
9910 
          iprot.skip(ftype)
9911 
      elif fid == 3:
9912 
        if ftype == TType.BOOL:
9913 
          self.cod = iprot.readBool();
9914 
        else:
9915 
          iprot.skip(ftype)
9916 
      else:
9917 
        iprot.skip(ftype)
9918 
      iprot.readFieldEnd()
9919 
    iprot.readStructEnd()
9920 
 
9921 
  def write(self, oprot):
9922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9924 
      return
9925 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
9926 
    if self.warehouseId is not None:
9927 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9928 
      oprot.writeI64(self.warehouseId)
9929 
      oprot.writeFieldEnd()
9930 
    if self.providerId is not None:
9931 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
9932 
      oprot.writeI64(self.providerId)
9933 
      oprot.writeFieldEnd()
9934 
    if self.cod is not None:
9935 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9936 
      oprot.writeBool(self.cod)
9937 
      oprot.writeFieldEnd()
9938 
    oprot.writeFieldStop()
9939 
    oprot.writeStructEnd()
9940 
 
9941 
  def validate(self):
9942 
    return
9943 
 
9944 
 
9945 
  def __repr__(self):
9946 
    L = ['%s=%r' % (key, value)
9947 
      for key, value in self.__dict__.iteritems()]
9948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9949 
 
9950 
  def __eq__(self, other):
9951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9952 
 
9953 
  def __ne__(self, other):
9954 
    return not (self == other)
9955 
 
9956 
class markOrdersAsShippedFromWarehouse_result:
9957 
  """
9958 
  Attributes:
9959 
   - success
9960 
   - ex
9961 
  """
9962 
 
9963 
  thrift_spec = (
9964 
    (0, TType.BOOL, 'success', None, None, ), # 0
9965 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9966 
  )
9967 
 
9968 
  def __init__(self, success=None, ex=None,):
9969 
    self.success = success
9970 
    self.ex = ex
9971 
 
9972 
  def read(self, iprot):
9973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9975 
      return
9976 
    iprot.readStructBegin()
9977 
    while True:
9978 
      (fname, ftype, fid) = iprot.readFieldBegin()
9979 
      if ftype == TType.STOP:
9980 
        break
9981 
      if fid == 0:
9982 
        if ftype == TType.BOOL:
9983 
          self.success = iprot.readBool();
9984 
        else:
9985 
          iprot.skip(ftype)
9986 
      elif fid == 1:
9987 
        if ftype == TType.STRUCT:
9988 
          self.ex = TransactionServiceException()
9989 
          self.ex.read(iprot)
9990 
        else:
9991 
          iprot.skip(ftype)
9992 
      else:
9993 
        iprot.skip(ftype)
9994 
      iprot.readFieldEnd()
9995 
    iprot.readStructEnd()
9996 
 
9997 
  def write(self, oprot):
9998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10000 
      return
10001 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
10002 
    if self.success is not None:
10003 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10004 
      oprot.writeBool(self.success)
10005 
      oprot.writeFieldEnd()
10006 
    if self.ex is not None:
10007 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10008 
      self.ex.write(oprot)
10009 
      oprot.writeFieldEnd()
10010 
    oprot.writeFieldStop()
10011 
    oprot.writeStructEnd()
10012 
 
10013 
  def validate(self):
10014 
    return
10015 
 
10016 
 
10017 
  def __repr__(self):
10018 
    L = ['%s=%r' % (key, value)
10019 
      for key, value in self.__dict__.iteritems()]
10020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10021 
 
10022 
  def __eq__(self, other):
10023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10024 
 
10025 
  def __ne__(self, other):
10026 
    return not (self == other)
10027 
 
3064 chandransh 10028 
class markOrdersAsPickedUp_args:
304 ashish 10029 
  """
10030 
  Attributes:
3064 chandransh 10031 
   - providerId
10032 
   - pickupDetails
304 ashish 10033 
  """
94 ashish 10034 
 
304 ashish 10035 
  thrift_spec = (
10036 
    None, # 0
3064 chandransh 10037 
    (1, TType.I64, 'providerId', None, None, ), # 1
10038 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10039 
  )
10040 
 
3064 chandransh 10041 
  def __init__(self, providerId=None, pickupDetails=None,):
10042 
    self.providerId = providerId
10043 
    self.pickupDetails = pickupDetails
304 ashish 10044 
 
10045 
  def read(self, iprot):
10046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10048 
      return
10049 
    iprot.readStructBegin()
10050 
    while True:
10051 
      (fname, ftype, fid) = iprot.readFieldBegin()
10052 
      if ftype == TType.STOP:
10053 
        break
10054 
      if fid == 1:
10055 
        if ftype == TType.I64:
3064 chandransh 10056 
          self.providerId = iprot.readI64();
304 ashish 10057 
        else:
10058 
          iprot.skip(ftype)
10059 
      elif fid == 2:
3064 chandransh 10060 
        if ftype == TType.MAP:
10061 
          self.pickupDetails = {}
4133 chandransh 10062 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
10063 
          for _i144 in xrange(_size140):
10064 
            _key145 = iprot.readString();
10065 
            _val146 = iprot.readString();
10066 
            self.pickupDetails[_key145] = _val146
3064 chandransh 10067 
          iprot.readMapEnd()
304 ashish 10068 
        else:
10069 
          iprot.skip(ftype)
10070 
      else:
10071 
        iprot.skip(ftype)
10072 
      iprot.readFieldEnd()
10073 
    iprot.readStructEnd()
10074 
 
10075 
  def write(self, oprot):
10076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10078 
      return
3064 chandransh 10079 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 10080 
    if self.providerId is not None:
3064 chandransh 10081 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10082 
      oprot.writeI64(self.providerId)
304 ashish 10083 
      oprot.writeFieldEnd()
3431 rajveer 10084 
    if self.pickupDetails is not None:
3064 chandransh 10085 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10086 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10087 
      for kiter147,viter148 in self.pickupDetails.items():
10088 
        oprot.writeString(kiter147)
10089 
        oprot.writeString(viter148)
3064 chandransh 10090 
      oprot.writeMapEnd()
304 ashish 10091 
      oprot.writeFieldEnd()
10092 
    oprot.writeFieldStop()
10093 
    oprot.writeStructEnd()
10094 
 
3431 rajveer 10095 
  def validate(self):
10096 
    return
10097 
 
10098 
 
304 ashish 10099 
  def __repr__(self):
10100 
    L = ['%s=%r' % (key, value)
10101 
      for key, value in self.__dict__.iteritems()]
10102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10103 
 
10104 
  def __eq__(self, other):
10105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10106 
 
10107 
  def __ne__(self, other):
10108 
    return not (self == other)
10109 
 
3064 chandransh 10110 
class markOrdersAsPickedUp_result:
304 ashish 10111 
  """
10112 
  Attributes:
10113 
   - success
3064 chandransh 10114 
   - ex
304 ashish 10115 
  """
10116 
 
10117 
  thrift_spec = (
3064 chandransh 10118 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10119 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10120 
  )
10121 
 
3064 chandransh 10122 
  def __init__(self, success=None, ex=None,):
304 ashish 10123 
    self.success = success
3064 chandransh 10124 
    self.ex = ex
304 ashish 10125 
 
10126 
  def read(self, iprot):
10127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10129 
      return
10130 
    iprot.readStructBegin()
10131 
    while True:
10132 
      (fname, ftype, fid) = iprot.readFieldBegin()
10133 
      if ftype == TType.STOP:
10134 
        break
10135 
      if fid == 0:
10136 
        if ftype == TType.LIST:
10137 
          self.success = []
4133 chandransh 10138 
          (_etype152, _size149) = iprot.readListBegin()
10139 
          for _i153 in xrange(_size149):
10140 
            _elem154 = Order()
10141 
            _elem154.read(iprot)
10142 
            self.success.append(_elem154)
304 ashish 10143 
          iprot.readListEnd()
10144 
        else:
10145 
          iprot.skip(ftype)
3064 chandransh 10146 
      elif fid == 1:
10147 
        if ftype == TType.STRUCT:
10148 
          self.ex = TransactionServiceException()
10149 
          self.ex.read(iprot)
10150 
        else:
10151 
          iprot.skip(ftype)
304 ashish 10152 
      else:
10153 
        iprot.skip(ftype)
10154 
      iprot.readFieldEnd()
10155 
    iprot.readStructEnd()
10156 
 
10157 
  def write(self, oprot):
10158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10160 
      return
3064 chandransh 10161 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 10162 
    if self.success is not None:
304 ashish 10163 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10164 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10165 
      for iter155 in self.success:
10166 
        iter155.write(oprot)
304 ashish 10167 
      oprot.writeListEnd()
10168 
      oprot.writeFieldEnd()
3431 rajveer 10169 
    if self.ex is not None:
3064 chandransh 10170 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10171 
      self.ex.write(oprot)
10172 
      oprot.writeFieldEnd()
304 ashish 10173 
    oprot.writeFieldStop()
10174 
    oprot.writeStructEnd()
10175 
 
3431 rajveer 10176 
  def validate(self):
10177 
    return
10178 
 
10179 
 
304 ashish 10180 
  def __repr__(self):
10181 
    L = ['%s=%r' % (key, value)
10182 
      for key, value in self.__dict__.iteritems()]
10183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10184 
 
10185 
  def __eq__(self, other):
10186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10187 
 
10188 
  def __ne__(self, other):
10189 
    return not (self == other)
10190 
 
3064 chandransh 10191 
class markOrdersAsDelivered_args:
304 ashish 10192 
  """
10193 
  Attributes:
3064 chandransh 10194 
   - providerId
10195 
   - deliveredOrders
304 ashish 10196 
  """
10197 
 
10198 
  thrift_spec = (
10199 
    None, # 0
3064 chandransh 10200 
    (1, TType.I64, 'providerId', None, None, ), # 1
10201 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10202 
  )
10203 
 
3064 chandransh 10204 
  def __init__(self, providerId=None, deliveredOrders=None,):
10205 
    self.providerId = providerId
10206 
    self.deliveredOrders = deliveredOrders
304 ashish 10207 
 
10208 
  def read(self, iprot):
10209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10211 
      return
10212 
    iprot.readStructBegin()
10213 
    while True:
10214 
      (fname, ftype, fid) = iprot.readFieldBegin()
10215 
      if ftype == TType.STOP:
10216 
        break
10217 
      if fid == 1:
10218 
        if ftype == TType.I64:
3064 chandransh 10219 
          self.providerId = iprot.readI64();
304 ashish 10220 
        else:
10221 
          iprot.skip(ftype)
10222 
      elif fid == 2:
3064 chandransh 10223 
        if ftype == TType.MAP:
10224 
          self.deliveredOrders = {}
4133 chandransh 10225 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
10226 
          for _i160 in xrange(_size156):
10227 
            _key161 = iprot.readString();
10228 
            _val162 = iprot.readString();
10229 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 10230 
          iprot.readMapEnd()
304 ashish 10231 
        else:
10232 
          iprot.skip(ftype)
10233 
      else:
10234 
        iprot.skip(ftype)
10235 
      iprot.readFieldEnd()
10236 
    iprot.readStructEnd()
10237 
 
10238 
  def write(self, oprot):
10239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10241 
      return
3064 chandransh 10242 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 10243 
    if self.providerId is not None:
3064 chandransh 10244 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10245 
      oprot.writeI64(self.providerId)
304 ashish 10246 
      oprot.writeFieldEnd()
3431 rajveer 10247 
    if self.deliveredOrders is not None:
3064 chandransh 10248 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
10249 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 10250 
      for kiter163,viter164 in self.deliveredOrders.items():
10251 
        oprot.writeString(kiter163)
10252 
        oprot.writeString(viter164)
3064 chandransh 10253 
      oprot.writeMapEnd()
304 ashish 10254 
      oprot.writeFieldEnd()
10255 
    oprot.writeFieldStop()
10256 
    oprot.writeStructEnd()
10257 
 
3431 rajveer 10258 
  def validate(self):
10259 
    return
10260 
 
10261 
 
304 ashish 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 markOrdersAsDelivered_result:
10274 
  """
10275 
  Attributes:
10276 
   - ex
10277 
  """
304 ashish 10278 
 
10279 
  thrift_spec = (
3064 chandransh 10280 
    None, # 0
10281 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10282 
  )
10283 
 
3064 chandransh 10284 
  def __init__(self, ex=None,):
10285 
    self.ex = ex
304 ashish 10286 
 
1596 ankur.sing 10287 
  def read(self, iprot):
10288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10290 
      return
10291 
    iprot.readStructBegin()
10292 
    while True:
10293 
      (fname, ftype, fid) = iprot.readFieldBegin()
10294 
      if ftype == TType.STOP:
10295 
        break
3064 chandransh 10296 
      if fid == 1:
10297 
        if ftype == TType.STRUCT:
10298 
          self.ex = TransactionServiceException()
10299 
          self.ex.read(iprot)
10300 
        else:
10301 
          iprot.skip(ftype)
1596 ankur.sing 10302 
      else:
10303 
        iprot.skip(ftype)
10304 
      iprot.readFieldEnd()
10305 
    iprot.readStructEnd()
10306 
 
10307 
  def write(self, oprot):
10308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10310 
      return
3064 chandransh 10311 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 10312 
    if self.ex is not None:
3064 chandransh 10313 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10314 
      self.ex.write(oprot)
10315 
      oprot.writeFieldEnd()
1596 ankur.sing 10316 
    oprot.writeFieldStop()
10317 
    oprot.writeStructEnd()
10318 
 
3431 rajveer 10319 
  def validate(self):
10320 
    return
10321 
 
10322 
 
1596 ankur.sing 10323 
  def __repr__(self):
10324 
    L = ['%s=%r' % (key, value)
10325 
      for key, value in self.__dict__.iteritems()]
10326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10327 
 
10328 
  def __eq__(self, other):
10329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10330 
 
10331 
  def __ne__(self, other):
10332 
    return not (self == other)
10333 
 
3064 chandransh 10334 
class markOrdersAsFailed_args:
1596 ankur.sing 10335 
  """
10336 
  Attributes:
3064 chandransh 10337 
   - providerId
10338 
   - returnedOrders
1596 ankur.sing 10339 
  """
10340 
 
10341 
  thrift_spec = (
3064 chandransh 10342 
    None, # 0
10343 
    (1, TType.I64, 'providerId', None, None, ), # 1
10344 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 10345 
  )
10346 
 
3064 chandransh 10347 
  def __init__(self, providerId=None, returnedOrders=None,):
10348 
    self.providerId = providerId
10349 
    self.returnedOrders = returnedOrders
1596 ankur.sing 10350 
 
10351 
  def read(self, iprot):
10352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10354 
      return
10355 
    iprot.readStructBegin()
10356 
    while True:
10357 
      (fname, ftype, fid) = iprot.readFieldBegin()
10358 
      if ftype == TType.STOP:
10359 
        break
3064 chandransh 10360 
      if fid == 1:
1596 ankur.sing 10361 
        if ftype == TType.I64:
3064 chandransh 10362 
          self.providerId = iprot.readI64();
1596 ankur.sing 10363 
        else:
10364 
          iprot.skip(ftype)
3064 chandransh 10365 
      elif fid == 2:
10366 
        if ftype == TType.MAP:
10367 
          self.returnedOrders = {}
4133 chandransh 10368 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
10369 
          for _i169 in xrange(_size165):
10370 
            _key170 = iprot.readString();
10371 
            _val171 = iprot.readString();
10372 
            self.returnedOrders[_key170] = _val171
3064 chandransh 10373 
          iprot.readMapEnd()
10374 
        else:
10375 
          iprot.skip(ftype)
1596 ankur.sing 10376 
      else:
10377 
        iprot.skip(ftype)
10378 
      iprot.readFieldEnd()
10379 
    iprot.readStructEnd()
10380 
 
10381 
  def write(self, oprot):
10382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10384 
      return
3064 chandransh 10385 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 10386 
    if self.providerId is not None:
3064 chandransh 10387 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10388 
      oprot.writeI64(self.providerId)
1596 ankur.sing 10389 
      oprot.writeFieldEnd()
3431 rajveer 10390 
    if self.returnedOrders is not None:
3064 chandransh 10391 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
10392 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 10393 
      for kiter172,viter173 in self.returnedOrders.items():
10394 
        oprot.writeString(kiter172)
10395 
        oprot.writeString(viter173)
3064 chandransh 10396 
      oprot.writeMapEnd()
10397 
      oprot.writeFieldEnd()
1596 ankur.sing 10398 
    oprot.writeFieldStop()
10399 
    oprot.writeStructEnd()
10400 
 
3431 rajveer 10401 
  def validate(self):
10402 
    return
10403 
 
10404 
 
1596 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 markOrdersAsFailed_result:
10417 
  """
10418 
  Attributes:
10419 
   - ex
10420 
  """
1596 ankur.sing 10421 
 
1627 ankur.sing 10422 
  thrift_spec = (
3064 chandransh 10423 
    None, # 0
10424 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10425 
  )
10426 
 
3064 chandransh 10427 
  def __init__(self, ex=None,):
10428 
    self.ex = ex
10429 
 
1627 ankur.sing 10430 
  def read(self, iprot):
10431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10433 
      return
10434 
    iprot.readStructBegin()
10435 
    while True:
10436 
      (fname, ftype, fid) = iprot.readFieldBegin()
10437 
      if ftype == TType.STOP:
10438 
        break
3064 chandransh 10439 
      if fid == 1:
10440 
        if ftype == TType.STRUCT:
10441 
          self.ex = TransactionServiceException()
10442 
          self.ex.read(iprot)
10443 
        else:
10444 
          iprot.skip(ftype)
1627 ankur.sing 10445 
      else:
10446 
        iprot.skip(ftype)
10447 
      iprot.readFieldEnd()
10448 
    iprot.readStructEnd()
10449 
 
10450 
  def write(self, oprot):
10451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10453 
      return
3064 chandransh 10454 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 10455 
    if self.ex is not None:
3064 chandransh 10456 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10457 
      self.ex.write(oprot)
10458 
      oprot.writeFieldEnd()
1627 ankur.sing 10459 
    oprot.writeFieldStop()
10460 
    oprot.writeStructEnd()
10461 
 
3431 rajveer 10462 
  def validate(self):
10463 
    return
10464 
 
10465 
 
1627 ankur.sing 10466 
  def __repr__(self):
10467 
    L = ['%s=%r' % (key, value)
10468 
      for key, value in self.__dict__.iteritems()]
10469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10470 
 
10471 
  def __eq__(self, other):
10472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10473 
 
10474 
  def __ne__(self, other):
10475 
    return not (self == other)
10476 
 
3064 chandransh 10477 
class updateNonDeliveryReason_args:
1627 ankur.sing 10478 
  """
10479 
  Attributes:
3064 chandransh 10480 
   - providerId
10481 
   - undeliveredOrders
1627 ankur.sing 10482 
  """
10483 
 
10484 
  thrift_spec = (
3064 chandransh 10485 
    None, # 0
10486 
    (1, TType.I64, 'providerId', None, None, ), # 1
10487 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 10488 
  )
10489 
 
3064 chandransh 10490 
  def __init__(self, providerId=None, undeliveredOrders=None,):
10491 
    self.providerId = providerId
10492 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 10493 
 
10494 
  def read(self, iprot):
10495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10497 
      return
10498 
    iprot.readStructBegin()
10499 
    while True:
10500 
      (fname, ftype, fid) = iprot.readFieldBegin()
10501 
      if ftype == TType.STOP:
10502 
        break
3064 chandransh 10503 
      if fid == 1:
1627 ankur.sing 10504 
        if ftype == TType.I64:
3064 chandransh 10505 
          self.providerId = iprot.readI64();
1627 ankur.sing 10506 
        else:
10507 
          iprot.skip(ftype)
3064 chandransh 10508 
      elif fid == 2:
10509 
        if ftype == TType.MAP:
10510 
          self.undeliveredOrders = {}
4133 chandransh 10511 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
10512 
          for _i178 in xrange(_size174):
10513 
            _key179 = iprot.readString();
10514 
            _val180 = iprot.readString();
10515 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 10516 
          iprot.readMapEnd()
10517 
        else:
10518 
          iprot.skip(ftype)
1627 ankur.sing 10519 
      else:
10520 
        iprot.skip(ftype)
10521 
      iprot.readFieldEnd()
10522 
    iprot.readStructEnd()
10523 
 
10524 
  def write(self, oprot):
10525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10527 
      return
3064 chandransh 10528 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 10529 
    if self.providerId is not None:
3064 chandransh 10530 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10531 
      oprot.writeI64(self.providerId)
1627 ankur.sing 10532 
      oprot.writeFieldEnd()
3431 rajveer 10533 
    if self.undeliveredOrders is not None:
3064 chandransh 10534 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
10535 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 10536 
      for kiter181,viter182 in self.undeliveredOrders.items():
10537 
        oprot.writeString(kiter181)
10538 
        oprot.writeString(viter182)
3064 chandransh 10539 
      oprot.writeMapEnd()
10540 
      oprot.writeFieldEnd()
1627 ankur.sing 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 updateNonDeliveryReason_result:
1627 ankur.sing 10560 
  """
10561 
  Attributes:
3064 chandransh 10562 
   - ex
1627 ankur.sing 10563 
  """
10564 
 
10565 
  thrift_spec = (
3064 chandransh 10566 
    None, # 0
10567 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10568 
  )
10569 
 
3064 chandransh 10570 
  def __init__(self, ex=None,):
10571 
    self.ex = ex
1627 ankur.sing 10572 
 
10573 
  def read(self, iprot):
10574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10576 
      return
10577 
    iprot.readStructBegin()
10578 
    while True:
10579 
      (fname, ftype, fid) = iprot.readFieldBegin()
10580 
      if ftype == TType.STOP:
10581 
        break
3064 chandransh 10582 
      if fid == 1:
10583 
        if ftype == TType.STRUCT:
10584 
          self.ex = TransactionServiceException()
10585 
          self.ex.read(iprot)
1627 ankur.sing 10586 
        else:
10587 
          iprot.skip(ftype)
10588 
      else:
10589 
        iprot.skip(ftype)
10590 
      iprot.readFieldEnd()
10591 
    iprot.readStructEnd()
10592 
 
10593 
  def write(self, oprot):
10594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10596 
      return
3064 chandransh 10597 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 10598 
    if self.ex is not None:
3064 chandransh 10599 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10600 
      self.ex.write(oprot)
1627 ankur.sing 10601 
      oprot.writeFieldEnd()
10602 
    oprot.writeFieldStop()
10603 
    oprot.writeStructEnd()
10604 
 
3431 rajveer 10605 
  def validate(self):
10606 
    return
10607 
 
10608 
 
1627 ankur.sing 10609 
  def __repr__(self):
10610 
    L = ['%s=%r' % (key, value)
10611 
      for key, value in self.__dict__.iteritems()]
10612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10613 
 
10614 
  def __eq__(self, other):
10615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10616 
 
10617 
  def __ne__(self, other):
10618 
    return not (self == other)
10619 
 
3064 chandransh 10620 
class getUndeliveredOrders_args:
1886 ankur.sing 10621 
  """
10622 
  Attributes:
3064 chandransh 10623 
   - providerId
10624 
   - warehouseId
1886 ankur.sing 10625 
  """
1627 ankur.sing 10626 
 
1886 ankur.sing 10627 
  thrift_spec = (
10628 
    None, # 0
3064 chandransh 10629 
    (1, TType.I64, 'providerId', None, None, ), # 1
10630 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 10631 
  )
10632 
 
3064 chandransh 10633 
  def __init__(self, providerId=None, warehouseId=None,):
10634 
    self.providerId = providerId
10635 
    self.warehouseId = warehouseId
1886 ankur.sing 10636 
 
10637 
  def read(self, iprot):
10638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10640 
      return
10641 
    iprot.readStructBegin()
10642 
    while True:
10643 
      (fname, ftype, fid) = iprot.readFieldBegin()
10644 
      if ftype == TType.STOP:
10645 
        break
10646 
      if fid == 1:
10647 
        if ftype == TType.I64:
3064 chandransh 10648 
          self.providerId = iprot.readI64();
1886 ankur.sing 10649 
        else:
10650 
          iprot.skip(ftype)
3064 chandransh 10651 
      elif fid == 2:
10652 
        if ftype == TType.I64:
10653 
          self.warehouseId = iprot.readI64();
10654 
        else:
10655 
          iprot.skip(ftype)
1886 ankur.sing 10656 
      else:
10657 
        iprot.skip(ftype)
10658 
      iprot.readFieldEnd()
10659 
    iprot.readStructEnd()
10660 
 
10661 
  def write(self, oprot):
10662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10664 
      return
3064 chandransh 10665 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 10666 
    if self.providerId is not None:
3064 chandransh 10667 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10668 
      oprot.writeI64(self.providerId)
1886 ankur.sing 10669 
      oprot.writeFieldEnd()
3431 rajveer 10670 
    if self.warehouseId is not None:
3064 chandransh 10671 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10672 
      oprot.writeI64(self.warehouseId)
10673 
      oprot.writeFieldEnd()
1886 ankur.sing 10674 
    oprot.writeFieldStop()
10675 
    oprot.writeStructEnd()
10676 
 
3431 rajveer 10677 
  def validate(self):
10678 
    return
10679 
 
10680 
 
1886 ankur.sing 10681 
  def __repr__(self):
10682 
    L = ['%s=%r' % (key, value)
10683 
      for key, value in self.__dict__.iteritems()]
10684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10685 
 
10686 
  def __eq__(self, other):
10687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10688 
 
10689 
  def __ne__(self, other):
10690 
    return not (self == other)
10691 
 
3064 chandransh 10692 
class getUndeliveredOrders_result:
1886 ankur.sing 10693 
  """
10694 
  Attributes:
10695 
   - success
10696 
  """
10697 
 
10698 
  thrift_spec = (
10699 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10700 
  )
10701 
 
10702 
  def __init__(self, success=None,):
10703 
    self.success = success
10704 
 
10705 
  def read(self, iprot):
10706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10708 
      return
10709 
    iprot.readStructBegin()
10710 
    while True:
10711 
      (fname, ftype, fid) = iprot.readFieldBegin()
10712 
      if ftype == TType.STOP:
10713 
        break
10714 
      if fid == 0:
10715 
        if ftype == TType.LIST:
10716 
          self.success = []
4133 chandransh 10717 
          (_etype186, _size183) = iprot.readListBegin()
10718 
          for _i187 in xrange(_size183):
10719 
            _elem188 = Order()
10720 
            _elem188.read(iprot)
10721 
            self.success.append(_elem188)
1886 ankur.sing 10722 
          iprot.readListEnd()
10723 
        else:
10724 
          iprot.skip(ftype)
10725 
      else:
10726 
        iprot.skip(ftype)
10727 
      iprot.readFieldEnd()
10728 
    iprot.readStructEnd()
10729 
 
10730 
  def write(self, oprot):
10731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10733 
      return
3064 chandransh 10734 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 10735 
    if self.success is not None:
1886 ankur.sing 10736 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10737 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10738 
      for iter189 in self.success:
10739 
        iter189.write(oprot)
1886 ankur.sing 10740 
      oprot.writeListEnd()
10741 
      oprot.writeFieldEnd()
10742 
    oprot.writeFieldStop()
10743 
    oprot.writeStructEnd()
10744 
 
3431 rajveer 10745 
  def validate(self):
10746 
    return
10747 
 
10748 
 
1886 ankur.sing 10749 
  def __repr__(self):
10750 
    L = ['%s=%r' % (key, value)
10751 
      for key, value in self.__dict__.iteritems()]
10752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10753 
 
10754 
  def __eq__(self, other):
10755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10756 
 
10757 
  def __ne__(self, other):
10758 
    return not (self == other)
10759 
 
2536 chandransh 10760 
class toggleDOAFlag_args:
10761 
  """
10762 
  Attributes:
10763 
   - orderId
10764 
  """
1886 ankur.sing 10765 
 
2536 chandransh 10766 
  thrift_spec = (
10767 
    None, # 0
10768 
    (1, TType.I64, 'orderId', None, None, ), # 1
10769 
  )
10770 
 
10771 
  def __init__(self, orderId=None,):
10772 
    self.orderId = orderId
10773 
 
10774 
  def read(self, iprot):
10775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10777 
      return
10778 
    iprot.readStructBegin()
10779 
    while True:
10780 
      (fname, ftype, fid) = iprot.readFieldBegin()
10781 
      if ftype == TType.STOP:
10782 
        break
10783 
      if fid == 1:
10784 
        if ftype == TType.I64:
10785 
          self.orderId = iprot.readI64();
10786 
        else:
10787 
          iprot.skip(ftype)
10788 
      else:
10789 
        iprot.skip(ftype)
10790 
      iprot.readFieldEnd()
10791 
    iprot.readStructEnd()
10792 
 
10793 
  def write(self, oprot):
10794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10796 
      return
10797 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 10798 
    if self.orderId is not None:
2536 chandransh 10799 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10800 
      oprot.writeI64(self.orderId)
10801 
      oprot.writeFieldEnd()
10802 
    oprot.writeFieldStop()
10803 
    oprot.writeStructEnd()
10804 
 
3431 rajveer 10805 
  def validate(self):
10806 
    return
10807 
 
10808 
 
2536 chandransh 10809 
  def __repr__(self):
10810 
    L = ['%s=%r' % (key, value)
10811 
      for key, value in self.__dict__.iteritems()]
10812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10813 
 
10814 
  def __eq__(self, other):
10815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10816 
 
10817 
  def __ne__(self, other):
10818 
    return not (self == other)
10819 
 
10820 
class toggleDOAFlag_result:
10821 
  """
10822 
  Attributes:
10823 
   - success
10824 
   - ex
10825 
  """
10826 
 
10827 
  thrift_spec = (
10828 
    (0, TType.BOOL, 'success', None, None, ), # 0
10829 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10830 
  )
10831 
 
10832 
  def __init__(self, success=None, ex=None,):
10833 
    self.success = success
10834 
    self.ex = ex
10835 
 
10836 
  def read(self, iprot):
10837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10839 
      return
10840 
    iprot.readStructBegin()
10841 
    while True:
10842 
      (fname, ftype, fid) = iprot.readFieldBegin()
10843 
      if ftype == TType.STOP:
10844 
        break
10845 
      if fid == 0:
10846 
        if ftype == TType.BOOL:
10847 
          self.success = iprot.readBool();
10848 
        else:
10849 
          iprot.skip(ftype)
10850 
      elif fid == 1:
10851 
        if ftype == TType.STRUCT:
10852 
          self.ex = TransactionServiceException()
10853 
          self.ex.read(iprot)
10854 
        else:
10855 
          iprot.skip(ftype)
10856 
      else:
10857 
        iprot.skip(ftype)
10858 
      iprot.readFieldEnd()
10859 
    iprot.readStructEnd()
10860 
 
10861 
  def write(self, oprot):
10862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10864 
      return
10865 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 10866 
    if self.success is not None:
2536 chandransh 10867 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10868 
      oprot.writeBool(self.success)
10869 
      oprot.writeFieldEnd()
3431 rajveer 10870 
    if self.ex is not None:
2536 chandransh 10871 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10872 
      self.ex.write(oprot)
10873 
      oprot.writeFieldEnd()
10874 
    oprot.writeFieldStop()
10875 
    oprot.writeStructEnd()
10876 
 
3431 rajveer 10877 
  def validate(self):
10878 
    return
10879 
 
10880 
 
2536 chandransh 10881 
  def __repr__(self):
10882 
    L = ['%s=%r' % (key, value)
10883 
      for key, value in self.__dict__.iteritems()]
10884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10885 
 
10886 
  def __eq__(self, other):
10887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10888 
 
10889 
  def __ne__(self, other):
10890 
    return not (self == other)
10891 
 
4454 rajveer 10892 
class markOrderDoaRequestReceived_args:
10893 
  """
10894 
  Attributes:
10895 
   - orderId
10896 
  """
10897 
 
10898 
  thrift_spec = (
10899 
    None, # 0
10900 
    (1, TType.I64, 'orderId', None, None, ), # 1
10901 
  )
10902 
 
10903 
  def __init__(self, orderId=None,):
10904 
    self.orderId = orderId
10905 
 
10906 
  def read(self, iprot):
10907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10909 
      return
10910 
    iprot.readStructBegin()
10911 
    while True:
10912 
      (fname, ftype, fid) = iprot.readFieldBegin()
10913 
      if ftype == TType.STOP:
10914 
        break
10915 
      if fid == 1:
10916 
        if ftype == TType.I64:
10917 
          self.orderId = iprot.readI64();
10918 
        else:
10919 
          iprot.skip(ftype)
10920 
      else:
10921 
        iprot.skip(ftype)
10922 
      iprot.readFieldEnd()
10923 
    iprot.readStructEnd()
10924 
 
10925 
  def write(self, oprot):
10926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10928 
      return
10929 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
10930 
    if self.orderId is not None:
10931 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10932 
      oprot.writeI64(self.orderId)
10933 
      oprot.writeFieldEnd()
10934 
    oprot.writeFieldStop()
10935 
    oprot.writeStructEnd()
10936 
 
10937 
  def validate(self):
10938 
    return
10939 
 
10940 
 
10941 
  def __repr__(self):
10942 
    L = ['%s=%r' % (key, value)
10943 
      for key, value in self.__dict__.iteritems()]
10944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10945 
 
10946 
  def __eq__(self, other):
10947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10948 
 
10949 
  def __ne__(self, other):
10950 
    return not (self == other)
10951 
 
10952 
class markOrderDoaRequestReceived_result:
10953 
  """
10954 
  Attributes:
10955 
   - success
10956 
   - ex
10957 
  """
10958 
 
10959 
  thrift_spec = (
10960 
    (0, TType.BOOL, 'success', None, None, ), # 0
10961 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10962 
  )
10963 
 
10964 
  def __init__(self, success=None, ex=None,):
10965 
    self.success = success
10966 
    self.ex = ex
10967 
 
10968 
  def read(self, iprot):
10969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10971 
      return
10972 
    iprot.readStructBegin()
10973 
    while True:
10974 
      (fname, ftype, fid) = iprot.readFieldBegin()
10975 
      if ftype == TType.STOP:
10976 
        break
10977 
      if fid == 0:
10978 
        if ftype == TType.BOOL:
10979 
          self.success = iprot.readBool();
10980 
        else:
10981 
          iprot.skip(ftype)
10982 
      elif fid == 1:
10983 
        if ftype == TType.STRUCT:
10984 
          self.ex = TransactionServiceException()
10985 
          self.ex.read(iprot)
10986 
        else:
10987 
          iprot.skip(ftype)
10988 
      else:
10989 
        iprot.skip(ftype)
10990 
      iprot.readFieldEnd()
10991 
    iprot.readStructEnd()
10992 
 
10993 
  def write(self, oprot):
10994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10996 
      return
10997 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
10998 
    if self.success is not None:
10999 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11000 
      oprot.writeBool(self.success)
11001 
      oprot.writeFieldEnd()
11002 
    if self.ex is not None:
11003 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11004 
      self.ex.write(oprot)
11005 
      oprot.writeFieldEnd()
11006 
    oprot.writeFieldStop()
11007 
    oprot.writeStructEnd()
11008 
 
11009 
  def validate(self):
11010 
    return
11011 
 
11012 
 
11013 
  def __repr__(self):
11014 
    L = ['%s=%r' % (key, value)
11015 
      for key, value in self.__dict__.iteritems()]
11016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11017 
 
11018 
  def __eq__(self, other):
11019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11020 
 
11021 
  def __ne__(self, other):
11022 
    return not (self == other)
11023 
 
11024 
class markOrderDoaRequestAuthorized_args:
11025 
  """
11026 
  Attributes:
11027 
   - orderId
11028 
   - isAuthorized
11029 
  """
11030 
 
11031 
  thrift_spec = (
11032 
    None, # 0
11033 
    (1, TType.I64, 'orderId', None, None, ), # 1
11034 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11035 
  )
11036 
 
11037 
  def __init__(self, orderId=None, isAuthorized=None,):
11038 
    self.orderId = orderId
11039 
    self.isAuthorized = isAuthorized
11040 
 
11041 
  def read(self, iprot):
11042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11044 
      return
11045 
    iprot.readStructBegin()
11046 
    while True:
11047 
      (fname, ftype, fid) = iprot.readFieldBegin()
11048 
      if ftype == TType.STOP:
11049 
        break
11050 
      if fid == 1:
11051 
        if ftype == TType.I64:
11052 
          self.orderId = iprot.readI64();
11053 
        else:
11054 
          iprot.skip(ftype)
11055 
      elif fid == 2:
11056 
        if ftype == TType.BOOL:
11057 
          self.isAuthorized = iprot.readBool();
11058 
        else:
11059 
          iprot.skip(ftype)
11060 
      else:
11061 
        iprot.skip(ftype)
11062 
      iprot.readFieldEnd()
11063 
    iprot.readStructEnd()
11064 
 
11065 
  def write(self, oprot):
11066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11068 
      return
11069 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
11070 
    if self.orderId is not None:
11071 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11072 
      oprot.writeI64(self.orderId)
11073 
      oprot.writeFieldEnd()
11074 
    if self.isAuthorized is not None:
11075 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11076 
      oprot.writeBool(self.isAuthorized)
11077 
      oprot.writeFieldEnd()
11078 
    oprot.writeFieldStop()
11079 
    oprot.writeStructEnd()
11080 
 
11081 
  def validate(self):
11082 
    return
11083 
 
11084 
 
11085 
  def __repr__(self):
11086 
    L = ['%s=%r' % (key, value)
11087 
      for key, value in self.__dict__.iteritems()]
11088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11089 
 
11090 
  def __eq__(self, other):
11091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11092 
 
11093 
  def __ne__(self, other):
11094 
    return not (self == other)
11095 
 
11096 
class markOrderDoaRequestAuthorized_result:
11097 
  """
11098 
  Attributes:
11099 
   - success
11100 
   - ex
11101 
  """
11102 
 
11103 
  thrift_spec = (
11104 
    (0, TType.BOOL, 'success', None, None, ), # 0
11105 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11106 
  )
11107 
 
11108 
  def __init__(self, success=None, ex=None,):
11109 
    self.success = success
11110 
    self.ex = ex
11111 
 
11112 
  def read(self, iprot):
11113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11115 
      return
11116 
    iprot.readStructBegin()
11117 
    while True:
11118 
      (fname, ftype, fid) = iprot.readFieldBegin()
11119 
      if ftype == TType.STOP:
11120 
        break
11121 
      if fid == 0:
11122 
        if ftype == TType.BOOL:
11123 
          self.success = iprot.readBool();
11124 
        else:
11125 
          iprot.skip(ftype)
11126 
      elif fid == 1:
11127 
        if ftype == TType.STRUCT:
11128 
          self.ex = TransactionServiceException()
11129 
          self.ex.read(iprot)
11130 
        else:
11131 
          iprot.skip(ftype)
11132 
      else:
11133 
        iprot.skip(ftype)
11134 
      iprot.readFieldEnd()
11135 
    iprot.readStructEnd()
11136 
 
11137 
  def write(self, oprot):
11138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11140 
      return
11141 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
11142 
    if self.success is not None:
11143 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11144 
      oprot.writeBool(self.success)
11145 
      oprot.writeFieldEnd()
11146 
    if self.ex is not None:
11147 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11148 
      self.ex.write(oprot)
11149 
      oprot.writeFieldEnd()
11150 
    oprot.writeFieldStop()
11151 
    oprot.writeStructEnd()
11152 
 
11153 
  def validate(self):
11154 
    return
11155 
 
11156 
 
11157 
  def __repr__(self):
11158 
    L = ['%s=%r' % (key, value)
11159 
      for key, value in self.__dict__.iteritems()]
11160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11161 
 
11162 
  def __eq__(self, other):
11163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11164 
 
11165 
  def __ne__(self, other):
11166 
    return not (self == other)
11167 
 
4488 rajveer 11168 
class markOrderReturnRequestReceived_args:
11169 
  """
11170 
  Attributes:
11171 
   - orderId
11172 
  """
11173 
 
11174 
  thrift_spec = (
11175 
    None, # 0
11176 
    (1, TType.I64, 'orderId', None, None, ), # 1
11177 
  )
11178 
 
11179 
  def __init__(self, orderId=None,):
11180 
    self.orderId = orderId
11181 
 
11182 
  def read(self, iprot):
11183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11185 
      return
11186 
    iprot.readStructBegin()
11187 
    while True:
11188 
      (fname, ftype, fid) = iprot.readFieldBegin()
11189 
      if ftype == TType.STOP:
11190 
        break
11191 
      if fid == 1:
11192 
        if ftype == TType.I64:
11193 
          self.orderId = iprot.readI64();
11194 
        else:
11195 
          iprot.skip(ftype)
11196 
      else:
11197 
        iprot.skip(ftype)
11198 
      iprot.readFieldEnd()
11199 
    iprot.readStructEnd()
11200 
 
11201 
  def write(self, oprot):
11202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11204 
      return
11205 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
11206 
    if self.orderId is not None:
11207 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11208 
      oprot.writeI64(self.orderId)
11209 
      oprot.writeFieldEnd()
11210 
    oprot.writeFieldStop()
11211 
    oprot.writeStructEnd()
11212 
 
11213 
  def validate(self):
11214 
    return
11215 
 
11216 
 
11217 
  def __repr__(self):
11218 
    L = ['%s=%r' % (key, value)
11219 
      for key, value in self.__dict__.iteritems()]
11220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11221 
 
11222 
  def __eq__(self, other):
11223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11224 
 
11225 
  def __ne__(self, other):
11226 
    return not (self == other)
11227 
 
11228 
class markOrderReturnRequestReceived_result:
11229 
  """
11230 
  Attributes:
11231 
   - success
11232 
   - ex
11233 
  """
11234 
 
11235 
  thrift_spec = (
11236 
    (0, TType.BOOL, 'success', None, None, ), # 0
11237 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11238 
  )
11239 
 
11240 
  def __init__(self, success=None, ex=None,):
11241 
    self.success = success
11242 
    self.ex = ex
11243 
 
11244 
  def read(self, iprot):
11245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11247 
      return
11248 
    iprot.readStructBegin()
11249 
    while True:
11250 
      (fname, ftype, fid) = iprot.readFieldBegin()
11251 
      if ftype == TType.STOP:
11252 
        break
11253 
      if fid == 0:
11254 
        if ftype == TType.BOOL:
11255 
          self.success = iprot.readBool();
11256 
        else:
11257 
          iprot.skip(ftype)
11258 
      elif fid == 1:
11259 
        if ftype == TType.STRUCT:
11260 
          self.ex = TransactionServiceException()
11261 
          self.ex.read(iprot)
11262 
        else:
11263 
          iprot.skip(ftype)
11264 
      else:
11265 
        iprot.skip(ftype)
11266 
      iprot.readFieldEnd()
11267 
    iprot.readStructEnd()
11268 
 
11269 
  def write(self, oprot):
11270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11272 
      return
11273 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
11274 
    if self.success is not None:
11275 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11276 
      oprot.writeBool(self.success)
11277 
      oprot.writeFieldEnd()
11278 
    if self.ex is not None:
11279 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11280 
      self.ex.write(oprot)
11281 
      oprot.writeFieldEnd()
11282 
    oprot.writeFieldStop()
11283 
    oprot.writeStructEnd()
11284 
 
11285 
  def validate(self):
11286 
    return
11287 
 
11288 
 
11289 
  def __repr__(self):
11290 
    L = ['%s=%r' % (key, value)
11291 
      for key, value in self.__dict__.iteritems()]
11292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11293 
 
11294 
  def __eq__(self, other):
11295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11296 
 
11297 
  def __ne__(self, other):
11298 
    return not (self == other)
11299 
 
11300 
class markOrderReturnRequestAuthorized_args:
11301 
  """
11302 
  Attributes:
11303 
   - orderId
11304 
   - isAuthorized
11305 
  """
11306 
 
11307 
  thrift_spec = (
11308 
    None, # 0
11309 
    (1, TType.I64, 'orderId', None, None, ), # 1
11310 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11311 
  )
11312 
 
11313 
  def __init__(self, orderId=None, isAuthorized=None,):
11314 
    self.orderId = orderId
11315 
    self.isAuthorized = isAuthorized
11316 
 
11317 
  def read(self, iprot):
11318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11320 
      return
11321 
    iprot.readStructBegin()
11322 
    while True:
11323 
      (fname, ftype, fid) = iprot.readFieldBegin()
11324 
      if ftype == TType.STOP:
11325 
        break
11326 
      if fid == 1:
11327 
        if ftype == TType.I64:
11328 
          self.orderId = iprot.readI64();
11329 
        else:
11330 
          iprot.skip(ftype)
11331 
      elif fid == 2:
11332 
        if ftype == TType.BOOL:
11333 
          self.isAuthorized = iprot.readBool();
11334 
        else:
11335 
          iprot.skip(ftype)
11336 
      else:
11337 
        iprot.skip(ftype)
11338 
      iprot.readFieldEnd()
11339 
    iprot.readStructEnd()
11340 
 
11341 
  def write(self, oprot):
11342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11344 
      return
11345 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
11346 
    if self.orderId is not None:
11347 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11348 
      oprot.writeI64(self.orderId)
11349 
      oprot.writeFieldEnd()
11350 
    if self.isAuthorized is not None:
11351 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11352 
      oprot.writeBool(self.isAuthorized)
11353 
      oprot.writeFieldEnd()
11354 
    oprot.writeFieldStop()
11355 
    oprot.writeStructEnd()
11356 
 
11357 
  def validate(self):
11358 
    return
11359 
 
11360 
 
11361 
  def __repr__(self):
11362 
    L = ['%s=%r' % (key, value)
11363 
      for key, value in self.__dict__.iteritems()]
11364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11365 
 
11366 
  def __eq__(self, other):
11367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11368 
 
11369 
  def __ne__(self, other):
11370 
    return not (self == other)
11371 
 
11372 
class markOrderReturnRequestAuthorized_result:
11373 
  """
11374 
  Attributes:
11375 
   - success
11376 
   - ex
11377 
  """
11378 
 
11379 
  thrift_spec = (
11380 
    (0, TType.BOOL, 'success', None, None, ), # 0
11381 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11382 
  )
11383 
 
11384 
  def __init__(self, success=None, ex=None,):
11385 
    self.success = success
11386 
    self.ex = ex
11387 
 
11388 
  def read(self, iprot):
11389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11391 
      return
11392 
    iprot.readStructBegin()
11393 
    while True:
11394 
      (fname, ftype, fid) = iprot.readFieldBegin()
11395 
      if ftype == TType.STOP:
11396 
        break
11397 
      if fid == 0:
11398 
        if ftype == TType.BOOL:
11399 
          self.success = iprot.readBool();
11400 
        else:
11401 
          iprot.skip(ftype)
11402 
      elif fid == 1:
11403 
        if ftype == TType.STRUCT:
11404 
          self.ex = TransactionServiceException()
11405 
          self.ex.read(iprot)
11406 
        else:
11407 
          iprot.skip(ftype)
11408 
      else:
11409 
        iprot.skip(ftype)
11410 
      iprot.readFieldEnd()
11411 
    iprot.readStructEnd()
11412 
 
11413 
  def write(self, oprot):
11414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11416 
      return
11417 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
11418 
    if self.success is not None:
11419 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11420 
      oprot.writeBool(self.success)
11421 
      oprot.writeFieldEnd()
11422 
    if self.ex is not None:
11423 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11424 
      self.ex.write(oprot)
11425 
      oprot.writeFieldEnd()
11426 
    oprot.writeFieldStop()
11427 
    oprot.writeStructEnd()
11428 
 
11429 
  def validate(self):
11430 
    return
11431 
 
11432 
 
11433 
  def __repr__(self):
11434 
    L = ['%s=%r' % (key, value)
11435 
      for key, value in self.__dict__.iteritems()]
11436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11437 
 
11438 
  def __eq__(self, other):
11439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11440 
 
11441 
  def __ne__(self, other):
11442 
    return not (self == other)
11443 
 
2536 chandransh 11444 
class requestPickupNumber_args:
11445 
  """
11446 
  Attributes:
11447 
   - orderId
11448 
  """
11449 
 
11450 
  thrift_spec = (
11451 
    None, # 0
11452 
    (1, TType.I64, 'orderId', None, None, ), # 1
11453 
  )
11454 
 
11455 
  def __init__(self, orderId=None,):
11456 
    self.orderId = orderId
11457 
 
11458 
  def read(self, iprot):
11459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11461 
      return
11462 
    iprot.readStructBegin()
11463 
    while True:
11464 
      (fname, ftype, fid) = iprot.readFieldBegin()
11465 
      if ftype == TType.STOP:
11466 
        break
11467 
      if fid == 1:
11468 
        if ftype == TType.I64:
11469 
          self.orderId = iprot.readI64();
11470 
        else:
11471 
          iprot.skip(ftype)
11472 
      else:
11473 
        iprot.skip(ftype)
11474 
      iprot.readFieldEnd()
11475 
    iprot.readStructEnd()
11476 
 
11477 
  def write(self, oprot):
11478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11480 
      return
11481 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 11482 
    if self.orderId is not None:
2536 chandransh 11483 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11484 
      oprot.writeI64(self.orderId)
11485 
      oprot.writeFieldEnd()
11486 
    oprot.writeFieldStop()
11487 
    oprot.writeStructEnd()
11488 
 
3431 rajveer 11489 
  def validate(self):
11490 
    return
11491 
 
11492 
 
2536 chandransh 11493 
  def __repr__(self):
11494 
    L = ['%s=%r' % (key, value)
11495 
      for key, value in self.__dict__.iteritems()]
11496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11497 
 
11498 
  def __eq__(self, other):
11499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11500 
 
11501 
  def __ne__(self, other):
11502 
    return not (self == other)
11503 
 
11504 
class requestPickupNumber_result:
11505 
  """
11506 
  Attributes:
11507 
   - success
11508 
   - ex
11509 
  """
11510 
 
11511 
  thrift_spec = (
11512 
    (0, TType.BOOL, 'success', None, None, ), # 0
11513 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11514 
  )
11515 
 
11516 
  def __init__(self, success=None, ex=None,):
11517 
    self.success = success
11518 
    self.ex = ex
11519 
 
11520 
  def read(self, iprot):
11521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11523 
      return
11524 
    iprot.readStructBegin()
11525 
    while True:
11526 
      (fname, ftype, fid) = iprot.readFieldBegin()
11527 
      if ftype == TType.STOP:
11528 
        break
11529 
      if fid == 0:
11530 
        if ftype == TType.BOOL:
11531 
          self.success = iprot.readBool();
11532 
        else:
11533 
          iprot.skip(ftype)
11534 
      elif fid == 1:
11535 
        if ftype == TType.STRUCT:
11536 
          self.ex = TransactionServiceException()
11537 
          self.ex.read(iprot)
11538 
        else:
11539 
          iprot.skip(ftype)
11540 
      else:
11541 
        iprot.skip(ftype)
11542 
      iprot.readFieldEnd()
11543 
    iprot.readStructEnd()
11544 
 
11545 
  def write(self, oprot):
11546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11548 
      return
11549 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 11550 
    if self.success is not None:
2536 chandransh 11551 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11552 
      oprot.writeBool(self.success)
11553 
      oprot.writeFieldEnd()
3431 rajveer 11554 
    if self.ex is not None:
2536 chandransh 11555 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11556 
      self.ex.write(oprot)
11557 
      oprot.writeFieldEnd()
11558 
    oprot.writeFieldStop()
11559 
    oprot.writeStructEnd()
11560 
 
3431 rajveer 11561 
  def validate(self):
11562 
    return
11563 
 
11564 
 
2536 chandransh 11565 
  def __repr__(self):
11566 
    L = ['%s=%r' % (key, value)
11567 
      for key, value in self.__dict__.iteritems()]
11568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11569 
 
11570 
  def __eq__(self, other):
11571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11572 
 
11573 
  def __ne__(self, other):
11574 
    return not (self == other)
11575 
 
11576 
class authorizePickup_args:
11577 
  """
11578 
  Attributes:
11579 
   - orderId
11580 
   - pickupNumber
11581 
  """
11582 
 
11583 
  thrift_spec = (
11584 
    None, # 0
11585 
    (1, TType.I64, 'orderId', None, None, ), # 1
11586 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
11587 
  )
11588 
 
11589 
  def __init__(self, orderId=None, pickupNumber=None,):
11590 
    self.orderId = orderId
11591 
    self.pickupNumber = pickupNumber
11592 
 
11593 
  def read(self, iprot):
11594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11596 
      return
11597 
    iprot.readStructBegin()
11598 
    while True:
11599 
      (fname, ftype, fid) = iprot.readFieldBegin()
11600 
      if ftype == TType.STOP:
11601 
        break
11602 
      if fid == 1:
11603 
        if ftype == TType.I64:
11604 
          self.orderId = iprot.readI64();
11605 
        else:
11606 
          iprot.skip(ftype)
11607 
      elif fid == 2:
11608 
        if ftype == TType.STRING:
11609 
          self.pickupNumber = iprot.readString();
11610 
        else:
11611 
          iprot.skip(ftype)
11612 
      else:
11613 
        iprot.skip(ftype)
11614 
      iprot.readFieldEnd()
11615 
    iprot.readStructEnd()
11616 
 
11617 
  def write(self, oprot):
11618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11620 
      return
11621 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 11622 
    if self.orderId is not None:
2536 chandransh 11623 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11624 
      oprot.writeI64(self.orderId)
11625 
      oprot.writeFieldEnd()
3431 rajveer 11626 
    if self.pickupNumber is not None:
2536 chandransh 11627 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
11628 
      oprot.writeString(self.pickupNumber)
11629 
      oprot.writeFieldEnd()
11630 
    oprot.writeFieldStop()
11631 
    oprot.writeStructEnd()
11632 
 
3431 rajveer 11633 
  def validate(self):
11634 
    return
11635 
 
11636 
 
2536 chandransh 11637 
  def __repr__(self):
11638 
    L = ['%s=%r' % (key, value)
11639 
      for key, value in self.__dict__.iteritems()]
11640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11641 
 
11642 
  def __eq__(self, other):
11643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11644 
 
11645 
  def __ne__(self, other):
11646 
    return not (self == other)
11647 
 
11648 
class authorizePickup_result:
11649 
  """
11650 
  Attributes:
11651 
   - success
11652 
   - ex
11653 
  """
11654 
 
11655 
  thrift_spec = (
11656 
    (0, TType.BOOL, 'success', None, None, ), # 0
11657 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11658 
  )
11659 
 
11660 
  def __init__(self, success=None, ex=None,):
11661 
    self.success = success
11662 
    self.ex = ex
11663 
 
11664 
  def read(self, iprot):
11665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11667 
      return
11668 
    iprot.readStructBegin()
11669 
    while True:
11670 
      (fname, ftype, fid) = iprot.readFieldBegin()
11671 
      if ftype == TType.STOP:
11672 
        break
11673 
      if fid == 0:
11674 
        if ftype == TType.BOOL:
11675 
          self.success = iprot.readBool();
11676 
        else:
11677 
          iprot.skip(ftype)
11678 
      elif fid == 1:
11679 
        if ftype == TType.STRUCT:
11680 
          self.ex = TransactionServiceException()
11681 
          self.ex.read(iprot)
11682 
        else:
11683 
          iprot.skip(ftype)
11684 
      else:
11685 
        iprot.skip(ftype)
11686 
      iprot.readFieldEnd()
11687 
    iprot.readStructEnd()
11688 
 
11689 
  def write(self, oprot):
11690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11692 
      return
11693 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 11694 
    if self.success is not None:
2536 chandransh 11695 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11696 
      oprot.writeBool(self.success)
11697 
      oprot.writeFieldEnd()
3431 rajveer 11698 
    if self.ex is not None:
2536 chandransh 11699 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11700 
      self.ex.write(oprot)
11701 
      oprot.writeFieldEnd()
11702 
    oprot.writeFieldStop()
11703 
    oprot.writeStructEnd()
11704 
 
3431 rajveer 11705 
  def validate(self):
11706 
    return
11707 
 
11708 
 
2536 chandransh 11709 
  def __repr__(self):
11710 
    L = ['%s=%r' % (key, value)
11711 
      for key, value in self.__dict__.iteritems()]
11712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11713 
 
11714 
  def __eq__(self, other):
11715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11716 
 
11717 
  def __ne__(self, other):
11718 
    return not (self == other)
11719 
 
2764 chandransh 11720 
class markDoasAsPickedUp_args:
11721 
  """
11722 
  Attributes:
11723 
   - providerId
11724 
   - pickupDetails
11725 
  """
11726 
 
11727 
  thrift_spec = (
11728 
    None, # 0
11729 
    (1, TType.I64, 'providerId', None, None, ), # 1
11730 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
11731 
  )
11732 
 
11733 
  def __init__(self, providerId=None, pickupDetails=None,):
11734 
    self.providerId = providerId
11735 
    self.pickupDetails = pickupDetails
11736 
 
11737 
  def read(self, iprot):
11738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11740 
      return
11741 
    iprot.readStructBegin()
11742 
    while True:
11743 
      (fname, ftype, fid) = iprot.readFieldBegin()
11744 
      if ftype == TType.STOP:
11745 
        break
11746 
      if fid == 1:
11747 
        if ftype == TType.I64:
11748 
          self.providerId = iprot.readI64();
11749 
        else:
11750 
          iprot.skip(ftype)
11751 
      elif fid == 2:
11752 
        if ftype == TType.MAP:
11753 
          self.pickupDetails = {}
4133 chandransh 11754 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
11755 
          for _i194 in xrange(_size190):
11756 
            _key195 = iprot.readString();
11757 
            _val196 = iprot.readString();
11758 
            self.pickupDetails[_key195] = _val196
2764 chandransh 11759 
          iprot.readMapEnd()
11760 
        else:
11761 
          iprot.skip(ftype)
11762 
      else:
11763 
        iprot.skip(ftype)
11764 
      iprot.readFieldEnd()
11765 
    iprot.readStructEnd()
11766 
 
11767 
  def write(self, oprot):
11768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11770 
      return
11771 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 11772 
    if self.providerId is not None:
2764 chandransh 11773 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11774 
      oprot.writeI64(self.providerId)
11775 
      oprot.writeFieldEnd()
3431 rajveer 11776 
    if self.pickupDetails is not None:
2764 chandransh 11777 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11778 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 11779 
      for kiter197,viter198 in self.pickupDetails.items():
11780 
        oprot.writeString(kiter197)
11781 
        oprot.writeString(viter198)
2764 chandransh 11782 
      oprot.writeMapEnd()
11783 
      oprot.writeFieldEnd()
11784 
    oprot.writeFieldStop()
11785 
    oprot.writeStructEnd()
11786 
 
3431 rajveer 11787 
  def validate(self):
11788 
    return
11789 
 
11790 
 
2764 chandransh 11791 
  def __repr__(self):
11792 
    L = ['%s=%r' % (key, value)
11793 
      for key, value in self.__dict__.iteritems()]
11794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11795 
 
11796 
  def __eq__(self, other):
11797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11798 
 
11799 
  def __ne__(self, other):
11800 
    return not (self == other)
11801 
 
11802 
class markDoasAsPickedUp_result:
11803 
  """
11804 
  Attributes:
11805 
   - success
11806 
  """
11807 
 
11808 
  thrift_spec = (
11809 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11810 
  )
11811 
 
11812 
  def __init__(self, success=None,):
11813 
    self.success = success
11814 
 
11815 
  def read(self, iprot):
11816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11818 
      return
11819 
    iprot.readStructBegin()
11820 
    while True:
11821 
      (fname, ftype, fid) = iprot.readFieldBegin()
11822 
      if ftype == TType.STOP:
11823 
        break
11824 
      if fid == 0:
11825 
        if ftype == TType.LIST:
11826 
          self.success = []
4133 chandransh 11827 
          (_etype202, _size199) = iprot.readListBegin()
11828 
          for _i203 in xrange(_size199):
11829 
            _elem204 = Order()
11830 
            _elem204.read(iprot)
11831 
            self.success.append(_elem204)
2764 chandransh 11832 
          iprot.readListEnd()
11833 
        else:
11834 
          iprot.skip(ftype)
11835 
      else:
11836 
        iprot.skip(ftype)
11837 
      iprot.readFieldEnd()
11838 
    iprot.readStructEnd()
11839 
 
11840 
  def write(self, oprot):
11841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11843 
      return
11844 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 11845 
    if self.success is not None:
2764 chandransh 11846 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11847 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11848 
      for iter205 in self.success:
11849 
        iter205.write(oprot)
2764 chandransh 11850 
      oprot.writeListEnd()
11851 
      oprot.writeFieldEnd()
11852 
    oprot.writeFieldStop()
11853 
    oprot.writeStructEnd()
11854 
 
3431 rajveer 11855 
  def validate(self):
11856 
    return
11857 
 
11858 
 
2764 chandransh 11859 
  def __repr__(self):
11860 
    L = ['%s=%r' % (key, value)
11861 
      for key, value in self.__dict__.iteritems()]
11862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11863 
 
11864 
  def __eq__(self, other):
11865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11866 
 
11867 
  def __ne__(self, other):
11868 
    return not (self == other)
11869 
 
2616 chandransh 11870 
class receiveReturn_args:
2591 chandransh 11871 
  """
11872 
  Attributes:
11873 
   - orderId
4479 rajveer 11874 
   - receiveCondition
2591 chandransh 11875 
  """
2536 chandransh 11876 
 
2591 chandransh 11877 
  thrift_spec = (
11878 
    None, # 0
11879 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 11880 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 11881 
  )
11882 
 
4479 rajveer 11883 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 11884 
    self.orderId = orderId
4479 rajveer 11885 
    self.receiveCondition = receiveCondition
2591 chandransh 11886 
 
11887 
  def read(self, iprot):
11888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11890 
      return
11891 
    iprot.readStructBegin()
11892 
    while True:
11893 
      (fname, ftype, fid) = iprot.readFieldBegin()
11894 
      if ftype == TType.STOP:
11895 
        break
11896 
      if fid == 1:
11897 
        if ftype == TType.I64:
11898 
          self.orderId = iprot.readI64();
11899 
        else:
11900 
          iprot.skip(ftype)
4479 rajveer 11901 
      elif fid == 2:
11902 
        if ftype == TType.I64:
11903 
          self.receiveCondition = iprot.readI64();
11904 
        else:
11905 
          iprot.skip(ftype)
2591 chandransh 11906 
      else:
11907 
        iprot.skip(ftype)
11908 
      iprot.readFieldEnd()
11909 
    iprot.readStructEnd()
11910 
 
11911 
  def write(self, oprot):
11912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11914 
      return
2616 chandransh 11915 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 11916 
    if self.orderId is not None:
2591 chandransh 11917 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11918 
      oprot.writeI64(self.orderId)
11919 
      oprot.writeFieldEnd()
4479 rajveer 11920 
    if self.receiveCondition is not None:
11921 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
11922 
      oprot.writeI64(self.receiveCondition)
11923 
      oprot.writeFieldEnd()
2591 chandransh 11924 
    oprot.writeFieldStop()
11925 
    oprot.writeStructEnd()
11926 
 
3431 rajveer 11927 
  def validate(self):
11928 
    return
11929 
 
11930 
 
2591 chandransh 11931 
  def __repr__(self):
11932 
    L = ['%s=%r' % (key, value)
11933 
      for key, value in self.__dict__.iteritems()]
11934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11935 
 
11936 
  def __eq__(self, other):
11937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11938 
 
11939 
  def __ne__(self, other):
11940 
    return not (self == other)
11941 
 
2616 chandransh 11942 
class receiveReturn_result:
2591 chandransh 11943 
  """
11944 
  Attributes:
11945 
   - success
11946 
   - ex
11947 
  """
11948 
 
11949 
  thrift_spec = (
11950 
    (0, TType.BOOL, 'success', None, None, ), # 0
11951 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11952 
  )
11953 
 
11954 
  def __init__(self, success=None, ex=None,):
11955 
    self.success = success
11956 
    self.ex = ex
11957 
 
11958 
  def read(self, iprot):
11959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11961 
      return
11962 
    iprot.readStructBegin()
11963 
    while True:
11964 
      (fname, ftype, fid) = iprot.readFieldBegin()
11965 
      if ftype == TType.STOP:
11966 
        break
11967 
      if fid == 0:
11968 
        if ftype == TType.BOOL:
11969 
          self.success = iprot.readBool();
11970 
        else:
11971 
          iprot.skip(ftype)
11972 
      elif fid == 1:
11973 
        if ftype == TType.STRUCT:
11974 
          self.ex = TransactionServiceException()
11975 
          self.ex.read(iprot)
11976 
        else:
11977 
          iprot.skip(ftype)
11978 
      else:
11979 
        iprot.skip(ftype)
11980 
      iprot.readFieldEnd()
11981 
    iprot.readStructEnd()
11982 
 
11983 
  def write(self, oprot):
11984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11986 
      return
2616 chandransh 11987 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 11988 
    if self.success is not None:
2591 chandransh 11989 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11990 
      oprot.writeBool(self.success)
11991 
      oprot.writeFieldEnd()
3431 rajveer 11992 
    if self.ex is not None:
2591 chandransh 11993 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11994 
      self.ex.write(oprot)
11995 
      oprot.writeFieldEnd()
11996 
    oprot.writeFieldStop()
11997 
    oprot.writeStructEnd()
11998 
 
3431 rajveer 11999 
  def validate(self):
12000 
    return
12001 
 
12002 
 
2591 chandransh 12003 
  def __repr__(self):
12004 
    L = ['%s=%r' % (key, value)
12005 
      for key, value in self.__dict__.iteritems()]
12006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12007 
 
12008 
  def __eq__(self, other):
12009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12010 
 
12011 
  def __ne__(self, other):
12012 
    return not (self == other)
12013 
 
12014 
class validateDoa_args:
12015 
  """
12016 
  Attributes:
12017 
   - orderId
12018 
   - isValid
12019 
  """
12020 
 
12021 
  thrift_spec = (
12022 
    None, # 0
12023 
    (1, TType.I64, 'orderId', None, None, ), # 1
12024 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
12025 
  )
12026 
 
12027 
  def __init__(self, orderId=None, isValid=None,):
12028 
    self.orderId = orderId
12029 
    self.isValid = isValid
12030 
 
12031 
  def read(self, iprot):
12032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12034 
      return
12035 
    iprot.readStructBegin()
12036 
    while True:
12037 
      (fname, ftype, fid) = iprot.readFieldBegin()
12038 
      if ftype == TType.STOP:
12039 
        break
12040 
      if fid == 1:
12041 
        if ftype == TType.I64:
12042 
          self.orderId = iprot.readI64();
12043 
        else:
12044 
          iprot.skip(ftype)
12045 
      elif fid == 2:
12046 
        if ftype == TType.BOOL:
12047 
          self.isValid = iprot.readBool();
12048 
        else:
12049 
          iprot.skip(ftype)
12050 
      else:
12051 
        iprot.skip(ftype)
12052 
      iprot.readFieldEnd()
12053 
    iprot.readStructEnd()
12054 
 
12055 
  def write(self, oprot):
12056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12058 
      return
12059 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 12060 
    if self.orderId is not None:
2591 chandransh 12061 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12062 
      oprot.writeI64(self.orderId)
12063 
      oprot.writeFieldEnd()
3431 rajveer 12064 
    if self.isValid is not None:
2591 chandransh 12065 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
12066 
      oprot.writeBool(self.isValid)
12067 
      oprot.writeFieldEnd()
12068 
    oprot.writeFieldStop()
12069 
    oprot.writeStructEnd()
12070 
 
3431 rajveer 12071 
  def validate(self):
12072 
    return
12073 
 
12074 
 
2591 chandransh 12075 
  def __repr__(self):
12076 
    L = ['%s=%r' % (key, value)
12077 
      for key, value in self.__dict__.iteritems()]
12078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12079 
 
12080 
  def __eq__(self, other):
12081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12082 
 
12083 
  def __ne__(self, other):
12084 
    return not (self == other)
12085 
 
12086 
class validateDoa_result:
12087 
  """
12088 
  Attributes:
12089 
   - success
12090 
   - ex
12091 
  """
12092 
 
12093 
  thrift_spec = (
12094 
    (0, TType.BOOL, 'success', None, None, ), # 0
12095 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12096 
  )
12097 
 
12098 
  def __init__(self, success=None, ex=None,):
12099 
    self.success = success
12100 
    self.ex = ex
12101 
 
12102 
  def read(self, iprot):
12103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12105 
      return
12106 
    iprot.readStructBegin()
12107 
    while True:
12108 
      (fname, ftype, fid) = iprot.readFieldBegin()
12109 
      if ftype == TType.STOP:
12110 
        break
12111 
      if fid == 0:
12112 
        if ftype == TType.BOOL:
12113 
          self.success = iprot.readBool();
12114 
        else:
12115 
          iprot.skip(ftype)
12116 
      elif fid == 1:
12117 
        if ftype == TType.STRUCT:
12118 
          self.ex = TransactionServiceException()
12119 
          self.ex.read(iprot)
12120 
        else:
12121 
          iprot.skip(ftype)
12122 
      else:
12123 
        iprot.skip(ftype)
12124 
      iprot.readFieldEnd()
12125 
    iprot.readStructEnd()
12126 
 
12127 
  def write(self, oprot):
12128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12130 
      return
12131 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 12132 
    if self.success is not None:
2591 chandransh 12133 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12134 
      oprot.writeBool(self.success)
12135 
      oprot.writeFieldEnd()
3431 rajveer 12136 
    if self.ex is not None:
2591 chandransh 12137 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12138 
      self.ex.write(oprot)
12139 
      oprot.writeFieldEnd()
12140 
    oprot.writeFieldStop()
12141 
    oprot.writeStructEnd()
12142 
 
3431 rajveer 12143 
  def validate(self):
12144 
    return
12145 
 
12146 
 
2591 chandransh 12147 
  def __repr__(self):
12148 
    L = ['%s=%r' % (key, value)
12149 
      for key, value in self.__dict__.iteritems()]
12150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12151 
 
12152 
  def __eq__(self, other):
12153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12154 
 
12155 
  def __ne__(self, other):
12156 
    return not (self == other)
12157 
 
4495 rajveer 12158 
class validateReturnProduct_args:
12159 
  """
12160 
  Attributes:
12161 
   - orderId
12162 
   - isUsable
12163 
  """
12164 
 
12165 
  thrift_spec = (
12166 
    None, # 0
12167 
    (1, TType.I64, 'orderId', None, None, ), # 1
12168 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
12169 
  )
12170 
 
12171 
  def __init__(self, orderId=None, isUsable=None,):
12172 
    self.orderId = orderId
12173 
    self.isUsable = isUsable
12174 
 
12175 
  def read(self, iprot):
12176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12178 
      return
12179 
    iprot.readStructBegin()
12180 
    while True:
12181 
      (fname, ftype, fid) = iprot.readFieldBegin()
12182 
      if ftype == TType.STOP:
12183 
        break
12184 
      if fid == 1:
12185 
        if ftype == TType.I64:
12186 
          self.orderId = iprot.readI64();
12187 
        else:
12188 
          iprot.skip(ftype)
12189 
      elif fid == 2:
12190 
        if ftype == TType.BOOL:
12191 
          self.isUsable = iprot.readBool();
12192 
        else:
12193 
          iprot.skip(ftype)
12194 
      else:
12195 
        iprot.skip(ftype)
12196 
      iprot.readFieldEnd()
12197 
    iprot.readStructEnd()
12198 
 
12199 
  def write(self, oprot):
12200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12202 
      return
12203 
    oprot.writeStructBegin('validateReturnProduct_args')
12204 
    if self.orderId is not None:
12205 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12206 
      oprot.writeI64(self.orderId)
12207 
      oprot.writeFieldEnd()
12208 
    if self.isUsable is not None:
12209 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
12210 
      oprot.writeBool(self.isUsable)
12211 
      oprot.writeFieldEnd()
12212 
    oprot.writeFieldStop()
12213 
    oprot.writeStructEnd()
12214 
 
12215 
  def validate(self):
12216 
    return
12217 
 
12218 
 
12219 
  def __repr__(self):
12220 
    L = ['%s=%r' % (key, value)
12221 
      for key, value in self.__dict__.iteritems()]
12222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12223 
 
12224 
  def __eq__(self, other):
12225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12226 
 
12227 
  def __ne__(self, other):
12228 
    return not (self == other)
12229 
 
12230 
class validateReturnProduct_result:
12231 
  """
12232 
  Attributes:
12233 
   - success
12234 
   - ex
12235 
  """
12236 
 
12237 
  thrift_spec = (
12238 
    (0, TType.BOOL, 'success', None, None, ), # 0
12239 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12240 
  )
12241 
 
12242 
  def __init__(self, success=None, ex=None,):
12243 
    self.success = success
12244 
    self.ex = ex
12245 
 
12246 
  def read(self, iprot):
12247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12249 
      return
12250 
    iprot.readStructBegin()
12251 
    while True:
12252 
      (fname, ftype, fid) = iprot.readFieldBegin()
12253 
      if ftype == TType.STOP:
12254 
        break
12255 
      if fid == 0:
12256 
        if ftype == TType.BOOL:
12257 
          self.success = iprot.readBool();
12258 
        else:
12259 
          iprot.skip(ftype)
12260 
      elif fid == 1:
12261 
        if ftype == TType.STRUCT:
12262 
          self.ex = TransactionServiceException()
12263 
          self.ex.read(iprot)
12264 
        else:
12265 
          iprot.skip(ftype)
12266 
      else:
12267 
        iprot.skip(ftype)
12268 
      iprot.readFieldEnd()
12269 
    iprot.readStructEnd()
12270 
 
12271 
  def write(self, oprot):
12272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12274 
      return
12275 
    oprot.writeStructBegin('validateReturnProduct_result')
12276 
    if self.success is not None:
12277 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12278 
      oprot.writeBool(self.success)
12279 
      oprot.writeFieldEnd()
12280 
    if self.ex is not None:
12281 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12282 
      self.ex.write(oprot)
12283 
      oprot.writeFieldEnd()
12284 
    oprot.writeFieldStop()
12285 
    oprot.writeStructEnd()
12286 
 
12287 
  def validate(self):
12288 
    return
12289 
 
12290 
 
12291 
  def __repr__(self):
12292 
    L = ['%s=%r' % (key, value)
12293 
      for key, value in self.__dict__.iteritems()]
12294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12295 
 
12296 
  def __eq__(self, other):
12297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12298 
 
12299 
  def __ne__(self, other):
12300 
    return not (self == other)
12301 
 
2616 chandransh 12302 
class reshipOrder_args:
12303 
  """
12304 
  Attributes:
12305 
   - orderId
12306 
  """
2591 chandransh 12307 
 
2616 chandransh 12308 
  thrift_spec = (
12309 
    None, # 0
12310 
    (1, TType.I64, 'orderId', None, None, ), # 1
12311 
  )
12312 
 
12313 
  def __init__(self, orderId=None,):
12314 
    self.orderId = orderId
12315 
 
12316 
  def read(self, iprot):
12317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12319 
      return
12320 
    iprot.readStructBegin()
12321 
    while True:
12322 
      (fname, ftype, fid) = iprot.readFieldBegin()
12323 
      if ftype == TType.STOP:
12324 
        break
12325 
      if fid == 1:
12326 
        if ftype == TType.I64:
12327 
          self.orderId = iprot.readI64();
12328 
        else:
12329 
          iprot.skip(ftype)
12330 
      else:
12331 
        iprot.skip(ftype)
12332 
      iprot.readFieldEnd()
12333 
    iprot.readStructEnd()
12334 
 
12335 
  def write(self, oprot):
12336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12338 
      return
12339 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 12340 
    if self.orderId is not None:
2616 chandransh 12341 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12342 
      oprot.writeI64(self.orderId)
12343 
      oprot.writeFieldEnd()
12344 
    oprot.writeFieldStop()
12345 
    oprot.writeStructEnd()
12346 
 
3431 rajveer 12347 
  def validate(self):
12348 
    return
12349 
 
12350 
 
2616 chandransh 12351 
  def __repr__(self):
12352 
    L = ['%s=%r' % (key, value)
12353 
      for key, value in self.__dict__.iteritems()]
12354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12355 
 
12356 
  def __eq__(self, other):
12357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12358 
 
12359 
  def __ne__(self, other):
12360 
    return not (self == other)
12361 
 
12362 
class reshipOrder_result:
12363 
  """
12364 
  Attributes:
12365 
   - success
12366 
   - ex
12367 
  """
12368 
 
12369 
  thrift_spec = (
12370 
    (0, TType.I64, 'success', None, None, ), # 0
12371 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12372 
  )
12373 
 
12374 
  def __init__(self, success=None, ex=None,):
12375 
    self.success = success
12376 
    self.ex = ex
12377 
 
12378 
  def read(self, iprot):
12379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12381 
      return
12382 
    iprot.readStructBegin()
12383 
    while True:
12384 
      (fname, ftype, fid) = iprot.readFieldBegin()
12385 
      if ftype == TType.STOP:
12386 
        break
12387 
      if fid == 0:
12388 
        if ftype == TType.I64:
12389 
          self.success = iprot.readI64();
12390 
        else:
12391 
          iprot.skip(ftype)
12392 
      elif fid == 1:
12393 
        if ftype == TType.STRUCT:
12394 
          self.ex = TransactionServiceException()
12395 
          self.ex.read(iprot)
12396 
        else:
12397 
          iprot.skip(ftype)
12398 
      else:
12399 
        iprot.skip(ftype)
12400 
      iprot.readFieldEnd()
12401 
    iprot.readStructEnd()
12402 
 
12403 
  def write(self, oprot):
12404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12406 
      return
12407 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 12408 
    if self.success is not None:
2616 chandransh 12409 
      oprot.writeFieldBegin('success', TType.I64, 0)
12410 
      oprot.writeI64(self.success)
12411 
      oprot.writeFieldEnd()
3431 rajveer 12412 
    if self.ex is not None:
2616 chandransh 12413 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12414 
      self.ex.write(oprot)
12415 
      oprot.writeFieldEnd()
12416 
    oprot.writeFieldStop()
12417 
    oprot.writeStructEnd()
12418 
 
3431 rajveer 12419 
  def validate(self):
12420 
    return
12421 
 
12422 
 
2616 chandransh 12423 
  def __repr__(self):
12424 
    L = ['%s=%r' % (key, value)
12425 
      for key, value in self.__dict__.iteritems()]
12426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12427 
 
12428 
  def __eq__(self, other):
12429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12430 
 
12431 
  def __ne__(self, other):
12432 
    return not (self == other)
12433 
 
12434 
class refundOrder_args:
12435 
  """
12436 
  Attributes:
12437 
   - orderId
3226 chandransh 12438 
   - refundedBy
12439 
   - reason
2616 chandransh 12440 
  """
12441 
 
12442 
  thrift_spec = (
12443 
    None, # 0
12444 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 12445 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
12446 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 12447 
  )
12448 
 
3226 chandransh 12449 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 12450 
    self.orderId = orderId
3226 chandransh 12451 
    self.refundedBy = refundedBy
12452 
    self.reason = reason
2616 chandransh 12453 
 
12454 
  def read(self, iprot):
12455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12457 
      return
12458 
    iprot.readStructBegin()
12459 
    while True:
12460 
      (fname, ftype, fid) = iprot.readFieldBegin()
12461 
      if ftype == TType.STOP:
12462 
        break
12463 
      if fid == 1:
12464 
        if ftype == TType.I64:
12465 
          self.orderId = iprot.readI64();
12466 
        else:
12467 
          iprot.skip(ftype)
3226 chandransh 12468 
      elif fid == 2:
12469 
        if ftype == TType.STRING:
12470 
          self.refundedBy = iprot.readString();
12471 
        else:
12472 
          iprot.skip(ftype)
12473 
      elif fid == 3:
12474 
        if ftype == TType.STRING:
12475 
          self.reason = iprot.readString();
12476 
        else:
12477 
          iprot.skip(ftype)
2616 chandransh 12478 
      else:
12479 
        iprot.skip(ftype)
12480 
      iprot.readFieldEnd()
12481 
    iprot.readStructEnd()
12482 
 
12483 
  def write(self, oprot):
12484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12486 
      return
12487 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 12488 
    if self.orderId is not None:
2616 chandransh 12489 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12490 
      oprot.writeI64(self.orderId)
12491 
      oprot.writeFieldEnd()
3431 rajveer 12492 
    if self.refundedBy is not None:
3226 chandransh 12493 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
12494 
      oprot.writeString(self.refundedBy)
12495 
      oprot.writeFieldEnd()
3431 rajveer 12496 
    if self.reason is not None:
3226 chandransh 12497 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
12498 
      oprot.writeString(self.reason)
12499 
      oprot.writeFieldEnd()
2616 chandransh 12500 
    oprot.writeFieldStop()
12501 
    oprot.writeStructEnd()
12502 
 
3431 rajveer 12503 
  def validate(self):
12504 
    return
12505 
 
12506 
 
2616 chandransh 12507 
  def __repr__(self):
12508 
    L = ['%s=%r' % (key, value)
12509 
      for key, value in self.__dict__.iteritems()]
12510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12511 
 
12512 
  def __eq__(self, other):
12513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12514 
 
12515 
  def __ne__(self, other):
12516 
    return not (self == other)
12517 
 
12518 
class refundOrder_result:
12519 
  """
12520 
  Attributes:
12521 
   - success
12522 
   - ex
12523 
  """
12524 
 
12525 
  thrift_spec = (
12526 
    (0, TType.BOOL, 'success', None, None, ), # 0
12527 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12528 
  )
12529 
 
12530 
  def __init__(self, success=None, ex=None,):
12531 
    self.success = success
12532 
    self.ex = ex
12533 
 
12534 
  def read(self, iprot):
12535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12537 
      return
12538 
    iprot.readStructBegin()
12539 
    while True:
12540 
      (fname, ftype, fid) = iprot.readFieldBegin()
12541 
      if ftype == TType.STOP:
12542 
        break
12543 
      if fid == 0:
12544 
        if ftype == TType.BOOL:
12545 
          self.success = iprot.readBool();
12546 
        else:
12547 
          iprot.skip(ftype)
12548 
      elif fid == 1:
12549 
        if ftype == TType.STRUCT:
12550 
          self.ex = TransactionServiceException()
12551 
          self.ex.read(iprot)
12552 
        else:
12553 
          iprot.skip(ftype)
12554 
      else:
12555 
        iprot.skip(ftype)
12556 
      iprot.readFieldEnd()
12557 
    iprot.readStructEnd()
12558 
 
12559 
  def write(self, oprot):
12560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12562 
      return
12563 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 12564 
    if self.success is not None:
2616 chandransh 12565 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12566 
      oprot.writeBool(self.success)
12567 
      oprot.writeFieldEnd()
3431 rajveer 12568 
    if self.ex is not None:
2616 chandransh 12569 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12570 
      self.ex.write(oprot)
12571 
      oprot.writeFieldEnd()
12572 
    oprot.writeFieldStop()
12573 
    oprot.writeStructEnd()
12574 
 
3431 rajveer 12575 
  def validate(self):
12576 
    return
12577 
 
12578 
 
2616 chandransh 12579 
  def __repr__(self):
12580 
    L = ['%s=%r' % (key, value)
12581 
      for key, value in self.__dict__.iteritems()]
12582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12583 
 
12584 
  def __eq__(self, other):
12585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12586 
 
12587 
  def __ne__(self, other):
12588 
    return not (self == other)
12589 
 
2690 chandransh 12590 
class getReturnOrders_args:
12591 
  """
12592 
  Attributes:
12593 
   - warehouseId
12594 
   - fromDate
12595 
   - toDate
12596 
  """
2616 chandransh 12597 
 
2690 chandransh 12598 
  thrift_spec = (
12599 
    None, # 0
12600 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12601 
    (2, TType.I64, 'fromDate', None, None, ), # 2
12602 
    (3, TType.I64, 'toDate', None, None, ), # 3
12603 
  )
12604 
 
12605 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
12606 
    self.warehouseId = warehouseId
12607 
    self.fromDate = fromDate
12608 
    self.toDate = toDate
12609 
 
12610 
  def read(self, iprot):
12611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12613 
      return
12614 
    iprot.readStructBegin()
12615 
    while True:
12616 
      (fname, ftype, fid) = iprot.readFieldBegin()
12617 
      if ftype == TType.STOP:
12618 
        break
12619 
      if fid == 1:
12620 
        if ftype == TType.I64:
12621 
          self.warehouseId = iprot.readI64();
12622 
        else:
12623 
          iprot.skip(ftype)
12624 
      elif fid == 2:
12625 
        if ftype == TType.I64:
12626 
          self.fromDate = iprot.readI64();
12627 
        else:
12628 
          iprot.skip(ftype)
12629 
      elif fid == 3:
12630 
        if ftype == TType.I64:
12631 
          self.toDate = iprot.readI64();
12632 
        else:
12633 
          iprot.skip(ftype)
12634 
      else:
12635 
        iprot.skip(ftype)
12636 
      iprot.readFieldEnd()
12637 
    iprot.readStructEnd()
12638 
 
12639 
  def write(self, oprot):
12640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12642 
      return
12643 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 12644 
    if self.warehouseId is not None:
2690 chandransh 12645 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12646 
      oprot.writeI64(self.warehouseId)
12647 
      oprot.writeFieldEnd()
3431 rajveer 12648 
    if self.fromDate is not None:
2690 chandransh 12649 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
12650 
      oprot.writeI64(self.fromDate)
12651 
      oprot.writeFieldEnd()
3431 rajveer 12652 
    if self.toDate is not None:
2690 chandransh 12653 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
12654 
      oprot.writeI64(self.toDate)
12655 
      oprot.writeFieldEnd()
12656 
    oprot.writeFieldStop()
12657 
    oprot.writeStructEnd()
12658 
 
3431 rajveer 12659 
  def validate(self):
12660 
    return
12661 
 
12662 
 
2690 chandransh 12663 
  def __repr__(self):
12664 
    L = ['%s=%r' % (key, value)
12665 
      for key, value in self.__dict__.iteritems()]
12666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12667 
 
12668 
  def __eq__(self, other):
12669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12670 
 
12671 
  def __ne__(self, other):
12672 
    return not (self == other)
12673 
 
12674 
class getReturnOrders_result:
12675 
  """
12676 
  Attributes:
12677 
   - success
12678 
  """
12679 
 
12680 
  thrift_spec = (
12681 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
12682 
  )
12683 
 
12684 
  def __init__(self, success=None,):
12685 
    self.success = success
12686 
 
12687 
  def read(self, iprot):
12688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12690 
      return
12691 
    iprot.readStructBegin()
12692 
    while True:
12693 
      (fname, ftype, fid) = iprot.readFieldBegin()
12694 
      if ftype == TType.STOP:
12695 
        break
12696 
      if fid == 0:
12697 
        if ftype == TType.LIST:
12698 
          self.success = []
4133 chandransh 12699 
          (_etype209, _size206) = iprot.readListBegin()
12700 
          for _i210 in xrange(_size206):
12701 
            _elem211 = ReturnOrder()
12702 
            _elem211.read(iprot)
12703 
            self.success.append(_elem211)
2690 chandransh 12704 
          iprot.readListEnd()
12705 
        else:
12706 
          iprot.skip(ftype)
12707 
      else:
12708 
        iprot.skip(ftype)
12709 
      iprot.readFieldEnd()
12710 
    iprot.readStructEnd()
12711 
 
12712 
  def write(self, oprot):
12713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12715 
      return
12716 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 12717 
    if self.success is not None:
2690 chandransh 12718 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12719 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 12720 
      for iter212 in self.success:
12721 
        iter212.write(oprot)
2690 chandransh 12722 
      oprot.writeListEnd()
12723 
      oprot.writeFieldEnd()
12724 
    oprot.writeFieldStop()
12725 
    oprot.writeStructEnd()
12726 
 
3431 rajveer 12727 
  def validate(self):
12728 
    return
12729 
 
12730 
 
2690 chandransh 12731 
  def __repr__(self):
12732 
    L = ['%s=%r' % (key, value)
12733 
      for key, value in self.__dict__.iteritems()]
12734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12735 
 
12736 
  def __eq__(self, other):
12737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12738 
 
12739 
  def __ne__(self, other):
12740 
    return not (self == other)
12741 
 
2700 chandransh 12742 
class getReturnOrder_args:
12743 
  """
12744 
  Attributes:
12745 
   - id
12746 
  """
12747 
 
12748 
  thrift_spec = (
12749 
    None, # 0
12750 
    (1, TType.I64, 'id', None, None, ), # 1
12751 
  )
12752 
 
12753 
  def __init__(self, id=None,):
12754 
    self.id = id
12755 
 
12756 
  def read(self, iprot):
12757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12759 
      return
12760 
    iprot.readStructBegin()
12761 
    while True:
12762 
      (fname, ftype, fid) = iprot.readFieldBegin()
12763 
      if ftype == TType.STOP:
12764 
        break
12765 
      if fid == 1:
12766 
        if ftype == TType.I64:
12767 
          self.id = iprot.readI64();
12768 
        else:
12769 
          iprot.skip(ftype)
12770 
      else:
12771 
        iprot.skip(ftype)
12772 
      iprot.readFieldEnd()
12773 
    iprot.readStructEnd()
12774 
 
12775 
  def write(self, oprot):
12776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12778 
      return
12779 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 12780 
    if self.id is not None:
2700 chandransh 12781 
      oprot.writeFieldBegin('id', TType.I64, 1)
12782 
      oprot.writeI64(self.id)
12783 
      oprot.writeFieldEnd()
12784 
    oprot.writeFieldStop()
12785 
    oprot.writeStructEnd()
12786 
 
3431 rajveer 12787 
  def validate(self):
12788 
    return
12789 
 
12790 
 
2700 chandransh 12791 
  def __repr__(self):
12792 
    L = ['%s=%r' % (key, value)
12793 
      for key, value in self.__dict__.iteritems()]
12794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12795 
 
12796 
  def __eq__(self, other):
12797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12798 
 
12799 
  def __ne__(self, other):
12800 
    return not (self == other)
12801 
 
12802 
class getReturnOrder_result:
12803 
  """
12804 
  Attributes:
12805 
   - success
12806 
   - ex
12807 
  """
12808 
 
12809 
  thrift_spec = (
12810 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
12811 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12812 
  )
12813 
 
12814 
  def __init__(self, success=None, ex=None,):
12815 
    self.success = success
12816 
    self.ex = ex
12817 
 
12818 
  def read(self, iprot):
12819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12821 
      return
12822 
    iprot.readStructBegin()
12823 
    while True:
12824 
      (fname, ftype, fid) = iprot.readFieldBegin()
12825 
      if ftype == TType.STOP:
12826 
        break
12827 
      if fid == 0:
12828 
        if ftype == TType.STRUCT:
12829 
          self.success = ReturnOrder()
12830 
          self.success.read(iprot)
12831 
        else:
12832 
          iprot.skip(ftype)
12833 
      elif fid == 1:
12834 
        if ftype == TType.STRUCT:
12835 
          self.ex = TransactionServiceException()
12836 
          self.ex.read(iprot)
12837 
        else:
12838 
          iprot.skip(ftype)
12839 
      else:
12840 
        iprot.skip(ftype)
12841 
      iprot.readFieldEnd()
12842 
    iprot.readStructEnd()
12843 
 
12844 
  def write(self, oprot):
12845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12847 
      return
12848 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 12849 
    if self.success is not None:
2700 chandransh 12850 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12851 
      self.success.write(oprot)
12852 
      oprot.writeFieldEnd()
3431 rajveer 12853 
    if self.ex is not None:
2700 chandransh 12854 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12855 
      self.ex.write(oprot)
12856 
      oprot.writeFieldEnd()
12857 
    oprot.writeFieldStop()
12858 
    oprot.writeStructEnd()
12859 
 
3431 rajveer 12860 
  def validate(self):
12861 
    return
12862 
 
12863 
 
2700 chandransh 12864 
  def __repr__(self):
12865 
    L = ['%s=%r' % (key, value)
12866 
      for key, value in self.__dict__.iteritems()]
12867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12868 
 
12869 
  def __eq__(self, other):
12870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12871 
 
12872 
  def __ne__(self, other):
12873 
    return not (self == other)
12874 
 
2690 chandransh 12875 
class processReturn_args:
12876 
  """
12877 
  Attributes:
12878 
   - returnOrderId
12879 
  """
12880 
 
12881 
  thrift_spec = (
12882 
    None, # 0
12883 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
12884 
  )
12885 
 
12886 
  def __init__(self, returnOrderId=None,):
12887 
    self.returnOrderId = returnOrderId
12888 
 
12889 
  def read(self, iprot):
12890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12892 
      return
12893 
    iprot.readStructBegin()
12894 
    while True:
12895 
      (fname, ftype, fid) = iprot.readFieldBegin()
12896 
      if ftype == TType.STOP:
12897 
        break
12898 
      if fid == 1:
12899 
        if ftype == TType.I64:
12900 
          self.returnOrderId = iprot.readI64();
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_args')
3431 rajveer 12913 
    if self.returnOrderId is not None:
2690 chandransh 12914 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
12915 
      oprot.writeI64(self.returnOrderId)
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 
 
12935 
class processReturn_result:
12936 
  """
12937 
  Attributes:
12938 
   - ex
12939 
  """
12940 
 
12941 
  thrift_spec = (
12942 
    None, # 0
12943 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12944 
  )
12945 
 
12946 
  def __init__(self, ex=None,):
12947 
    self.ex = ex
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.STRUCT:
12960 
          self.ex = TransactionServiceException()
12961 
          self.ex.read(iprot)
12962 
        else:
12963 
          iprot.skip(ftype)
12964 
      else:
12965 
        iprot.skip(ftype)
12966 
      iprot.readFieldEnd()
12967 
    iprot.readStructEnd()
12968 
 
12969 
  def write(self, oprot):
12970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12972 
      return
12973 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 12974 
    if self.ex is not None:
2690 chandransh 12975 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12976 
      self.ex.write(oprot)
12977 
      oprot.writeFieldEnd()
12978 
    oprot.writeFieldStop()
12979 
    oprot.writeStructEnd()
12980 
 
3431 rajveer 12981 
  def validate(self):
12982 
    return
12983 
 
12984 
 
2690 chandransh 12985 
  def __repr__(self):
12986 
    L = ['%s=%r' % (key, value)
12987 
      for key, value in self.__dict__.iteritems()]
12988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12989 
 
12990 
  def __eq__(self, other):
12991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12992 
 
12993 
  def __ne__(self, other):
12994 
    return not (self == other)
12995 
 
2819 chandransh 12996 
class createPurchaseOrder_args:
12997 
  """
12998 
  Attributes:
12999 
   - warehouseId
13000 
  """
2690 chandransh 13001 
 
2819 chandransh 13002 
  thrift_spec = (
13003 
    None, # 0
13004 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13005 
  )
13006 
 
13007 
  def __init__(self, warehouseId=None,):
13008 
    self.warehouseId = warehouseId
13009 
 
13010 
  def read(self, iprot):
13011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13013 
      return
13014 
    iprot.readStructBegin()
13015 
    while True:
13016 
      (fname, ftype, fid) = iprot.readFieldBegin()
13017 
      if ftype == TType.STOP:
13018 
        break
13019 
      if fid == 1:
13020 
        if ftype == TType.I64:
13021 
          self.warehouseId = iprot.readI64();
13022 
        else:
13023 
          iprot.skip(ftype)
13024 
      else:
13025 
        iprot.skip(ftype)
13026 
      iprot.readFieldEnd()
13027 
    iprot.readStructEnd()
13028 
 
13029 
  def write(self, oprot):
13030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13032 
      return
13033 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 13034 
    if self.warehouseId is not None:
2819 chandransh 13035 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13036 
      oprot.writeI64(self.warehouseId)
13037 
      oprot.writeFieldEnd()
13038 
    oprot.writeFieldStop()
13039 
    oprot.writeStructEnd()
13040 
 
3431 rajveer 13041 
  def validate(self):
13042 
    return
13043 
 
13044 
 
2819 chandransh 13045 
  def __repr__(self):
13046 
    L = ['%s=%r' % (key, value)
13047 
      for key, value in self.__dict__.iteritems()]
13048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13049 
 
13050 
  def __eq__(self, other):
13051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13052 
 
13053 
  def __ne__(self, other):
13054 
    return not (self == other)
13055 
 
13056 
class createPurchaseOrder_result:
13057 
  """
13058 
  Attributes:
13059 
   - success
13060 
   - ex
13061 
  """
13062 
 
13063 
  thrift_spec = (
13064 
    (0, TType.I64, 'success', None, None, ), # 0
13065 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13066 
  )
13067 
 
13068 
  def __init__(self, success=None, ex=None,):
13069 
    self.success = success
13070 
    self.ex = ex
13071 
 
13072 
  def read(self, iprot):
13073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13075 
      return
13076 
    iprot.readStructBegin()
13077 
    while True:
13078 
      (fname, ftype, fid) = iprot.readFieldBegin()
13079 
      if ftype == TType.STOP:
13080 
        break
13081 
      if fid == 0:
13082 
        if ftype == TType.I64:
13083 
          self.success = iprot.readI64();
13084 
        else:
13085 
          iprot.skip(ftype)
13086 
      elif fid == 1:
13087 
        if ftype == TType.STRUCT:
13088 
          self.ex = TransactionServiceException()
13089 
          self.ex.read(iprot)
13090 
        else:
13091 
          iprot.skip(ftype)
13092 
      else:
13093 
        iprot.skip(ftype)
13094 
      iprot.readFieldEnd()
13095 
    iprot.readStructEnd()
13096 
 
13097 
  def write(self, oprot):
13098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13100 
      return
13101 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 13102 
    if self.success is not None:
2819 chandransh 13103 
      oprot.writeFieldBegin('success', TType.I64, 0)
13104 
      oprot.writeI64(self.success)
13105 
      oprot.writeFieldEnd()
3431 rajveer 13106 
    if self.ex is not None:
2819 chandransh 13107 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13108 
      self.ex.write(oprot)
13109 
      oprot.writeFieldEnd()
13110 
    oprot.writeFieldStop()
13111 
    oprot.writeStructEnd()
13112 
 
3431 rajveer 13113 
  def validate(self):
13114 
    return
13115 
 
13116 
 
2819 chandransh 13117 
  def __repr__(self):
13118 
    L = ['%s=%r' % (key, value)
13119 
      for key, value in self.__dict__.iteritems()]
13120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13121 
 
13122 
  def __eq__(self, other):
13123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13124 
 
13125 
  def __ne__(self, other):
13126 
    return not (self == other)
3451 chandransh 13127 
 
13128 
class updateWeight_args:
13129 
  """
13130 
  Attributes:
13131 
   - orderId
13132 
   - weight
13133 
  """
13134 
 
13135 
  thrift_spec = (
13136 
    None, # 0
13137 
    (1, TType.I64, 'orderId', None, None, ), # 1
13138 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
13139 
  )
13140 
 
13141 
  def __init__(self, orderId=None, weight=None,):
13142 
    self.orderId = orderId
13143 
    self.weight = weight
13144 
 
13145 
  def read(self, iprot):
13146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13148 
      return
13149 
    iprot.readStructBegin()
13150 
    while True:
13151 
      (fname, ftype, fid) = iprot.readFieldBegin()
13152 
      if ftype == TType.STOP:
13153 
        break
13154 
      if fid == 1:
13155 
        if ftype == TType.I64:
13156 
          self.orderId = iprot.readI64();
13157 
        else:
13158 
          iprot.skip(ftype)
13159 
      elif fid == 2:
13160 
        if ftype == TType.DOUBLE:
13161 
          self.weight = iprot.readDouble();
13162 
        else:
13163 
          iprot.skip(ftype)
13164 
      else:
13165 
        iprot.skip(ftype)
13166 
      iprot.readFieldEnd()
13167 
    iprot.readStructEnd()
13168 
 
13169 
  def write(self, oprot):
13170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13172 
      return
13173 
    oprot.writeStructBegin('updateWeight_args')
13174 
    if self.orderId is not None:
13175 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13176 
      oprot.writeI64(self.orderId)
13177 
      oprot.writeFieldEnd()
13178 
    if self.weight is not None:
13179 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
13180 
      oprot.writeDouble(self.weight)
13181 
      oprot.writeFieldEnd()
13182 
    oprot.writeFieldStop()
13183 
    oprot.writeStructEnd()
13184 
 
13185 
  def validate(self):
13186 
    return
13187 
 
13188 
 
13189 
  def __repr__(self):
13190 
    L = ['%s=%r' % (key, value)
13191 
      for key, value in self.__dict__.iteritems()]
13192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13193 
 
13194 
  def __eq__(self, other):
13195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13196 
 
13197 
  def __ne__(self, other):
13198 
    return not (self == other)
13199 
 
13200 
class updateWeight_result:
13201 
  """
13202 
  Attributes:
13203 
   - success
13204 
   - ex
13205 
  """
13206 
 
13207 
  thrift_spec = (
13208 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13209 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13210 
  )
13211 
 
13212 
  def __init__(self, success=None, ex=None,):
13213 
    self.success = success
13214 
    self.ex = ex
13215 
 
13216 
  def read(self, iprot):
13217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13219 
      return
13220 
    iprot.readStructBegin()
13221 
    while True:
13222 
      (fname, ftype, fid) = iprot.readFieldBegin()
13223 
      if ftype == TType.STOP:
13224 
        break
13225 
      if fid == 0:
13226 
        if ftype == TType.STRUCT:
13227 
          self.success = Order()
13228 
          self.success.read(iprot)
13229 
        else:
13230 
          iprot.skip(ftype)
13231 
      elif fid == 1:
13232 
        if ftype == TType.STRUCT:
13233 
          self.ex = TransactionServiceException()
13234 
          self.ex.read(iprot)
13235 
        else:
13236 
          iprot.skip(ftype)
13237 
      else:
13238 
        iprot.skip(ftype)
13239 
      iprot.readFieldEnd()
13240 
    iprot.readStructEnd()
13241 
 
13242 
  def write(self, oprot):
13243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13245 
      return
13246 
    oprot.writeStructBegin('updateWeight_result')
13247 
    if self.success is not None:
13248 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13249 
      self.success.write(oprot)
13250 
      oprot.writeFieldEnd()
13251 
    if self.ex is not None:
13252 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13253 
      self.ex.write(oprot)
13254 
      oprot.writeFieldEnd()
13255 
    oprot.writeFieldStop()
13256 
    oprot.writeStructEnd()
13257 
 
13258 
  def validate(self):
13259 
    return
13260 
 
13261 
 
13262 
  def __repr__(self):
13263 
    L = ['%s=%r' % (key, value)
13264 
      for key, value in self.__dict__.iteritems()]
13265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13266 
 
13267 
  def __eq__(self, other):
13268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13269 
 
13270 
  def __ne__(self, other):
13271 
    return not (self == other)
3469 chandransh 13272 
 
13273 
class changeItem_args:
13274 
  """
13275 
  Attributes:
13276 
   - orderId
13277 
   - itemId
13278 
  """
13279 
 
13280 
  thrift_spec = (
13281 
    None, # 0
13282 
    (1, TType.I64, 'orderId', None, None, ), # 1
13283 
    (2, TType.I64, 'itemId', None, None, ), # 2
13284 
  )
13285 
 
13286 
  def __init__(self, orderId=None, itemId=None,):
13287 
    self.orderId = orderId
13288 
    self.itemId = itemId
13289 
 
13290 
  def read(self, iprot):
13291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13293 
      return
13294 
    iprot.readStructBegin()
13295 
    while True:
13296 
      (fname, ftype, fid) = iprot.readFieldBegin()
13297 
      if ftype == TType.STOP:
13298 
        break
13299 
      if fid == 1:
13300 
        if ftype == TType.I64:
13301 
          self.orderId = iprot.readI64();
13302 
        else:
13303 
          iprot.skip(ftype)
13304 
      elif fid == 2:
13305 
        if ftype == TType.I64:
13306 
          self.itemId = iprot.readI64();
13307 
        else:
13308 
          iprot.skip(ftype)
13309 
      else:
13310 
        iprot.skip(ftype)
13311 
      iprot.readFieldEnd()
13312 
    iprot.readStructEnd()
13313 
 
13314 
  def write(self, oprot):
13315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13317 
      return
13318 
    oprot.writeStructBegin('changeItem_args')
13319 
    if self.orderId is not None:
13320 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13321 
      oprot.writeI64(self.orderId)
13322 
      oprot.writeFieldEnd()
13323 
    if self.itemId is not None:
13324 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13325 
      oprot.writeI64(self.itemId)
13326 
      oprot.writeFieldEnd()
13327 
    oprot.writeFieldStop()
13328 
    oprot.writeStructEnd()
13329 
 
13330 
  def validate(self):
13331 
    return
13332 
 
13333 
 
13334 
  def __repr__(self):
13335 
    L = ['%s=%r' % (key, value)
13336 
      for key, value in self.__dict__.iteritems()]
13337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13338 
 
13339 
  def __eq__(self, other):
13340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13341 
 
13342 
  def __ne__(self, other):
13343 
    return not (self == other)
13344 
 
13345 
class changeItem_result:
13346 
  """
13347 
  Attributes:
13348 
   - success
13349 
   - ex
13350 
  """
13351 
 
13352 
  thrift_spec = (
13353 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13354 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13355 
  )
13356 
 
13357 
  def __init__(self, success=None, ex=None,):
13358 
    self.success = success
13359 
    self.ex = ex
13360 
 
13361 
  def read(self, iprot):
13362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13364 
      return
13365 
    iprot.readStructBegin()
13366 
    while True:
13367 
      (fname, ftype, fid) = iprot.readFieldBegin()
13368 
      if ftype == TType.STOP:
13369 
        break
13370 
      if fid == 0:
13371 
        if ftype == TType.STRUCT:
13372 
          self.success = Order()
13373 
          self.success.read(iprot)
13374 
        else:
13375 
          iprot.skip(ftype)
13376 
      elif fid == 1:
13377 
        if ftype == TType.STRUCT:
13378 
          self.ex = TransactionServiceException()
13379 
          self.ex.read(iprot)
13380 
        else:
13381 
          iprot.skip(ftype)
13382 
      else:
13383 
        iprot.skip(ftype)
13384 
      iprot.readFieldEnd()
13385 
    iprot.readStructEnd()
13386 
 
13387 
  def write(self, oprot):
13388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13390 
      return
13391 
    oprot.writeStructBegin('changeItem_result')
13392 
    if self.success is not None:
13393 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13394 
      self.success.write(oprot)
13395 
      oprot.writeFieldEnd()
13396 
    if self.ex is not None:
13397 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13398 
      self.ex.write(oprot)
13399 
      oprot.writeFieldEnd()
13400 
    oprot.writeFieldStop()
13401 
    oprot.writeStructEnd()
13402 
 
13403 
  def validate(self):
13404 
    return
13405 
 
13406 
 
13407 
  def __repr__(self):
13408 
    L = ['%s=%r' % (key, value)
13409 
      for key, value in self.__dict__.iteritems()]
13410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13411 
 
13412 
  def __eq__(self, other):
13413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13414 
 
13415 
  def __ne__(self, other):
13416 
    return not (self == other)
13417 
 
13418 
class shiftToWarehouse_args:
13419 
  """
13420 
  Attributes:
13421 
   - orderId
13422 
   - warehouseId
13423 
  """
13424 
 
13425 
  thrift_spec = (
13426 
    None, # 0
13427 
    (1, TType.I64, 'orderId', None, None, ), # 1
13428 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13429 
  )
13430 
 
13431 
  def __init__(self, orderId=None, warehouseId=None,):
13432 
    self.orderId = orderId
13433 
    self.warehouseId = warehouseId
13434 
 
13435 
  def read(self, iprot):
13436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13438 
      return
13439 
    iprot.readStructBegin()
13440 
    while True:
13441 
      (fname, ftype, fid) = iprot.readFieldBegin()
13442 
      if ftype == TType.STOP:
13443 
        break
13444 
      if fid == 1:
13445 
        if ftype == TType.I64:
13446 
          self.orderId = iprot.readI64();
13447 
        else:
13448 
          iprot.skip(ftype)
13449 
      elif fid == 2:
13450 
        if ftype == TType.I64:
13451 
          self.warehouseId = iprot.readI64();
13452 
        else:
13453 
          iprot.skip(ftype)
13454 
      else:
13455 
        iprot.skip(ftype)
13456 
      iprot.readFieldEnd()
13457 
    iprot.readStructEnd()
13458 
 
13459 
  def write(self, oprot):
13460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13462 
      return
13463 
    oprot.writeStructBegin('shiftToWarehouse_args')
13464 
    if self.orderId is not None:
13465 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13466 
      oprot.writeI64(self.orderId)
13467 
      oprot.writeFieldEnd()
13468 
    if self.warehouseId is not None:
13469 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13470 
      oprot.writeI64(self.warehouseId)
13471 
      oprot.writeFieldEnd()
13472 
    oprot.writeFieldStop()
13473 
    oprot.writeStructEnd()
13474 
 
13475 
  def validate(self):
13476 
    return
13477 
 
13478 
 
13479 
  def __repr__(self):
13480 
    L = ['%s=%r' % (key, value)
13481 
      for key, value in self.__dict__.iteritems()]
13482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13483 
 
13484 
  def __eq__(self, other):
13485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13486 
 
13487 
  def __ne__(self, other):
13488 
    return not (self == other)
13489 
 
13490 
class shiftToWarehouse_result:
13491 
  """
13492 
  Attributes:
13493 
   - success
13494 
   - ex
13495 
  """
13496 
 
13497 
  thrift_spec = (
13498 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13499 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13500 
  )
13501 
 
13502 
  def __init__(self, success=None, ex=None,):
13503 
    self.success = success
13504 
    self.ex = ex
13505 
 
13506 
  def read(self, iprot):
13507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13509 
      return
13510 
    iprot.readStructBegin()
13511 
    while True:
13512 
      (fname, ftype, fid) = iprot.readFieldBegin()
13513 
      if ftype == TType.STOP:
13514 
        break
13515 
      if fid == 0:
13516 
        if ftype == TType.STRUCT:
13517 
          self.success = Order()
13518 
          self.success.read(iprot)
13519 
        else:
13520 
          iprot.skip(ftype)
13521 
      elif fid == 1:
13522 
        if ftype == TType.STRUCT:
13523 
          self.ex = TransactionServiceException()
13524 
          self.ex.read(iprot)
13525 
        else:
13526 
          iprot.skip(ftype)
13527 
      else:
13528 
        iprot.skip(ftype)
13529 
      iprot.readFieldEnd()
13530 
    iprot.readStructEnd()
13531 
 
13532 
  def write(self, oprot):
13533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13535 
      return
13536 
    oprot.writeStructBegin('shiftToWarehouse_result')
13537 
    if self.success is not None:
13538 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13539 
      self.success.write(oprot)
13540 
      oprot.writeFieldEnd()
13541 
    if self.ex is not None:
13542 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13543 
      self.ex.write(oprot)
13544 
      oprot.writeFieldEnd()
13545 
    oprot.writeFieldStop()
13546 
    oprot.writeStructEnd()
13547 
 
13548 
  def validate(self):
13549 
    return
13550 
 
13551 
 
13552 
  def __repr__(self):
13553 
    L = ['%s=%r' % (key, value)
13554 
      for key, value in self.__dict__.iteritems()]
13555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13556 
 
13557 
  def __eq__(self, other):
13558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13559 
 
13560 
  def __ne__(self, other):
13561 
    return not (self == other)
3553 chandransh 13562 
 
13563 
class addDelayReason_args:
13564 
  """
13565 
  Attributes:
13566 
   - orderId
13567 
   - delayReason
3986 chandransh 13568 
   - furtherDelay
3553 chandransh 13569 
  """
13570 
 
13571 
  thrift_spec = (
13572 
    None, # 0
13573 
    (1, TType.I64, 'orderId', None, None, ), # 1
13574 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 13575 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 13576 
  )
13577 
 
3986 chandransh 13578 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 13579 
    self.orderId = orderId
13580 
    self.delayReason = delayReason
3986 chandransh 13581 
    self.furtherDelay = furtherDelay
3553 chandransh 13582 
 
13583 
  def read(self, iprot):
13584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13586 
      return
13587 
    iprot.readStructBegin()
13588 
    while True:
13589 
      (fname, ftype, fid) = iprot.readFieldBegin()
13590 
      if ftype == TType.STOP:
13591 
        break
13592 
      if fid == 1:
13593 
        if ftype == TType.I64:
13594 
          self.orderId = iprot.readI64();
13595 
        else:
13596 
          iprot.skip(ftype)
13597 
      elif fid == 2:
13598 
        if ftype == TType.I32:
13599 
          self.delayReason = iprot.readI32();
13600 
        else:
13601 
          iprot.skip(ftype)
3986 chandransh 13602 
      elif fid == 3:
13603 
        if ftype == TType.I64:
13604 
          self.furtherDelay = iprot.readI64();
13605 
        else:
13606 
          iprot.skip(ftype)
3553 chandransh 13607 
      else:
13608 
        iprot.skip(ftype)
13609 
      iprot.readFieldEnd()
13610 
    iprot.readStructEnd()
13611 
 
13612 
  def write(self, oprot):
13613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13615 
      return
13616 
    oprot.writeStructBegin('addDelayReason_args')
13617 
    if self.orderId is not None:
13618 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13619 
      oprot.writeI64(self.orderId)
13620 
      oprot.writeFieldEnd()
13621 
    if self.delayReason is not None:
13622 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
13623 
      oprot.writeI32(self.delayReason)
13624 
      oprot.writeFieldEnd()
3986 chandransh 13625 
    if self.furtherDelay is not None:
13626 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
13627 
      oprot.writeI64(self.furtherDelay)
13628 
      oprot.writeFieldEnd()
3553 chandransh 13629 
    oprot.writeFieldStop()
13630 
    oprot.writeStructEnd()
13631 
 
13632 
  def validate(self):
13633 
    return
13634 
 
13635 
 
13636 
  def __repr__(self):
13637 
    L = ['%s=%r' % (key, value)
13638 
      for key, value in self.__dict__.iteritems()]
13639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13640 
 
13641 
  def __eq__(self, other):
13642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13643 
 
13644 
  def __ne__(self, other):
13645 
    return not (self == other)
13646 
 
13647 
class addDelayReason_result:
13648 
  """
13649 
  Attributes:
13650 
   - success
13651 
   - ex
13652 
  """
13653 
 
13654 
  thrift_spec = (
13655 
    (0, TType.BOOL, 'success', None, None, ), # 0
13656 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13657 
  )
13658 
 
13659 
  def __init__(self, success=None, ex=None,):
13660 
    self.success = success
13661 
    self.ex = ex
13662 
 
13663 
  def read(self, iprot):
13664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13666 
      return
13667 
    iprot.readStructBegin()
13668 
    while True:
13669 
      (fname, ftype, fid) = iprot.readFieldBegin()
13670 
      if ftype == TType.STOP:
13671 
        break
13672 
      if fid == 0:
13673 
        if ftype == TType.BOOL:
13674 
          self.success = iprot.readBool();
13675 
        else:
13676 
          iprot.skip(ftype)
13677 
      elif fid == 1:
13678 
        if ftype == TType.STRUCT:
13679 
          self.ex = TransactionServiceException()
13680 
          self.ex.read(iprot)
13681 
        else:
13682 
          iprot.skip(ftype)
13683 
      else:
13684 
        iprot.skip(ftype)
13685 
      iprot.readFieldEnd()
13686 
    iprot.readStructEnd()
13687 
 
13688 
  def write(self, oprot):
13689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13691 
      return
13692 
    oprot.writeStructBegin('addDelayReason_result')
13693 
    if self.success is not None:
13694 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13695 
      oprot.writeBool(self.success)
13696 
      oprot.writeFieldEnd()
13697 
    if self.ex is not None:
13698 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13699 
      self.ex.write(oprot)
13700 
      oprot.writeFieldEnd()
13701 
    oprot.writeFieldStop()
13702 
    oprot.writeStructEnd()
13703 
 
13704 
  def validate(self):
13705 
    return
13706 
 
13707 
 
13708 
  def __repr__(self):
13709 
    L = ['%s=%r' % (key, value)
13710 
      for key, value in self.__dict__.iteritems()]
13711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13712 
 
13713 
  def __eq__(self, other):
13714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13715 
 
13716 
  def __ne__(self, other):
13717 
    return not (self == other)
3956 chandransh 13718 
 
13719 
class reconcileCodCollection_args:
13720 
  """
13721 
  Attributes:
13722 
   - collectedAmountMap
13723 
   - xferBy
13724 
   - xferTxnId
13725 
   - xferDate
13726 
  """
13727 
 
13728 
  thrift_spec = (
13729 
    None, # 0
13730 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
13731 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
13732 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
13733 
    (4, TType.I64, 'xferDate', None, None, ), # 4
13734 
  )
13735 
 
13736 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
13737 
    self.collectedAmountMap = collectedAmountMap
13738 
    self.xferBy = xferBy
13739 
    self.xferTxnId = xferTxnId
13740 
    self.xferDate = xferDate
13741 
 
13742 
  def read(self, iprot):
13743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13745 
      return
13746 
    iprot.readStructBegin()
13747 
    while True:
13748 
      (fname, ftype, fid) = iprot.readFieldBegin()
13749 
      if ftype == TType.STOP:
13750 
        break
13751 
      if fid == 1:
13752 
        if ftype == TType.MAP:
13753 
          self.collectedAmountMap = {}
4133 chandransh 13754 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
13755 
          for _i217 in xrange(_size213):
13756 
            _key218 = iprot.readString();
13757 
            _val219 = iprot.readDouble();
13758 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 13759 
          iprot.readMapEnd()
13760 
        else:
13761 
          iprot.skip(ftype)
13762 
      elif fid == 2:
13763 
        if ftype == TType.STRING:
13764 
          self.xferBy = iprot.readString();
13765 
        else:
13766 
          iprot.skip(ftype)
13767 
      elif fid == 3:
13768 
        if ftype == TType.STRING:
13769 
          self.xferTxnId = iprot.readString();
13770 
        else:
13771 
          iprot.skip(ftype)
13772 
      elif fid == 4:
13773 
        if ftype == TType.I64:
13774 
          self.xferDate = iprot.readI64();
13775 
        else:
13776 
          iprot.skip(ftype)
13777 
      else:
13778 
        iprot.skip(ftype)
13779 
      iprot.readFieldEnd()
13780 
    iprot.readStructEnd()
13781 
 
13782 
  def write(self, oprot):
13783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13785 
      return
13786 
    oprot.writeStructBegin('reconcileCodCollection_args')
13787 
    if self.collectedAmountMap is not None:
13788 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
13789 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 13790 
      for kiter220,viter221 in self.collectedAmountMap.items():
13791 
        oprot.writeString(kiter220)
13792 
        oprot.writeDouble(viter221)
3956 chandransh 13793 
      oprot.writeMapEnd()
13794 
      oprot.writeFieldEnd()
13795 
    if self.xferBy is not None:
13796 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
13797 
      oprot.writeString(self.xferBy)
13798 
      oprot.writeFieldEnd()
13799 
    if self.xferTxnId is not None:
13800 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
13801 
      oprot.writeString(self.xferTxnId)
13802 
      oprot.writeFieldEnd()
13803 
    if self.xferDate is not None:
13804 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
13805 
      oprot.writeI64(self.xferDate)
13806 
      oprot.writeFieldEnd()
13807 
    oprot.writeFieldStop()
13808 
    oprot.writeStructEnd()
13809 
 
13810 
  def validate(self):
13811 
    return
13812 
 
13813 
 
13814 
  def __repr__(self):
13815 
    L = ['%s=%r' % (key, value)
13816 
      for key, value in self.__dict__.iteritems()]
13817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13818 
 
13819 
  def __eq__(self, other):
13820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13821 
 
13822 
  def __ne__(self, other):
13823 
    return not (self == other)
13824 
 
13825 
class reconcileCodCollection_result:
13826 
  """
13827 
  Attributes:
13828 
   - success
13829 
   - ex
13830 
  """
13831 
 
13832 
  thrift_spec = (
13833 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
13834 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13835 
  )
13836 
 
13837 
  def __init__(self, success=None, ex=None,):
13838 
    self.success = success
13839 
    self.ex = ex
13840 
 
13841 
  def read(self, iprot):
13842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13844 
      return
13845 
    iprot.readStructBegin()
13846 
    while True:
13847 
      (fname, ftype, fid) = iprot.readFieldBegin()
13848 
      if ftype == TType.STOP:
13849 
        break
13850 
      if fid == 0:
13851 
        if ftype == TType.MAP:
13852 
          self.success = {}
4133 chandransh 13853 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
13854 
          for _i226 in xrange(_size222):
13855 
            _key227 = iprot.readString();
13856 
            _val228 = iprot.readString();
13857 
            self.success[_key227] = _val228
3956 chandransh 13858 
          iprot.readMapEnd()
13859 
        else:
13860 
          iprot.skip(ftype)
13861 
      elif fid == 1:
13862 
        if ftype == TType.STRUCT:
13863 
          self.ex = TransactionServiceException()
13864 
          self.ex.read(iprot)
13865 
        else:
13866 
          iprot.skip(ftype)
13867 
      else:
13868 
        iprot.skip(ftype)
13869 
      iprot.readFieldEnd()
13870 
    iprot.readStructEnd()
13871 
 
13872 
  def write(self, oprot):
13873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13875 
      return
13876 
    oprot.writeStructBegin('reconcileCodCollection_result')
13877 
    if self.success is not None:
13878 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13879 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 13880 
      for kiter229,viter230 in self.success.items():
13881 
        oprot.writeString(kiter229)
13882 
        oprot.writeString(viter230)
3956 chandransh 13883 
      oprot.writeMapEnd()
13884 
      oprot.writeFieldEnd()
13885 
    if self.ex is not None:
13886 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13887 
      self.ex.write(oprot)
13888 
      oprot.writeFieldEnd()
13889 
    oprot.writeFieldStop()
13890 
    oprot.writeStructEnd()
13891 
 
13892 
  def validate(self):
13893 
    return
13894 
 
13895 
 
13896 
  def __repr__(self):
13897 
    L = ['%s=%r' % (key, value)
13898 
      for key, value in self.__dict__.iteritems()]
13899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13900 
 
13901 
  def __eq__(self, other):
13902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13903 
 
13904 
  def __ne__(self, other):
13905 
    return not (self == other)
4008 mandeep.dh 13906 
 
13907 
class getTransactionsRequiringExtraProcessing_args:
13908 
  """
13909 
  Attributes:
13910 
   - category
13911 
  """
13912 
 
13913 
  thrift_spec = (
13914 
    None, # 0
13915 
    (1, TType.I32, 'category', None, None, ), # 1
13916 
  )
13917 
 
13918 
  def __init__(self, category=None,):
13919 
    self.category = category
13920 
 
13921 
  def read(self, iprot):
13922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13924 
      return
13925 
    iprot.readStructBegin()
13926 
    while True:
13927 
      (fname, ftype, fid) = iprot.readFieldBegin()
13928 
      if ftype == TType.STOP:
13929 
        break
13930 
      if fid == 1:
13931 
        if ftype == TType.I32:
13932 
          self.category = iprot.readI32();
13933 
        else:
13934 
          iprot.skip(ftype)
13935 
      else:
13936 
        iprot.skip(ftype)
13937 
      iprot.readFieldEnd()
13938 
    iprot.readStructEnd()
13939 
 
13940 
  def write(self, oprot):
13941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13943 
      return
13944 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
13945 
    if self.category is not None:
13946 
      oprot.writeFieldBegin('category', TType.I32, 1)
13947 
      oprot.writeI32(self.category)
13948 
      oprot.writeFieldEnd()
13949 
    oprot.writeFieldStop()
13950 
    oprot.writeStructEnd()
13951 
 
13952 
  def validate(self):
13953 
    return
13954 
 
13955 
 
13956 
  def __repr__(self):
13957 
    L = ['%s=%r' % (key, value)
13958 
      for key, value in self.__dict__.iteritems()]
13959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13960 
 
13961 
  def __eq__(self, other):
13962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13963 
 
13964 
  def __ne__(self, other):
13965 
    return not (self == other)
13966 
 
13967 
class getTransactionsRequiringExtraProcessing_result:
13968 
  """
13969 
  Attributes:
13970 
   - success
13971 
  """
13972 
 
13973 
  thrift_spec = (
13974 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13975 
  )
13976 
 
13977 
  def __init__(self, success=None,):
13978 
    self.success = success
13979 
 
13980 
  def read(self, iprot):
13981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13983 
      return
13984 
    iprot.readStructBegin()
13985 
    while True:
13986 
      (fname, ftype, fid) = iprot.readFieldBegin()
13987 
      if ftype == TType.STOP:
13988 
        break
13989 
      if fid == 0:
13990 
        if ftype == TType.LIST:
13991 
          self.success = []
4133 chandransh 13992 
          (_etype234, _size231) = iprot.readListBegin()
13993 
          for _i235 in xrange(_size231):
13994 
            _elem236 = iprot.readI64();
13995 
            self.success.append(_elem236)
4008 mandeep.dh 13996 
          iprot.readListEnd()
13997 
        else:
13998 
          iprot.skip(ftype)
13999 
      else:
14000 
        iprot.skip(ftype)
14001 
      iprot.readFieldEnd()
14002 
    iprot.readStructEnd()
14003 
 
14004 
  def write(self, oprot):
14005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14007 
      return
14008 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
14009 
    if self.success is not None:
14010 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14011 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 14012 
      for iter237 in self.success:
14013 
        oprot.writeI64(iter237)
4008 mandeep.dh 14014 
      oprot.writeListEnd()
14015 
      oprot.writeFieldEnd()
14016 
    oprot.writeFieldStop()
14017 
    oprot.writeStructEnd()
14018 
 
14019 
  def validate(self):
14020 
    return
14021 
 
14022 
 
14023 
  def __repr__(self):
14024 
    L = ['%s=%r' % (key, value)
14025 
      for key, value in self.__dict__.iteritems()]
14026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14027 
 
14028 
  def __eq__(self, other):
14029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14030 
 
14031 
  def __ne__(self, other):
14032 
    return not (self == other)
14033 
 
14034 
class markTransactionAsProcessed_args:
14035 
  """
14036 
  Attributes:
14037 
   - transactionId
14038 
   - category
14039 
  """
14040 
 
14041 
  thrift_spec = (
14042 
    None, # 0
14043 
    (1, TType.I64, 'transactionId', None, None, ), # 1
14044 
    (2, TType.I32, 'category', None, None, ), # 2
14045 
  )
14046 
 
14047 
  def __init__(self, transactionId=None, category=None,):
14048 
    self.transactionId = transactionId
14049 
    self.category = category
14050 
 
14051 
  def read(self, iprot):
14052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14054 
      return
14055 
    iprot.readStructBegin()
14056 
    while True:
14057 
      (fname, ftype, fid) = iprot.readFieldBegin()
14058 
      if ftype == TType.STOP:
14059 
        break
14060 
      if fid == 1:
14061 
        if ftype == TType.I64:
14062 
          self.transactionId = iprot.readI64();
14063 
        else:
14064 
          iprot.skip(ftype)
14065 
      elif fid == 2:
14066 
        if ftype == TType.I32:
14067 
          self.category = iprot.readI32();
14068 
        else:
14069 
          iprot.skip(ftype)
14070 
      else:
14071 
        iprot.skip(ftype)
14072 
      iprot.readFieldEnd()
14073 
    iprot.readStructEnd()
14074 
 
14075 
  def write(self, oprot):
14076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14078 
      return
14079 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
14080 
    if self.transactionId is not None:
14081 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14082 
      oprot.writeI64(self.transactionId)
14083 
      oprot.writeFieldEnd()
14084 
    if self.category is not None:
14085 
      oprot.writeFieldBegin('category', TType.I32, 2)
14086 
      oprot.writeI32(self.category)
14087 
      oprot.writeFieldEnd()
14088 
    oprot.writeFieldStop()
14089 
    oprot.writeStructEnd()
14090 
 
14091 
  def validate(self):
14092 
    return
14093 
 
14094 
 
14095 
  def __repr__(self):
14096 
    L = ['%s=%r' % (key, value)
14097 
      for key, value in self.__dict__.iteritems()]
14098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14099 
 
14100 
  def __eq__(self, other):
14101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14102 
 
14103 
  def __ne__(self, other):
14104 
    return not (self == other)
14105 
 
14106 
class markTransactionAsProcessed_result:
14107 
 
14108 
  thrift_spec = (
14109 
  )
14110 
 
14111 
  def read(self, iprot):
14112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14114 
      return
14115 
    iprot.readStructBegin()
14116 
    while True:
14117 
      (fname, ftype, fid) = iprot.readFieldBegin()
14118 
      if ftype == TType.STOP:
14119 
        break
14120 
      else:
14121 
        iprot.skip(ftype)
14122 
      iprot.readFieldEnd()
14123 
    iprot.readStructEnd()
14124 
 
14125 
  def write(self, oprot):
14126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14128 
      return
14129 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
14130 
    oprot.writeFieldStop()
14131 
    oprot.writeStructEnd()
14132 
 
14133 
  def validate(self):
14134 
    return
14135 
 
14136 
 
14137 
  def __repr__(self):
14138 
    L = ['%s=%r' % (key, value)
14139 
      for key, value in self.__dict__.iteritems()]
14140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14141 
 
14142 
  def __eq__(self, other):
14143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14144 
 
14145 
  def __ne__(self, other):
14146 
    return not (self == other)
4018 chandransh 14147 
 
14148 
class getItemWiseRiskyOrdersCount_args:
14149 
 
14150 
  thrift_spec = (
14151 
  )
14152 
 
14153 
  def read(self, iprot):
14154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14156 
      return
14157 
    iprot.readStructBegin()
14158 
    while True:
14159 
      (fname, ftype, fid) = iprot.readFieldBegin()
14160 
      if ftype == TType.STOP:
14161 
        break
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_args')
14172 
    oprot.writeFieldStop()
14173 
    oprot.writeStructEnd()
14174 
 
14175 
  def validate(self):
14176 
    return
14177 
 
14178 
 
14179 
  def __repr__(self):
14180 
    L = ['%s=%r' % (key, value)
14181 
      for key, value in self.__dict__.iteritems()]
14182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14183 
 
14184 
  def __eq__(self, other):
14185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14186 
 
14187 
  def __ne__(self, other):
14188 
    return not (self == other)
14189 
 
14190 
class getItemWiseRiskyOrdersCount_result:
14191 
  """
14192 
  Attributes:
14193 
   - success
14194 
  """
14195 
 
14196 
  thrift_spec = (
14197 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
14198 
  )
14199 
 
14200 
  def __init__(self, success=None,):
14201 
    self.success = success
14202 
 
14203 
  def read(self, iprot):
14204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14206 
      return
14207 
    iprot.readStructBegin()
14208 
    while True:
14209 
      (fname, ftype, fid) = iprot.readFieldBegin()
14210 
      if ftype == TType.STOP:
14211 
        break
14212 
      if fid == 0:
14213 
        if ftype == TType.MAP:
14214 
          self.success = {}
4133 chandransh 14215 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
14216 
          for _i242 in xrange(_size238):
14217 
            _key243 = iprot.readI64();
14218 
            _val244 = iprot.readI64();
14219 
            self.success[_key243] = _val244
4018 chandransh 14220 
          iprot.readMapEnd()
14221 
        else:
14222 
          iprot.skip(ftype)
14223 
      else:
14224 
        iprot.skip(ftype)
14225 
      iprot.readFieldEnd()
14226 
    iprot.readStructEnd()
14227 
 
14228 
  def write(self, oprot):
14229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14231 
      return
14232 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
14233 
    if self.success is not None:
14234 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14235 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 14236 
      for kiter245,viter246 in self.success.items():
14237 
        oprot.writeI64(kiter245)
14238 
        oprot.writeI64(viter246)
4018 chandransh 14239 
      oprot.writeMapEnd()
14240 
      oprot.writeFieldEnd()
14241 
    oprot.writeFieldStop()
14242 
    oprot.writeStructEnd()
14243 
 
14244 
  def validate(self):
14245 
    return
14246 
 
14247 
 
14248 
  def __repr__(self):
14249 
    L = ['%s=%r' % (key, value)
14250 
      for key, value in self.__dict__.iteritems()]
14251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14252 
 
14253 
  def __eq__(self, other):
14254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14255 
 
14256 
  def __ne__(self, other):
14257 
    return not (self == other)
4247 rajveer 14258 
 
4295 varun.gupt 14259 
class getOrdersForItemIds_args:
14260 
  """
14261 
  Attributes:
14262 
   - itemIds
14263 
  """
14264 
 
14265 
  thrift_spec = (
14266 
    None, # 0
14267 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
14268 
  )
14269 
 
14270 
  def __init__(self, itemIds=None,):
14271 
    self.itemIds = itemIds
14272 
 
14273 
  def read(self, iprot):
14274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14276 
      return
14277 
    iprot.readStructBegin()
14278 
    while True:
14279 
      (fname, ftype, fid) = iprot.readFieldBegin()
14280 
      if ftype == TType.STOP:
14281 
        break
14282 
      if fid == 1:
14283 
        if ftype == TType.LIST:
14284 
          self.itemIds = []
14285 
          (_etype250, _size247) = iprot.readListBegin()
14286 
          for _i251 in xrange(_size247):
14287 
            _elem252 = iprot.readI64();
14288 
            self.itemIds.append(_elem252)
14289 
          iprot.readListEnd()
14290 
        else:
14291 
          iprot.skip(ftype)
14292 
      else:
14293 
        iprot.skip(ftype)
14294 
      iprot.readFieldEnd()
14295 
    iprot.readStructEnd()
14296 
 
14297 
  def write(self, oprot):
14298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14300 
      return
14301 
    oprot.writeStructBegin('getOrdersForItemIds_args')
14302 
    if self.itemIds is not None:
14303 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
14304 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
14305 
      for iter253 in self.itemIds:
14306 
        oprot.writeI64(iter253)
14307 
      oprot.writeListEnd()
14308 
      oprot.writeFieldEnd()
14309 
    oprot.writeFieldStop()
14310 
    oprot.writeStructEnd()
14311 
 
14312 
  def validate(self):
14313 
    return
14314 
 
14315 
 
14316 
  def __repr__(self):
14317 
    L = ['%s=%r' % (key, value)
14318 
      for key, value in self.__dict__.iteritems()]
14319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14320 
 
14321 
  def __eq__(self, other):
14322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14323 
 
14324 
  def __ne__(self, other):
14325 
    return not (self == other)
14326 
 
14327 
class getOrdersForItemIds_result:
14328 
  """
14329 
  Attributes:
14330 
   - success
14331 
  """
14332 
 
14333 
  thrift_spec = (
14334 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14335 
  )
14336 
 
14337 
  def __init__(self, success=None,):
14338 
    self.success = success
14339 
 
14340 
  def read(self, iprot):
14341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14343 
      return
14344 
    iprot.readStructBegin()
14345 
    while True:
14346 
      (fname, ftype, fid) = iprot.readFieldBegin()
14347 
      if ftype == TType.STOP:
14348 
        break
14349 
      if fid == 0:
14350 
        if ftype == TType.LIST:
14351 
          self.success = []
14352 
          (_etype257, _size254) = iprot.readListBegin()
14353 
          for _i258 in xrange(_size254):
14354 
            _elem259 = Order()
14355 
            _elem259.read(iprot)
14356 
            self.success.append(_elem259)
14357 
          iprot.readListEnd()
14358 
        else:
14359 
          iprot.skip(ftype)
14360 
      else:
14361 
        iprot.skip(ftype)
14362 
      iprot.readFieldEnd()
14363 
    iprot.readStructEnd()
14364 
 
14365 
  def write(self, oprot):
14366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14368 
      return
14369 
    oprot.writeStructBegin('getOrdersForItemIds_result')
14370 
    if self.success is not None:
14371 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14372 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
14373 
      for iter260 in self.success:
14374 
        iter260.write(oprot)
14375 
      oprot.writeListEnd()
14376 
      oprot.writeFieldEnd()
14377 
    oprot.writeFieldStop()
14378 
    oprot.writeStructEnd()
14379 
 
14380 
  def validate(self):
14381 
    return
14382 
 
14383 
 
14384 
  def __repr__(self):
14385 
    L = ['%s=%r' % (key, value)
14386 
      for key, value in self.__dict__.iteritems()]
14387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14388 
 
14389 
  def __eq__(self, other):
14390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14391 
 
14392 
  def __ne__(self, other):
14393 
    return not (self == other)
14394 
 
4247 rajveer 14395 
class markOrderCancellationRequestReceived_args:
14396 
  """
14397 
  Attributes:
14398 
   - orderId
14399 
  """
14400 
 
14401 
  thrift_spec = (
14402 
    None, # 0
14403 
    (1, TType.I64, 'orderId', None, None, ), # 1
14404 
  )
14405 
 
14406 
  def __init__(self, orderId=None,):
14407 
    self.orderId = orderId
14408 
 
14409 
  def read(self, iprot):
14410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14412 
      return
14413 
    iprot.readStructBegin()
14414 
    while True:
14415 
      (fname, ftype, fid) = iprot.readFieldBegin()
14416 
      if ftype == TType.STOP:
14417 
        break
14418 
      if fid == 1:
14419 
        if ftype == TType.I64:
14420 
          self.orderId = iprot.readI64();
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_args')
14433 
    if self.orderId is not None:
14434 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14435 
      oprot.writeI64(self.orderId)
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 markOrderCancellationRequestReceived_result:
14456 
  """
14457 
  Attributes:
14458 
   - ex
14459 
  """
14460 
 
14461 
  thrift_spec = (
14462 
    None, # 0
14463 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14464 
  )
14465 
 
14466 
  def __init__(self, ex=None,):
14467 
    self.ex = ex
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.STRUCT:
14480 
          self.ex = TransactionServiceException()
14481 
          self.ex.read(iprot)
14482 
        else:
14483 
          iprot.skip(ftype)
14484 
      else:
14485 
        iprot.skip(ftype)
14486 
      iprot.readFieldEnd()
14487 
    iprot.readStructEnd()
14488 
 
14489 
  def write(self, oprot):
14490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14492 
      return
14493 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
14494 
    if self.ex is not None:
14495 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14496 
      self.ex.write(oprot)
14497 
      oprot.writeFieldEnd()
14498 
    oprot.writeFieldStop()
14499 
    oprot.writeStructEnd()
14500 
 
14501 
  def validate(self):
14502 
    return
14503 
 
14504 
 
14505 
  def __repr__(self):
14506 
    L = ['%s=%r' % (key, value)
14507 
      for key, value in self.__dict__.iteritems()]
14508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14509 
 
14510 
  def __eq__(self, other):
14511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14512 
 
14513 
  def __ne__(self, other):
14514 
    return not (self == other)
14515 
 
14516 
class markOrderCancellationRequestConfirmed_args:
14517 
  """
14518 
  Attributes:
14519 
   - orderId
14520 
  """
14521 
 
14522 
  thrift_spec = (
14523 
    None, # 0
14524 
    (1, TType.I64, 'orderId', None, None, ), # 1
14525 
  )
14526 
 
14527 
  def __init__(self, orderId=None,):
14528 
    self.orderId = orderId
14529 
 
14530 
  def read(self, iprot):
14531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14533 
      return
14534 
    iprot.readStructBegin()
14535 
    while True:
14536 
      (fname, ftype, fid) = iprot.readFieldBegin()
14537 
      if ftype == TType.STOP:
14538 
        break
14539 
      if fid == 1:
14540 
        if ftype == TType.I64:
14541 
          self.orderId = iprot.readI64();
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_args')
14554 
    if self.orderId is not None:
14555 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14556 
      oprot.writeI64(self.orderId)
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 markOrderCancellationRequestConfirmed_result:
14577 
  """
14578 
  Attributes:
14579 
   - ex
14580 
  """
14581 
 
14582 
  thrift_spec = (
14583 
    None, # 0
14584 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14585 
  )
14586 
 
14587 
  def __init__(self, ex=None,):
14588 
    self.ex = ex
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.STRUCT:
14601 
          self.ex = TransactionServiceException()
14602 
          self.ex.read(iprot)
14603 
        else:
14604 
          iprot.skip(ftype)
14605 
      else:
14606 
        iprot.skip(ftype)
14607 
      iprot.readFieldEnd()
14608 
    iprot.readStructEnd()
14609 
 
14610 
  def write(self, oprot):
14611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14613 
      return
14614 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
14615 
    if self.ex is not None:
14616 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14617 
      self.ex.write(oprot)
14618 
      oprot.writeFieldEnd()
14619 
    oprot.writeFieldStop()
14620 
    oprot.writeStructEnd()
14621 
 
14622 
  def validate(self):
14623 
    return
14624 
 
14625 
 
14626 
  def __repr__(self):
14627 
    L = ['%s=%r' % (key, value)
14628 
      for key, value in self.__dict__.iteritems()]
14629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14630 
 
14631 
  def __eq__(self, other):
14632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14633 
 
14634 
  def __ne__(self, other):
14635 
    return not (self == other)
14636 
 
14637 
class markOrderCancellationRequestDenied_args:
14638 
  """
14639 
  Attributes:
14640 
   - orderId
14641 
  """
14642 
 
14643 
  thrift_spec = (
14644 
    None, # 0
14645 
    (1, TType.I64, 'orderId', None, None, ), # 1
14646 
  )
14647 
 
14648 
  def __init__(self, orderId=None,):
14649 
    self.orderId = orderId
14650 
 
14651 
  def read(self, iprot):
14652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14654 
      return
14655 
    iprot.readStructBegin()
14656 
    while True:
14657 
      (fname, ftype, fid) = iprot.readFieldBegin()
14658 
      if ftype == TType.STOP:
14659 
        break
14660 
      if fid == 1:
14661 
        if ftype == TType.I64:
14662 
          self.orderId = iprot.readI64();
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_args')
14675 
    if self.orderId is not None:
14676 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14677 
      oprot.writeI64(self.orderId)
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 
 
14697 
class markOrderCancellationRequestDenied_result:
14698 
  """
14699 
  Attributes:
14700 
   - ex
14701 
  """
14702 
 
14703 
  thrift_spec = (
14704 
    None, # 0
14705 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14706 
  )
14707 
 
14708 
  def __init__(self, ex=None,):
14709 
    self.ex = ex
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.STRUCT:
14722 
          self.ex = TransactionServiceException()
14723 
          self.ex.read(iprot)
14724 
        else:
14725 
          iprot.skip(ftype)
14726 
      else:
14727 
        iprot.skip(ftype)
14728 
      iprot.readFieldEnd()
14729 
    iprot.readStructEnd()
14730 
 
14731 
  def write(self, oprot):
14732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14734 
      return
14735 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
14736 
    if self.ex is not None:
14737 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14738 
      self.ex.write(oprot)
14739 
      oprot.writeFieldEnd()
14740 
    oprot.writeFieldStop()
14741 
    oprot.writeStructEnd()
14742 
 
14743 
  def validate(self):
14744 
    return
14745 
 
14746 
 
14747 
  def __repr__(self):
14748 
    L = ['%s=%r' % (key, value)
14749 
      for key, value in self.__dict__.iteritems()]
14750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14751 
 
14752 
  def __eq__(self, other):
14753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14754 
 
14755 
  def __ne__(self, other):
14756 
    return not (self == other)
14757 
 
4258 rajveer 14758 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 14759 
  """
14760 
  Attributes:
4258 rajveer 14761 
   - transactionId
4247 rajveer 14762 
  """
14763 
 
14764 
  thrift_spec = (
14765 
    None, # 0
4258 rajveer 14766 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 14767 
  )
14768 
 
4258 rajveer 14769 
  def __init__(self, transactionId=None,):
14770 
    self.transactionId = transactionId
4247 rajveer 14771 
 
14772 
  def read(self, iprot):
14773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14775 
      return
14776 
    iprot.readStructBegin()
14777 
    while True:
14778 
      (fname, ftype, fid) = iprot.readFieldBegin()
14779 
      if ftype == TType.STOP:
14780 
        break
14781 
      if fid == 1:
14782 
        if ftype == TType.I64:
4258 rajveer 14783 
          self.transactionId = iprot.readI64();
4247 rajveer 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_args')
14796 
    if self.transactionId is not None:
14797 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14798 
      oprot.writeI64(self.transactionId)
4247 rajveer 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)
14817 
 
4258 rajveer 14818 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 14819 
  """
14820 
  Attributes:
14821 
   - ex
14822 
  """
14823 
 
14824 
  thrift_spec = (
14825 
    None, # 0
14826 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14827 
  )
14828 
 
14829 
  def __init__(self, ex=None,):
14830 
    self.ex = ex
14831 
 
14832 
  def read(self, iprot):
14833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14835 
      return
14836 
    iprot.readStructBegin()
14837 
    while True:
14838 
      (fname, ftype, fid) = iprot.readFieldBegin()
14839 
      if ftype == TType.STOP:
14840 
        break
14841 
      if fid == 1:
14842 
        if ftype == TType.STRUCT:
14843 
          self.ex = TransactionServiceException()
14844 
          self.ex.read(iprot)
14845 
        else:
14846 
          iprot.skip(ftype)
14847 
      else:
14848 
        iprot.skip(ftype)
14849 
      iprot.readFieldEnd()
14850 
    iprot.readStructEnd()
14851 
 
14852 
  def write(self, oprot):
14853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14855 
      return
4258 rajveer 14856 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 14857 
    if self.ex is not None:
14858 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14859 
      self.ex.write(oprot)
14860 
      oprot.writeFieldEnd()
14861 
    oprot.writeFieldStop()
14862 
    oprot.writeStructEnd()
14863 
 
14864 
  def validate(self):
14865 
    return
14866 
 
14867 
 
14868 
  def __repr__(self):
14869 
    L = ['%s=%r' % (key, value)
14870 
      for key, value in self.__dict__.iteritems()]
14871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14872 
 
14873 
  def __eq__(self, other):
14874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14875 
 
14876 
  def __ne__(self, other):
14877 
    return not (self == other)
4259 anupam.sin 14878 
 
14879 
class refundTransaction_args:
14880 
  """
14881 
  Attributes:
14882 
   - transactionId
14883 
   - refundedBy
14884 
   - reason
14885 
  """
14886 
 
14887 
  thrift_spec = (
14888 
    None, # 0
14889 
    (1, TType.I64, 'transactionId', None, None, ), # 1
14890 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
14891 
    (3, TType.STRING, 'reason', None, None, ), # 3
14892 
  )
14893 
 
14894 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
14895 
    self.transactionId = transactionId
14896 
    self.refundedBy = refundedBy
14897 
    self.reason = reason
14898 
 
14899 
  def read(self, iprot):
14900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14902 
      return
14903 
    iprot.readStructBegin()
14904 
    while True:
14905 
      (fname, ftype, fid) = iprot.readFieldBegin()
14906 
      if ftype == TType.STOP:
14907 
        break
14908 
      if fid == 1:
14909 
        if ftype == TType.I64:
14910 
          self.transactionId = iprot.readI64();
14911 
        else:
14912 
          iprot.skip(ftype)
14913 
      elif fid == 2:
14914 
        if ftype == TType.STRING:
14915 
          self.refundedBy = iprot.readString();
14916 
        else:
14917 
          iprot.skip(ftype)
14918 
      elif fid == 3:
14919 
        if ftype == TType.STRING:
14920 
          self.reason = iprot.readString();
14921 
        else:
14922 
          iprot.skip(ftype)
14923 
      else:
14924 
        iprot.skip(ftype)
14925 
      iprot.readFieldEnd()
14926 
    iprot.readStructEnd()
14927 
 
14928 
  def write(self, oprot):
14929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14931 
      return
14932 
    oprot.writeStructBegin('refundTransaction_args')
14933 
    if self.transactionId is not None:
14934 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14935 
      oprot.writeI64(self.transactionId)
14936 
      oprot.writeFieldEnd()
14937 
    if self.refundedBy is not None:
14938 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
14939 
      oprot.writeString(self.refundedBy)
14940 
      oprot.writeFieldEnd()
14941 
    if self.reason is not None:
14942 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14943 
      oprot.writeString(self.reason)
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)
14962 
 
14963 
class refundTransaction_result:
14964 
  """
14965 
  Attributes:
14966 
   - ex
14967 
  """
14968 
 
14969 
  thrift_spec = (
14970 
    None, # 0
14971 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14972 
  )
14973 
 
14974 
  def __init__(self, ex=None,):
14975 
    self.ex = ex
14976 
 
14977 
  def read(self, iprot):
14978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14980 
      return
14981 
    iprot.readStructBegin()
14982 
    while True:
14983 
      (fname, ftype, fid) = iprot.readFieldBegin()
14984 
      if ftype == TType.STOP:
14985 
        break
14986 
      if fid == 1:
14987 
        if ftype == TType.STRUCT:
14988 
          self.ex = TransactionServiceException()
14989 
          self.ex.read(iprot)
14990 
        else:
14991 
          iprot.skip(ftype)
14992 
      else:
14993 
        iprot.skip(ftype)
14994 
      iprot.readFieldEnd()
14995 
    iprot.readStructEnd()
14996 
 
14997 
  def write(self, oprot):
14998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15000 
      return
15001 
    oprot.writeStructBegin('refundTransaction_result')
15002 
    if self.ex is not None:
15003 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15004 
      self.ex.write(oprot)
15005 
      oprot.writeFieldEnd()
15006 
    oprot.writeFieldStop()
15007 
    oprot.writeStructEnd()
15008 
 
15009 
  def validate(self):
15010 
    return
15011 
 
15012 
 
15013 
  def __repr__(self):
15014 
    L = ['%s=%r' % (key, value)
15015 
      for key, value in self.__dict__.iteritems()]
15016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15017 
 
15018 
  def __eq__(self, other):
15019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15020 
 
15021 
  def __ne__(self, other):
15022 
    return not (self == other)
4285 rajveer 15023 
 
4324 mandeep.dh 15024 
class updateShipmentAddress_args:
15025 
  """
15026 
  Attributes:
15027 
   - orderId
15028 
   - addressId
15029 
  """
15030 
 
15031 
  thrift_spec = (
15032 
    None, # 0
15033 
    (1, TType.I64, 'orderId', None, None, ), # 1
15034 
    (2, TType.I64, 'addressId', None, None, ), # 2
15035 
  )
15036 
 
15037 
  def __init__(self, orderId=None, addressId=None,):
15038 
    self.orderId = orderId
15039 
    self.addressId = addressId
15040 
 
15041 
  def read(self, iprot):
15042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15044 
      return
15045 
    iprot.readStructBegin()
15046 
    while True:
15047 
      (fname, ftype, fid) = iprot.readFieldBegin()
15048 
      if ftype == TType.STOP:
15049 
        break
15050 
      if fid == 1:
15051 
        if ftype == TType.I64:
15052 
          self.orderId = iprot.readI64();
15053 
        else:
15054 
          iprot.skip(ftype)
15055 
      elif fid == 2:
15056 
        if ftype == TType.I64:
15057 
          self.addressId = iprot.readI64();
15058 
        else:
15059 
          iprot.skip(ftype)
15060 
      else:
15061 
        iprot.skip(ftype)
15062 
      iprot.readFieldEnd()
15063 
    iprot.readStructEnd()
15064 
 
15065 
  def write(self, oprot):
15066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15068 
      return
15069 
    oprot.writeStructBegin('updateShipmentAddress_args')
15070 
    if self.orderId is not None:
15071 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15072 
      oprot.writeI64(self.orderId)
15073 
      oprot.writeFieldEnd()
15074 
    if self.addressId is not None:
15075 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
15076 
      oprot.writeI64(self.addressId)
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 
 
15096 
class updateShipmentAddress_result:
15097 
  """
15098 
  Attributes:
15099 
   - ex
15100 
  """
15101 
 
15102 
  thrift_spec = (
15103 
    None, # 0
15104 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15105 
  )
15106 
 
15107 
  def __init__(self, ex=None,):
15108 
    self.ex = ex
15109 
 
15110 
  def read(self, iprot):
15111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15113 
      return
15114 
    iprot.readStructBegin()
15115 
    while True:
15116 
      (fname, ftype, fid) = iprot.readFieldBegin()
15117 
      if ftype == TType.STOP:
15118 
        break
15119 
      if fid == 1:
15120 
        if ftype == TType.STRUCT:
15121 
          self.ex = TransactionServiceException()
15122 
          self.ex.read(iprot)
15123 
        else:
15124 
          iprot.skip(ftype)
15125 
      else:
15126 
        iprot.skip(ftype)
15127 
      iprot.readFieldEnd()
15128 
    iprot.readStructEnd()
15129 
 
15130 
  def write(self, oprot):
15131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15133 
      return
15134 
    oprot.writeStructBegin('updateShipmentAddress_result')
15135 
    if self.ex is not None:
15136 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15137 
      self.ex.write(oprot)
15138 
      oprot.writeFieldEnd()
15139 
    oprot.writeFieldStop()
15140 
    oprot.writeStructEnd()
15141 
 
15142 
  def validate(self):
15143 
    return
15144 
 
15145 
 
15146 
  def __repr__(self):
15147 
    L = ['%s=%r' % (key, value)
15148 
      for key, value in self.__dict__.iteritems()]
15149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15150 
 
15151 
  def __eq__(self, other):
15152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15153 
 
15154 
  def __ne__(self, other):
15155 
    return not (self == other)
15156 
 
4285 rajveer 15157 
class acceptOrdersForItemId_args:
15158 
  """
15159 
  Attributes:
15160 
   - itemId
15161 
   - inventory
15162 
  """
15163 
 
15164 
  thrift_spec = (
15165 
    None, # 0
15166 
    (1, TType.I64, 'itemId', None, None, ), # 1
15167 
    (2, TType.I64, 'inventory', None, None, ), # 2
15168 
  )
15169 
 
15170 
  def __init__(self, itemId=None, inventory=None,):
15171 
    self.itemId = itemId
15172 
    self.inventory = inventory
15173 
 
15174 
  def read(self, iprot):
15175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15177 
      return
15178 
    iprot.readStructBegin()
15179 
    while True:
15180 
      (fname, ftype, fid) = iprot.readFieldBegin()
15181 
      if ftype == TType.STOP:
15182 
        break
15183 
      if fid == 1:
15184 
        if ftype == TType.I64:
15185 
          self.itemId = iprot.readI64();
15186 
        else:
15187 
          iprot.skip(ftype)
15188 
      elif fid == 2:
15189 
        if ftype == TType.I64:
15190 
          self.inventory = iprot.readI64();
15191 
        else:
15192 
          iprot.skip(ftype)
15193 
      else:
15194 
        iprot.skip(ftype)
15195 
      iprot.readFieldEnd()
15196 
    iprot.readStructEnd()
15197 
 
15198 
  def write(self, oprot):
15199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15201 
      return
15202 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
15203 
    if self.itemId is not None:
15204 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15205 
      oprot.writeI64(self.itemId)
15206 
      oprot.writeFieldEnd()
15207 
    if self.inventory is not None:
15208 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
15209 
      oprot.writeI64(self.inventory)
15210 
      oprot.writeFieldEnd()
15211 
    oprot.writeFieldStop()
15212 
    oprot.writeStructEnd()
15213 
 
15214 
  def validate(self):
15215 
    return
15216 
 
15217 
 
15218 
  def __repr__(self):
15219 
    L = ['%s=%r' % (key, value)
15220 
      for key, value in self.__dict__.iteritems()]
15221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15222 
 
15223 
  def __eq__(self, other):
15224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15225 
 
15226 
  def __ne__(self, other):
15227 
    return not (self == other)
15228 
 
15229 
class acceptOrdersForItemId_result:
15230 
  """
15231 
  Attributes:
15232 
   - success
15233 
   - ex
15234 
  """
15235 
 
15236 
  thrift_spec = (
15237 
    (0, TType.BOOL, 'success', None, None, ), # 0
15238 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15239 
  )
15240 
 
15241 
  def __init__(self, success=None, ex=None,):
15242 
    self.success = success
15243 
    self.ex = ex
15244 
 
15245 
  def read(self, iprot):
15246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15248 
      return
15249 
    iprot.readStructBegin()
15250 
    while True:
15251 
      (fname, ftype, fid) = iprot.readFieldBegin()
15252 
      if ftype == TType.STOP:
15253 
        break
15254 
      if fid == 0:
15255 
        if ftype == TType.BOOL:
15256 
          self.success = iprot.readBool();
15257 
        else:
15258 
          iprot.skip(ftype)
15259 
      elif fid == 1:
15260 
        if ftype == TType.STRUCT:
15261 
          self.ex = TransactionServiceException()
15262 
          self.ex.read(iprot)
15263 
        else:
15264 
          iprot.skip(ftype)
15265 
      else:
15266 
        iprot.skip(ftype)
15267 
      iprot.readFieldEnd()
15268 
    iprot.readStructEnd()
15269 
 
15270 
  def write(self, oprot):
15271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15273 
      return
15274 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
15275 
    if self.success is not None:
15276 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15277 
      oprot.writeBool(self.success)
15278 
      oprot.writeFieldEnd()
15279 
    if self.ex is not None:
15280 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15281 
      self.ex.write(oprot)
15282 
      oprot.writeFieldEnd()
15283 
    oprot.writeFieldStop()
15284 
    oprot.writeStructEnd()
15285 
 
15286 
  def validate(self):
15287 
    return
15288 
 
15289 
 
15290 
  def __repr__(self):
15291 
    L = ['%s=%r' % (key, value)
15292 
      for key, value in self.__dict__.iteritems()]
15293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15294 
 
15295 
  def __eq__(self, other):
15296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15297 
 
15298 
  def __ne__(self, other):
15299 
    return not (self == other)
4303 rajveer 15300 
 
15301 
class markOrdersAsPORaised_args:
15302 
  """
15303 
  Attributes:
15304 
   - vendorId
15305 
   - itemId
15306 
   - quantity
15307 
   - estimate
4369 rajveer 15308 
   - isReminder
4303 rajveer 15309 
  """
15310 
 
15311 
  thrift_spec = (
15312 
    None, # 0
15313 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15314 
    (2, TType.I64, 'itemId', None, None, ), # 2
15315 
    (3, TType.I64, 'quantity', None, None, ), # 3
15316 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15317 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15318 
  )
15319 
 
4369 rajveer 15320 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15321 
    self.vendorId = vendorId
15322 
    self.itemId = itemId
15323 
    self.quantity = quantity
15324 
    self.estimate = estimate
4369 rajveer 15325 
    self.isReminder = isReminder
4303 rajveer 15326 
 
15327 
  def read(self, iprot):
15328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15330 
      return
15331 
    iprot.readStructBegin()
15332 
    while True:
15333 
      (fname, ftype, fid) = iprot.readFieldBegin()
15334 
      if ftype == TType.STOP:
15335 
        break
15336 
      if fid == 1:
15337 
        if ftype == TType.I64:
15338 
          self.vendorId = iprot.readI64();
15339 
        else:
15340 
          iprot.skip(ftype)
15341 
      elif fid == 2:
15342 
        if ftype == TType.I64:
15343 
          self.itemId = iprot.readI64();
15344 
        else:
15345 
          iprot.skip(ftype)
15346 
      elif fid == 3:
15347 
        if ftype == TType.I64:
15348 
          self.quantity = iprot.readI64();
15349 
        else:
15350 
          iprot.skip(ftype)
15351 
      elif fid == 4:
15352 
        if ftype == TType.I64:
15353 
          self.estimate = iprot.readI64();
15354 
        else:
15355 
          iprot.skip(ftype)
4369 rajveer 15356 
      elif fid == 5:
15357 
        if ftype == TType.BOOL:
15358 
          self.isReminder = iprot.readBool();
15359 
        else:
15360 
          iprot.skip(ftype)
4303 rajveer 15361 
      else:
15362 
        iprot.skip(ftype)
15363 
      iprot.readFieldEnd()
15364 
    iprot.readStructEnd()
15365 
 
15366 
  def write(self, oprot):
15367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15369 
      return
15370 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
15371 
    if self.vendorId is not None:
15372 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15373 
      oprot.writeI64(self.vendorId)
15374 
      oprot.writeFieldEnd()
15375 
    if self.itemId is not None:
15376 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15377 
      oprot.writeI64(self.itemId)
15378 
      oprot.writeFieldEnd()
15379 
    if self.quantity is not None:
15380 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15381 
      oprot.writeI64(self.quantity)
15382 
      oprot.writeFieldEnd()
15383 
    if self.estimate is not None:
15384 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15385 
      oprot.writeI64(self.estimate)
15386 
      oprot.writeFieldEnd()
4369 rajveer 15387 
    if self.isReminder is not None:
15388 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15389 
      oprot.writeBool(self.isReminder)
15390 
      oprot.writeFieldEnd()
4303 rajveer 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 markOrdersAsPORaised_result:
15410 
  """
15411 
  Attributes:
15412 
   - ex
15413 
  """
15414 
 
15415 
  thrift_spec = (
15416 
    None, # 0
15417 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15418 
  )
15419 
 
15420 
  def __init__(self, ex=None,):
15421 
    self.ex = ex
15422 
 
15423 
  def read(self, iprot):
15424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15426 
      return
15427 
    iprot.readStructBegin()
15428 
    while True:
15429 
      (fname, ftype, fid) = iprot.readFieldBegin()
15430 
      if ftype == TType.STOP:
15431 
        break
15432 
      if fid == 1:
15433 
        if ftype == TType.STRUCT:
15434 
          self.ex = TransactionServiceException()
15435 
          self.ex.read(iprot)
15436 
        else:
15437 
          iprot.skip(ftype)
15438 
      else:
15439 
        iprot.skip(ftype)
15440 
      iprot.readFieldEnd()
15441 
    iprot.readStructEnd()
15442 
 
15443 
  def write(self, oprot):
15444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15446 
      return
15447 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
15448 
    if self.ex is not None:
15449 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15450 
      self.ex.write(oprot)
15451 
      oprot.writeFieldEnd()
15452 
    oprot.writeFieldStop()
15453 
    oprot.writeStructEnd()
15454 
 
15455 
  def validate(self):
15456 
    return
15457 
 
15458 
 
15459 
  def __repr__(self):
15460 
    L = ['%s=%r' % (key, value)
15461 
      for key, value in self.__dict__.iteritems()]
15462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15463 
 
15464 
  def __eq__(self, other):
15465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15466 
 
15467 
  def __ne__(self, other):
15468 
    return not (self == other)
15469 
 
15470 
class markOrdersAsReversalInitiated_args:
15471 
  """
15472 
  Attributes:
15473 
   - vendorId
15474 
   - itemId
15475 
   - quantity
15476 
   - estimate
4369 rajveer 15477 
   - isReminder
4303 rajveer 15478 
  """
15479 
 
15480 
  thrift_spec = (
15481 
    None, # 0
15482 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15483 
    (2, TType.I64, 'itemId', None, None, ), # 2
15484 
    (3, TType.I64, 'quantity', None, None, ), # 3
15485 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15486 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15487 
  )
15488 
 
4369 rajveer 15489 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15490 
    self.vendorId = vendorId
15491 
    self.itemId = itemId
15492 
    self.quantity = quantity
15493 
    self.estimate = estimate
4369 rajveer 15494 
    self.isReminder = isReminder
4303 rajveer 15495 
 
15496 
  def read(self, iprot):
15497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15499 
      return
15500 
    iprot.readStructBegin()
15501 
    while True:
15502 
      (fname, ftype, fid) = iprot.readFieldBegin()
15503 
      if ftype == TType.STOP:
15504 
        break
15505 
      if fid == 1:
15506 
        if ftype == TType.I64:
15507 
          self.vendorId = iprot.readI64();
15508 
        else:
15509 
          iprot.skip(ftype)
15510 
      elif fid == 2:
15511 
        if ftype == TType.I64:
15512 
          self.itemId = iprot.readI64();
15513 
        else:
15514 
          iprot.skip(ftype)
15515 
      elif fid == 3:
15516 
        if ftype == TType.I64:
15517 
          self.quantity = iprot.readI64();
15518 
        else:
15519 
          iprot.skip(ftype)
15520 
      elif fid == 4:
15521 
        if ftype == TType.I64:
15522 
          self.estimate = iprot.readI64();
15523 
        else:
15524 
          iprot.skip(ftype)
4369 rajveer 15525 
      elif fid == 5:
15526 
        if ftype == TType.BOOL:
15527 
          self.isReminder = iprot.readBool();
15528 
        else:
15529 
          iprot.skip(ftype)
4303 rajveer 15530 
      else:
15531 
        iprot.skip(ftype)
15532 
      iprot.readFieldEnd()
15533 
    iprot.readStructEnd()
15534 
 
15535 
  def write(self, oprot):
15536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15538 
      return
15539 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
15540 
    if self.vendorId is not None:
15541 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15542 
      oprot.writeI64(self.vendorId)
15543 
      oprot.writeFieldEnd()
15544 
    if self.itemId is not None:
15545 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15546 
      oprot.writeI64(self.itemId)
15547 
      oprot.writeFieldEnd()
15548 
    if self.quantity is not None:
15549 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15550 
      oprot.writeI64(self.quantity)
15551 
      oprot.writeFieldEnd()
15552 
    if self.estimate is not None:
15553 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15554 
      oprot.writeI64(self.estimate)
15555 
      oprot.writeFieldEnd()
4369 rajveer 15556 
    if self.isReminder is not None:
15557 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15558 
      oprot.writeBool(self.isReminder)
15559 
      oprot.writeFieldEnd()
4303 rajveer 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 markOrdersAsReversalInitiated_result:
15579 
  """
15580 
  Attributes:
15581 
   - ex
15582 
  """
15583 
 
15584 
  thrift_spec = (
15585 
    None, # 0
15586 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15587 
  )
15588 
 
15589 
  def __init__(self, ex=None,):
15590 
    self.ex = ex
15591 
 
15592 
  def read(self, iprot):
15593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15595 
      return
15596 
    iprot.readStructBegin()
15597 
    while True:
15598 
      (fname, ftype, fid) = iprot.readFieldBegin()
15599 
      if ftype == TType.STOP:
15600 
        break
15601 
      if fid == 1:
15602 
        if ftype == TType.STRUCT:
15603 
          self.ex = TransactionServiceException()
15604 
          self.ex.read(iprot)
15605 
        else:
15606 
          iprot.skip(ftype)
15607 
      else:
15608 
        iprot.skip(ftype)
15609 
      iprot.readFieldEnd()
15610 
    iprot.readStructEnd()
15611 
 
15612 
  def write(self, oprot):
15613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15615 
      return
15616 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
15617 
    if self.ex is not None:
15618 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15619 
      self.ex.write(oprot)
15620 
      oprot.writeFieldEnd()
15621 
    oprot.writeFieldStop()
15622 
    oprot.writeStructEnd()
15623 
 
15624 
  def validate(self):
15625 
    return
15626 
 
15627 
 
15628 
  def __repr__(self):
15629 
    L = ['%s=%r' % (key, value)
15630 
      for key, value in self.__dict__.iteritems()]
15631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15632 
 
15633 
  def __eq__(self, other):
15634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15635 
 
15636 
  def __ne__(self, other):
15637 
    return not (self == other)
15638 
 
15639 
class markOrdersAsNotAvailabke_args:
15640 
  """
15641 
  Attributes:
15642 
   - vendorId
15643 
   - itemId
15644 
   - quantity
15645 
   - estimate
4369 rajveer 15646 
   - isReminder
4303 rajveer 15647 
  """
15648 
 
15649 
  thrift_spec = (
15650 
    None, # 0
15651 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15652 
    (2, TType.I64, 'itemId', None, None, ), # 2
15653 
    (3, TType.I64, 'quantity', None, None, ), # 3
15654 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15655 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15656 
  )
15657 
 
4369 rajveer 15658 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15659 
    self.vendorId = vendorId
15660 
    self.itemId = itemId
15661 
    self.quantity = quantity
15662 
    self.estimate = estimate
4369 rajveer 15663 
    self.isReminder = isReminder
4303 rajveer 15664 
 
15665 
  def read(self, iprot):
15666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15668 
      return
15669 
    iprot.readStructBegin()
15670 
    while True:
15671 
      (fname, ftype, fid) = iprot.readFieldBegin()
15672 
      if ftype == TType.STOP:
15673 
        break
15674 
      if fid == 1:
15675 
        if ftype == TType.I64:
15676 
          self.vendorId = iprot.readI64();
15677 
        else:
15678 
          iprot.skip(ftype)
15679 
      elif fid == 2:
15680 
        if ftype == TType.I64:
15681 
          self.itemId = iprot.readI64();
15682 
        else:
15683 
          iprot.skip(ftype)
15684 
      elif fid == 3:
15685 
        if ftype == TType.I64:
15686 
          self.quantity = iprot.readI64();
15687 
        else:
15688 
          iprot.skip(ftype)
15689 
      elif fid == 4:
15690 
        if ftype == TType.I64:
15691 
          self.estimate = iprot.readI64();
15692 
        else:
15693 
          iprot.skip(ftype)
4369 rajveer 15694 
      elif fid == 5:
15695 
        if ftype == TType.BOOL:
15696 
          self.isReminder = iprot.readBool();
15697 
        else:
15698 
          iprot.skip(ftype)
4303 rajveer 15699 
      else:
15700 
        iprot.skip(ftype)
15701 
      iprot.readFieldEnd()
15702 
    iprot.readStructEnd()
15703 
 
15704 
  def write(self, oprot):
15705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15707 
      return
15708 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
15709 
    if self.vendorId is not None:
15710 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15711 
      oprot.writeI64(self.vendorId)
15712 
      oprot.writeFieldEnd()
15713 
    if self.itemId is not None:
15714 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15715 
      oprot.writeI64(self.itemId)
15716 
      oprot.writeFieldEnd()
15717 
    if self.quantity is not None:
15718 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15719 
      oprot.writeI64(self.quantity)
15720 
      oprot.writeFieldEnd()
15721 
    if self.estimate is not None:
15722 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15723 
      oprot.writeI64(self.estimate)
15724 
      oprot.writeFieldEnd()
4369 rajveer 15725 
    if self.isReminder is not None:
15726 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15727 
      oprot.writeBool(self.isReminder)
15728 
      oprot.writeFieldEnd()
4303 rajveer 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)
15746 
 
15747 
class markOrdersAsNotAvailabke_result:
15748 
  """
15749 
  Attributes:
15750 
   - ex
15751 
  """
15752 
 
15753 
  thrift_spec = (
15754 
    None, # 0
15755 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15756 
  )
15757 
 
15758 
  def __init__(self, ex=None,):
15759 
    self.ex = ex
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.STRUCT:
15772 
          self.ex = TransactionServiceException()
15773 
          self.ex.read(iprot)
15774 
        else:
15775 
          iprot.skip(ftype)
15776 
      else:
15777 
        iprot.skip(ftype)
15778 
      iprot.readFieldEnd()
15779 
    iprot.readStructEnd()
15780 
 
15781 
  def write(self, oprot):
15782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15784 
      return
15785 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
15786 
    if self.ex is not None:
15787 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15788 
      self.ex.write(oprot)
15789 
      oprot.writeFieldEnd()
15790 
    oprot.writeFieldStop()
15791 
    oprot.writeStructEnd()
15792 
 
15793 
  def validate(self):
15794 
    return
15795 
 
15796 
 
15797 
  def __repr__(self):
15798 
    L = ['%s=%r' % (key, value)
15799 
      for key, value in self.__dict__.iteritems()]
15800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15801 
 
15802 
  def __eq__(self, other):
15803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15804 
 
15805 
  def __ne__(self, other):
15806 
    return not (self == other)
4369 rajveer 15807 
 
15808 
class markOrdersAsTimeout_args:
15809 
  """
15810 
  Attributes:
15811 
   - vendorId
15812 
  """
15813 
 
15814 
  thrift_spec = (
15815 
    None, # 0
15816 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15817 
  )
15818 
 
15819 
  def __init__(self, vendorId=None,):
15820 
    self.vendorId = vendorId
15821 
 
15822 
  def read(self, iprot):
15823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15825 
      return
15826 
    iprot.readStructBegin()
15827 
    while True:
15828 
      (fname, ftype, fid) = iprot.readFieldBegin()
15829 
      if ftype == TType.STOP:
15830 
        break
15831 
      if fid == 1:
15832 
        if ftype == TType.I64:
15833 
          self.vendorId = iprot.readI64();
15834 
        else:
15835 
          iprot.skip(ftype)
15836 
      else:
15837 
        iprot.skip(ftype)
15838 
      iprot.readFieldEnd()
15839 
    iprot.readStructEnd()
15840 
 
15841 
  def write(self, oprot):
15842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15844 
      return
15845 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
15846 
    if self.vendorId is not None:
15847 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15848 
      oprot.writeI64(self.vendorId)
15849 
      oprot.writeFieldEnd()
15850 
    oprot.writeFieldStop()
15851 
    oprot.writeStructEnd()
15852 
 
15853 
  def validate(self):
15854 
    return
15855 
 
15856 
 
15857 
  def __repr__(self):
15858 
    L = ['%s=%r' % (key, value)
15859 
      for key, value in self.__dict__.iteritems()]
15860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15861 
 
15862 
  def __eq__(self, other):
15863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15864 
 
15865 
  def __ne__(self, other):
15866 
    return not (self == other)
15867 
 
15868 
class markOrdersAsTimeout_result:
15869 
  """
15870 
  Attributes:
15871 
   - success
15872 
   - ex
15873 
  """
15874 
 
15875 
  thrift_spec = (
15876 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
15877 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15878 
  )
15879 
 
15880 
  def __init__(self, success=None, ex=None,):
15881 
    self.success = success
15882 
    self.ex = ex
15883 
 
15884 
  def read(self, iprot):
15885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15887 
      return
15888 
    iprot.readStructBegin()
15889 
    while True:
15890 
      (fname, ftype, fid) = iprot.readFieldBegin()
15891 
      if ftype == TType.STOP:
15892 
        break
15893 
      if fid == 0:
15894 
        if ftype == TType.MAP:
15895 
          self.success = {}
15896 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
15897 
          for _i265 in xrange(_size261):
15898 
            _key266 = iprot.readI32();
15899 
            _val267 = TimeoutSummary()
15900 
            _val267.read(iprot)
15901 
            self.success[_key266] = _val267
15902 
          iprot.readMapEnd()
15903 
        else:
15904 
          iprot.skip(ftype)
15905 
      elif fid == 1:
15906 
        if ftype == TType.STRUCT:
15907 
          self.ex = TransactionServiceException()
15908 
          self.ex.read(iprot)
15909 
        else:
15910 
          iprot.skip(ftype)
15911 
      else:
15912 
        iprot.skip(ftype)
15913 
      iprot.readFieldEnd()
15914 
    iprot.readStructEnd()
15915 
 
15916 
  def write(self, oprot):
15917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15919 
      return
15920 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
15921 
    if self.success is not None:
15922 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15923 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
15924 
      for kiter268,viter269 in self.success.items():
15925 
        oprot.writeI32(kiter268)
15926 
        viter269.write(oprot)
15927 
      oprot.writeMapEnd()
15928 
      oprot.writeFieldEnd()
15929 
    if self.ex is not None:
15930 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15931 
      self.ex.write(oprot)
15932 
      oprot.writeFieldEnd()
15933 
    oprot.writeFieldStop()
15934 
    oprot.writeStructEnd()
15935 
 
15936 
  def validate(self):
15937 
    return
15938 
 
15939 
 
15940 
  def __repr__(self):
15941 
    L = ['%s=%r' % (key, value)
15942 
      for key, value in self.__dict__.iteritems()]
15943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15944 
 
15945 
  def __eq__(self, other):
15946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15947 
 
15948 
  def __ne__(self, other):
15949 
    return not (self == other)
4386 anupam.sin 15950 
 
15951 
class getOrderForAwb_args:
15952 
  """
15953 
  Attributes:
15954 
   - awb
15955 
  """
15956 
 
15957 
  thrift_spec = (
15958 
    None, # 0
15959 
    (1, TType.STRING, 'awb', None, None, ), # 1
15960 
  )
15961 
 
15962 
  def __init__(self, awb=None,):
15963 
    self.awb = awb
15964 
 
15965 
  def read(self, iprot):
15966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15968 
      return
15969 
    iprot.readStructBegin()
15970 
    while True:
15971 
      (fname, ftype, fid) = iprot.readFieldBegin()
15972 
      if ftype == TType.STOP:
15973 
        break
15974 
      if fid == 1:
15975 
        if ftype == TType.STRING:
15976 
          self.awb = iprot.readString();
15977 
        else:
15978 
          iprot.skip(ftype)
15979 
      else:
15980 
        iprot.skip(ftype)
15981 
      iprot.readFieldEnd()
15982 
    iprot.readStructEnd()
15983 
 
15984 
  def write(self, oprot):
15985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15987 
      return
15988 
    oprot.writeStructBegin('getOrderForAwb_args')
15989 
    if self.awb is not None:
15990 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
15991 
      oprot.writeString(self.awb)
15992 
      oprot.writeFieldEnd()
15993 
    oprot.writeFieldStop()
15994 
    oprot.writeStructEnd()
15995 
 
15996 
  def validate(self):
15997 
    return
15998 
 
15999 
 
16000 
  def __repr__(self):
16001 
    L = ['%s=%r' % (key, value)
16002 
      for key, value in self.__dict__.iteritems()]
16003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16004 
 
16005 
  def __eq__(self, other):
16006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16007 
 
16008 
  def __ne__(self, other):
16009 
    return not (self == other)
16010 
 
16011 
class getOrderForAwb_result:
16012 
  """
16013 
  Attributes:
16014 
   - success
16015 
   - ex
16016 
  """
16017 
 
16018 
  thrift_spec = (
16019 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16020 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16021 
  )
16022 
 
16023 
  def __init__(self, success=None, ex=None,):
16024 
    self.success = success
16025 
    self.ex = ex
16026 
 
16027 
  def read(self, iprot):
16028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16030 
      return
16031 
    iprot.readStructBegin()
16032 
    while True:
16033 
      (fname, ftype, fid) = iprot.readFieldBegin()
16034 
      if ftype == TType.STOP:
16035 
        break
16036 
      if fid == 0:
16037 
        if ftype == TType.STRUCT:
16038 
          self.success = Order()
16039 
          self.success.read(iprot)
16040 
        else:
16041 
          iprot.skip(ftype)
16042 
      elif fid == 1:
16043 
        if ftype == TType.STRUCT:
16044 
          self.ex = TransactionServiceException()
16045 
          self.ex.read(iprot)
16046 
        else:
16047 
          iprot.skip(ftype)
16048 
      else:
16049 
        iprot.skip(ftype)
16050 
      iprot.readFieldEnd()
16051 
    iprot.readStructEnd()
16052 
 
16053 
  def write(self, oprot):
16054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16056 
      return
16057 
    oprot.writeStructBegin('getOrderForAwb_result')
16058 
    if self.success is not None:
16059 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16060 
      self.success.write(oprot)
16061 
      oprot.writeFieldEnd()
16062 
    if self.ex is not None:
16063 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16064 
      self.ex.write(oprot)
16065 
      oprot.writeFieldEnd()
16066 
    oprot.writeFieldStop()
16067 
    oprot.writeStructEnd()
16068 
 
16069 
  def validate(self):
16070 
    return
16071 
 
16072 
 
16073 
  def __repr__(self):
16074 
    L = ['%s=%r' % (key, value)
16075 
      for key, value in self.__dict__.iteritems()]
16076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16077 
 
16078 
  def __eq__(self, other):
16079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16080 
 
16081 
  def __ne__(self, other):
16082 
    return not (self == other)
4506 phani.kuma 16083 
 
16084 
class getOrdersForProviderForStatus_args:
16085 
  """
16086 
  Attributes:
16087 
   - logistics_provider_id
16088 
   - order_status
16089 
  """
16090 
 
16091 
  thrift_spec = (
16092 
    None, # 0
16093 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
16094 
    (2, TType.I32, 'order_status', None, None, ), # 2
16095 
  )
16096 
 
16097 
  def __init__(self, logistics_provider_id=None, order_status=None,):
16098 
    self.logistics_provider_id = logistics_provider_id
16099 
    self.order_status = order_status
16100 
 
16101 
  def read(self, iprot):
16102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16104 
      return
16105 
    iprot.readStructBegin()
16106 
    while True:
16107 
      (fname, ftype, fid) = iprot.readFieldBegin()
16108 
      if ftype == TType.STOP:
16109 
        break
16110 
      if fid == 1:
16111 
        if ftype == TType.I64:
16112 
          self.logistics_provider_id = iprot.readI64();
16113 
        else:
16114 
          iprot.skip(ftype)
16115 
      elif fid == 2:
16116 
        if ftype == TType.I32:
16117 
          self.order_status = iprot.readI32();
16118 
        else:
16119 
          iprot.skip(ftype)
16120 
      else:
16121 
        iprot.skip(ftype)
16122 
      iprot.readFieldEnd()
16123 
    iprot.readStructEnd()
16124 
 
16125 
  def write(self, oprot):
16126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16128 
      return
16129 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
16130 
    if self.logistics_provider_id is not None:
16131 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
16132 
      oprot.writeI64(self.logistics_provider_id)
16133 
      oprot.writeFieldEnd()
16134 
    if self.order_status is not None:
16135 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
16136 
      oprot.writeI32(self.order_status)
16137 
      oprot.writeFieldEnd()
16138 
    oprot.writeFieldStop()
16139 
    oprot.writeStructEnd()
16140 
 
16141 
  def validate(self):
16142 
    return
16143 
 
16144 
 
16145 
  def __repr__(self):
16146 
    L = ['%s=%r' % (key, value)
16147 
      for key, value in self.__dict__.iteritems()]
16148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16149 
 
16150 
  def __eq__(self, other):
16151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16152 
 
16153 
  def __ne__(self, other):
16154 
    return not (self == other)
16155 
 
16156 
class getOrdersForProviderForStatus_result:
16157 
  """
16158 
  Attributes:
16159 
   - success
16160 
   - ex
16161 
  """
16162 
 
16163 
  thrift_spec = (
16164 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16165 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16166 
  )
16167 
 
16168 
  def __init__(self, success=None, ex=None,):
16169 
    self.success = success
16170 
    self.ex = ex
16171 
 
16172 
  def read(self, iprot):
16173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16175 
      return
16176 
    iprot.readStructBegin()
16177 
    while True:
16178 
      (fname, ftype, fid) = iprot.readFieldBegin()
16179 
      if ftype == TType.STOP:
16180 
        break
16181 
      if fid == 0:
16182 
        if ftype == TType.LIST:
16183 
          self.success = []
16184 
          (_etype273, _size270) = iprot.readListBegin()
16185 
          for _i274 in xrange(_size270):
16186 
            _elem275 = Order()
16187 
            _elem275.read(iprot)
16188 
            self.success.append(_elem275)
16189 
          iprot.readListEnd()
16190 
        else:
16191 
          iprot.skip(ftype)
16192 
      elif fid == 1:
16193 
        if ftype == TType.STRUCT:
16194 
          self.ex = TransactionServiceException()
16195 
          self.ex.read(iprot)
16196 
        else:
16197 
          iprot.skip(ftype)
16198 
      else:
16199 
        iprot.skip(ftype)
16200 
      iprot.readFieldEnd()
16201 
    iprot.readStructEnd()
16202 
 
16203 
  def write(self, oprot):
16204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16206 
      return
16207 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
16208 
    if self.success is not None:
16209 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16210 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16211 
      for iter276 in self.success:
16212 
        iter276.write(oprot)
16213 
      oprot.writeListEnd()
16214 
      oprot.writeFieldEnd()
16215 
    if self.ex is not None:
16216 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16217 
      self.ex.write(oprot)
16218 
      oprot.writeFieldEnd()
16219 
    oprot.writeFieldStop()
16220 
    oprot.writeStructEnd()
16221 
 
16222 
  def validate(self):
16223 
    return
16224 
 
16225 
 
16226 
  def __repr__(self):
16227 
    L = ['%s=%r' % (key, value)
16228 
      for key, value in self.__dict__.iteritems()]
16229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16230 
 
16231 
  def __eq__(self, other):
16232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16233 
 
16234 
  def __ne__(self, other):
16235 
    return not (self == other)