Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
483 rajveer 74 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
483 rajveer 77 
     - status
78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
4444 rajveer 219 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 220 
    """
221 
    Parameters:
4394 rajveer 222 
     - type
4444 rajveer 223 
     - warehouseId
4394 rajveer 224 
     - status
225 
     - timestamp
3064 chandransh 226 
    """
227 
    pass
228 
 
4444 rajveer 229 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 230 
    """
231 
    Parameters:
232 
     - type
4444 rajveer 233 
     - warehouseId
4394 rajveer 234 
     - description
3064 chandransh 235 
    """
236 
    pass
237 
 
4444 rajveer 238 
  def markAlertsAsSeen(self, warehouseId):
239 
    """
240 
    Parameters:
241 
     - warehouseId
242 
    """
243 
    pass
244 
 
3064 chandransh 245 
  def getValidOrderCount(self, ):
246 
    """
247 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
248 
    """
249 
    pass
250 
 
251 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
252 
    """
253 
    Returns the number of distinct customers who have done successful transactions
254 
    """
255 
    pass
256 
 
257 
  def getValidOrdersAmountRange(self, ):
258 
    """
259 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
260 
    List contains two values, first minimum amount and second maximum amount.
261 
    """
262 
    pass
263 
 
264 
  def getValidOrders(self, limit):
265 
    """
266 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
267 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 268 
 
3064 chandransh 269 
    Parameters:
270 
     - limit
271 
    """
272 
    pass
273 
 
1220 chandransh 274 
  def batchOrders(self, warehouseId):
275 
    """
276 
    Create a batch of all the pending orders for the given warehouse.
277 
    The returned list is orderd by created_timestamp.
278 
    If there are no pending orders, an empty list is returned.
3431 rajveer 279 
 
1220 chandransh 280 
    Parameters:
281 
     - warehouseId
282 
    """
283 
    pass
284 
 
1208 chandransh 285 
  def markOrderAsOutOfStock(self, orderId):
286 
    """
287 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 288 
 
1208 chandransh 289 
    Parameters:
290 
     - orderId
291 
    """
292 
    pass
293 
 
3064 chandransh 294 
  def verifyOrder(self, orderId):
759 chandransh 295 
    """
3064 chandransh 296 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
297 
    timestamp. It is intended to be used for COD orders but can be harmlessly
298 
    used for all other orders as well.
299 
    Throws an exception if no such order exists.
3431 rajveer 300 
 
759 chandransh 301 
    Parameters:
3064 chandransh 302 
     - orderId
303 
    """
304 
    pass
305 
 
306 
  def acceptOrder(self, orderId):
307 
    """
308 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
309 
    given order is not a COD order, it also captures the payment if the same has
310 
    not been captured.
311 
    Throws an exception if no such order exists.
3431 rajveer 312 
 
3064 chandransh 313 
    Parameters:
314 
     - orderId
315 
    """
316 
    pass
317 
 
4283 anupam.sin 318 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 319 
    """
320 
    Add billing details such as the bill number and the biller to the Order.
321 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
322 
    the IMEI no. if a -1 is supplied.
323 
    Also, it generates an invoice number for the order, marks the order as
324 
    BILLED and sets the billing timestamp.
325 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 326 
 
3064 chandransh 327 
    Parameters:
328 
     - orderId
4283 anupam.sin 329 
     - invoice_number
3064 chandransh 330 
     - imeiNumber
331 
     - itemNumber
4283 anupam.sin 332 
     - billed_by
333 
     - jacketNumber
3064 chandransh 334 
     - billingType
4283 anupam.sin 335 
     - vendorId
3064 chandransh 336 
    """
337 
    pass
338 
 
4579 rajveer 339 
  def addInvoiceNumber(self, orderId, invoiceNumber):
340 
    """
341 
    Add the invoice number to the order.
342 
 
343 
    Parameters:
344 
     - orderId
345 
     - invoiceNumber
346 
    """
347 
    pass
348 
 
3064 chandransh 349 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
350 
    """
351 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 352 
    given warehouse and were picked up by the given provider as MANIFESTED.
353 
 
354 
    Parameters:
355 
     - warehouseId
356 
     - providerId
357 
     - cod
358 
    """
359 
    pass
360 
 
361 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
362 
    """
363 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
3064 chandransh 364 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 365 
 
3064 chandransh 366 
    Parameters:
759 chandransh 367 
     - warehouseId
368 
     - providerId
3064 chandransh 369 
     - cod
759 chandransh 370 
    """
371 
    pass
372 
 
1113 chandransh 373 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
374 
    """
375 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
376 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
377 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 378 
 
1113 chandransh 379 
    Parameters:
380 
     - providerId
381 
     - pickupDetails
382 
    """
383 
    pass
384 
 
1132 chandransh 385 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
386 
    """
387 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
388 
    the name of the receiver.
389 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 390 
 
1132 chandransh 391 
    Parameters:
392 
     - providerId
393 
     - deliveredOrders
394 
    """
395 
    pass
396 
 
1135 chandransh 397 
  def markOrdersAsFailed(self, providerId, returnedOrders):
398 
    """
399 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
400 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 401 
 
1135 chandransh 402 
    Parameters:
403 
     - providerId
404 
     - returnedOrders
405 
    """
406 
    pass
407 
 
1246 chandransh 408 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
409 
    """
410 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 411 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 412 
 
1246 chandransh 413 
    Parameters:
414 
     - providerId
415 
     - undeliveredOrders
416 
    """
417 
    pass
418 
 
1408 ankur.sing 419 
  def getUndeliveredOrders(self, providerId, warehouseId):
420 
    """
421 
    Returns the list of orders whose delivery time has passed but have not been
422 
    delivered yet for the given provider and warehouse. To get a complete list of
423 
    undelivered orders, pass them as -1.
424 
    Returns an empty list if no such orders exist.
3431 rajveer 425 
 
1408 ankur.sing 426 
    Parameters:
427 
     - providerId
428 
     - warehouseId
429 
    """
430 
    pass
431 
 
2536 chandransh 432 
  def toggleDOAFlag(self, orderId):
433 
    """
434 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
435 
    Returns the final flag status.
436 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 437 
 
2536 chandransh 438 
    Parameters:
439 
     - orderId
440 
    """
441 
    pass
1886 ankur.sing 442 
 
4454 rajveer 443 
  def markOrderDoaRequestReceived(self, orderId):
444 
    """
445 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
446 
 
447 
    Parameters:
448 
     - orderId
449 
    """
450 
    pass
451 
 
452 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
453 
    """
454 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
455 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
456 
 
457 
    Parameters:
458 
     - orderId
459 
     - isAuthorized
460 
    """
461 
    pass
462 
 
4488 rajveer 463 
  def markOrderReturnRequestReceived(self, orderId):
464 
    """
465 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
466 
 
467 
    Parameters:
468 
     - orderId
469 
    """
470 
    pass
471 
 
472 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
473 
    """
474 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
475 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
476 
 
477 
    Parameters:
478 
     - orderId
479 
     - isAuthorized
480 
    """
481 
    pass
482 
 
4579 rajveer 483 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 484 
    """
485 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 486 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
487 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 488 
    For any other status, it returns false.
489 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 490 
 
2536 chandransh 491 
    Parameters:
492 
     - orderId
4579 rajveer 493 
     - providerId
2536 chandransh 494 
    """
495 
    pass
496 
 
497 
  def authorizePickup(self, orderId, pickupNumber):
498 
    """
4452 rajveer 499 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 500 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
501 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
502 
    	3. Returns true
2591 chandransh 503 
    If the order is in any other status, it returns false.
2536 chandransh 504 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 505 
 
2536 chandransh 506 
    Parameters:
507 
     - orderId
508 
     - pickupNumber
509 
    """
510 
    pass
511 
 
2764 chandransh 512 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
513 
    """
514 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
515 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 516 
 
2764 chandransh 517 
    Parameters:
518 
     - providerId
519 
     - pickupDetails
520 
    """
521 
    pass
522 
 
4479 rajveer 523 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 524 
    """
4452 rajveer 525 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 526 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 527 
    If the order is in any other state, it returns false.
528 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 529 
 
2591 chandransh 530 
    Parameters:
531 
     - orderId
4479 rajveer 532 
     - receiveCondition
2591 chandransh 533 
    """
534 
    pass
2536 chandransh 535 
 
2591 chandransh 536 
  def validateDoa(self, orderId, isValid):
537 
    """
4452 rajveer 538 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 539 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 540 
    If the order is in any other state, it returns false.
541 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 542 
 
2591 chandransh 543 
    Parameters:
544 
     - orderId
545 
     - isValid
546 
    """
547 
    pass
548 
 
4495 rajveer 549 
  def validateReturnProduct(self, orderId, isUsable):
550 
    """
551 
    Parameters:
552 
     - orderId
553 
     - isUsable
554 
    """
555 
    pass
556 
 
2616 chandransh 557 
  def reshipOrder(self, orderId):
558 
    """
4484 rajveer 559 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 560 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 561 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 562 
 
563 
    If the order is in DOA_CERT_VALID state, it does the following:
564 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
565 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 566 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 567 
 
2616 chandransh 568 
    Returns the id of the newly created order.
3431 rajveer 569 
 
2616 chandransh 570 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 571 
 
2616 chandransh 572 
    Parameters:
573 
     - orderId
574 
    """
575 
    pass
2591 chandransh 576 
 
3226 chandransh 577 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 578 
    """
4484 rajveer 579 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 580 
    	1. Creates a refund request for batch processing.
581 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 582 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 583 
 
2616 chandransh 584 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
585 
    	1. Creates a refund request for batch processing.
3226 chandransh 586 
    	2. Cancels the reservation of the item in the warehouse.
587 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 588 
 
3226 chandransh 589 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
590 
    	1. Cancels the reservation of the item in the warehouse.
591 
    	2. Marks the current order as CANCELED.
592 
 
593 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
594 
 
2616 chandransh 595 
    Returns True if it is successful, False otherwise.
3431 rajveer 596 
 
2616 chandransh 597 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 598 
 
2616 chandransh 599 
    Parameters:
600 
     - orderId
3226 chandransh 601 
     - refundedBy
602 
     - reason
2616 chandransh 603 
    """
604 
    pass
605 
 
2690 chandransh 606 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
607 
    """
608 
    Get all return orders created between the from and to dates for the given warehouse.
609 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 610 
 
2690 chandransh 611 
    Parameters:
612 
     - warehouseId
613 
     - fromDate
614 
     - toDate
615 
    """
616 
    pass
2616 chandransh 617 
 
2700 chandransh 618 
  def getReturnOrder(self, id):
619 
    """
620 
    Returns the ReturnOrder corresponding to the given id.
621 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 622 
 
2700 chandransh 623 
    Parameters:
624 
     - id
625 
    """
626 
    pass
627 
 
2690 chandransh 628 
  def processReturn(self, returnOrderId):
629 
    """
630 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 631 
 
2690 chandransh 632 
    Parameters:
633 
     - returnOrderId
634 
    """
635 
    pass
636 
 
2819 chandransh 637 
  def createPurchaseOrder(self, warehouseId):
638 
    """
4586 mandeep.dh 639 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
640 
    Returns the list of PO no. of the newly created purchase order.
641 
    Returns null if no new purchase order had to be created.
3431 rajveer 642 
 
2819 chandransh 643 
    Parameters:
644 
     - warehouseId
645 
    """
646 
    pass
2690 chandransh 647 
 
3451 chandransh 648 
  def updateWeight(self, orderId, weight):
649 
    """
650 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 651 
 
3451 chandransh 652 
    Parameters:
653 
     - orderId
654 
     - weight
655 
    """
656 
    pass
657 
 
3469 chandransh 658 
  def changeItem(self, orderId, itemId):
659 
    """
660 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
661 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 662 
 
3469 chandransh 663 
    Parameters:
664 
     - orderId
665 
     - itemId
666 
    """
667 
    pass
668 
 
669 
  def shiftToWarehouse(self, orderId, warehouseId):
670 
    """
671 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
672 
 
673 
    Parameters:
674 
     - orderId
675 
     - warehouseId
676 
    """
677 
    pass
678 
 
3986 chandransh 679 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 680 
    """
681 
    Adds the given delay reason to the given order.
3986 chandransh 682 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 683 
    Raises an exception if no order with the given id can be found.
3469 chandransh 684 
 
3553 chandransh 685 
    Parameters:
686 
     - orderId
687 
     - delayReason
3986 chandransh 688 
     - furtherDelay
3553 chandransh 689 
    """
690 
    pass
691 
 
3956 chandransh 692 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
693 
    """
694 
    Marks the COD orders with given AWB nos. as having been processed.
695 
    Updates the captured amount for the corresponding payment.
3553 chandransh 696 
 
3956 chandransh 697 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
698 
    1. There is no order corresponding to an AWB number.
699 
    2. The captured amount for a payment exceeds the total payment.
700 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
701 
 
702 
    Parameters:
703 
     - collectedAmountMap
704 
     - xferBy
705 
     - xferTxnId
706 
     - xferDate
707 
    """
708 
    pass
709 
 
4008 mandeep.dh 710 
  def getTransactionsRequiringExtraProcessing(self, category):
711 
    """
4065 mandeep.dh 712 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 713 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 714 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 715 
 
4008 mandeep.dh 716 
    Parameters:
717 
     - category
718 
    """
719 
    pass
720 
 
721 
  def markTransactionAsProcessed(self, transactionId, category):
722 
    """
723 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 724 
    It essentially deletes the transaction id record for a particular
725 
    processing type category (if present) from DB.
726 
    This is currently used by CRM application.
4008 mandeep.dh 727 
 
728 
    Parameters:
729 
     - transactionId
730 
     - category
731 
    """
732 
    pass
733 
 
4018 chandransh 734 
  def getItemWiseRiskyOrdersCount(self, ):
735 
    """
736 
    Returns a map containing the number of risky orders keyed by item id. A risky order
737 
    is defined as one whose shipping date is about to expire.
738 
    """
739 
    pass
4008 mandeep.dh 740 
 
4295 varun.gupt 741 
  def getOrdersForItemIds(self, itemIds):
742 
    """
743 
    Returns a list of all orders which have items with given id
744 
 
745 
    Parameters:
746 
     - itemIds
747 
    """
748 
    pass
749 
 
4247 rajveer 750 
  def markOrderCancellationRequestReceived(self, orderId):
751 
    """
752 
    Mark order as cancellation request received. If customer sends request of cancellation of
753 
    a particular order, this method will be called. It will just change status of the order
754 
    depending on its current status. It also records the previous status, so that we can move
755 
    back to that status if cancellation request is denied.
4018 chandransh 756 
 
4247 rajveer 757 
    Parameters:
758 
     - orderId
759 
    """
760 
    pass
761 
 
762 
  def markOrderCancellationRequestConfirmed(self, orderId):
763 
    """
764 
    If we decide to to cancel order, CRM will call this method to move the status of order to
765 
    cancellation request confirmed. After this OM will be able to cancel the order.
766 
 
767 
    Parameters:
768 
     - orderId
769 
    """
770 
    pass
771 
 
772 
  def markOrderCancellationRequestDenied(self, orderId):
773 
    """
774 
    If we decide to not to cancel order, we will move the order ro previous status.
775 
 
776 
    Parameters:
777 
     - orderId
778 
    """
779 
    pass
780 
 
4258 rajveer 781 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 782 
    """
4258 rajveer 783 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
784 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 785 
 
786 
    Parameters:
4258 rajveer 787 
     - transactionId
4247 rajveer 788 
    """
789 
    pass
790 
 
4259 anupam.sin 791 
  def refundTransaction(self, transactionId, refundedBy, reason):
792 
    """
793 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
794 
    need to be cancelled
4247 rajveer 795 
 
4259 anupam.sin 796 
    Parameters:
797 
     - transactionId
798 
     - refundedBy
799 
     - reason
800 
    """
801 
    pass
802 
 
4324 mandeep.dh 803 
  def updateShipmentAddress(self, orderId, addressId):
804 
    """
805 
    Updates shipment address of an order. Delivery and shipping date estimates
806 
    etc. are also updated here.
807 
 
808 
    Throws TransactionServiceException in case address change is not
809 
    possible due to certain reasons such as new pincode in address is
810 
    not serviceable etc.
811 
 
812 
    Parameters:
813 
     - orderId
814 
     - addressId
815 
    """
816 
    pass
817 
 
4285 rajveer 818 
  def acceptOrdersForItemId(self, itemId, inventory):
819 
    """
820 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
821 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 822 
 
4285 rajveer 823 
    Parameters:
824 
     - itemId
825 
     - inventory
826 
    """
827 
    pass
828 
 
4369 rajveer 829 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 830 
    """
831 
    Parameters:
832 
     - vendorId
833 
     - itemId
834 
     - quantity
835 
     - estimate
4369 rajveer 836 
     - isReminder
4303 rajveer 837 
    """
838 
    pass
4285 rajveer 839 
 
4369 rajveer 840 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 841 
    """
842 
    Parameters:
843 
     - vendorId
844 
     - itemId
845 
     - quantity
846 
     - estimate
4369 rajveer 847 
     - isReminder
4303 rajveer 848 
    """
849 
    pass
850 
 
4369 rajveer 851 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 852 
    """
853 
    Parameters:
854 
     - vendorId
855 
     - itemId
856 
     - quantity
857 
     - estimate
4369 rajveer 858 
     - isReminder
4303 rajveer 859 
    """
860 
    pass
861 
 
4369 rajveer 862 
  def markOrdersAsTimeout(self, vendorId):
863 
    """
864 
    Parameters:
865 
     - vendorId
866 
    """
867 
    pass
4303 rajveer 868 
 
4386 anupam.sin 869 
  def getOrderForAwb(self, awb):
870 
    """
871 
    Returns the order corresponding to an AWB number
4369 rajveer 872 
 
4386 anupam.sin 873 
    Parameters:
874 
     - awb
875 
    """
876 
    pass
877 
 
4506 phani.kuma 878 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
879 
    """
880 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 881 
 
4506 phani.kuma 882 
    Parameters:
883 
     - logistics_provider_id
884 
     - order_status
885 
    """
886 
    pass
887 
 
888 
 
3376 rajveer 889 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 890 
  def __init__(self, iprot, oprot=None):
3376 rajveer 891 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 892 
 
893 
  def createTransaction(self, transaction):
894 
    """
895 
    Parameters:
896 
     - transaction
897 
    """
898 
    self.send_createTransaction(transaction)
132 ashish 899 
    return self.recv_createTransaction()
94 ashish 900 
 
901 
  def send_createTransaction(self, transaction):
902 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
903 
    args = createTransaction_args()
904 
    args.transaction = transaction
905 
    args.write(self._oprot)
906 
    self._oprot.writeMessageEnd()
907 
    self._oprot.trans.flush()
908 
 
909 
  def recv_createTransaction(self, ):
910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
911 
    if mtype == TMessageType.EXCEPTION:
912 
      x = TApplicationException()
913 
      x.read(self._iprot)
914 
      self._iprot.readMessageEnd()
915 
      raise x
916 
    result = createTransaction_result()
917 
    result.read(self._iprot)
918 
    self._iprot.readMessageEnd()
3431 rajveer 919 
    if result.success is not None:
132 ashish 920 
      return result.success
3431 rajveer 921 
    if result.ex is not None:
94 ashish 922 
      raise result.ex
132 ashish 923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 924 
 
925 
  def getTransaction(self, id):
926 
    """
927 
    Parameters:
928 
     - id
929 
    """
930 
    self.send_getTransaction(id)
931 
    return self.recv_getTransaction()
932 
 
933 
  def send_getTransaction(self, id):
934 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
935 
    args = getTransaction_args()
936 
    args.id = id
937 
    args.write(self._oprot)
938 
    self._oprot.writeMessageEnd()
939 
    self._oprot.trans.flush()
940 
 
941 
  def recv_getTransaction(self, ):
942 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
943 
    if mtype == TMessageType.EXCEPTION:
944 
      x = TApplicationException()
945 
      x.read(self._iprot)
946 
      self._iprot.readMessageEnd()
947 
      raise x
948 
    result = getTransaction_result()
949 
    result.read(self._iprot)
950 
    self._iprot.readMessageEnd()
3431 rajveer 951 
    if result.success is not None:
94 ashish 952 
      return result.success
3431 rajveer 953 
    if result.ex is not None:
94 ashish 954 
      raise result.ex
955 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
956 
 
957 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
958 
    """
959 
    Parameters:
960 
     - customerId
961 
     - from_date
962 
     - to_date
963 
     - status
964 
    """
965 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
966 
    return self.recv_getTransactionsForCustomer()
967 
 
968 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
969 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
970 
    args = getTransactionsForCustomer_args()
971 
    args.customerId = customerId
972 
    args.from_date = from_date
973 
    args.to_date = to_date
974 
    args.status = status
975 
    args.write(self._oprot)
976 
    self._oprot.writeMessageEnd()
977 
    self._oprot.trans.flush()
978 
 
979 
  def recv_getTransactionsForCustomer(self, ):
980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
981 
    if mtype == TMessageType.EXCEPTION:
982 
      x = TApplicationException()
983 
      x.read(self._iprot)
984 
      self._iprot.readMessageEnd()
985 
      raise x
986 
    result = getTransactionsForCustomer_result()
987 
    result.read(self._iprot)
988 
    self._iprot.readMessageEnd()
3431 rajveer 989 
    if result.success is not None:
94 ashish 990 
      return result.success
3431 rajveer 991 
    if result.ex is not None:
94 ashish 992 
      raise result.ex
993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
994 
 
132 ashish 995 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
996 
    """
997 
    Parameters:
998 
     - shoppingCartId
999 
    """
1000 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1001 
    return self.recv_getTransactionsForShoppingCartId()
1002 
 
1003 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1004 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1005 
    args = getTransactionsForShoppingCartId_args()
1006 
    args.shoppingCartId = shoppingCartId
1007 
    args.write(self._oprot)
1008 
    self._oprot.writeMessageEnd()
1009 
    self._oprot.trans.flush()
1010 
 
1011 
  def recv_getTransactionsForShoppingCartId(self, ):
1012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1013 
    if mtype == TMessageType.EXCEPTION:
1014 
      x = TApplicationException()
1015 
      x.read(self._iprot)
1016 
      self._iprot.readMessageEnd()
1017 
      raise x
1018 
    result = getTransactionsForShoppingCartId_result()
1019 
    result.read(self._iprot)
1020 
    self._iprot.readMessageEnd()
3431 rajveer 1021 
    if result.success is not None:
132 ashish 1022 
      return result.success
3431 rajveer 1023 
    if result.ex is not None:
132 ashish 1024 
      raise result.ex
1025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1026 
 
94 ashish 1027 
  def getTransactionStatus(self, transactionId):
1028 
    """
1029 
    Parameters:
1030 
     - transactionId
1031 
    """
1032 
    self.send_getTransactionStatus(transactionId)
1033 
    return self.recv_getTransactionStatus()
1034 
 
1035 
  def send_getTransactionStatus(self, transactionId):
1036 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1037 
    args = getTransactionStatus_args()
1038 
    args.transactionId = transactionId
1039 
    args.write(self._oprot)
1040 
    self._oprot.writeMessageEnd()
1041 
    self._oprot.trans.flush()
1042 
 
1043 
  def recv_getTransactionStatus(self, ):
1044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1045 
    if mtype == TMessageType.EXCEPTION:
1046 
      x = TApplicationException()
1047 
      x.read(self._iprot)
1048 
      self._iprot.readMessageEnd()
1049 
      raise x
1050 
    result = getTransactionStatus_result()
1051 
    result.read(self._iprot)
1052 
    self._iprot.readMessageEnd()
3431 rajveer 1053 
    if result.success is not None:
94 ashish 1054 
      return result.success
3431 rajveer 1055 
    if result.ex is not None:
94 ashish 1056 
      raise result.ex
1057 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1058 
 
1059 
  def changeTransactionStatus(self, transactionId, status, description):
1060 
    """
1061 
    Parameters:
1062 
     - transactionId
1063 
     - status
1064 
     - description
1065 
    """
1066 
    self.send_changeTransactionStatus(transactionId, status, description)
1067 
    return self.recv_changeTransactionStatus()
1068 
 
1069 
  def send_changeTransactionStatus(self, transactionId, status, description):
1070 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1071 
    args = changeTransactionStatus_args()
1072 
    args.transactionId = transactionId
1073 
    args.status = status
1074 
    args.description = description
1075 
    args.write(self._oprot)
1076 
    self._oprot.writeMessageEnd()
1077 
    self._oprot.trans.flush()
1078 
 
1079 
  def recv_changeTransactionStatus(self, ):
1080 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1081 
    if mtype == TMessageType.EXCEPTION:
1082 
      x = TApplicationException()
1083 
      x.read(self._iprot)
1084 
      self._iprot.readMessageEnd()
1085 
      raise x
1086 
    result = changeTransactionStatus_result()
1087 
    result.read(self._iprot)
1088 
    self._iprot.readMessageEnd()
3431 rajveer 1089 
    if result.success is not None:
94 ashish 1090 
      return result.success
3431 rajveer 1091 
    if result.ex is not None:
94 ashish 1092 
      raise result.ex
1093 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1094 
 
1398 varun.gupt 1095 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1096 
    """
1097 
    Parameters:
1098 
     - transactionId
1099 
    """
1398 varun.gupt 1100 
    self.send_enqueueTransactionInfoEmail(transactionId)
1101 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1102 
 
1398 varun.gupt 1103 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1104 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1105 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1106 
    args.transactionId = transactionId
1107 
    args.write(self._oprot)
1108 
    self._oprot.writeMessageEnd()
1109 
    self._oprot.trans.flush()
1110 
 
1398 varun.gupt 1111 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1113 
    if mtype == TMessageType.EXCEPTION:
1114 
      x = TApplicationException()
1115 
      x.read(self._iprot)
1116 
      self._iprot.readMessageEnd()
1117 
      raise x
1398 varun.gupt 1118 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1119 
    result.read(self._iprot)
1120 
    self._iprot.readMessageEnd()
3431 rajveer 1121 
    if result.success is not None:
1382 varun.gupt 1122 
      return result.success
3431 rajveer 1123 
    if result.ex is not None:
1382 varun.gupt 1124 
      raise result.ex
1398 varun.gupt 1125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1126 
 
483 rajveer 1127 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1128 
    """
1129 
    Parameters:
483 rajveer 1130 
     - status
1131 
     - from_date
1132 
     - to_date
1133 
     - warehouse_id
94 ashish 1134 
    """
483 rajveer 1135 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1136 
    return self.recv_getAllOrders()
94 ashish 1137 
 
483 rajveer 1138 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1139 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1140 
    args = getAllOrders_args()
1141 
    args.status = status
1142 
    args.from_date = from_date
1143 
    args.to_date = to_date
1144 
    args.warehouse_id = warehouse_id
94 ashish 1145 
    args.write(self._oprot)
1146 
    self._oprot.writeMessageEnd()
1147 
    self._oprot.trans.flush()
1148 
 
483 rajveer 1149 
  def recv_getAllOrders(self, ):
94 ashish 1150 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1151 
    if mtype == TMessageType.EXCEPTION:
1152 
      x = TApplicationException()
1153 
      x.read(self._iprot)
1154 
      self._iprot.readMessageEnd()
1155 
      raise x
483 rajveer 1156 
    result = getAllOrders_result()
94 ashish 1157 
    result.read(self._iprot)
1158 
    self._iprot.readMessageEnd()
3431 rajveer 1159 
    if result.success is not None:
94 ashish 1160 
      return result.success
3431 rajveer 1161 
    if result.ex is not None:
94 ashish 1162 
      raise result.ex
483 rajveer 1163 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1164 
 
4133 chandransh 1165 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1166 
    """
1167 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1168 
    Pass the status as null and the limit as 0 to ignore them.
1169 
 
1170 
    Parameters:
1171 
     - statuses
1172 
     - offset
1173 
     - limit
1174 
     - warehouse_id
1175 
    """
1176 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1177 
    return self.recv_getOrdersInBatch()
1178 
 
1179 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1180 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1181 
    args = getOrdersInBatch_args()
1182 
    args.statuses = statuses
1183 
    args.offset = offset
1184 
    args.limit = limit
1185 
    args.warehouse_id = warehouse_id
1186 
    args.write(self._oprot)
1187 
    self._oprot.writeMessageEnd()
1188 
    self._oprot.trans.flush()
1189 
 
1190 
  def recv_getOrdersInBatch(self, ):
1191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1192 
    if mtype == TMessageType.EXCEPTION:
1193 
      x = TApplicationException()
1194 
      x.read(self._iprot)
1195 
      self._iprot.readMessageEnd()
1196 
      raise x
1197 
    result = getOrdersInBatch_result()
1198 
    result.read(self._iprot)
1199 
    self._iprot.readMessageEnd()
1200 
    if result.success is not None:
1201 
      return result.success
1202 
    if result.ex is not None:
1203 
      raise result.ex
1204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1205 
 
1206 
  def getOrderCount(self, statuses, warehouseId):
1207 
    """
1208 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1209 
 
1210 
    Parameters:
1211 
     - statuses
1212 
     - warehouseId
1213 
    """
1214 
    self.send_getOrderCount(statuses, warehouseId)
1215 
    return self.recv_getOrderCount()
1216 
 
1217 
  def send_getOrderCount(self, statuses, warehouseId):
1218 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1219 
    args = getOrderCount_args()
1220 
    args.statuses = statuses
1221 
    args.warehouseId = warehouseId
1222 
    args.write(self._oprot)
1223 
    self._oprot.writeMessageEnd()
1224 
    self._oprot.trans.flush()
1225 
 
1226 
  def recv_getOrderCount(self, ):
1227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1228 
    if mtype == TMessageType.EXCEPTION:
1229 
      x = TApplicationException()
1230 
      x.read(self._iprot)
1231 
      self._iprot.readMessageEnd()
1232 
      raise x
1233 
    result = getOrderCount_result()
1234 
    result.read(self._iprot)
1235 
    self._iprot.readMessageEnd()
1236 
    if result.success is not None:
1237 
      return result.success
1238 
    if result.ex is not None:
1239 
      raise result.ex
1240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1241 
 
999 varun.gupt 1242 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1243 
    """
1132 chandransh 1244 
    Returns orders within a range of their billing dates
3431 rajveer 1245 
 
999 varun.gupt 1246 
    Parameters:
1247 
     - status
1248 
     - start_billing_date
1249 
     - end_billing_date
1250 
     - warehouse_id
1251 
    """
1252 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1253 
    return self.recv_getOrdersByBillingDate()
1254 
 
1255 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1256 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1257 
    args = getOrdersByBillingDate_args()
1258 
    args.status = status
1259 
    args.start_billing_date = start_billing_date
1260 
    args.end_billing_date = end_billing_date
1261 
    args.warehouse_id = warehouse_id
1262 
    args.write(self._oprot)
1263 
    self._oprot.writeMessageEnd()
1264 
    self._oprot.trans.flush()
1265 
 
1266 
  def recv_getOrdersByBillingDate(self, ):
1267 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1268 
    if mtype == TMessageType.EXCEPTION:
1269 
      x = TApplicationException()
1270 
      x.read(self._iprot)
1271 
      self._iprot.readMessageEnd()
1272 
      raise x
1273 
    result = getOrdersByBillingDate_result()
1274 
    result.read(self._iprot)
1275 
    self._iprot.readMessageEnd()
3431 rajveer 1276 
    if result.success is not None:
999 varun.gupt 1277 
      return result.success
3431 rajveer 1278 
    if result.ex is not None:
999 varun.gupt 1279 
      raise result.ex
1280 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1281 
 
3451 chandransh 1282 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1283 
    """
1284 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1285 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1286 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1287 
 
3427 chandransh 1288 
    Parameters:
1289 
     - fromShippingDate
1290 
     - toShippingDate
1291 
     - providerId
1292 
     - warehouseId
3451 chandransh 1293 
     - cod
3427 chandransh 1294 
    """
3451 chandransh 1295 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1296 
    return self.recv_getOrdersByShippingDate()
1297 
 
3451 chandransh 1298 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1299 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1300 
    args = getOrdersByShippingDate_args()
1301 
    args.fromShippingDate = fromShippingDate
1302 
    args.toShippingDate = toShippingDate
1303 
    args.providerId = providerId
1304 
    args.warehouseId = warehouseId
3451 chandransh 1305 
    args.cod = cod
3427 chandransh 1306 
    args.write(self._oprot)
1307 
    self._oprot.writeMessageEnd()
1308 
    self._oprot.trans.flush()
1309 
 
1310 
  def recv_getOrdersByShippingDate(self, ):
1311 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1312 
    if mtype == TMessageType.EXCEPTION:
1313 
      x = TApplicationException()
1314 
      x.read(self._iprot)
1315 
      self._iprot.readMessageEnd()
1316 
      raise x
1317 
    result = getOrdersByShippingDate_result()
1318 
    result.read(self._iprot)
1319 
    self._iprot.readMessageEnd()
3431 rajveer 1320 
    if result.success is not None:
3427 chandransh 1321 
      return result.success
3431 rajveer 1322 
    if result.ex is not None:
3427 chandransh 1323 
      raise result.ex
1324 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1325 
 
1382 varun.gupt 1326 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1327 
    """
1328 
    Returns order ids for orders which can be returned
3431 rajveer 1329 
 
1382 varun.gupt 1330 
    Parameters:
1331 
     - customer_id
1332 
     - limit
1333 
    """
1334 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1335 
    return self.recv_getReturnableOrdersForCustomer()
1336 
 
1337 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1338 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1339 
    args = getReturnableOrdersForCustomer_args()
1340 
    args.customer_id = customer_id
1341 
    args.limit = limit
1342 
    args.write(self._oprot)
1343 
    self._oprot.writeMessageEnd()
1344 
    self._oprot.trans.flush()
1345 
 
1346 
  def recv_getReturnableOrdersForCustomer(self, ):
1347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1348 
    if mtype == TMessageType.EXCEPTION:
1349 
      x = TApplicationException()
1350 
      x.read(self._iprot)
1351 
      self._iprot.readMessageEnd()
1352 
      raise x
1353 
    result = getReturnableOrdersForCustomer_result()
1354 
    result.read(self._iprot)
1355 
    self._iprot.readMessageEnd()
3431 rajveer 1356 
    if result.success is not None:
1382 varun.gupt 1357 
      return result.success
3431 rajveer 1358 
    if result.ex is not None:
1382 varun.gupt 1359 
      raise result.ex
1360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1361 
 
1362 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1363 
    """
1364 
    Returns order ids for orders which can be cancelled
3431 rajveer 1365 
 
1382 varun.gupt 1366 
    Parameters:
1367 
     - customer_id
1368 
     - limit
1369 
    """
1370 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1371 
    return self.recv_getCancellableOrdersForCustomer()
1372 
 
1373 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1374 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1375 
    args = getCancellableOrdersForCustomer_args()
1376 
    args.customer_id = customer_id
1377 
    args.limit = limit
1378 
    args.write(self._oprot)
1379 
    self._oprot.writeMessageEnd()
1380 
    self._oprot.trans.flush()
1381 
 
1382 
  def recv_getCancellableOrdersForCustomer(self, ):
1383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1384 
    if mtype == TMessageType.EXCEPTION:
1385 
      x = TApplicationException()
1386 
      x.read(self._iprot)
1387 
      self._iprot.readMessageEnd()
1388 
      raise x
1389 
    result = getCancellableOrdersForCustomer_result()
1390 
    result.read(self._iprot)
1391 
    self._iprot.readMessageEnd()
3431 rajveer 1392 
    if result.success is not None:
1382 varun.gupt 1393 
      return result.success
3431 rajveer 1394 
    if result.ex is not None:
1382 varun.gupt 1395 
      raise result.ex
1396 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1397 
 
483 rajveer 1398 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1399 
    """
1400 
    Parameters:
483 rajveer 1401 
     - orderId
1402 
     - status
1403 
     - description
94 ashish 1404 
    """
483 rajveer 1405 
    self.send_changeOrderStatus(orderId, status, description)
1406 
    return self.recv_changeOrderStatus()
94 ashish 1407 
 
483 rajveer 1408 
  def send_changeOrderStatus(self, orderId, status, description):
1409 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1410 
    args = changeOrderStatus_args()
1411 
    args.orderId = orderId
1412 
    args.status = status
1413 
    args.description = description
94 ashish 1414 
    args.write(self._oprot)
1415 
    self._oprot.writeMessageEnd()
1416 
    self._oprot.trans.flush()
1417 
 
483 rajveer 1418 
  def recv_changeOrderStatus(self, ):
94 ashish 1419 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1420 
    if mtype == TMessageType.EXCEPTION:
1421 
      x = TApplicationException()
1422 
      x.read(self._iprot)
1423 
      self._iprot.readMessageEnd()
1424 
      raise x
483 rajveer 1425 
    result = changeOrderStatus_result()
94 ashish 1426 
    result.read(self._iprot)
1427 
    self._iprot.readMessageEnd()
3431 rajveer 1428 
    if result.success is not None:
94 ashish 1429 
      return result.success
3431 rajveer 1430 
    if result.ex is not None:
94 ashish 1431 
      raise result.ex
483 rajveer 1432 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1433 
 
1528 ankur.sing 1434 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1435 
    """
1528 ankur.sing 1436 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1437 
    only user who owns the transaction can view its order details.
3431 rajveer 1438 
 
94 ashish 1439 
    Parameters:
1440 
     - transactionId
1528 ankur.sing 1441 
     - customerId
94 ashish 1442 
    """
1528 ankur.sing 1443 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1444 
    return self.recv_getOrdersForTransaction()
94 ashish 1445 
 
1528 ankur.sing 1446 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1447 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1448 
    args = getOrdersForTransaction_args()
94 ashish 1449 
    args.transactionId = transactionId
1528 ankur.sing 1450 
    args.customerId = customerId
94 ashish 1451 
    args.write(self._oprot)
1452 
    self._oprot.writeMessageEnd()
1453 
    self._oprot.trans.flush()
1454 
 
483 rajveer 1455 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1456 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1457 
    if mtype == TMessageType.EXCEPTION:
1458 
      x = TApplicationException()
1459 
      x.read(self._iprot)
1460 
      self._iprot.readMessageEnd()
1461 
      raise x
483 rajveer 1462 
    result = getOrdersForTransaction_result()
94 ashish 1463 
    result.read(self._iprot)
1464 
    self._iprot.readMessageEnd()
3431 rajveer 1465 
    if result.success is not None:
94 ashish 1466 
      return result.success
3431 rajveer 1467 
    if result.ex is not None:
94 ashish 1468 
      raise result.ex
483 rajveer 1469 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1470 
 
3014 chandransh 1471 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1472 
    """
3014 chandransh 1473 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1474 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1475 
 
94 ashish 1476 
    Parameters:
483 rajveer 1477 
     - customerId
1478 
     - from_date
1479 
     - to_date
3014 chandransh 1480 
     - statuses
94 ashish 1481 
    """
3014 chandransh 1482 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1483 
    return self.recv_getOrdersForCustomer()
94 ashish 1484 
 
3014 chandransh 1485 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1486 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1487 
    args = getOrdersForCustomer_args()
1488 
    args.customerId = customerId
1489 
    args.from_date = from_date
1490 
    args.to_date = to_date
3014 chandransh 1491 
    args.statuses = statuses
94 ashish 1492 
    args.write(self._oprot)
1493 
    self._oprot.writeMessageEnd()
1494 
    self._oprot.trans.flush()
1495 
 
483 rajveer 1496 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1498 
    if mtype == TMessageType.EXCEPTION:
1499 
      x = TApplicationException()
1500 
      x.read(self._iprot)
1501 
      self._iprot.readMessageEnd()
1502 
      raise x
483 rajveer 1503 
    result = getOrdersForCustomer_result()
94 ashish 1504 
    result.read(self._iprot)
1505 
    self._iprot.readMessageEnd()
3431 rajveer 1506 
    if result.success is not None:
94 ashish 1507 
      return result.success
3431 rajveer 1508 
    if result.ex is not None:
94 ashish 1509 
      raise result.ex
483 rajveer 1510 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1511 
 
483 rajveer 1512 
  def createOrder(self, order):
94 ashish 1513 
    """
1514 
    Parameters:
483 rajveer 1515 
     - order
94 ashish 1516 
    """
483 rajveer 1517 
    self.send_createOrder(order)
1518 
    return self.recv_createOrder()
94 ashish 1519 
 
483 rajveer 1520 
  def send_createOrder(self, order):
1521 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1522 
    args = createOrder_args()
1523 
    args.order = order
94 ashish 1524 
    args.write(self._oprot)
1525 
    self._oprot.writeMessageEnd()
1526 
    self._oprot.trans.flush()
1527 
 
483 rajveer 1528 
  def recv_createOrder(self, ):
94 ashish 1529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1530 
    if mtype == TMessageType.EXCEPTION:
1531 
      x = TApplicationException()
1532 
      x.read(self._iprot)
1533 
      self._iprot.readMessageEnd()
1534 
      raise x
483 rajveer 1535 
    result = createOrder_result()
94 ashish 1536 
    result.read(self._iprot)
1537 
    self._iprot.readMessageEnd()
3431 rajveer 1538 
    if result.success is not None:
94 ashish 1539 
      return result.success
3431 rajveer 1540 
    if result.ex is not None:
94 ashish 1541 
      raise result.ex
483 rajveer 1542 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1543 
 
483 rajveer 1544 
  def getOrder(self, id):
94 ashish 1545 
    """
1546 
    Parameters:
483 rajveer 1547 
     - id
94 ashish 1548 
    """
483 rajveer 1549 
    self.send_getOrder(id)
1550 
    return self.recv_getOrder()
94 ashish 1551 
 
483 rajveer 1552 
  def send_getOrder(self, id):
1553 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1554 
    args = getOrder_args()
1555 
    args.id = id
94 ashish 1556 
    args.write(self._oprot)
1557 
    self._oprot.writeMessageEnd()
1558 
    self._oprot.trans.flush()
1559 
 
483 rajveer 1560 
  def recv_getOrder(self, ):
94 ashish 1561 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1562 
    if mtype == TMessageType.EXCEPTION:
1563 
      x = TApplicationException()
1564 
      x.read(self._iprot)
1565 
      self._iprot.readMessageEnd()
1566 
      raise x
483 rajveer 1567 
    result = getOrder_result()
94 ashish 1568 
    result.read(self._iprot)
1569 
    self._iprot.readMessageEnd()
3431 rajveer 1570 
    if result.success is not None:
94 ashish 1571 
      return result.success
3431 rajveer 1572 
    if result.ex is not None:
94 ashish 1573 
      raise result.ex
483 rajveer 1574 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1575 
 
483 rajveer 1576 
  def getLineItemsForOrder(self, orderId):
94 ashish 1577 
    """
1578 
    Parameters:
483 rajveer 1579 
     - orderId
94 ashish 1580 
    """
483 rajveer 1581 
    self.send_getLineItemsForOrder(orderId)
1582 
    return self.recv_getLineItemsForOrder()
94 ashish 1583 
 
483 rajveer 1584 
  def send_getLineItemsForOrder(self, orderId):
1585 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1586 
    args = getLineItemsForOrder_args()
1587 
    args.orderId = orderId
94 ashish 1588 
    args.write(self._oprot)
1589 
    self._oprot.writeMessageEnd()
1590 
    self._oprot.trans.flush()
1591 
 
483 rajveer 1592 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1594 
    if mtype == TMessageType.EXCEPTION:
1595 
      x = TApplicationException()
1596 
      x.read(self._iprot)
1597 
      self._iprot.readMessageEnd()
1598 
      raise x
483 rajveer 1599 
    result = getLineItemsForOrder_result()
94 ashish 1600 
    result.read(self._iprot)
1601 
    self._iprot.readMessageEnd()
3431 rajveer 1602 
    if result.success is not None:
94 ashish 1603 
      return result.success
3431 rajveer 1604 
    if result.ex is not None:
94 ashish 1605 
      raise result.ex
483 rajveer 1606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1607 
 
1528 ankur.sing 1608 
  def getOrderForCustomer(self, orderId, customerId):
1609 
    """
1610 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1611 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1612 
 
1528 ankur.sing 1613 
    Parameters:
1614 
     - orderId
1615 
     - customerId
1616 
    """
1617 
    self.send_getOrderForCustomer(orderId, customerId)
1618 
    return self.recv_getOrderForCustomer()
1619 
 
1620 
  def send_getOrderForCustomer(self, orderId, customerId):
1621 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1622 
    args = getOrderForCustomer_args()
1623 
    args.orderId = orderId
1624 
    args.customerId = customerId
1625 
    args.write(self._oprot)
1626 
    self._oprot.writeMessageEnd()
1627 
    self._oprot.trans.flush()
1628 
 
1629 
  def recv_getOrderForCustomer(self, ):
1630 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1631 
    if mtype == TMessageType.EXCEPTION:
1632 
      x = TApplicationException()
1633 
      x.read(self._iprot)
1634 
      self._iprot.readMessageEnd()
1635 
      raise x
1636 
    result = getOrderForCustomer_result()
1637 
    result.read(self._iprot)
1638 
    self._iprot.readMessageEnd()
3431 rajveer 1639 
    if result.success is not None:
1528 ankur.sing 1640 
      return result.success
3431 rajveer 1641 
    if result.ex is not None:
1528 ankur.sing 1642 
      raise result.ex
1643 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1644 
 
4444 rajveer 1645 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1646 
    """
1647 
    Parameters:
4394 rajveer 1648 
     - type
4444 rajveer 1649 
     - warehouseId
4394 rajveer 1650 
     - status
1651 
     - timestamp
3064 chandransh 1652 
    """
4444 rajveer 1653 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1654 
    return self.recv_getAlerts()
1655 
 
4444 rajveer 1656 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1657 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1658 
    args = getAlerts_args()
4394 rajveer 1659 
    args.type = type
4444 rajveer 1660 
    args.warehouseId = warehouseId
4394 rajveer 1661 
    args.status = status
1662 
    args.timestamp = timestamp
3064 chandransh 1663 
    args.write(self._oprot)
1664 
    self._oprot.writeMessageEnd()
1665 
    self._oprot.trans.flush()
1666 
 
1667 
  def recv_getAlerts(self, ):
1668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1669 
    if mtype == TMessageType.EXCEPTION:
1670 
      x = TApplicationException()
1671 
      x.read(self._iprot)
1672 
      self._iprot.readMessageEnd()
1673 
      raise x
1674 
    result = getAlerts_result()
1675 
    result.read(self._iprot)
1676 
    self._iprot.readMessageEnd()
3431 rajveer 1677 
    if result.success is not None:
3064 chandransh 1678 
      return result.success
1679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1680 
 
4444 rajveer 1681 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1682 
    """
1683 
    Parameters:
1684 
     - type
4444 rajveer 1685 
     - warehouseId
4394 rajveer 1686 
     - description
3064 chandransh 1687 
    """
4444 rajveer 1688 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1689 
    self.recv_addAlert()
3064 chandransh 1690 
 
4444 rajveer 1691 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1692 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1693 
    args = addAlert_args()
3064 chandransh 1694 
    args.type = type
4444 rajveer 1695 
    args.warehouseId = warehouseId
4394 rajveer 1696 
    args.description = description
3064 chandransh 1697 
    args.write(self._oprot)
1698 
    self._oprot.writeMessageEnd()
1699 
    self._oprot.trans.flush()
1700 
 
4394 rajveer 1701 
  def recv_addAlert(self, ):
3064 chandransh 1702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1703 
    if mtype == TMessageType.EXCEPTION:
1704 
      x = TApplicationException()
1705 
      x.read(self._iprot)
1706 
      self._iprot.readMessageEnd()
1707 
      raise x
4394 rajveer 1708 
    result = addAlert_result()
3064 chandransh 1709 
    result.read(self._iprot)
1710 
    self._iprot.readMessageEnd()
1711 
    return
1712 
 
4444 rajveer 1713 
  def markAlertsAsSeen(self, warehouseId):
1714 
    """
1715 
    Parameters:
1716 
     - warehouseId
1717 
    """
1718 
    self.send_markAlertsAsSeen(warehouseId)
1719 
    self.recv_markAlertsAsSeen()
1720 
 
1721 
  def send_markAlertsAsSeen(self, warehouseId):
1722 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1723 
    args = markAlertsAsSeen_args()
1724 
    args.warehouseId = warehouseId
1725 
    args.write(self._oprot)
1726 
    self._oprot.writeMessageEnd()
1727 
    self._oprot.trans.flush()
1728 
 
1729 
  def recv_markAlertsAsSeen(self, ):
1730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1731 
    if mtype == TMessageType.EXCEPTION:
1732 
      x = TApplicationException()
1733 
      x.read(self._iprot)
1734 
      self._iprot.readMessageEnd()
1735 
      raise x
1736 
    result = markAlertsAsSeen_result()
1737 
    result.read(self._iprot)
1738 
    self._iprot.readMessageEnd()
1739 
    return
1740 
 
3064 chandransh 1741 
  def getValidOrderCount(self, ):
1742 
    """
1743 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1744 
    """
1745 
    self.send_getValidOrderCount()
1746 
    return self.recv_getValidOrderCount()
1747 
 
1748 
  def send_getValidOrderCount(self, ):
1749 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1750 
    args = getValidOrderCount_args()
1751 
    args.write(self._oprot)
1752 
    self._oprot.writeMessageEnd()
1753 
    self._oprot.trans.flush()
1754 
 
1755 
  def recv_getValidOrderCount(self, ):
1756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1757 
    if mtype == TMessageType.EXCEPTION:
1758 
      x = TApplicationException()
1759 
      x.read(self._iprot)
1760 
      self._iprot.readMessageEnd()
1761 
      raise x
1762 
    result = getValidOrderCount_result()
1763 
    result.read(self._iprot)
1764 
    self._iprot.readMessageEnd()
3431 rajveer 1765 
    if result.success is not None:
3064 chandransh 1766 
      return result.success
1767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1768 
 
1769 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1770 
    """
1771 
    Returns the number of distinct customers who have done successful transactions
1772 
    """
1773 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1774 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1775 
 
1776 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1777 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1778 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1779 
    args.write(self._oprot)
1780 
    self._oprot.writeMessageEnd()
1781 
    self._oprot.trans.flush()
1782 
 
1783 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1785 
    if mtype == TMessageType.EXCEPTION:
1786 
      x = TApplicationException()
1787 
      x.read(self._iprot)
1788 
      self._iprot.readMessageEnd()
1789 
      raise x
1790 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1791 
    result.read(self._iprot)
1792 
    self._iprot.readMessageEnd()
3431 rajveer 1793 
    if result.success is not None:
3064 chandransh 1794 
      return result.success
1795 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1796 
 
1797 
  def getValidOrdersAmountRange(self, ):
1798 
    """
1799 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1800 
    List contains two values, first minimum amount and second maximum amount.
1801 
    """
1802 
    self.send_getValidOrdersAmountRange()
1803 
    return self.recv_getValidOrdersAmountRange()
1804 
 
1805 
  def send_getValidOrdersAmountRange(self, ):
1806 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1807 
    args = getValidOrdersAmountRange_args()
1808 
    args.write(self._oprot)
1809 
    self._oprot.writeMessageEnd()
1810 
    self._oprot.trans.flush()
1811 
 
1812 
  def recv_getValidOrdersAmountRange(self, ):
1813 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1814 
    if mtype == TMessageType.EXCEPTION:
1815 
      x = TApplicationException()
1816 
      x.read(self._iprot)
1817 
      self._iprot.readMessageEnd()
1818 
      raise x
1819 
    result = getValidOrdersAmountRange_result()
1820 
    result.read(self._iprot)
1821 
    self._iprot.readMessageEnd()
3431 rajveer 1822 
    if result.success is not None:
3064 chandransh 1823 
      return result.success
1824 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1825 
 
1826 
  def getValidOrders(self, limit):
1827 
    """
1828 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1829 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1830 
 
3064 chandransh 1831 
    Parameters:
1832 
     - limit
1833 
    """
1834 
    self.send_getValidOrders(limit)
1835 
    return self.recv_getValidOrders()
1836 
 
1837 
  def send_getValidOrders(self, limit):
1838 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1839 
    args = getValidOrders_args()
1840 
    args.limit = limit
1841 
    args.write(self._oprot)
1842 
    self._oprot.writeMessageEnd()
1843 
    self._oprot.trans.flush()
1844 
 
1845 
  def recv_getValidOrders(self, ):
1846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1847 
    if mtype == TMessageType.EXCEPTION:
1848 
      x = TApplicationException()
1849 
      x.read(self._iprot)
1850 
      self._iprot.readMessageEnd()
1851 
      raise x
1852 
    result = getValidOrders_result()
1853 
    result.read(self._iprot)
1854 
    self._iprot.readMessageEnd()
3431 rajveer 1855 
    if result.success is not None:
3064 chandransh 1856 
      return result.success
1857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1858 
 
1220 chandransh 1859 
  def batchOrders(self, warehouseId):
1860 
    """
1861 
    Create a batch of all the pending orders for the given warehouse.
1862 
    The returned list is orderd by created_timestamp.
1863 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1864 
 
1220 chandransh 1865 
    Parameters:
1866 
     - warehouseId
1867 
    """
1868 
    self.send_batchOrders(warehouseId)
1869 
    return self.recv_batchOrders()
1870 
 
1871 
  def send_batchOrders(self, warehouseId):
1872 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1873 
    args = batchOrders_args()
1874 
    args.warehouseId = warehouseId
1875 
    args.write(self._oprot)
1876 
    self._oprot.writeMessageEnd()
1877 
    self._oprot.trans.flush()
1878 
 
1879 
  def recv_batchOrders(self, ):
1880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1881 
    if mtype == TMessageType.EXCEPTION:
1882 
      x = TApplicationException()
1883 
      x.read(self._iprot)
1884 
      self._iprot.readMessageEnd()
1885 
      raise x
1886 
    result = batchOrders_result()
1887 
    result.read(self._iprot)
1888 
    self._iprot.readMessageEnd()
3431 rajveer 1889 
    if result.success is not None:
1220 chandransh 1890 
      return result.success
3431 rajveer 1891 
    if result.ex is not None:
1220 chandransh 1892 
      raise result.ex
1893 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1894 
 
1208 chandransh 1895 
  def markOrderAsOutOfStock(self, orderId):
1896 
    """
1897 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1898 
 
1208 chandransh 1899 
    Parameters:
1900 
     - orderId
1901 
    """
1902 
    self.send_markOrderAsOutOfStock(orderId)
1903 
    return self.recv_markOrderAsOutOfStock()
1904 
 
1905 
  def send_markOrderAsOutOfStock(self, orderId):
1906 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1907 
    args = markOrderAsOutOfStock_args()
1908 
    args.orderId = orderId
1909 
    args.write(self._oprot)
1910 
    self._oprot.writeMessageEnd()
1911 
    self._oprot.trans.flush()
1912 
 
1913 
  def recv_markOrderAsOutOfStock(self, ):
1914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1915 
    if mtype == TMessageType.EXCEPTION:
1916 
      x = TApplicationException()
1917 
      x.read(self._iprot)
1918 
      self._iprot.readMessageEnd()
1919 
      raise x
1920 
    result = markOrderAsOutOfStock_result()
1921 
    result.read(self._iprot)
1922 
    self._iprot.readMessageEnd()
3431 rajveer 1923 
    if result.success is not None:
1208 chandransh 1924 
      return result.success
3431 rajveer 1925 
    if result.ex is not None:
1208 chandransh 1926 
      raise result.ex
1927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1928 
 
3064 chandransh 1929 
  def verifyOrder(self, orderId):
759 chandransh 1930 
    """
3064 chandransh 1931 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1932 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1933 
    used for all other orders as well.
1934 
    Throws an exception if no such order exists.
3431 rajveer 1935 
 
759 chandransh 1936 
    Parameters:
3064 chandransh 1937 
     - orderId
759 chandransh 1938 
    """
3064 chandransh 1939 
    self.send_verifyOrder(orderId)
1940 
    return self.recv_verifyOrder()
759 chandransh 1941 
 
3064 chandransh 1942 
  def send_verifyOrder(self, orderId):
1943 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1944 
    args = verifyOrder_args()
1945 
    args.orderId = orderId
759 chandransh 1946 
    args.write(self._oprot)
1947 
    self._oprot.writeMessageEnd()
1948 
    self._oprot.trans.flush()
1949 
 
3064 chandransh 1950 
  def recv_verifyOrder(self, ):
759 chandransh 1951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1952 
    if mtype == TMessageType.EXCEPTION:
1953 
      x = TApplicationException()
1954 
      x.read(self._iprot)
1955 
      self._iprot.readMessageEnd()
1956 
      raise x
3064 chandransh 1957 
    result = verifyOrder_result()
759 chandransh 1958 
    result.read(self._iprot)
1959 
    self._iprot.readMessageEnd()
3431 rajveer 1960 
    if result.success is not None:
759 chandransh 1961 
      return result.success
3431 rajveer 1962 
    if result.ex is not None:
759 chandransh 1963 
      raise result.ex
3064 chandransh 1964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1965 
 
3064 chandransh 1966 
  def acceptOrder(self, orderId):
1113 chandransh 1967 
    """
3064 chandransh 1968 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1969 
    given order is not a COD order, it also captures the payment if the same has
1970 
    not been captured.
1971 
    Throws an exception if no such order exists.
3431 rajveer 1972 
 
1113 chandransh 1973 
    Parameters:
3064 chandransh 1974 
     - orderId
1113 chandransh 1975 
    """
3064 chandransh 1976 
    self.send_acceptOrder(orderId)
1977 
    return self.recv_acceptOrder()
1113 chandransh 1978 
 
3064 chandransh 1979 
  def send_acceptOrder(self, orderId):
1980 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1981 
    args = acceptOrder_args()
1982 
    args.orderId = orderId
1113 chandransh 1983 
    args.write(self._oprot)
1984 
    self._oprot.writeMessageEnd()
1985 
    self._oprot.trans.flush()
1986 
 
3064 chandransh 1987 
  def recv_acceptOrder(self, ):
1113 chandransh 1988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1989 
    if mtype == TMessageType.EXCEPTION:
1990 
      x = TApplicationException()
1991 
      x.read(self._iprot)
1992 
      self._iprot.readMessageEnd()
1993 
      raise x
3064 chandransh 1994 
    result = acceptOrder_result()
1113 chandransh 1995 
    result.read(self._iprot)
1996 
    self._iprot.readMessageEnd()
3431 rajveer 1997 
    if result.success is not None:
1113 chandransh 1998 
      return result.success
3431 rajveer 1999 
    if result.ex is not None:
1113 chandransh 2000 
      raise result.ex
3064 chandransh 2001 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2002 
 
4283 anupam.sin 2003 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 2004 
    """
3064 chandransh 2005 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 2006 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
2007 
    the IMEI no. if a -1 is supplied.
2008 
    Also, it generates an invoice number for the order, marks the order as
2009 
    BILLED and sets the billing timestamp.
2010 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2011 
 
1135 chandransh 2012 
    Parameters:
3064 chandransh 2013 
     - orderId
2014 
     - invoice_number
4283 anupam.sin 2015 
     - imeiNumber
2016 
     - itemNumber
3064 chandransh 2017 
     - billed_by
4264 rajveer 2018 
     - jacketNumber
4283 anupam.sin 2019 
     - billingType
2020 
     - vendorId
1135 chandransh 2021 
    """
4283 anupam.sin 2022 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 2023 
    return self.recv_addBillingDetails()
1135 chandransh 2024 
 
4283 anupam.sin 2025 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 2026 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2027 
    args = addBillingDetails_args()
2028 
    args.orderId = orderId
2029 
    args.invoice_number = invoice_number
4283 anupam.sin 2030 
    args.imeiNumber = imeiNumber
2031 
    args.itemNumber = itemNumber
3064 chandransh 2032 
    args.billed_by = billed_by
4264 rajveer 2033 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2034 
    args.billingType = billingType
2035 
    args.vendorId = vendorId
1135 chandransh 2036 
    args.write(self._oprot)
2037 
    self._oprot.writeMessageEnd()
2038 
    self._oprot.trans.flush()
2039 
 
3064 chandransh 2040 
  def recv_addBillingDetails(self, ):
1135 chandransh 2041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2042 
    if mtype == TMessageType.EXCEPTION:
2043 
      x = TApplicationException()
2044 
      x.read(self._iprot)
2045 
      self._iprot.readMessageEnd()
2046 
      raise x
3064 chandransh 2047 
    result = addBillingDetails_result()
1135 chandransh 2048 
    result.read(self._iprot)
2049 
    self._iprot.readMessageEnd()
3431 rajveer 2050 
    if result.success is not None:
3064 chandransh 2051 
      return result.success
3431 rajveer 2052 
    if result.ex is not None:
1135 chandransh 2053 
      raise result.ex
3064 chandransh 2054 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2055 
 
4579 rajveer 2056 
  def addInvoiceNumber(self, orderId, invoiceNumber):
2057 
    """
2058 
    Add the invoice number to the order.
2059 
 
2060 
    Parameters:
2061 
     - orderId
2062 
     - invoiceNumber
2063 
    """
2064 
    self.send_addInvoiceNumber(orderId, invoiceNumber)
2065 
    self.recv_addInvoiceNumber()
2066 
 
2067 
  def send_addInvoiceNumber(self, orderId, invoiceNumber):
2068 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2069 
    args = addInvoiceNumber_args()
2070 
    args.orderId = orderId
2071 
    args.invoiceNumber = invoiceNumber
2072 
    args.write(self._oprot)
2073 
    self._oprot.writeMessageEnd()
2074 
    self._oprot.trans.flush()
2075 
 
2076 
  def recv_addInvoiceNumber(self, ):
2077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2078 
    if mtype == TMessageType.EXCEPTION:
2079 
      x = TApplicationException()
2080 
      x.read(self._iprot)
2081 
      self._iprot.readMessageEnd()
2082 
      raise x
2083 
    result = addInvoiceNumber_result()
2084 
    result.read(self._iprot)
2085 
    self._iprot.readMessageEnd()
2086 
    if result.ex is not None:
2087 
      raise result.ex
2088 
    return
2089 
 
3064 chandransh 2090 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2091 
    """
3064 chandransh 2092 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2093 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2094 
 
1408 ankur.sing 2095 
    Parameters:
3064 chandransh 2096 
     - warehouseId
1408 ankur.sing 2097 
     - providerId
3064 chandransh 2098 
     - cod
1408 ankur.sing 2099 
    """
3064 chandransh 2100 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2101 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2102 
 
3064 chandransh 2103 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2104 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2105 
    args = markOrdersAsManifested_args()
2106 
    args.warehouseId = warehouseId
1408 ankur.sing 2107 
    args.providerId = providerId
3064 chandransh 2108 
    args.cod = cod
1408 ankur.sing 2109 
    args.write(self._oprot)
2110 
    self._oprot.writeMessageEnd()
2111 
    self._oprot.trans.flush()
2112 
 
3064 chandransh 2113 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2115 
    if mtype == TMessageType.EXCEPTION:
2116 
      x = TApplicationException()
2117 
      x.read(self._iprot)
2118 
      self._iprot.readMessageEnd()
2119 
      raise x
3064 chandransh 2120 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2121 
    result.read(self._iprot)
2122 
    self._iprot.readMessageEnd()
3431 rajveer 2123 
    if result.success is not None:
1408 ankur.sing 2124 
      return result.success
3431 rajveer 2125 
    if result.ex is not None:
3064 chandransh 2126 
      raise result.ex
2127 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2128 
 
4410 rajveer 2129 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2130 
    """
2131 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2132 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2133 
 
2134 
    Parameters:
2135 
     - warehouseId
2136 
     - providerId
2137 
     - cod
2138 
    """
2139 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2140 
    return self.recv_markOrdersAsShippedFromWarehouse()
2141 
 
2142 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2143 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2144 
    args = markOrdersAsShippedFromWarehouse_args()
2145 
    args.warehouseId = warehouseId
2146 
    args.providerId = providerId
2147 
    args.cod = cod
2148 
    args.write(self._oprot)
2149 
    self._oprot.writeMessageEnd()
2150 
    self._oprot.trans.flush()
2151 
 
2152 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2154 
    if mtype == TMessageType.EXCEPTION:
2155 
      x = TApplicationException()
2156 
      x.read(self._iprot)
2157 
      self._iprot.readMessageEnd()
2158 
      raise x
2159 
    result = markOrdersAsShippedFromWarehouse_result()
2160 
    result.read(self._iprot)
2161 
    self._iprot.readMessageEnd()
2162 
    if result.success is not None:
2163 
      return result.success
2164 
    if result.ex is not None:
2165 
      raise result.ex
2166 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2167 
 
3064 chandransh 2168 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2169 
    """
3064 chandransh 2170 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2171 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2172 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2173 
 
94 ashish 2174 
    Parameters:
3064 chandransh 2175 
     - providerId
2176 
     - pickupDetails
304 ashish 2177 
    """
3064 chandransh 2178 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2179 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2180 
 
3064 chandransh 2181 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2182 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2183 
    args = markOrdersAsPickedUp_args()
2184 
    args.providerId = providerId
2185 
    args.pickupDetails = pickupDetails
304 ashish 2186 
    args.write(self._oprot)
2187 
    self._oprot.writeMessageEnd()
2188 
    self._oprot.trans.flush()
2189 
 
3064 chandransh 2190 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2192 
    if mtype == TMessageType.EXCEPTION:
2193 
      x = TApplicationException()
2194 
      x.read(self._iprot)
2195 
      self._iprot.readMessageEnd()
2196 
      raise x
3064 chandransh 2197 
    result = markOrdersAsPickedUp_result()
304 ashish 2198 
    result.read(self._iprot)
2199 
    self._iprot.readMessageEnd()
3431 rajveer 2200 
    if result.success is not None:
304 ashish 2201 
      return result.success
3431 rajveer 2202 
    if result.ex is not None:
3064 chandransh 2203 
      raise result.ex
2204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2205 
 
3064 chandransh 2206 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2207 
    """
3064 chandransh 2208 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2209 
    the name of the receiver.
2210 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2211 
 
304 ashish 2212 
    Parameters:
3064 chandransh 2213 
     - providerId
2214 
     - deliveredOrders
304 ashish 2215 
    """
3064 chandransh 2216 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2217 
    self.recv_markOrdersAsDelivered()
304 ashish 2218 
 
3064 chandransh 2219 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2220 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2221 
    args = markOrdersAsDelivered_args()
2222 
    args.providerId = providerId
2223 
    args.deliveredOrders = deliveredOrders
304 ashish 2224 
    args.write(self._oprot)
2225 
    self._oprot.writeMessageEnd()
2226 
    self._oprot.trans.flush()
2227 
 
3064 chandransh 2228 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2230 
    if mtype == TMessageType.EXCEPTION:
2231 
      x = TApplicationException()
2232 
      x.read(self._iprot)
2233 
      self._iprot.readMessageEnd()
2234 
      raise x
3064 chandransh 2235 
    result = markOrdersAsDelivered_result()
304 ashish 2236 
    result.read(self._iprot)
2237 
    self._iprot.readMessageEnd()
3431 rajveer 2238 
    if result.ex is not None:
3064 chandransh 2239 
      raise result.ex
304 ashish 2240 
    return
2241 
 
3064 chandransh 2242 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2243 
    """
3064 chandransh 2244 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2245 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2246 
 
3064 chandransh 2247 
    Parameters:
2248 
     - providerId
2249 
     - returnedOrders
1596 ankur.sing 2250 
    """
3064 chandransh 2251 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2252 
    self.recv_markOrdersAsFailed()
304 ashish 2253 
 
3064 chandransh 2254 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2255 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2256 
    args = markOrdersAsFailed_args()
2257 
    args.providerId = providerId
2258 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2259 
    args.write(self._oprot)
2260 
    self._oprot.writeMessageEnd()
2261 
    self._oprot.trans.flush()
2262 
 
3064 chandransh 2263 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2265 
    if mtype == TMessageType.EXCEPTION:
2266 
      x = TApplicationException()
2267 
      x.read(self._iprot)
2268 
      self._iprot.readMessageEnd()
2269 
      raise x
3064 chandransh 2270 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2271 
    result.read(self._iprot)
2272 
    self._iprot.readMessageEnd()
3431 rajveer 2273 
    if result.ex is not None:
3064 chandransh 2274 
      raise result.ex
2275 
    return
1596 ankur.sing 2276 
 
3064 chandransh 2277 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2278 
    """
3064 chandransh 2279 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2280 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2281 
 
3064 chandransh 2282 
    Parameters:
2283 
     - providerId
2284 
     - undeliveredOrders
1627 ankur.sing 2285 
    """
3064 chandransh 2286 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2287 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2288 
 
3064 chandransh 2289 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2290 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2291 
    args = updateNonDeliveryReason_args()
2292 
    args.providerId = providerId
2293 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2294 
    args.write(self._oprot)
2295 
    self._oprot.writeMessageEnd()
2296 
    self._oprot.trans.flush()
2297 
 
3064 chandransh 2298 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2300 
    if mtype == TMessageType.EXCEPTION:
2301 
      x = TApplicationException()
2302 
      x.read(self._iprot)
2303 
      self._iprot.readMessageEnd()
2304 
      raise x
3064 chandransh 2305 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2306 
    result.read(self._iprot)
2307 
    self._iprot.readMessageEnd()
4581 phani.kuma 2308 
    if result.success is not None:
2309 
      return result.success
3431 rajveer 2310 
    if result.ex is not None:
3064 chandransh 2311 
      raise result.ex
4581 phani.kuma 2312 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2313 
 
3064 chandransh 2314 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2315 
    """
3064 chandransh 2316 
    Returns the list of orders whose delivery time has passed but have not been
2317 
    delivered yet for the given provider and warehouse. To get a complete list of
2318 
    undelivered orders, pass them as -1.
2319 
    Returns an empty list if no such orders exist.
3431 rajveer 2320 
 
1886 ankur.sing 2321 
    Parameters:
3064 chandransh 2322 
     - providerId
2323 
     - warehouseId
1886 ankur.sing 2324 
    """
3064 chandransh 2325 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2326 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2327 
 
3064 chandransh 2328 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2329 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2330 
    args = getUndeliveredOrders_args()
2331 
    args.providerId = providerId
2332 
    args.warehouseId = warehouseId
1886 ankur.sing 2333 
    args.write(self._oprot)
2334 
    self._oprot.writeMessageEnd()
2335 
    self._oprot.trans.flush()
2336 
 
3064 chandransh 2337 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2339 
    if mtype == TMessageType.EXCEPTION:
2340 
      x = TApplicationException()
2341 
      x.read(self._iprot)
2342 
      self._iprot.readMessageEnd()
2343 
      raise x
3064 chandransh 2344 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2345 
    result.read(self._iprot)
2346 
    self._iprot.readMessageEnd()
3431 rajveer 2347 
    if result.success is not None:
1886 ankur.sing 2348 
      return result.success
3064 chandransh 2349 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2350 
 
2536 chandransh 2351 
  def toggleDOAFlag(self, orderId):
2352 
    """
2353 
    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.
2354 
    Returns the final flag status.
2355 
    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 2356 
 
2536 chandransh 2357 
    Parameters:
2358 
     - orderId
2359 
    """
2360 
    self.send_toggleDOAFlag(orderId)
2361 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2362 
 
2536 chandransh 2363 
  def send_toggleDOAFlag(self, orderId):
2364 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2365 
    args = toggleDOAFlag_args()
2366 
    args.orderId = orderId
2367 
    args.write(self._oprot)
2368 
    self._oprot.writeMessageEnd()
2369 
    self._oprot.trans.flush()
2370 
 
2371 
  def recv_toggleDOAFlag(self, ):
2372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2373 
    if mtype == TMessageType.EXCEPTION:
2374 
      x = TApplicationException()
2375 
      x.read(self._iprot)
2376 
      self._iprot.readMessageEnd()
2377 
      raise x
2378 
    result = toggleDOAFlag_result()
2379 
    result.read(self._iprot)
2380 
    self._iprot.readMessageEnd()
3431 rajveer 2381 
    if result.success is not None:
2536 chandransh 2382 
      return result.success
3431 rajveer 2383 
    if result.ex is not None:
2536 chandransh 2384 
      raise result.ex
2385 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2386 
 
4454 rajveer 2387 
  def markOrderDoaRequestReceived(self, orderId):
2388 
    """
2389 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2390 
 
2391 
    Parameters:
2392 
     - orderId
2393 
    """
2394 
    self.send_markOrderDoaRequestReceived(orderId)
2395 
    return self.recv_markOrderDoaRequestReceived()
2396 
 
2397 
  def send_markOrderDoaRequestReceived(self, orderId):
2398 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2399 
    args = markOrderDoaRequestReceived_args()
2400 
    args.orderId = orderId
2401 
    args.write(self._oprot)
2402 
    self._oprot.writeMessageEnd()
2403 
    self._oprot.trans.flush()
2404 
 
2405 
  def recv_markOrderDoaRequestReceived(self, ):
2406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2407 
    if mtype == TMessageType.EXCEPTION:
2408 
      x = TApplicationException()
2409 
      x.read(self._iprot)
2410 
      self._iprot.readMessageEnd()
2411 
      raise x
2412 
    result = markOrderDoaRequestReceived_result()
2413 
    result.read(self._iprot)
2414 
    self._iprot.readMessageEnd()
2415 
    if result.success is not None:
2416 
      return result.success
2417 
    if result.ex is not None:
2418 
      raise result.ex
2419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2420 
 
2421 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2422 
    """
2423 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2424 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2425 
 
2426 
    Parameters:
2427 
     - orderId
2428 
     - isAuthorized
2429 
    """
2430 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2431 
    return self.recv_markOrderDoaRequestAuthorized()
2432 
 
2433 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2434 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2435 
    args = markOrderDoaRequestAuthorized_args()
2436 
    args.orderId = orderId
2437 
    args.isAuthorized = isAuthorized
2438 
    args.write(self._oprot)
2439 
    self._oprot.writeMessageEnd()
2440 
    self._oprot.trans.flush()
2441 
 
2442 
  def recv_markOrderDoaRequestAuthorized(self, ):
2443 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2444 
    if mtype == TMessageType.EXCEPTION:
2445 
      x = TApplicationException()
2446 
      x.read(self._iprot)
2447 
      self._iprot.readMessageEnd()
2448 
      raise x
2449 
    result = markOrderDoaRequestAuthorized_result()
2450 
    result.read(self._iprot)
2451 
    self._iprot.readMessageEnd()
2452 
    if result.success is not None:
2453 
      return result.success
2454 
    if result.ex is not None:
2455 
      raise result.ex
2456 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2457 
 
4488 rajveer 2458 
  def markOrderReturnRequestReceived(self, orderId):
2459 
    """
2460 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2461 
 
2462 
    Parameters:
2463 
     - orderId
2464 
    """
2465 
    self.send_markOrderReturnRequestReceived(orderId)
2466 
    return self.recv_markOrderReturnRequestReceived()
2467 
 
2468 
  def send_markOrderReturnRequestReceived(self, orderId):
2469 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2470 
    args = markOrderReturnRequestReceived_args()
2471 
    args.orderId = orderId
2472 
    args.write(self._oprot)
2473 
    self._oprot.writeMessageEnd()
2474 
    self._oprot.trans.flush()
2475 
 
2476 
  def recv_markOrderReturnRequestReceived(self, ):
2477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2478 
    if mtype == TMessageType.EXCEPTION:
2479 
      x = TApplicationException()
2480 
      x.read(self._iprot)
2481 
      self._iprot.readMessageEnd()
2482 
      raise x
2483 
    result = markOrderReturnRequestReceived_result()
2484 
    result.read(self._iprot)
2485 
    self._iprot.readMessageEnd()
2486 
    if result.success is not None:
2487 
      return result.success
2488 
    if result.ex is not None:
2489 
      raise result.ex
2490 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2491 
 
2492 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2493 
    """
2494 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2495 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2496 
 
2497 
    Parameters:
2498 
     - orderId
2499 
     - isAuthorized
2500 
    """
2501 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2502 
    return self.recv_markOrderReturnRequestAuthorized()
2503 
 
2504 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2505 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2506 
    args = markOrderReturnRequestAuthorized_args()
2507 
    args.orderId = orderId
2508 
    args.isAuthorized = isAuthorized
2509 
    args.write(self._oprot)
2510 
    self._oprot.writeMessageEnd()
2511 
    self._oprot.trans.flush()
2512 
 
2513 
  def recv_markOrderReturnRequestAuthorized(self, ):
2514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2515 
    if mtype == TMessageType.EXCEPTION:
2516 
      x = TApplicationException()
2517 
      x.read(self._iprot)
2518 
      self._iprot.readMessageEnd()
2519 
      raise x
2520 
    result = markOrderReturnRequestAuthorized_result()
2521 
    result.read(self._iprot)
2522 
    self._iprot.readMessageEnd()
2523 
    if result.success is not None:
2524 
      return result.success
2525 
    if result.ex is not None:
2526 
      raise result.ex
2527 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2528 
 
4579 rajveer 2529 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2530 
    """
2531 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2532 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2533 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2534 
    For any other status, it returns false.
2535 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2536 
 
2536 chandransh 2537 
    Parameters:
2538 
     - orderId
4579 rajveer 2539 
     - providerId
2536 chandransh 2540 
    """
4579 rajveer 2541 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2542 
    return self.recv_requestPickupNumber()
2543 
 
4579 rajveer 2544 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2545 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2546 
    args = requestPickupNumber_args()
2547 
    args.orderId = orderId
4579 rajveer 2548 
    args.providerId = providerId
2536 chandransh 2549 
    args.write(self._oprot)
2550 
    self._oprot.writeMessageEnd()
2551 
    self._oprot.trans.flush()
2552 
 
2553 
  def recv_requestPickupNumber(self, ):
2554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2555 
    if mtype == TMessageType.EXCEPTION:
2556 
      x = TApplicationException()
2557 
      x.read(self._iprot)
2558 
      self._iprot.readMessageEnd()
2559 
      raise x
2560 
    result = requestPickupNumber_result()
2561 
    result.read(self._iprot)
2562 
    self._iprot.readMessageEnd()
3431 rajveer 2563 
    if result.success is not None:
2536 chandransh 2564 
      return result.success
3431 rajveer 2565 
    if result.ex is not None:
2536 chandransh 2566 
      raise result.ex
2567 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2568 
 
2569 
  def authorizePickup(self, orderId, pickupNumber):
2570 
    """
4452 rajveer 2571 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2572 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2573 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2574 
    	3. Returns true
2591 chandransh 2575 
    If the order is in any other status, it returns false.
2536 chandransh 2576 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2577 
 
2536 chandransh 2578 
    Parameters:
2579 
     - orderId
2580 
     - pickupNumber
2581 
    """
2582 
    self.send_authorizePickup(orderId, pickupNumber)
2583 
    return self.recv_authorizePickup()
2584 
 
2585 
  def send_authorizePickup(self, orderId, pickupNumber):
2586 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2587 
    args = authorizePickup_args()
2588 
    args.orderId = orderId
2589 
    args.pickupNumber = pickupNumber
2590 
    args.write(self._oprot)
2591 
    self._oprot.writeMessageEnd()
2592 
    self._oprot.trans.flush()
2593 
 
2594 
  def recv_authorizePickup(self, ):
2595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2596 
    if mtype == TMessageType.EXCEPTION:
2597 
      x = TApplicationException()
2598 
      x.read(self._iprot)
2599 
      self._iprot.readMessageEnd()
2600 
      raise x
2601 
    result = authorizePickup_result()
2602 
    result.read(self._iprot)
2603 
    self._iprot.readMessageEnd()
3431 rajveer 2604 
    if result.success is not None:
2536 chandransh 2605 
      return result.success
3431 rajveer 2606 
    if result.ex is not None:
2536 chandransh 2607 
      raise result.ex
2608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2609 
 
2764 chandransh 2610 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2611 
    """
2612 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2613 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2614 
 
2764 chandransh 2615 
    Parameters:
2616 
     - providerId
2617 
     - pickupDetails
2618 
    """
2619 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2620 
    return self.recv_markDoasAsPickedUp()
2621 
 
2622 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2623 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2624 
    args = markDoasAsPickedUp_args()
2625 
    args.providerId = providerId
2626 
    args.pickupDetails = pickupDetails
2627 
    args.write(self._oprot)
2628 
    self._oprot.writeMessageEnd()
2629 
    self._oprot.trans.flush()
2630 
 
2631 
  def recv_markDoasAsPickedUp(self, ):
2632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2633 
    if mtype == TMessageType.EXCEPTION:
2634 
      x = TApplicationException()
2635 
      x.read(self._iprot)
2636 
      self._iprot.readMessageEnd()
2637 
      raise x
2638 
    result = markDoasAsPickedUp_result()
2639 
    result.read(self._iprot)
2640 
    self._iprot.readMessageEnd()
3431 rajveer 2641 
    if result.success is not None:
2764 chandransh 2642 
      return result.success
2643 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2644 
 
4479 rajveer 2645 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2646 
    """
4452 rajveer 2647 
    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 2648 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2649 
    If the order is in any other state, it returns false.
2650 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2651 
 
2591 chandransh 2652 
    Parameters:
2653 
     - orderId
4479 rajveer 2654 
     - receiveCondition
2591 chandransh 2655 
    """
4479 rajveer 2656 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2657 
    return self.recv_receiveReturn()
2536 chandransh 2658 
 
4479 rajveer 2659 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2660 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2661 
    args = receiveReturn_args()
2591 chandransh 2662 
    args.orderId = orderId
4479 rajveer 2663 
    args.receiveCondition = receiveCondition
2591 chandransh 2664 
    args.write(self._oprot)
2665 
    self._oprot.writeMessageEnd()
2666 
    self._oprot.trans.flush()
2667 
 
2616 chandransh 2668 
  def recv_receiveReturn(self, ):
2591 chandransh 2669 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2670 
    if mtype == TMessageType.EXCEPTION:
2671 
      x = TApplicationException()
2672 
      x.read(self._iprot)
2673 
      self._iprot.readMessageEnd()
2674 
      raise x
2616 chandransh 2675 
    result = receiveReturn_result()
2591 chandransh 2676 
    result.read(self._iprot)
2677 
    self._iprot.readMessageEnd()
3431 rajveer 2678 
    if result.success is not None:
2591 chandransh 2679 
      return result.success
3431 rajveer 2680 
    if result.ex is not None:
2591 chandransh 2681 
      raise result.ex
2616 chandransh 2682 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2683 
 
2684 
  def validateDoa(self, orderId, isValid):
2685 
    """
4452 rajveer 2686 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2687 
    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 2688 
    If the order is in any other state, it returns false.
2689 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2690 
 
2591 chandransh 2691 
    Parameters:
2692 
     - orderId
2693 
     - isValid
2694 
    """
2695 
    self.send_validateDoa(orderId, isValid)
2696 
    return self.recv_validateDoa()
2697 
 
2698 
  def send_validateDoa(self, orderId, isValid):
2699 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2700 
    args = validateDoa_args()
2701 
    args.orderId = orderId
2702 
    args.isValid = isValid
2703 
    args.write(self._oprot)
2704 
    self._oprot.writeMessageEnd()
2705 
    self._oprot.trans.flush()
2706 
 
2707 
  def recv_validateDoa(self, ):
2708 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2709 
    if mtype == TMessageType.EXCEPTION:
2710 
      x = TApplicationException()
2711 
      x.read(self._iprot)
2712 
      self._iprot.readMessageEnd()
2713 
      raise x
2714 
    result = validateDoa_result()
2715 
    result.read(self._iprot)
2716 
    self._iprot.readMessageEnd()
3431 rajveer 2717 
    if result.success is not None:
2591 chandransh 2718 
      return result.success
3431 rajveer 2719 
    if result.ex is not None:
2591 chandransh 2720 
      raise result.ex
2721 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2722 
 
4495 rajveer 2723 
  def validateReturnProduct(self, orderId, isUsable):
2724 
    """
2725 
    Parameters:
2726 
     - orderId
2727 
     - isUsable
2728 
    """
2729 
    self.send_validateReturnProduct(orderId, isUsable)
2730 
    return self.recv_validateReturnProduct()
2731 
 
2732 
  def send_validateReturnProduct(self, orderId, isUsable):
2733 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2734 
    args = validateReturnProduct_args()
2735 
    args.orderId = orderId
2736 
    args.isUsable = isUsable
2737 
    args.write(self._oprot)
2738 
    self._oprot.writeMessageEnd()
2739 
    self._oprot.trans.flush()
2740 
 
2741 
  def recv_validateReturnProduct(self, ):
2742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2743 
    if mtype == TMessageType.EXCEPTION:
2744 
      x = TApplicationException()
2745 
      x.read(self._iprot)
2746 
      self._iprot.readMessageEnd()
2747 
      raise x
2748 
    result = validateReturnProduct_result()
2749 
    result.read(self._iprot)
2750 
    self._iprot.readMessageEnd()
2751 
    if result.success is not None:
2752 
      return result.success
2753 
    if result.ex is not None:
2754 
      raise result.ex
2755 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2756 
 
2616 chandransh 2757 
  def reshipOrder(self, orderId):
2758 
    """
4484 rajveer 2759 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2760 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2761 
    	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 2762 
 
2763 
    If the order is in DOA_CERT_VALID state, it does the following:
2764 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2765 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2766 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2767 
 
2616 chandransh 2768 
    Returns the id of the newly created order.
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
2774 
    """
2775 
    self.send_reshipOrder(orderId)
2776 
    return self.recv_reshipOrder()
2591 chandransh 2777 
 
2616 chandransh 2778 
  def send_reshipOrder(self, orderId):
2779 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2780 
    args = reshipOrder_args()
2781 
    args.orderId = orderId
2782 
    args.write(self._oprot)
2783 
    self._oprot.writeMessageEnd()
2784 
    self._oprot.trans.flush()
2785 
 
2786 
  def recv_reshipOrder(self, ):
2787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2788 
    if mtype == TMessageType.EXCEPTION:
2789 
      x = TApplicationException()
2790 
      x.read(self._iprot)
2791 
      self._iprot.readMessageEnd()
2792 
      raise x
2793 
    result = reshipOrder_result()
2794 
    result.read(self._iprot)
2795 
    self._iprot.readMessageEnd()
3431 rajveer 2796 
    if result.success is not None:
2616 chandransh 2797 
      return result.success
3431 rajveer 2798 
    if result.ex is not None:
2616 chandransh 2799 
      raise result.ex
2800 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2801 
 
3226 chandransh 2802 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2803 
    """
4484 rajveer 2804 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2805 
    	1. Creates a refund request for batch processing.
2806 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 2807 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2808 
 
2616 chandransh 2809 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2810 
    	1. Creates a refund request for batch processing.
3226 chandransh 2811 
    	2. Cancels the reservation of the item in the warehouse.
2812 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2813 
 
3226 chandransh 2814 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2815 
    	1. Cancels the reservation of the item in the warehouse.
2816 
    	2. Marks the current order as CANCELED.
2817 
 
2818 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2819 
 
2616 chandransh 2820 
    Returns True if it is successful, False otherwise.
3431 rajveer 2821 
 
2616 chandransh 2822 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2823 
 
2616 chandransh 2824 
    Parameters:
2825 
     - orderId
3226 chandransh 2826 
     - refundedBy
2827 
     - reason
2616 chandransh 2828 
    """
3226 chandransh 2829 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2830 
    return self.recv_refundOrder()
2831 
 
3226 chandransh 2832 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2833 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2834 
    args = refundOrder_args()
2835 
    args.orderId = orderId
3226 chandransh 2836 
    args.refundedBy = refundedBy
2837 
    args.reason = reason
2616 chandransh 2838 
    args.write(self._oprot)
2839 
    self._oprot.writeMessageEnd()
2840 
    self._oprot.trans.flush()
2841 
 
2842 
  def recv_refundOrder(self, ):
2843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2844 
    if mtype == TMessageType.EXCEPTION:
2845 
      x = TApplicationException()
2846 
      x.read(self._iprot)
2847 
      self._iprot.readMessageEnd()
2848 
      raise x
2849 
    result = refundOrder_result()
2850 
    result.read(self._iprot)
2851 
    self._iprot.readMessageEnd()
3431 rajveer 2852 
    if result.success is not None:
2616 chandransh 2853 
      return result.success
3431 rajveer 2854 
    if result.ex is not None:
2616 chandransh 2855 
      raise result.ex
2856 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2857 
 
2690 chandransh 2858 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2859 
    """
2860 
    Get all return orders created between the from and to dates for the given warehouse.
2861 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2862 
 
2690 chandransh 2863 
    Parameters:
2864 
     - warehouseId
2865 
     - fromDate
2866 
     - toDate
2867 
    """
2868 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2869 
    return self.recv_getReturnOrders()
2616 chandransh 2870 
 
2690 chandransh 2871 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2872 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2873 
    args = getReturnOrders_args()
2874 
    args.warehouseId = warehouseId
2875 
    args.fromDate = fromDate
2876 
    args.toDate = toDate
2877 
    args.write(self._oprot)
2878 
    self._oprot.writeMessageEnd()
2879 
    self._oprot.trans.flush()
2880 
 
2881 
  def recv_getReturnOrders(self, ):
2882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2883 
    if mtype == TMessageType.EXCEPTION:
2884 
      x = TApplicationException()
2885 
      x.read(self._iprot)
2886 
      self._iprot.readMessageEnd()
2887 
      raise x
2888 
    result = getReturnOrders_result()
2889 
    result.read(self._iprot)
2890 
    self._iprot.readMessageEnd()
3431 rajveer 2891 
    if result.success is not None:
2690 chandransh 2892 
      return result.success
2893 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2894 
 
2700 chandransh 2895 
  def getReturnOrder(self, id):
2896 
    """
2897 
    Returns the ReturnOrder corresponding to the given id.
2898 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2899 
 
2700 chandransh 2900 
    Parameters:
2901 
     - id
2902 
    """
2903 
    self.send_getReturnOrder(id)
2904 
    return self.recv_getReturnOrder()
2905 
 
2906 
  def send_getReturnOrder(self, id):
2907 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2908 
    args = getReturnOrder_args()
2909 
    args.id = id
2910 
    args.write(self._oprot)
2911 
    self._oprot.writeMessageEnd()
2912 
    self._oprot.trans.flush()
2913 
 
2914 
  def recv_getReturnOrder(self, ):
2915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2916 
    if mtype == TMessageType.EXCEPTION:
2917 
      x = TApplicationException()
2918 
      x.read(self._iprot)
2919 
      self._iprot.readMessageEnd()
2920 
      raise x
2921 
    result = getReturnOrder_result()
2922 
    result.read(self._iprot)
2923 
    self._iprot.readMessageEnd()
3431 rajveer 2924 
    if result.success is not None:
2700 chandransh 2925 
      return result.success
3431 rajveer 2926 
    if result.ex is not None:
2700 chandransh 2927 
      raise result.ex
2928 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2929 
 
2690 chandransh 2930 
  def processReturn(self, returnOrderId):
2931 
    """
2932 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2933 
 
2690 chandransh 2934 
    Parameters:
2935 
     - returnOrderId
2936 
    """
2937 
    self.send_processReturn(returnOrderId)
2938 
    self.recv_processReturn()
2939 
 
2940 
  def send_processReturn(self, returnOrderId):
2941 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2942 
    args = processReturn_args()
2943 
    args.returnOrderId = returnOrderId
2944 
    args.write(self._oprot)
2945 
    self._oprot.writeMessageEnd()
2946 
    self._oprot.trans.flush()
2947 
 
2948 
  def recv_processReturn(self, ):
2949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2950 
    if mtype == TMessageType.EXCEPTION:
2951 
      x = TApplicationException()
2952 
      x.read(self._iprot)
2953 
      self._iprot.readMessageEnd()
2954 
      raise x
2955 
    result = processReturn_result()
2956 
    result.read(self._iprot)
2957 
    self._iprot.readMessageEnd()
3431 rajveer 2958 
    if result.ex is not None:
2690 chandransh 2959 
      raise result.ex
2960 
    return
2961 
 
2819 chandransh 2962 
  def createPurchaseOrder(self, warehouseId):
2963 
    """
4586 mandeep.dh 2964 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
2965 
    Returns the list of PO no. of the newly created purchase order.
2966 
    Returns null if no new purchase order had to be created.
3431 rajveer 2967 
 
2819 chandransh 2968 
    Parameters:
2969 
     - warehouseId
2970 
    """
2971 
    self.send_createPurchaseOrder(warehouseId)
2972 
    return self.recv_createPurchaseOrder()
2690 chandransh 2973 
 
2819 chandransh 2974 
  def send_createPurchaseOrder(self, warehouseId):
2975 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2976 
    args = createPurchaseOrder_args()
2977 
    args.warehouseId = warehouseId
2978 
    args.write(self._oprot)
2979 
    self._oprot.writeMessageEnd()
2980 
    self._oprot.trans.flush()
2981 
 
2982 
  def recv_createPurchaseOrder(self, ):
2983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2984 
    if mtype == TMessageType.EXCEPTION:
2985 
      x = TApplicationException()
2986 
      x.read(self._iprot)
2987 
      self._iprot.readMessageEnd()
2988 
      raise x
2989 
    result = createPurchaseOrder_result()
2990 
    result.read(self._iprot)
2991 
    self._iprot.readMessageEnd()
3431 rajveer 2992 
    if result.success is not None:
2819 chandransh 2993 
      return result.success
3431 rajveer 2994 
    if result.ex is not None:
2819 chandransh 2995 
      raise result.ex
2996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2997 
 
3451 chandransh 2998 
  def updateWeight(self, orderId, weight):
2999 
    """
3000 
    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 3001 
 
3451 chandransh 3002 
    Parameters:
3003 
     - orderId
3004 
     - weight
3005 
    """
3006 
    self.send_updateWeight(orderId, weight)
3007 
    return self.recv_updateWeight()
3008 
 
3009 
  def send_updateWeight(self, orderId, weight):
3010 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3011 
    args = updateWeight_args()
3012 
    args.orderId = orderId
3013 
    args.weight = weight
3014 
    args.write(self._oprot)
3015 
    self._oprot.writeMessageEnd()
3016 
    self._oprot.trans.flush()
3017 
 
3018 
  def recv_updateWeight(self, ):
3019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3020 
    if mtype == TMessageType.EXCEPTION:
3021 
      x = TApplicationException()
3022 
      x.read(self._iprot)
3023 
      self._iprot.readMessageEnd()
3024 
      raise x
3025 
    result = updateWeight_result()
3026 
    result.read(self._iprot)
3027 
    self._iprot.readMessageEnd()
3028 
    if result.success is not None:
3029 
      return result.success
3030 
    if result.ex is not None:
3031 
      raise result.ex
3032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3033 
 
3469 chandransh 3034 
  def changeItem(self, orderId, itemId):
3035 
    """
3036 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3037 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3038 
 
3469 chandransh 3039 
    Parameters:
3040 
     - orderId
3041 
     - itemId
3042 
    """
3043 
    self.send_changeItem(orderId, itemId)
3044 
    return self.recv_changeItem()
3045 
 
3046 
  def send_changeItem(self, orderId, itemId):
3047 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3048 
    args = changeItem_args()
3049 
    args.orderId = orderId
3050 
    args.itemId = itemId
3051 
    args.write(self._oprot)
3052 
    self._oprot.writeMessageEnd()
3053 
    self._oprot.trans.flush()
3054 
 
3055 
  def recv_changeItem(self, ):
3056 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3057 
    if mtype == TMessageType.EXCEPTION:
3058 
      x = TApplicationException()
3059 
      x.read(self._iprot)
3060 
      self._iprot.readMessageEnd()
3061 
      raise x
3062 
    result = changeItem_result()
3063 
    result.read(self._iprot)
3064 
    self._iprot.readMessageEnd()
3065 
    if result.success is not None:
3066 
      return result.success
3067 
    if result.ex is not None:
3068 
      raise result.ex
3069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3070 
 
3071 
  def shiftToWarehouse(self, orderId, warehouseId):
3072 
    """
3073 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3074 
 
3075 
    Parameters:
3076 
     - orderId
3077 
     - warehouseId
3078 
    """
3079 
    self.send_shiftToWarehouse(orderId, warehouseId)
3080 
    return self.recv_shiftToWarehouse()
3081 
 
3082 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3083 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3084 
    args = shiftToWarehouse_args()
3085 
    args.orderId = orderId
3086 
    args.warehouseId = warehouseId
3087 
    args.write(self._oprot)
3088 
    self._oprot.writeMessageEnd()
3089 
    self._oprot.trans.flush()
3090 
 
3091 
  def recv_shiftToWarehouse(self, ):
3092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3093 
    if mtype == TMessageType.EXCEPTION:
3094 
      x = TApplicationException()
3095 
      x.read(self._iprot)
3096 
      self._iprot.readMessageEnd()
3097 
      raise x
3098 
    result = shiftToWarehouse_result()
3099 
    result.read(self._iprot)
3100 
    self._iprot.readMessageEnd()
3101 
    if result.success is not None:
3102 
      return result.success
3103 
    if result.ex is not None:
3104 
      raise result.ex
3105 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3106 
 
3986 chandransh 3107 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3108 
    """
3109 
    Adds the given delay reason to the given order.
3986 chandransh 3110 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3111 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3112 
 
3553 chandransh 3113 
    Parameters:
3114 
     - orderId
3115 
     - delayReason
3986 chandransh 3116 
     - furtherDelay
3553 chandransh 3117 
    """
3986 chandransh 3118 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 3119 
    return self.recv_addDelayReason()
3120 
 
3986 chandransh 3121 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3122 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3123 
    args = addDelayReason_args()
3124 
    args.orderId = orderId
3125 
    args.delayReason = delayReason
3986 chandransh 3126 
    args.furtherDelay = furtherDelay
3553 chandransh 3127 
    args.write(self._oprot)
3128 
    self._oprot.writeMessageEnd()
3129 
    self._oprot.trans.flush()
3130 
 
3131 
  def recv_addDelayReason(self, ):
3132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3133 
    if mtype == TMessageType.EXCEPTION:
3134 
      x = TApplicationException()
3135 
      x.read(self._iprot)
3136 
      self._iprot.readMessageEnd()
3137 
      raise x
3138 
    result = addDelayReason_result()
3139 
    result.read(self._iprot)
3140 
    self._iprot.readMessageEnd()
3141 
    if result.success is not None:
3142 
      return result.success
3143 
    if result.ex is not None:
3144 
      raise result.ex
3145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3146 
 
3956 chandransh 3147 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3148 
    """
3149 
    Marks the COD orders with given AWB nos. as having been processed.
3150 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3151 
 
3956 chandransh 3152 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3153 
    1. There is no order corresponding to an AWB number.
3154 
    2. The captured amount for a payment exceeds the total payment.
3155 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3156 
 
3157 
    Parameters:
3158 
     - collectedAmountMap
3159 
     - xferBy
3160 
     - xferTxnId
3161 
     - xferDate
3162 
    """
3163 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3164 
    return self.recv_reconcileCodCollection()
3165 
 
3166 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3167 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3168 
    args = reconcileCodCollection_args()
3169 
    args.collectedAmountMap = collectedAmountMap
3170 
    args.xferBy = xferBy
3171 
    args.xferTxnId = xferTxnId
3172 
    args.xferDate = xferDate
3173 
    args.write(self._oprot)
3174 
    self._oprot.writeMessageEnd()
3175 
    self._oprot.trans.flush()
3176 
 
3177 
  def recv_reconcileCodCollection(self, ):
3178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3179 
    if mtype == TMessageType.EXCEPTION:
3180 
      x = TApplicationException()
3181 
      x.read(self._iprot)
3182 
      self._iprot.readMessageEnd()
3183 
      raise x
3184 
    result = reconcileCodCollection_result()
3185 
    result.read(self._iprot)
3186 
    self._iprot.readMessageEnd()
3187 
    if result.success is not None:
3188 
      return result.success
3189 
    if result.ex is not None:
3190 
      raise result.ex
3191 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3192 
 
4008 mandeep.dh 3193 
  def getTransactionsRequiringExtraProcessing(self, category):
3194 
    """
4065 mandeep.dh 3195 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3196 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3197 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3198 
 
4008 mandeep.dh 3199 
    Parameters:
3200 
     - category
3201 
    """
3202 
    self.send_getTransactionsRequiringExtraProcessing(category)
3203 
    return self.recv_getTransactionsRequiringExtraProcessing()
3204 
 
3205 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3206 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3207 
    args = getTransactionsRequiringExtraProcessing_args()
3208 
    args.category = category
3209 
    args.write(self._oprot)
3210 
    self._oprot.writeMessageEnd()
3211 
    self._oprot.trans.flush()
3212 
 
3213 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3215 
    if mtype == TMessageType.EXCEPTION:
3216 
      x = TApplicationException()
3217 
      x.read(self._iprot)
3218 
      self._iprot.readMessageEnd()
3219 
      raise x
3220 
    result = getTransactionsRequiringExtraProcessing_result()
3221 
    result.read(self._iprot)
3222 
    self._iprot.readMessageEnd()
3223 
    if result.success is not None:
3224 
      return result.success
3225 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3226 
 
3227 
  def markTransactionAsProcessed(self, transactionId, category):
3228 
    """
3229 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3230 
    It essentially deletes the transaction id record for a particular
3231 
    processing type category (if present) from DB.
3232 
    This is currently used by CRM application.
4008 mandeep.dh 3233 
 
3234 
    Parameters:
3235 
     - transactionId
3236 
     - category
3237 
    """
3238 
    self.send_markTransactionAsProcessed(transactionId, category)
3239 
    self.recv_markTransactionAsProcessed()
3240 
 
3241 
  def send_markTransactionAsProcessed(self, transactionId, category):
3242 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3243 
    args = markTransactionAsProcessed_args()
3244 
    args.transactionId = transactionId
3245 
    args.category = category
3246 
    args.write(self._oprot)
3247 
    self._oprot.writeMessageEnd()
3248 
    self._oprot.trans.flush()
3249 
 
3250 
  def recv_markTransactionAsProcessed(self, ):
3251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3252 
    if mtype == TMessageType.EXCEPTION:
3253 
      x = TApplicationException()
3254 
      x.read(self._iprot)
3255 
      self._iprot.readMessageEnd()
3256 
      raise x
3257 
    result = markTransactionAsProcessed_result()
3258 
    result.read(self._iprot)
3259 
    self._iprot.readMessageEnd()
3260 
    return
3261 
 
4018 chandransh 3262 
  def getItemWiseRiskyOrdersCount(self, ):
3263 
    """
3264 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3265 
    is defined as one whose shipping date is about to expire.
3266 
    """
3267 
    self.send_getItemWiseRiskyOrdersCount()
3268 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3269 
 
4018 chandransh 3270 
  def send_getItemWiseRiskyOrdersCount(self, ):
3271 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3272 
    args = getItemWiseRiskyOrdersCount_args()
3273 
    args.write(self._oprot)
3274 
    self._oprot.writeMessageEnd()
3275 
    self._oprot.trans.flush()
3276 
 
3277 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3279 
    if mtype == TMessageType.EXCEPTION:
3280 
      x = TApplicationException()
3281 
      x.read(self._iprot)
3282 
      self._iprot.readMessageEnd()
3283 
      raise x
3284 
    result = getItemWiseRiskyOrdersCount_result()
3285 
    result.read(self._iprot)
3286 
    self._iprot.readMessageEnd()
3287 
    if result.success is not None:
3288 
      return result.success
3289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3290 
 
4295 varun.gupt 3291 
  def getOrdersForItemIds(self, itemIds):
3292 
    """
3293 
    Returns a list of all orders which have items with given id
3294 
 
3295 
    Parameters:
3296 
     - itemIds
3297 
    """
3298 
    self.send_getOrdersForItemIds(itemIds)
3299 
    return self.recv_getOrdersForItemIds()
3300 
 
3301 
  def send_getOrdersForItemIds(self, itemIds):
3302 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3303 
    args = getOrdersForItemIds_args()
3304 
    args.itemIds = itemIds
3305 
    args.write(self._oprot)
3306 
    self._oprot.writeMessageEnd()
3307 
    self._oprot.trans.flush()
3308 
 
3309 
  def recv_getOrdersForItemIds(self, ):
3310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3311 
    if mtype == TMessageType.EXCEPTION:
3312 
      x = TApplicationException()
3313 
      x.read(self._iprot)
3314 
      self._iprot.readMessageEnd()
3315 
      raise x
3316 
    result = getOrdersForItemIds_result()
3317 
    result.read(self._iprot)
3318 
    self._iprot.readMessageEnd()
3319 
    if result.success is not None:
3320 
      return result.success
3321 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3322 
 
4247 rajveer 3323 
  def markOrderCancellationRequestReceived(self, orderId):
3324 
    """
3325 
    Mark order as cancellation request received. If customer sends request of cancellation of
3326 
    a particular order, this method will be called. It will just change status of the order
3327 
    depending on its current status. It also records the previous status, so that we can move
3328 
    back to that status if cancellation request is denied.
4018 chandransh 3329 
 
4247 rajveer 3330 
    Parameters:
3331 
     - orderId
3332 
    """
3333 
    self.send_markOrderCancellationRequestReceived(orderId)
3334 
    self.recv_markOrderCancellationRequestReceived()
3335 
 
3336 
  def send_markOrderCancellationRequestReceived(self, orderId):
3337 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3338 
    args = markOrderCancellationRequestReceived_args()
3339 
    args.orderId = orderId
3340 
    args.write(self._oprot)
3341 
    self._oprot.writeMessageEnd()
3342 
    self._oprot.trans.flush()
3343 
 
3344 
  def recv_markOrderCancellationRequestReceived(self, ):
3345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3346 
    if mtype == TMessageType.EXCEPTION:
3347 
      x = TApplicationException()
3348 
      x.read(self._iprot)
3349 
      self._iprot.readMessageEnd()
3350 
      raise x
3351 
    result = markOrderCancellationRequestReceived_result()
3352 
    result.read(self._iprot)
3353 
    self._iprot.readMessageEnd()
3354 
    if result.ex is not None:
3355 
      raise result.ex
3356 
    return
3357 
 
3358 
  def markOrderCancellationRequestConfirmed(self, orderId):
3359 
    """
3360 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3361 
    cancellation request confirmed. After this OM will be able to cancel the order.
3362 
 
3363 
    Parameters:
3364 
     - orderId
3365 
    """
3366 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3367 
    self.recv_markOrderCancellationRequestConfirmed()
3368 
 
3369 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3370 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3371 
    args = markOrderCancellationRequestConfirmed_args()
3372 
    args.orderId = orderId
3373 
    args.write(self._oprot)
3374 
    self._oprot.writeMessageEnd()
3375 
    self._oprot.trans.flush()
3376 
 
3377 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3379 
    if mtype == TMessageType.EXCEPTION:
3380 
      x = TApplicationException()
3381 
      x.read(self._iprot)
3382 
      self._iprot.readMessageEnd()
3383 
      raise x
3384 
    result = markOrderCancellationRequestConfirmed_result()
3385 
    result.read(self._iprot)
3386 
    self._iprot.readMessageEnd()
3387 
    if result.ex is not None:
3388 
      raise result.ex
3389 
    return
3390 
 
3391 
  def markOrderCancellationRequestDenied(self, orderId):
3392 
    """
3393 
    If we decide to not to cancel order, we will move the order ro previous status.
3394 
 
3395 
    Parameters:
3396 
     - orderId
3397 
    """
3398 
    self.send_markOrderCancellationRequestDenied(orderId)
3399 
    self.recv_markOrderCancellationRequestDenied()
3400 
 
3401 
  def send_markOrderCancellationRequestDenied(self, orderId):
3402 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3403 
    args = markOrderCancellationRequestDenied_args()
3404 
    args.orderId = orderId
3405 
    args.write(self._oprot)
3406 
    self._oprot.writeMessageEnd()
3407 
    self._oprot.trans.flush()
3408 
 
3409 
  def recv_markOrderCancellationRequestDenied(self, ):
3410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3411 
    if mtype == TMessageType.EXCEPTION:
3412 
      x = TApplicationException()
3413 
      x.read(self._iprot)
3414 
      self._iprot.readMessageEnd()
3415 
      raise x
3416 
    result = markOrderCancellationRequestDenied_result()
3417 
    result.read(self._iprot)
3418 
    self._iprot.readMessageEnd()
3419 
    if result.ex is not None:
3420 
      raise result.ex
3421 
    return
3422 
 
4258 rajveer 3423 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3424 
    """
4258 rajveer 3425 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3426 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3427 
 
3428 
    Parameters:
4258 rajveer 3429 
     - transactionId
4247 rajveer 3430 
    """
4258 rajveer 3431 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3432 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3433 
 
4258 rajveer 3434 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3435 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3436 
    args = markTransactionAsPaymentFlagRemoved_args()
3437 
    args.transactionId = transactionId
4247 rajveer 3438 
    args.write(self._oprot)
3439 
    self._oprot.writeMessageEnd()
3440 
    self._oprot.trans.flush()
3441 
 
4258 rajveer 3442 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3443 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3444 
    if mtype == TMessageType.EXCEPTION:
3445 
      x = TApplicationException()
3446 
      x.read(self._iprot)
3447 
      self._iprot.readMessageEnd()
3448 
      raise x
4258 rajveer 3449 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3450 
    result.read(self._iprot)
3451 
    self._iprot.readMessageEnd()
3452 
    if result.ex is not None:
3453 
      raise result.ex
3454 
    return
3455 
 
4259 anupam.sin 3456 
  def refundTransaction(self, transactionId, refundedBy, reason):
3457 
    """
3458 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3459 
    need to be cancelled
4247 rajveer 3460 
 
4259 anupam.sin 3461 
    Parameters:
3462 
     - transactionId
3463 
     - refundedBy
3464 
     - reason
3465 
    """
3466 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3467 
    self.recv_refundTransaction()
3468 
 
3469 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3470 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3471 
    args = refundTransaction_args()
3472 
    args.transactionId = transactionId
3473 
    args.refundedBy = refundedBy
3474 
    args.reason = reason
3475 
    args.write(self._oprot)
3476 
    self._oprot.writeMessageEnd()
3477 
    self._oprot.trans.flush()
3478 
 
3479 
  def recv_refundTransaction(self, ):
3480 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3481 
    if mtype == TMessageType.EXCEPTION:
3482 
      x = TApplicationException()
3483 
      x.read(self._iprot)
3484 
      self._iprot.readMessageEnd()
3485 
      raise x
3486 
    result = refundTransaction_result()
3487 
    result.read(self._iprot)
3488 
    self._iprot.readMessageEnd()
3489 
    if result.ex is not None:
3490 
      raise result.ex
3491 
    return
3492 
 
4324 mandeep.dh 3493 
  def updateShipmentAddress(self, orderId, addressId):
3494 
    """
3495 
    Updates shipment address of an order. Delivery and shipping date estimates
3496 
    etc. are also updated here.
3497 
 
3498 
    Throws TransactionServiceException in case address change is not
3499 
    possible due to certain reasons such as new pincode in address is
3500 
    not serviceable etc.
3501 
 
3502 
    Parameters:
3503 
     - orderId
3504 
     - addressId
3505 
    """
3506 
    self.send_updateShipmentAddress(orderId, addressId)
3507 
    self.recv_updateShipmentAddress()
3508 
 
3509 
  def send_updateShipmentAddress(self, orderId, addressId):
3510 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3511 
    args = updateShipmentAddress_args()
3512 
    args.orderId = orderId
3513 
    args.addressId = addressId
3514 
    args.write(self._oprot)
3515 
    self._oprot.writeMessageEnd()
3516 
    self._oprot.trans.flush()
3517 
 
3518 
  def recv_updateShipmentAddress(self, ):
3519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3520 
    if mtype == TMessageType.EXCEPTION:
3521 
      x = TApplicationException()
3522 
      x.read(self._iprot)
3523 
      self._iprot.readMessageEnd()
3524 
      raise x
3525 
    result = updateShipmentAddress_result()
3526 
    result.read(self._iprot)
3527 
    self._iprot.readMessageEnd()
3528 
    if result.ex is not None:
3529 
      raise result.ex
3530 
    return
3531 
 
4285 rajveer 3532 
  def acceptOrdersForItemId(self, itemId, inventory):
3533 
    """
3534 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3535 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3536 
 
4285 rajveer 3537 
    Parameters:
3538 
     - itemId
3539 
     - inventory
3540 
    """
3541 
    self.send_acceptOrdersForItemId(itemId, inventory)
3542 
    return self.recv_acceptOrdersForItemId()
3543 
 
3544 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3545 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3546 
    args = acceptOrdersForItemId_args()
3547 
    args.itemId = itemId
3548 
    args.inventory = inventory
3549 
    args.write(self._oprot)
3550 
    self._oprot.writeMessageEnd()
3551 
    self._oprot.trans.flush()
3552 
 
3553 
  def recv_acceptOrdersForItemId(self, ):
3554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3555 
    if mtype == TMessageType.EXCEPTION:
3556 
      x = TApplicationException()
3557 
      x.read(self._iprot)
3558 
      self._iprot.readMessageEnd()
3559 
      raise x
3560 
    result = acceptOrdersForItemId_result()
3561 
    result.read(self._iprot)
3562 
    self._iprot.readMessageEnd()
3563 
    if result.success is not None:
3564 
      return result.success
3565 
    if result.ex is not None:
3566 
      raise result.ex
3567 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3568 
 
4369 rajveer 3569 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3570 
    """
3571 
    Parameters:
3572 
     - vendorId
3573 
     - itemId
3574 
     - quantity
3575 
     - estimate
4369 rajveer 3576 
     - isReminder
4303 rajveer 3577 
    """
4369 rajveer 3578 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3579 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3580 
 
4369 rajveer 3581 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3582 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3583 
    args = markOrdersAsPORaised_args()
3584 
    args.vendorId = vendorId
3585 
    args.itemId = itemId
3586 
    args.quantity = quantity
3587 
    args.estimate = estimate
4369 rajveer 3588 
    args.isReminder = isReminder
4303 rajveer 3589 
    args.write(self._oprot)
3590 
    self._oprot.writeMessageEnd()
3591 
    self._oprot.trans.flush()
3592 
 
3593 
  def recv_markOrdersAsPORaised(self, ):
3594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3595 
    if mtype == TMessageType.EXCEPTION:
3596 
      x = TApplicationException()
3597 
      x.read(self._iprot)
3598 
      self._iprot.readMessageEnd()
3599 
      raise x
3600 
    result = markOrdersAsPORaised_result()
3601 
    result.read(self._iprot)
3602 
    self._iprot.readMessageEnd()
3603 
    if result.ex is not None:
3604 
      raise result.ex
3605 
    return
3606 
 
4369 rajveer 3607 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3608 
    """
3609 
    Parameters:
3610 
     - vendorId
3611 
     - itemId
3612 
     - quantity
3613 
     - estimate
4369 rajveer 3614 
     - isReminder
4303 rajveer 3615 
    """
4369 rajveer 3616 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3617 
    self.recv_markOrdersAsReversalInitiated()
3618 
 
4369 rajveer 3619 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3620 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3621 
    args = markOrdersAsReversalInitiated_args()
3622 
    args.vendorId = vendorId
3623 
    args.itemId = itemId
3624 
    args.quantity = quantity
3625 
    args.estimate = estimate
4369 rajveer 3626 
    args.isReminder = isReminder
4303 rajveer 3627 
    args.write(self._oprot)
3628 
    self._oprot.writeMessageEnd()
3629 
    self._oprot.trans.flush()
3630 
 
3631 
  def recv_markOrdersAsReversalInitiated(self, ):
3632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3633 
    if mtype == TMessageType.EXCEPTION:
3634 
      x = TApplicationException()
3635 
      x.read(self._iprot)
3636 
      self._iprot.readMessageEnd()
3637 
      raise x
3638 
    result = markOrdersAsReversalInitiated_result()
3639 
    result.read(self._iprot)
3640 
    self._iprot.readMessageEnd()
3641 
    if result.ex is not None:
3642 
      raise result.ex
3643 
    return
3644 
 
4369 rajveer 3645 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3646 
    """
3647 
    Parameters:
3648 
     - vendorId
3649 
     - itemId
3650 
     - quantity
3651 
     - estimate
4369 rajveer 3652 
     - isReminder
4303 rajveer 3653 
    """
4369 rajveer 3654 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3655 
    self.recv_markOrdersAsNotAvailabke()
3656 
 
4369 rajveer 3657 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3658 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3659 
    args = markOrdersAsNotAvailabke_args()
3660 
    args.vendorId = vendorId
3661 
    args.itemId = itemId
3662 
    args.quantity = quantity
3663 
    args.estimate = estimate
4369 rajveer 3664 
    args.isReminder = isReminder
4303 rajveer 3665 
    args.write(self._oprot)
3666 
    self._oprot.writeMessageEnd()
3667 
    self._oprot.trans.flush()
3668 
 
3669 
  def recv_markOrdersAsNotAvailabke(self, ):
3670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3671 
    if mtype == TMessageType.EXCEPTION:
3672 
      x = TApplicationException()
3673 
      x.read(self._iprot)
3674 
      self._iprot.readMessageEnd()
3675 
      raise x
3676 
    result = markOrdersAsNotAvailabke_result()
3677 
    result.read(self._iprot)
3678 
    self._iprot.readMessageEnd()
3679 
    if result.ex is not None:
3680 
      raise result.ex
3681 
    return
3682 
 
4369 rajveer 3683 
  def markOrdersAsTimeout(self, vendorId):
3684 
    """
3685 
    Parameters:
3686 
     - vendorId
3687 
    """
3688 
    self.send_markOrdersAsTimeout(vendorId)
3689 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3690 
 
4369 rajveer 3691 
  def send_markOrdersAsTimeout(self, vendorId):
3692 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3693 
    args = markOrdersAsTimeout_args()
3694 
    args.vendorId = vendorId
3695 
    args.write(self._oprot)
3696 
    self._oprot.writeMessageEnd()
3697 
    self._oprot.trans.flush()
3698 
 
3699 
  def recv_markOrdersAsTimeout(self, ):
3700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3701 
    if mtype == TMessageType.EXCEPTION:
3702 
      x = TApplicationException()
3703 
      x.read(self._iprot)
3704 
      self._iprot.readMessageEnd()
3705 
      raise x
3706 
    result = markOrdersAsTimeout_result()
3707 
    result.read(self._iprot)
3708 
    self._iprot.readMessageEnd()
3709 
    if result.success is not None:
3710 
      return result.success
3711 
    if result.ex is not None:
3712 
      raise result.ex
3713 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3714 
 
4386 anupam.sin 3715 
  def getOrderForAwb(self, awb):
3716 
    """
3717 
    Returns the order corresponding to an AWB number
4369 rajveer 3718 
 
4386 anupam.sin 3719 
    Parameters:
3720 
     - awb
3721 
    """
3722 
    self.send_getOrderForAwb(awb)
3723 
    return self.recv_getOrderForAwb()
3724 
 
3725 
  def send_getOrderForAwb(self, awb):
3726 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3727 
    args = getOrderForAwb_args()
3728 
    args.awb = awb
3729 
    args.write(self._oprot)
3730 
    self._oprot.writeMessageEnd()
3731 
    self._oprot.trans.flush()
3732 
 
3733 
  def recv_getOrderForAwb(self, ):
3734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3735 
    if mtype == TMessageType.EXCEPTION:
3736 
      x = TApplicationException()
3737 
      x.read(self._iprot)
3738 
      self._iprot.readMessageEnd()
3739 
      raise x
3740 
    result = getOrderForAwb_result()
3741 
    result.read(self._iprot)
3742 
    self._iprot.readMessageEnd()
3743 
    if result.success is not None:
3744 
      return result.success
3745 
    if result.ex is not None:
3746 
      raise result.ex
3747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3748 
 
4506 phani.kuma 3749 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3750 
    """
3751 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3752 
 
4506 phani.kuma 3753 
    Parameters:
3754 
     - logistics_provider_id
3755 
     - order_status
3756 
    """
3757 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
3758 
    return self.recv_getOrdersForProviderForStatus()
3759 
 
3760 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3761 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
3762 
    args = getOrdersForProviderForStatus_args()
3763 
    args.logistics_provider_id = logistics_provider_id
3764 
    args.order_status = order_status
3765 
    args.write(self._oprot)
3766 
    self._oprot.writeMessageEnd()
3767 
    self._oprot.trans.flush()
3768 
 
3769 
  def recv_getOrdersForProviderForStatus(self, ):
3770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3771 
    if mtype == TMessageType.EXCEPTION:
3772 
      x = TApplicationException()
3773 
      x.read(self._iprot)
3774 
      self._iprot.readMessageEnd()
3775 
      raise x
3776 
    result = getOrdersForProviderForStatus_result()
3777 
    result.read(self._iprot)
3778 
    self._iprot.readMessageEnd()
3779 
    if result.success is not None:
3780 
      return result.success
3781 
    if result.ex is not None:
3782 
      raise result.ex
3783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
3784 
 
3785 
 
3376 rajveer 3786 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3787 
  def __init__(self, handler):
3376 rajveer 3788 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3789 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3790 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3791 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3792 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3793 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3794 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3795 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3796 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3797 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3798 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3799 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3800 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3801 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3802 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3803 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3804 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3805 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3806 
    self._processMap["createOrder"] = Processor.process_createOrder
3807 
    self._processMap["getOrder"] = Processor.process_getOrder
3808 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3809 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3810 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 3811 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 3812 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 3813 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3814 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3815 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3816 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3817 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3818 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3819 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3820 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3821 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 3822 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 3823 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 3824 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 3825 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3826 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3827 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3828 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3829 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3830 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4454 rajveer 3831 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
3832 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 3833 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
3834 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 3835 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3836 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3837 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3838 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3839 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 3840 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 3841 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3842 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3843 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3844 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3845 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3846 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3847 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3848 
    self._processMap["changeItem"] = Processor.process_changeItem
3849 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3850 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3851 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3852 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3853 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3854 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 3855 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 3856 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3857 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3858 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3859 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3860 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 3861 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 3862 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 3863 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
3864 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
3865 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 3866 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4386 anupam.sin 3867 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 3868 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
94 ashish 3869 
 
3870 
  def process(self, iprot, oprot):
3871 
    (name, type, seqid) = iprot.readMessageBegin()
3872 
    if name not in self._processMap:
3873 
      iprot.skip(TType.STRUCT)
3874 
      iprot.readMessageEnd()
3875 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3876 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3877 
      x.write(oprot)
3878 
      oprot.writeMessageEnd()
3879 
      oprot.trans.flush()
3880 
      return
3881 
    else:
3882 
      self._processMap[name](self, seqid, iprot, oprot)
3883 
    return True
3884 
 
3885 
  def process_createTransaction(self, seqid, iprot, oprot):
3886 
    args = createTransaction_args()
3887 
    args.read(iprot)
3888 
    iprot.readMessageEnd()
3889 
    result = createTransaction_result()
3890 
    try:
132 ashish 3891 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3892 
    except TransactionServiceException, ex:
3893 
      result.ex = ex
3894 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3895 
    result.write(oprot)
3896 
    oprot.writeMessageEnd()
3897 
    oprot.trans.flush()
3898 
 
3899 
  def process_getTransaction(self, seqid, iprot, oprot):
3900 
    args = getTransaction_args()
3901 
    args.read(iprot)
3902 
    iprot.readMessageEnd()
3903 
    result = getTransaction_result()
3904 
    try:
3905 
      result.success = self._handler.getTransaction(args.id)
3906 
    except TransactionServiceException, ex:
3907 
      result.ex = ex
3908 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3909 
    result.write(oprot)
3910 
    oprot.writeMessageEnd()
3911 
    oprot.trans.flush()
3912 
 
3913 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3914 
    args = getTransactionsForCustomer_args()
3915 
    args.read(iprot)
3916 
    iprot.readMessageEnd()
3917 
    result = getTransactionsForCustomer_result()
3918 
    try:
3919 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3920 
    except TransactionServiceException, ex:
3921 
      result.ex = ex
3922 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3923 
    result.write(oprot)
3924 
    oprot.writeMessageEnd()
3925 
    oprot.trans.flush()
3926 
 
132 ashish 3927 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3928 
    args = getTransactionsForShoppingCartId_args()
3929 
    args.read(iprot)
3930 
    iprot.readMessageEnd()
3931 
    result = getTransactionsForShoppingCartId_result()
3932 
    try:
3933 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3934 
    except TransactionServiceException, ex:
3935 
      result.ex = ex
3936 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3937 
    result.write(oprot)
3938 
    oprot.writeMessageEnd()
3939 
    oprot.trans.flush()
3940 
 
94 ashish 3941 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3942 
    args = getTransactionStatus_args()
3943 
    args.read(iprot)
3944 
    iprot.readMessageEnd()
3945 
    result = getTransactionStatus_result()
3946 
    try:
3947 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3948 
    except TransactionServiceException, ex:
3949 
      result.ex = ex
3950 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3951 
    result.write(oprot)
3952 
    oprot.writeMessageEnd()
3953 
    oprot.trans.flush()
3954 
 
3955 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3956 
    args = changeTransactionStatus_args()
3957 
    args.read(iprot)
3958 
    iprot.readMessageEnd()
3959 
    result = changeTransactionStatus_result()
3960 
    try:
3961 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3962 
    except TransactionServiceException, ex:
3963 
      result.ex = ex
3964 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3965 
    result.write(oprot)
3966 
    oprot.writeMessageEnd()
3967 
    oprot.trans.flush()
3968 
 
1398 varun.gupt 3969 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3970 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3971 
    args.read(iprot)
3972 
    iprot.readMessageEnd()
1398 varun.gupt 3973 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3974 
    try:
1398 varun.gupt 3975 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3976 
    except TransactionServiceException, ex:
3977 
      result.ex = ex
1398 varun.gupt 3978 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3979 
    result.write(oprot)
3980 
    oprot.writeMessageEnd()
3981 
    oprot.trans.flush()
3982 
 
483 rajveer 3983 
  def process_getAllOrders(self, seqid, iprot, oprot):
3984 
    args = getAllOrders_args()
94 ashish 3985 
    args.read(iprot)
3986 
    iprot.readMessageEnd()
483 rajveer 3987 
    result = getAllOrders_result()
94 ashish 3988 
    try:
483 rajveer 3989 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3990 
    except TransactionServiceException, ex:
3991 
      result.ex = ex
483 rajveer 3992 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3993 
    result.write(oprot)
3994 
    oprot.writeMessageEnd()
3995 
    oprot.trans.flush()
3996 
 
4133 chandransh 3997 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3998 
    args = getOrdersInBatch_args()
3999 
    args.read(iprot)
4000 
    iprot.readMessageEnd()
4001 
    result = getOrdersInBatch_result()
4002 
    try:
4003 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4004 
    except TransactionServiceException, ex:
4005 
      result.ex = ex
4006 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4007 
    result.write(oprot)
4008 
    oprot.writeMessageEnd()
4009 
    oprot.trans.flush()
4010 
 
4011 
  def process_getOrderCount(self, seqid, iprot, oprot):
4012 
    args = getOrderCount_args()
4013 
    args.read(iprot)
4014 
    iprot.readMessageEnd()
4015 
    result = getOrderCount_result()
4016 
    try:
4017 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4018 
    except TransactionServiceException, ex:
4019 
      result.ex = ex
4020 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4021 
    result.write(oprot)
4022 
    oprot.writeMessageEnd()
4023 
    oprot.trans.flush()
4024 
 
999 varun.gupt 4025 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4026 
    args = getOrdersByBillingDate_args()
4027 
    args.read(iprot)
4028 
    iprot.readMessageEnd()
4029 
    result = getOrdersByBillingDate_result()
4030 
    try:
4031 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4032 
    except TransactionServiceException, ex:
4033 
      result.ex = ex
4034 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4035 
    result.write(oprot)
4036 
    oprot.writeMessageEnd()
4037 
    oprot.trans.flush()
4038 
 
3427 chandransh 4039 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4040 
    args = getOrdersByShippingDate_args()
4041 
    args.read(iprot)
4042 
    iprot.readMessageEnd()
4043 
    result = getOrdersByShippingDate_result()
4044 
    try:
3451 chandransh 4045 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4046 
    except TransactionServiceException, ex:
4047 
      result.ex = ex
4048 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4049 
    result.write(oprot)
4050 
    oprot.writeMessageEnd()
4051 
    oprot.trans.flush()
4052 
 
1382 varun.gupt 4053 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4054 
    args = getReturnableOrdersForCustomer_args()
4055 
    args.read(iprot)
4056 
    iprot.readMessageEnd()
4057 
    result = getReturnableOrdersForCustomer_result()
4058 
    try:
4059 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4060 
    except TransactionServiceException, ex:
4061 
      result.ex = ex
4062 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4063 
    result.write(oprot)
4064 
    oprot.writeMessageEnd()
4065 
    oprot.trans.flush()
4066 
 
4067 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4068 
    args = getCancellableOrdersForCustomer_args()
4069 
    args.read(iprot)
4070 
    iprot.readMessageEnd()
4071 
    result = getCancellableOrdersForCustomer_result()
4072 
    try:
4073 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4074 
    except TransactionServiceException, ex:
4075 
      result.ex = ex
4076 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4077 
    result.write(oprot)
4078 
    oprot.writeMessageEnd()
4079 
    oprot.trans.flush()
4080 
 
483 rajveer 4081 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4082 
    args = changeOrderStatus_args()
94 ashish 4083 
    args.read(iprot)
4084 
    iprot.readMessageEnd()
483 rajveer 4085 
    result = changeOrderStatus_result()
94 ashish 4086 
    try:
483 rajveer 4087 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4088 
    except TransactionServiceException, ex:
4089 
      result.ex = ex
483 rajveer 4090 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4091 
    result.write(oprot)
4092 
    oprot.writeMessageEnd()
4093 
    oprot.trans.flush()
4094 
 
483 rajveer 4095 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4096 
    args = getOrdersForTransaction_args()
94 ashish 4097 
    args.read(iprot)
4098 
    iprot.readMessageEnd()
483 rajveer 4099 
    result = getOrdersForTransaction_result()
94 ashish 4100 
    try:
1528 ankur.sing 4101 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4102 
    except TransactionServiceException, ex:
4103 
      result.ex = ex
483 rajveer 4104 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4105 
    result.write(oprot)
4106 
    oprot.writeMessageEnd()
4107 
    oprot.trans.flush()
4108 
 
483 rajveer 4109 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4110 
    args = getOrdersForCustomer_args()
94 ashish 4111 
    args.read(iprot)
4112 
    iprot.readMessageEnd()
483 rajveer 4113 
    result = getOrdersForCustomer_result()
94 ashish 4114 
    try:
3014 chandransh 4115 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4116 
    except TransactionServiceException, ex:
4117 
      result.ex = ex
483 rajveer 4118 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4119 
    result.write(oprot)
4120 
    oprot.writeMessageEnd()
4121 
    oprot.trans.flush()
4122 
 
483 rajveer 4123 
  def process_createOrder(self, seqid, iprot, oprot):
4124 
    args = createOrder_args()
94 ashish 4125 
    args.read(iprot)
4126 
    iprot.readMessageEnd()
483 rajveer 4127 
    result = createOrder_result()
94 ashish 4128 
    try:
483 rajveer 4129 
      result.success = self._handler.createOrder(args.order)
94 ashish 4130 
    except TransactionServiceException, ex:
4131 
      result.ex = ex
483 rajveer 4132 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4133 
    result.write(oprot)
4134 
    oprot.writeMessageEnd()
4135 
    oprot.trans.flush()
4136 
 
483 rajveer 4137 
  def process_getOrder(self, seqid, iprot, oprot):
4138 
    args = getOrder_args()
94 ashish 4139 
    args.read(iprot)
4140 
    iprot.readMessageEnd()
483 rajveer 4141 
    result = getOrder_result()
94 ashish 4142 
    try:
483 rajveer 4143 
      result.success = self._handler.getOrder(args.id)
94 ashish 4144 
    except TransactionServiceException, ex:
4145 
      result.ex = ex
483 rajveer 4146 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4147 
    result.write(oprot)
4148 
    oprot.writeMessageEnd()
4149 
    oprot.trans.flush()
4150 
 
483 rajveer 4151 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4152 
    args = getLineItemsForOrder_args()
94 ashish 4153 
    args.read(iprot)
4154 
    iprot.readMessageEnd()
483 rajveer 4155 
    result = getLineItemsForOrder_result()
94 ashish 4156 
    try:
483 rajveer 4157 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4158 
    except TransactionServiceException, ex:
4159 
      result.ex = ex
483 rajveer 4160 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4161 
    result.write(oprot)
4162 
    oprot.writeMessageEnd()
4163 
    oprot.trans.flush()
4164 
 
1528 ankur.sing 4165 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4166 
    args = getOrderForCustomer_args()
4167 
    args.read(iprot)
4168 
    iprot.readMessageEnd()
4169 
    result = getOrderForCustomer_result()
4170 
    try:
4171 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4172 
    except TransactionServiceException, ex:
4173 
      result.ex = ex
4174 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4175 
    result.write(oprot)
4176 
    oprot.writeMessageEnd()
4177 
    oprot.trans.flush()
4178 
 
3064 chandransh 4179 
  def process_getAlerts(self, seqid, iprot, oprot):
4180 
    args = getAlerts_args()
4181 
    args.read(iprot)
4182 
    iprot.readMessageEnd()
4183 
    result = getAlerts_result()
4444 rajveer 4184 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4185 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4186 
    result.write(oprot)
4187 
    oprot.writeMessageEnd()
4188 
    oprot.trans.flush()
4189 
 
4394 rajveer 4190 
  def process_addAlert(self, seqid, iprot, oprot):
4191 
    args = addAlert_args()
3064 chandransh 4192 
    args.read(iprot)
4193 
    iprot.readMessageEnd()
4394 rajveer 4194 
    result = addAlert_result()
4444 rajveer 4195 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4196 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4197 
    result.write(oprot)
4198 
    oprot.writeMessageEnd()
4199 
    oprot.trans.flush()
4200 
 
4444 rajveer 4201 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4202 
    args = markAlertsAsSeen_args()
4203 
    args.read(iprot)
4204 
    iprot.readMessageEnd()
4205 
    result = markAlertsAsSeen_result()
4206 
    self._handler.markAlertsAsSeen(args.warehouseId)
4207 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4208 
    result.write(oprot)
4209 
    oprot.writeMessageEnd()
4210 
    oprot.trans.flush()
4211 
 
3064 chandransh 4212 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4213 
    args = getValidOrderCount_args()
4214 
    args.read(iprot)
4215 
    iprot.readMessageEnd()
4216 
    result = getValidOrderCount_result()
4217 
    result.success = self._handler.getValidOrderCount()
4218 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4219 
    result.write(oprot)
4220 
    oprot.writeMessageEnd()
4221 
    oprot.trans.flush()
4222 
 
4223 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4224 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4225 
    args.read(iprot)
4226 
    iprot.readMessageEnd()
4227 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4228 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4229 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4230 
    result.write(oprot)
4231 
    oprot.writeMessageEnd()
4232 
    oprot.trans.flush()
4233 
 
4234 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4235 
    args = getValidOrdersAmountRange_args()
4236 
    args.read(iprot)
4237 
    iprot.readMessageEnd()
4238 
    result = getValidOrdersAmountRange_result()
4239 
    result.success = self._handler.getValidOrdersAmountRange()
4240 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4241 
    result.write(oprot)
4242 
    oprot.writeMessageEnd()
4243 
    oprot.trans.flush()
4244 
 
4245 
  def process_getValidOrders(self, seqid, iprot, oprot):
4246 
    args = getValidOrders_args()
4247 
    args.read(iprot)
4248 
    iprot.readMessageEnd()
4249 
    result = getValidOrders_result()
4250 
    result.success = self._handler.getValidOrders(args.limit)
4251 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4252 
    result.write(oprot)
4253 
    oprot.writeMessageEnd()
4254 
    oprot.trans.flush()
4255 
 
1220 chandransh 4256 
  def process_batchOrders(self, seqid, iprot, oprot):
4257 
    args = batchOrders_args()
4258 
    args.read(iprot)
4259 
    iprot.readMessageEnd()
4260 
    result = batchOrders_result()
4261 
    try:
4262 
      result.success = self._handler.batchOrders(args.warehouseId)
4263 
    except TransactionServiceException, ex:
4264 
      result.ex = ex
4265 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4266 
    result.write(oprot)
4267 
    oprot.writeMessageEnd()
4268 
    oprot.trans.flush()
4269 
 
1208 chandransh 4270 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4271 
    args = markOrderAsOutOfStock_args()
4272 
    args.read(iprot)
4273 
    iprot.readMessageEnd()
4274 
    result = markOrderAsOutOfStock_result()
4275 
    try:
4276 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4277 
    except TransactionServiceException, ex:
4278 
      result.ex = ex
4279 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4280 
    result.write(oprot)
4281 
    oprot.writeMessageEnd()
4282 
    oprot.trans.flush()
4283 
 
3064 chandransh 4284 
  def process_verifyOrder(self, seqid, iprot, oprot):
4285 
    args = verifyOrder_args()
759 chandransh 4286 
    args.read(iprot)
4287 
    iprot.readMessageEnd()
3064 chandransh 4288 
    result = verifyOrder_result()
759 chandransh 4289 
    try:
3064 chandransh 4290 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4291 
    except TransactionServiceException, ex:
4292 
      result.ex = ex
3064 chandransh 4293 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4294 
    result.write(oprot)
4295 
    oprot.writeMessageEnd()
4296 
    oprot.trans.flush()
4297 
 
3064 chandransh 4298 
  def process_acceptOrder(self, seqid, iprot, oprot):
4299 
    args = acceptOrder_args()
1113 chandransh 4300 
    args.read(iprot)
4301 
    iprot.readMessageEnd()
3064 chandransh 4302 
    result = acceptOrder_result()
1113 chandransh 4303 
    try:
3064 chandransh 4304 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4305 
    except TransactionServiceException, ex:
4306 
      result.ex = ex
3064 chandransh 4307 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4308 
    result.write(oprot)
4309 
    oprot.writeMessageEnd()
4310 
    oprot.trans.flush()
4311 
 
3064 chandransh 4312 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4313 
    args = addBillingDetails_args()
1135 chandransh 4314 
    args.read(iprot)
4315 
    iprot.readMessageEnd()
3064 chandransh 4316 
    result = addBillingDetails_result()
1135 chandransh 4317 
    try:
4283 anupam.sin 4318 
      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 4319 
    except TransactionServiceException, ex:
4320 
      result.ex = ex
3064 chandransh 4321 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4322 
    result.write(oprot)
4323 
    oprot.writeMessageEnd()
4324 
    oprot.trans.flush()
4325 
 
4579 rajveer 4326 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
4327 
    args = addInvoiceNumber_args()
4328 
    args.read(iprot)
4329 
    iprot.readMessageEnd()
4330 
    result = addInvoiceNumber_result()
4331 
    try:
4332 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber)
4333 
    except TransactionServiceException, ex:
4334 
      result.ex = ex
4335 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
4336 
    result.write(oprot)
4337 
    oprot.writeMessageEnd()
4338 
    oprot.trans.flush()
4339 
 
3064 chandransh 4340 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4341 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4342 
    args.read(iprot)
4343 
    iprot.readMessageEnd()
3064 chandransh 4344 
    result = markOrdersAsManifested_result()
4345 
    try:
4346 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4347 
    except TransactionServiceException, ex:
4348 
      result.ex = ex
4349 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4350 
    result.write(oprot)
4351 
    oprot.writeMessageEnd()
4352 
    oprot.trans.flush()
4353 
 
4410 rajveer 4354 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4355 
    args = markOrdersAsShippedFromWarehouse_args()
4356 
    args.read(iprot)
4357 
    iprot.readMessageEnd()
4358 
    result = markOrdersAsShippedFromWarehouse_result()
4359 
    try:
4360 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4361 
    except TransactionServiceException, ex:
4362 
      result.ex = ex
4363 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4364 
    result.write(oprot)
4365 
    oprot.writeMessageEnd()
4366 
    oprot.trans.flush()
4367 
 
3064 chandransh 4368 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4369 
    args = markOrdersAsPickedUp_args()
304 ashish 4370 
    args.read(iprot)
4371 
    iprot.readMessageEnd()
3064 chandransh 4372 
    result = markOrdersAsPickedUp_result()
4373 
    try:
4374 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4375 
    except TransactionServiceException, ex:
4376 
      result.ex = ex
4377 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4378 
    result.write(oprot)
4379 
    oprot.writeMessageEnd()
4380 
    oprot.trans.flush()
94 ashish 4381 
 
3064 chandransh 4382 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4383 
    args = markOrdersAsDelivered_args()
304 ashish 4384 
    args.read(iprot)
4385 
    iprot.readMessageEnd()
3064 chandransh 4386 
    result = markOrdersAsDelivered_result()
4387 
    try:
4388 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4389 
    except TransactionServiceException, ex:
4390 
      result.ex = ex
4391 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4392 
    result.write(oprot)
4393 
    oprot.writeMessageEnd()
4394 
    oprot.trans.flush()
4395 
 
3064 chandransh 4396 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4397 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4398 
    args.read(iprot)
4399 
    iprot.readMessageEnd()
3064 chandransh 4400 
    result = markOrdersAsFailed_result()
4401 
    try:
4402 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4403 
    except TransactionServiceException, ex:
4404 
      result.ex = ex
4405 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4406 
    result.write(oprot)
4407 
    oprot.writeMessageEnd()
4408 
    oprot.trans.flush()
304 ashish 4409 
 
3064 chandransh 4410 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4411 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4412 
    args.read(iprot)
4413 
    iprot.readMessageEnd()
3064 chandransh 4414 
    result = updateNonDeliveryReason_result()
4415 
    try:
4581 phani.kuma 4416 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 4417 
    except TransactionServiceException, ex:
4418 
      result.ex = ex
4419 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4420 
    result.write(oprot)
4421 
    oprot.writeMessageEnd()
4422 
    oprot.trans.flush()
1596 ankur.sing 4423 
 
3064 chandransh 4424 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4425 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4426 
    args.read(iprot)
4427 
    iprot.readMessageEnd()
3064 chandransh 4428 
    result = getUndeliveredOrders_result()
4429 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4430 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4431 
    result.write(oprot)
4432 
    oprot.writeMessageEnd()
4433 
    oprot.trans.flush()
4434 
 
2536 chandransh 4435 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4436 
    args = toggleDOAFlag_args()
4437 
    args.read(iprot)
4438 
    iprot.readMessageEnd()
4439 
    result = toggleDOAFlag_result()
4440 
    try:
4441 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4442 
    except TransactionServiceException, ex:
4443 
      result.ex = ex
4444 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4445 
    result.write(oprot)
4446 
    oprot.writeMessageEnd()
4447 
    oprot.trans.flush()
1886 ankur.sing 4448 
 
4454 rajveer 4449 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
4450 
    args = markOrderDoaRequestReceived_args()
4451 
    args.read(iprot)
4452 
    iprot.readMessageEnd()
4453 
    result = markOrderDoaRequestReceived_result()
4454 
    try:
4455 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
4456 
    except TransactionServiceException, ex:
4457 
      result.ex = ex
4458 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
4459 
    result.write(oprot)
4460 
    oprot.writeMessageEnd()
4461 
    oprot.trans.flush()
4462 
 
4463 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
4464 
    args = markOrderDoaRequestAuthorized_args()
4465 
    args.read(iprot)
4466 
    iprot.readMessageEnd()
4467 
    result = markOrderDoaRequestAuthorized_result()
4468 
    try:
4469 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
4470 
    except TransactionServiceException, ex:
4471 
      result.ex = ex
4472 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
4473 
    result.write(oprot)
4474 
    oprot.writeMessageEnd()
4475 
    oprot.trans.flush()
4476 
 
4488 rajveer 4477 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
4478 
    args = markOrderReturnRequestReceived_args()
4479 
    args.read(iprot)
4480 
    iprot.readMessageEnd()
4481 
    result = markOrderReturnRequestReceived_result()
4482 
    try:
4483 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
4484 
    except TransactionServiceException, ex:
4485 
      result.ex = ex
4486 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
4487 
    result.write(oprot)
4488 
    oprot.writeMessageEnd()
4489 
    oprot.trans.flush()
4490 
 
4491 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
4492 
    args = markOrderReturnRequestAuthorized_args()
4493 
    args.read(iprot)
4494 
    iprot.readMessageEnd()
4495 
    result = markOrderReturnRequestAuthorized_result()
4496 
    try:
4497 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
4498 
    except TransactionServiceException, ex:
4499 
      result.ex = ex
4500 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
4501 
    result.write(oprot)
4502 
    oprot.writeMessageEnd()
4503 
    oprot.trans.flush()
4504 
 
2536 chandransh 4505 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
4506 
    args = requestPickupNumber_args()
4507 
    args.read(iprot)
4508 
    iprot.readMessageEnd()
4509 
    result = requestPickupNumber_result()
4510 
    try:
4579 rajveer 4511 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 4512 
    except TransactionServiceException, ex:
4513 
      result.ex = ex
4514 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
4515 
    result.write(oprot)
4516 
    oprot.writeMessageEnd()
4517 
    oprot.trans.flush()
4518 
 
4519 
  def process_authorizePickup(self, seqid, iprot, oprot):
4520 
    args = authorizePickup_args()
4521 
    args.read(iprot)
4522 
    iprot.readMessageEnd()
4523 
    result = authorizePickup_result()
4524 
    try:
4525 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
4526 
    except TransactionServiceException, ex:
4527 
      result.ex = ex
4528 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4529 
    result.write(oprot)
4530 
    oprot.writeMessageEnd()
4531 
    oprot.trans.flush()
4532 
 
2764 chandransh 4533 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4534 
    args = markDoasAsPickedUp_args()
4535 
    args.read(iprot)
4536 
    iprot.readMessageEnd()
4537 
    result = markDoasAsPickedUp_result()
4538 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4539 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4540 
    result.write(oprot)
4541 
    oprot.writeMessageEnd()
4542 
    oprot.trans.flush()
4543 
 
2616 chandransh 4544 
  def process_receiveReturn(self, seqid, iprot, oprot):
4545 
    args = receiveReturn_args()
2591 chandransh 4546 
    args.read(iprot)
4547 
    iprot.readMessageEnd()
2616 chandransh 4548 
    result = receiveReturn_result()
2591 chandransh 4549 
    try:
4479 rajveer 4550 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 4551 
    except TransactionServiceException, ex:
4552 
      result.ex = ex
2616 chandransh 4553 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4554 
    result.write(oprot)
4555 
    oprot.writeMessageEnd()
4556 
    oprot.trans.flush()
2536 chandransh 4557 
 
2591 chandransh 4558 
  def process_validateDoa(self, seqid, iprot, oprot):
4559 
    args = validateDoa_args()
4560 
    args.read(iprot)
4561 
    iprot.readMessageEnd()
4562 
    result = validateDoa_result()
4563 
    try:
4564 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4565 
    except TransactionServiceException, ex:
4566 
      result.ex = ex
4567 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4568 
    result.write(oprot)
4569 
    oprot.writeMessageEnd()
4570 
    oprot.trans.flush()
4571 
 
4495 rajveer 4572 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
4573 
    args = validateReturnProduct_args()
4574 
    args.read(iprot)
4575 
    iprot.readMessageEnd()
4576 
    result = validateReturnProduct_result()
4577 
    try:
4578 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
4579 
    except TransactionServiceException, ex:
4580 
      result.ex = ex
4581 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
4582 
    result.write(oprot)
4583 
    oprot.writeMessageEnd()
4584 
    oprot.trans.flush()
4585 
 
2616 chandransh 4586 
  def process_reshipOrder(self, seqid, iprot, oprot):
4587 
    args = reshipOrder_args()
4588 
    args.read(iprot)
4589 
    iprot.readMessageEnd()
4590 
    result = reshipOrder_result()
4591 
    try:
4592 
      result.success = self._handler.reshipOrder(args.orderId)
4593 
    except TransactionServiceException, ex:
4594 
      result.ex = ex
4595 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4596 
    result.write(oprot)
4597 
    oprot.writeMessageEnd()
4598 
    oprot.trans.flush()
2591 chandransh 4599 
 
2616 chandransh 4600 
  def process_refundOrder(self, seqid, iprot, oprot):
4601 
    args = refundOrder_args()
4602 
    args.read(iprot)
4603 
    iprot.readMessageEnd()
4604 
    result = refundOrder_result()
4605 
    try:
3226 chandransh 4606 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4607 
    except TransactionServiceException, ex:
4608 
      result.ex = ex
4609 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4610 
    result.write(oprot)
4611 
    oprot.writeMessageEnd()
4612 
    oprot.trans.flush()
4613 
 
2690 chandransh 4614 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4615 
    args = getReturnOrders_args()
4616 
    args.read(iprot)
4617 
    iprot.readMessageEnd()
4618 
    result = getReturnOrders_result()
4619 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4620 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4621 
    result.write(oprot)
4622 
    oprot.writeMessageEnd()
4623 
    oprot.trans.flush()
2616 chandransh 4624 
 
2700 chandransh 4625 
  def process_getReturnOrder(self, seqid, iprot, oprot):
4626 
    args = getReturnOrder_args()
4627 
    args.read(iprot)
4628 
    iprot.readMessageEnd()
4629 
    result = getReturnOrder_result()
4630 
    try:
4631 
      result.success = self._handler.getReturnOrder(args.id)
4632 
    except TransactionServiceException, ex:
4633 
      result.ex = ex
4634 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
4635 
    result.write(oprot)
4636 
    oprot.writeMessageEnd()
4637 
    oprot.trans.flush()
4638 
 
2690 chandransh 4639 
  def process_processReturn(self, seqid, iprot, oprot):
4640 
    args = processReturn_args()
4641 
    args.read(iprot)
4642 
    iprot.readMessageEnd()
4643 
    result = processReturn_result()
4644 
    try:
4645 
      self._handler.processReturn(args.returnOrderId)
4646 
    except TransactionServiceException, ex:
4647 
      result.ex = ex
4648 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
4649 
    result.write(oprot)
4650 
    oprot.writeMessageEnd()
4651 
    oprot.trans.flush()
4652 
 
2819 chandransh 4653 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
4654 
    args = createPurchaseOrder_args()
4655 
    args.read(iprot)
4656 
    iprot.readMessageEnd()
4657 
    result = createPurchaseOrder_result()
4658 
    try:
4659 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
4660 
    except TransactionServiceException, ex:
4661 
      result.ex = ex
4662 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
4663 
    result.write(oprot)
4664 
    oprot.writeMessageEnd()
4665 
    oprot.trans.flush()
2690 chandransh 4666 
 
3451 chandransh 4667 
  def process_updateWeight(self, seqid, iprot, oprot):
4668 
    args = updateWeight_args()
4669 
    args.read(iprot)
4670 
    iprot.readMessageEnd()
4671 
    result = updateWeight_result()
4672 
    try:
4673 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
4674 
    except TransactionServiceException, ex:
4675 
      result.ex = ex
4676 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
4677 
    result.write(oprot)
4678 
    oprot.writeMessageEnd()
4679 
    oprot.trans.flush()
2819 chandransh 4680 
 
3469 chandransh 4681 
  def process_changeItem(self, seqid, iprot, oprot):
4682 
    args = changeItem_args()
4683 
    args.read(iprot)
4684 
    iprot.readMessageEnd()
4685 
    result = changeItem_result()
4686 
    try:
4687 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
4688 
    except TransactionServiceException, ex:
4689 
      result.ex = ex
4690 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
4691 
    result.write(oprot)
4692 
    oprot.writeMessageEnd()
4693 
    oprot.trans.flush()
3451 chandransh 4694 
 
3469 chandransh 4695 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
4696 
    args = shiftToWarehouse_args()
4697 
    args.read(iprot)
4698 
    iprot.readMessageEnd()
4699 
    result = shiftToWarehouse_result()
4700 
    try:
4701 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
4702 
    except TransactionServiceException, ex:
4703 
      result.ex = ex
4704 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
4705 
    result.write(oprot)
4706 
    oprot.writeMessageEnd()
4707 
    oprot.trans.flush()
4708 
 
3553 chandransh 4709 
  def process_addDelayReason(self, seqid, iprot, oprot):
4710 
    args = addDelayReason_args()
4711 
    args.read(iprot)
4712 
    iprot.readMessageEnd()
4713 
    result = addDelayReason_result()
4714 
    try:
3986 chandransh 4715 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 4716 
    except TransactionServiceException, ex:
4717 
      result.ex = ex
4718 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
4719 
    result.write(oprot)
4720 
    oprot.writeMessageEnd()
4721 
    oprot.trans.flush()
3469 chandransh 4722 
 
3956 chandransh 4723 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
4724 
    args = reconcileCodCollection_args()
4725 
    args.read(iprot)
4726 
    iprot.readMessageEnd()
4727 
    result = reconcileCodCollection_result()
4728 
    try:
4729 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
4730 
    except TransactionServiceException, ex:
4731 
      result.ex = ex
4732 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
4733 
    result.write(oprot)
4734 
    oprot.writeMessageEnd()
4735 
    oprot.trans.flush()
3553 chandransh 4736 
 
4008 mandeep.dh 4737 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
4738 
    args = getTransactionsRequiringExtraProcessing_args()
4739 
    args.read(iprot)
4740 
    iprot.readMessageEnd()
4741 
    result = getTransactionsRequiringExtraProcessing_result()
4742 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
4743 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
4744 
    result.write(oprot)
4745 
    oprot.writeMessageEnd()
4746 
    oprot.trans.flush()
3956 chandransh 4747 
 
4008 mandeep.dh 4748 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
4749 
    args = markTransactionAsProcessed_args()
4750 
    args.read(iprot)
4751 
    iprot.readMessageEnd()
4752 
    result = markTransactionAsProcessed_result()
4753 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
4754 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
4755 
    result.write(oprot)
4756 
    oprot.writeMessageEnd()
4757 
    oprot.trans.flush()
4758 
 
4018 chandransh 4759 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
4760 
    args = getItemWiseRiskyOrdersCount_args()
4761 
    args.read(iprot)
4762 
    iprot.readMessageEnd()
4763 
    result = getItemWiseRiskyOrdersCount_result()
4764 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
4765 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
4766 
    result.write(oprot)
4767 
    oprot.writeMessageEnd()
4768 
    oprot.trans.flush()
4008 mandeep.dh 4769 
 
4295 varun.gupt 4770 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
4771 
    args = getOrdersForItemIds_args()
4772 
    args.read(iprot)
4773 
    iprot.readMessageEnd()
4774 
    result = getOrdersForItemIds_result()
4775 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
4776 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
4777 
    result.write(oprot)
4778 
    oprot.writeMessageEnd()
4779 
    oprot.trans.flush()
4780 
 
4247 rajveer 4781 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
4782 
    args = markOrderCancellationRequestReceived_args()
4783 
    args.read(iprot)
4784 
    iprot.readMessageEnd()
4785 
    result = markOrderCancellationRequestReceived_result()
4786 
    try:
4787 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
4788 
    except TransactionServiceException, ex:
4789 
      result.ex = ex
4790 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
4791 
    result.write(oprot)
4792 
    oprot.writeMessageEnd()
4793 
    oprot.trans.flush()
4018 chandransh 4794 
 
4247 rajveer 4795 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
4796 
    args = markOrderCancellationRequestConfirmed_args()
4797 
    args.read(iprot)
4798 
    iprot.readMessageEnd()
4799 
    result = markOrderCancellationRequestConfirmed_result()
4800 
    try:
4801 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
4802 
    except TransactionServiceException, ex:
4803 
      result.ex = ex
4804 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
4805 
    result.write(oprot)
4806 
    oprot.writeMessageEnd()
4807 
    oprot.trans.flush()
4808 
 
4809 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4810 
    args = markOrderCancellationRequestDenied_args()
4811 
    args.read(iprot)
4812 
    iprot.readMessageEnd()
4813 
    result = markOrderCancellationRequestDenied_result()
4814 
    try:
4815 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4816 
    except TransactionServiceException, ex:
4817 
      result.ex = ex
4818 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4819 
    result.write(oprot)
4820 
    oprot.writeMessageEnd()
4821 
    oprot.trans.flush()
4822 
 
4258 rajveer 4823 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4824 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4825 
    args.read(iprot)
4826 
    iprot.readMessageEnd()
4258 rajveer 4827 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4828 
    try:
4258 rajveer 4829 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4830 
    except TransactionServiceException, ex:
4831 
      result.ex = ex
4258 rajveer 4832 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4833 
    result.write(oprot)
4834 
    oprot.writeMessageEnd()
4835 
    oprot.trans.flush()
4836 
 
4259 anupam.sin 4837 
  def process_refundTransaction(self, seqid, iprot, oprot):
4838 
    args = refundTransaction_args()
4839 
    args.read(iprot)
4840 
    iprot.readMessageEnd()
4841 
    result = refundTransaction_result()
4842 
    try:
4843 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4844 
    except TransactionServiceException, ex:
4845 
      result.ex = ex
4846 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4847 
    result.write(oprot)
4848 
    oprot.writeMessageEnd()
4849 
    oprot.trans.flush()
4247 rajveer 4850 
 
4324 mandeep.dh 4851 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
4852 
    args = updateShipmentAddress_args()
4853 
    args.read(iprot)
4854 
    iprot.readMessageEnd()
4855 
    result = updateShipmentAddress_result()
4856 
    try:
4857 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
4858 
    except TransactionServiceException, ex:
4859 
      result.ex = ex
4860 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
4861 
    result.write(oprot)
4862 
    oprot.writeMessageEnd()
4863 
    oprot.trans.flush()
4864 
 
4285 rajveer 4865 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
4866 
    args = acceptOrdersForItemId_args()
4867 
    args.read(iprot)
4868 
    iprot.readMessageEnd()
4869 
    result = acceptOrdersForItemId_result()
4870 
    try:
4871 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
4872 
    except TransactionServiceException, ex:
4873 
      result.ex = ex
4874 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
4875 
    result.write(oprot)
4876 
    oprot.writeMessageEnd()
4877 
    oprot.trans.flush()
4259 anupam.sin 4878 
 
4303 rajveer 4879 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
4880 
    args = markOrdersAsPORaised_args()
4881 
    args.read(iprot)
4882 
    iprot.readMessageEnd()
4883 
    result = markOrdersAsPORaised_result()
4884 
    try:
4369 rajveer 4885 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4886 
    except TransactionServiceException, ex:
4887 
      result.ex = ex
4888 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
4889 
    result.write(oprot)
4890 
    oprot.writeMessageEnd()
4891 
    oprot.trans.flush()
4285 rajveer 4892 
 
4303 rajveer 4893 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
4894 
    args = markOrdersAsReversalInitiated_args()
4895 
    args.read(iprot)
4896 
    iprot.readMessageEnd()
4897 
    result = markOrdersAsReversalInitiated_result()
4898 
    try:
4369 rajveer 4899 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4900 
    except TransactionServiceException, ex:
4901 
      result.ex = ex
4902 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
4903 
    result.write(oprot)
4904 
    oprot.writeMessageEnd()
4905 
    oprot.trans.flush()
4906 
 
4907 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
4908 
    args = markOrdersAsNotAvailabke_args()
4909 
    args.read(iprot)
4910 
    iprot.readMessageEnd()
4911 
    result = markOrdersAsNotAvailabke_result()
4912 
    try:
4369 rajveer 4913 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4914 
    except TransactionServiceException, ex:
4915 
      result.ex = ex
4916 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
4917 
    result.write(oprot)
4918 
    oprot.writeMessageEnd()
4919 
    oprot.trans.flush()
4920 
 
4369 rajveer 4921 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
4922 
    args = markOrdersAsTimeout_args()
4923 
    args.read(iprot)
4924 
    iprot.readMessageEnd()
4925 
    result = markOrdersAsTimeout_result()
4926 
    try:
4927 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
4928 
    except TransactionServiceException, ex:
4929 
      result.ex = ex
4930 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
4931 
    result.write(oprot)
4932 
    oprot.writeMessageEnd()
4933 
    oprot.trans.flush()
4303 rajveer 4934 
 
4386 anupam.sin 4935 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
4936 
    args = getOrderForAwb_args()
4937 
    args.read(iprot)
4938 
    iprot.readMessageEnd()
4939 
    result = getOrderForAwb_result()
4940 
    try:
4941 
      result.success = self._handler.getOrderForAwb(args.awb)
4942 
    except TransactionServiceException, ex:
4943 
      result.ex = ex
4944 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
4945 
    result.write(oprot)
4946 
    oprot.writeMessageEnd()
4947 
    oprot.trans.flush()
4369 rajveer 4948 
 
4506 phani.kuma 4949 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
4950 
    args = getOrdersForProviderForStatus_args()
4951 
    args.read(iprot)
4952 
    iprot.readMessageEnd()
4953 
    result = getOrdersForProviderForStatus_result()
4954 
    try:
4955 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
4956 
    except TransactionServiceException, ex:
4957 
      result.ex = ex
4958 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
4959 
    result.write(oprot)
4960 
    oprot.writeMessageEnd()
4961 
    oprot.trans.flush()
4386 anupam.sin 4962 
 
4506 phani.kuma 4963 
 
94 ashish 4964 
# HELPER FUNCTIONS AND STRUCTURES
4965 
 
4966 
class createTransaction_args:
4967 
  """
4968 
  Attributes:
4969 
   - transaction
4970 
  """
4971 
 
4972 
  thrift_spec = (
4973 
    None, # 0
4974 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4975 
  )
4976 
 
4977 
  def __init__(self, transaction=None,):
4978 
    self.transaction = transaction
4979 
 
4980 
  def read(self, iprot):
4981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4983 
      return
4984 
    iprot.readStructBegin()
4985 
    while True:
4986 
      (fname, ftype, fid) = iprot.readFieldBegin()
4987 
      if ftype == TType.STOP:
4988 
        break
4989 
      if fid == 1:
4990 
        if ftype == TType.STRUCT:
4991 
          self.transaction = Transaction()
4992 
          self.transaction.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_args')
3431 rajveer 5005 
    if self.transaction is not None:
94 ashish 5006 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5007 
      self.transaction.write(oprot)
5008 
      oprot.writeFieldEnd()
5009 
    oprot.writeFieldStop()
5010 
    oprot.writeStructEnd()
5011 
 
3431 rajveer 5012 
  def validate(self):
5013 
    return
5014 
 
5015 
 
94 ashish 5016 
  def __repr__(self):
5017 
    L = ['%s=%r' % (key, value)
5018 
      for key, value in self.__dict__.iteritems()]
5019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5020 
 
5021 
  def __eq__(self, other):
5022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5023 
 
5024 
  def __ne__(self, other):
5025 
    return not (self == other)
5026 
 
5027 
class createTransaction_result:
5028 
  """
5029 
  Attributes:
132 ashish 5030 
   - success
94 ashish 5031 
   - ex
5032 
  """
5033 
 
5034 
  thrift_spec = (
132 ashish 5035 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5036 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5037 
  )
5038 
 
132 ashish 5039 
  def __init__(self, success=None, ex=None,):
5040 
    self.success = success
94 ashish 5041 
    self.ex = ex
5042 
 
5043 
  def read(self, iprot):
5044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5046 
      return
5047 
    iprot.readStructBegin()
5048 
    while True:
5049 
      (fname, ftype, fid) = iprot.readFieldBegin()
5050 
      if ftype == TType.STOP:
5051 
        break
132 ashish 5052 
      if fid == 0:
5053 
        if ftype == TType.I64:
5054 
          self.success = iprot.readI64();
5055 
        else:
5056 
          iprot.skip(ftype)
5057 
      elif fid == 1:
94 ashish 5058 
        if ftype == TType.STRUCT:
5059 
          self.ex = TransactionServiceException()
5060 
          self.ex.read(iprot)
5061 
        else:
5062 
          iprot.skip(ftype)
5063 
      else:
5064 
        iprot.skip(ftype)
5065 
      iprot.readFieldEnd()
5066 
    iprot.readStructEnd()
5067 
 
5068 
  def write(self, oprot):
5069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5071 
      return
5072 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5073 
    if self.success is not None:
132 ashish 5074 
      oprot.writeFieldBegin('success', TType.I64, 0)
5075 
      oprot.writeI64(self.success)
5076 
      oprot.writeFieldEnd()
3431 rajveer 5077 
    if self.ex is not None:
94 ashish 5078 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5079 
      self.ex.write(oprot)
5080 
      oprot.writeFieldEnd()
5081 
    oprot.writeFieldStop()
5082 
    oprot.writeStructEnd()
5083 
 
3431 rajveer 5084 
  def validate(self):
5085 
    return
5086 
 
5087 
 
94 ashish 5088 
  def __repr__(self):
5089 
    L = ['%s=%r' % (key, value)
5090 
      for key, value in self.__dict__.iteritems()]
5091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5092 
 
5093 
  def __eq__(self, other):
5094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5095 
 
5096 
  def __ne__(self, other):
5097 
    return not (self == other)
5098 
 
5099 
class getTransaction_args:
5100 
  """
5101 
  Attributes:
5102 
   - id
5103 
  """
5104 
 
5105 
  thrift_spec = (
5106 
    None, # 0
5107 
    (1, TType.I64, 'id', None, None, ), # 1
5108 
  )
5109 
 
5110 
  def __init__(self, id=None,):
5111 
    self.id = id
5112 
 
5113 
  def read(self, iprot):
5114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5116 
      return
5117 
    iprot.readStructBegin()
5118 
    while True:
5119 
      (fname, ftype, fid) = iprot.readFieldBegin()
5120 
      if ftype == TType.STOP:
5121 
        break
5122 
      if fid == 1:
5123 
        if ftype == TType.I64:
5124 
          self.id = iprot.readI64();
5125 
        else:
5126 
          iprot.skip(ftype)
5127 
      else:
5128 
        iprot.skip(ftype)
5129 
      iprot.readFieldEnd()
5130 
    iprot.readStructEnd()
5131 
 
5132 
  def write(self, oprot):
5133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5135 
      return
5136 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 5137 
    if self.id is not None:
94 ashish 5138 
      oprot.writeFieldBegin('id', TType.I64, 1)
5139 
      oprot.writeI64(self.id)
5140 
      oprot.writeFieldEnd()
5141 
    oprot.writeFieldStop()
5142 
    oprot.writeStructEnd()
5143 
 
3431 rajveer 5144 
  def validate(self):
5145 
    return
5146 
 
5147 
 
94 ashish 5148 
  def __repr__(self):
5149 
    L = ['%s=%r' % (key, value)
5150 
      for key, value in self.__dict__.iteritems()]
5151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5152 
 
5153 
  def __eq__(self, other):
5154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5155 
 
5156 
  def __ne__(self, other):
5157 
    return not (self == other)
5158 
 
5159 
class getTransaction_result:
5160 
  """
5161 
  Attributes:
5162 
   - success
5163 
   - ex
5164 
  """
5165 
 
5166 
  thrift_spec = (
5167 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
5168 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5169 
  )
5170 
 
5171 
  def __init__(self, success=None, ex=None,):
5172 
    self.success = success
5173 
    self.ex = ex
5174 
 
5175 
  def read(self, iprot):
5176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5178 
      return
5179 
    iprot.readStructBegin()
5180 
    while True:
5181 
      (fname, ftype, fid) = iprot.readFieldBegin()
5182 
      if ftype == TType.STOP:
5183 
        break
5184 
      if fid == 0:
5185 
        if ftype == TType.STRUCT:
5186 
          self.success = Transaction()
5187 
          self.success.read(iprot)
5188 
        else:
5189 
          iprot.skip(ftype)
5190 
      elif fid == 1:
5191 
        if ftype == TType.STRUCT:
5192 
          self.ex = TransactionServiceException()
5193 
          self.ex.read(iprot)
5194 
        else:
5195 
          iprot.skip(ftype)
5196 
      else:
5197 
        iprot.skip(ftype)
5198 
      iprot.readFieldEnd()
5199 
    iprot.readStructEnd()
5200 
 
5201 
  def write(self, oprot):
5202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5204 
      return
5205 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 5206 
    if self.success is not None:
94 ashish 5207 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5208 
      self.success.write(oprot)
5209 
      oprot.writeFieldEnd()
3431 rajveer 5210 
    if self.ex is not None:
94 ashish 5211 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5212 
      self.ex.write(oprot)
5213 
      oprot.writeFieldEnd()
5214 
    oprot.writeFieldStop()
5215 
    oprot.writeStructEnd()
5216 
 
3431 rajveer 5217 
  def validate(self):
5218 
    return
5219 
 
5220 
 
94 ashish 5221 
  def __repr__(self):
5222 
    L = ['%s=%r' % (key, value)
5223 
      for key, value in self.__dict__.iteritems()]
5224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5225 
 
5226 
  def __eq__(self, other):
5227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5228 
 
5229 
  def __ne__(self, other):
5230 
    return not (self == other)
5231 
 
5232 
class getTransactionsForCustomer_args:
5233 
  """
5234 
  Attributes:
5235 
   - customerId
5236 
   - from_date
5237 
   - to_date
5238 
   - status
5239 
  """
5240 
 
5241 
  thrift_spec = (
5242 
    None, # 0
5243 
    (1, TType.I64, 'customerId', None, None, ), # 1
5244 
    (2, TType.I64, 'from_date', None, None, ), # 2
5245 
    (3, TType.I64, 'to_date', None, None, ), # 3
5246 
    (4, TType.I32, 'status', None, None, ), # 4
5247 
  )
5248 
 
5249 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
5250 
    self.customerId = customerId
5251 
    self.from_date = from_date
5252 
    self.to_date = to_date
5253 
    self.status = status
5254 
 
5255 
  def read(self, iprot):
5256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5258 
      return
5259 
    iprot.readStructBegin()
5260 
    while True:
5261 
      (fname, ftype, fid) = iprot.readFieldBegin()
5262 
      if ftype == TType.STOP:
5263 
        break
5264 
      if fid == 1:
5265 
        if ftype == TType.I64:
5266 
          self.customerId = iprot.readI64();
5267 
        else:
5268 
          iprot.skip(ftype)
5269 
      elif fid == 2:
5270 
        if ftype == TType.I64:
5271 
          self.from_date = iprot.readI64();
5272 
        else:
5273 
          iprot.skip(ftype)
5274 
      elif fid == 3:
5275 
        if ftype == TType.I64:
5276 
          self.to_date = iprot.readI64();
5277 
        else:
5278 
          iprot.skip(ftype)
5279 
      elif fid == 4:
5280 
        if ftype == TType.I32:
5281 
          self.status = iprot.readI32();
5282 
        else:
5283 
          iprot.skip(ftype)
5284 
      else:
5285 
        iprot.skip(ftype)
5286 
      iprot.readFieldEnd()
5287 
    iprot.readStructEnd()
5288 
 
5289 
  def write(self, oprot):
5290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5292 
      return
5293 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 5294 
    if self.customerId is not None:
94 ashish 5295 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5296 
      oprot.writeI64(self.customerId)
5297 
      oprot.writeFieldEnd()
3431 rajveer 5298 
    if self.from_date is not None:
94 ashish 5299 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5300 
      oprot.writeI64(self.from_date)
5301 
      oprot.writeFieldEnd()
3431 rajveer 5302 
    if self.to_date is not None:
94 ashish 5303 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5304 
      oprot.writeI64(self.to_date)
5305 
      oprot.writeFieldEnd()
3431 rajveer 5306 
    if self.status is not None:
94 ashish 5307 
      oprot.writeFieldBegin('status', TType.I32, 4)
5308 
      oprot.writeI32(self.status)
5309 
      oprot.writeFieldEnd()
5310 
    oprot.writeFieldStop()
5311 
    oprot.writeStructEnd()
5312 
 
3431 rajveer 5313 
  def validate(self):
5314 
    return
5315 
 
5316 
 
94 ashish 5317 
  def __repr__(self):
5318 
    L = ['%s=%r' % (key, value)
5319 
      for key, value in self.__dict__.iteritems()]
5320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5321 
 
5322 
  def __eq__(self, other):
5323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5324 
 
5325 
  def __ne__(self, other):
5326 
    return not (self == other)
5327 
 
5328 
class getTransactionsForCustomer_result:
5329 
  """
5330 
  Attributes:
5331 
   - success
5332 
   - ex
5333 
  """
5334 
 
5335 
  thrift_spec = (
5336 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5337 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5338 
  )
5339 
 
5340 
  def __init__(self, success=None, ex=None,):
5341 
    self.success = success
5342 
    self.ex = ex
5343 
 
5344 
  def read(self, iprot):
5345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5347 
      return
5348 
    iprot.readStructBegin()
5349 
    while True:
5350 
      (fname, ftype, fid) = iprot.readFieldBegin()
5351 
      if ftype == TType.STOP:
5352 
        break
5353 
      if fid == 0:
5354 
        if ftype == TType.LIST:
5355 
          self.success = []
685 chandransh 5356 
          (_etype17, _size14) = iprot.readListBegin()
5357 
          for _i18 in xrange(_size14):
5358 
            _elem19 = Transaction()
5359 
            _elem19.read(iprot)
5360 
            self.success.append(_elem19)
94 ashish 5361 
          iprot.readListEnd()
5362 
        else:
5363 
          iprot.skip(ftype)
5364 
      elif fid == 1:
5365 
        if ftype == TType.STRUCT:
5366 
          self.ex = TransactionServiceException()
5367 
          self.ex.read(iprot)
5368 
        else:
5369 
          iprot.skip(ftype)
5370 
      else:
5371 
        iprot.skip(ftype)
5372 
      iprot.readFieldEnd()
5373 
    iprot.readStructEnd()
5374 
 
5375 
  def write(self, oprot):
5376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5378 
      return
5379 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 5380 
    if self.success is not None:
94 ashish 5381 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5382 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5383 
      for iter20 in self.success:
5384 
        iter20.write(oprot)
94 ashish 5385 
      oprot.writeListEnd()
5386 
      oprot.writeFieldEnd()
3431 rajveer 5387 
    if self.ex is not None:
94 ashish 5388 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5389 
      self.ex.write(oprot)
5390 
      oprot.writeFieldEnd()
5391 
    oprot.writeFieldStop()
5392 
    oprot.writeStructEnd()
5393 
 
3431 rajveer 5394 
  def validate(self):
5395 
    return
5396 
 
5397 
 
94 ashish 5398 
  def __repr__(self):
5399 
    L = ['%s=%r' % (key, value)
5400 
      for key, value in self.__dict__.iteritems()]
5401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5402 
 
5403 
  def __eq__(self, other):
5404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5405 
 
5406 
  def __ne__(self, other):
5407 
    return not (self == other)
5408 
 
132 ashish 5409 
class getTransactionsForShoppingCartId_args:
5410 
  """
5411 
  Attributes:
5412 
   - shoppingCartId
5413 
  """
5414 
 
5415 
  thrift_spec = (
5416 
    None, # 0
5417 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
5418 
  )
5419 
 
5420 
  def __init__(self, shoppingCartId=None,):
5421 
    self.shoppingCartId = shoppingCartId
5422 
 
5423 
  def read(self, iprot):
5424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5426 
      return
5427 
    iprot.readStructBegin()
5428 
    while True:
5429 
      (fname, ftype, fid) = iprot.readFieldBegin()
5430 
      if ftype == TType.STOP:
5431 
        break
5432 
      if fid == 1:
5433 
        if ftype == TType.I64:
5434 
          self.shoppingCartId = iprot.readI64();
5435 
        else:
5436 
          iprot.skip(ftype)
5437 
      else:
5438 
        iprot.skip(ftype)
5439 
      iprot.readFieldEnd()
5440 
    iprot.readStructEnd()
5441 
 
5442 
  def write(self, oprot):
5443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5445 
      return
5446 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 5447 
    if self.shoppingCartId is not None:
132 ashish 5448 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
5449 
      oprot.writeI64(self.shoppingCartId)
5450 
      oprot.writeFieldEnd()
5451 
    oprot.writeFieldStop()
5452 
    oprot.writeStructEnd()
5453 
 
3431 rajveer 5454 
  def validate(self):
5455 
    return
5456 
 
5457 
 
132 ashish 5458 
  def __repr__(self):
5459 
    L = ['%s=%r' % (key, value)
5460 
      for key, value in self.__dict__.iteritems()]
5461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5462 
 
5463 
  def __eq__(self, other):
5464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5465 
 
5466 
  def __ne__(self, other):
5467 
    return not (self == other)
5468 
 
5469 
class getTransactionsForShoppingCartId_result:
5470 
  """
5471 
  Attributes:
5472 
   - success
5473 
   - ex
5474 
  """
5475 
 
5476 
  thrift_spec = (
5477 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5478 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5479 
  )
5480 
 
5481 
  def __init__(self, success=None, ex=None,):
5482 
    self.success = success
5483 
    self.ex = ex
5484 
 
5485 
  def read(self, iprot):
5486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5488 
      return
5489 
    iprot.readStructBegin()
5490 
    while True:
5491 
      (fname, ftype, fid) = iprot.readFieldBegin()
5492 
      if ftype == TType.STOP:
5493 
        break
5494 
      if fid == 0:
5495 
        if ftype == TType.LIST:
5496 
          self.success = []
685 chandransh 5497 
          (_etype24, _size21) = iprot.readListBegin()
5498 
          for _i25 in xrange(_size21):
5499 
            _elem26 = Transaction()
5500 
            _elem26.read(iprot)
5501 
            self.success.append(_elem26)
132 ashish 5502 
          iprot.readListEnd()
5503 
        else:
5504 
          iprot.skip(ftype)
5505 
      elif fid == 1:
5506 
        if ftype == TType.STRUCT:
5507 
          self.ex = TransactionServiceException()
5508 
          self.ex.read(iprot)
5509 
        else:
5510 
          iprot.skip(ftype)
5511 
      else:
5512 
        iprot.skip(ftype)
5513 
      iprot.readFieldEnd()
5514 
    iprot.readStructEnd()
5515 
 
5516 
  def write(self, oprot):
5517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5519 
      return
5520 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 5521 
    if self.success is not None:
132 ashish 5522 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5523 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5524 
      for iter27 in self.success:
5525 
        iter27.write(oprot)
132 ashish 5526 
      oprot.writeListEnd()
5527 
      oprot.writeFieldEnd()
3431 rajveer 5528 
    if self.ex is not None:
132 ashish 5529 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5530 
      self.ex.write(oprot)
5531 
      oprot.writeFieldEnd()
5532 
    oprot.writeFieldStop()
5533 
    oprot.writeStructEnd()
5534 
 
3431 rajveer 5535 
  def validate(self):
5536 
    return
5537 
 
5538 
 
132 ashish 5539 
  def __repr__(self):
5540 
    L = ['%s=%r' % (key, value)
5541 
      for key, value in self.__dict__.iteritems()]
5542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5543 
 
5544 
  def __eq__(self, other):
5545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5546 
 
5547 
  def __ne__(self, other):
5548 
    return not (self == other)
5549 
 
94 ashish 5550 
class getTransactionStatus_args:
5551 
  """
5552 
  Attributes:
5553 
   - transactionId
5554 
  """
5555 
 
5556 
  thrift_spec = (
5557 
    None, # 0
5558 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5559 
  )
5560 
 
5561 
  def __init__(self, transactionId=None,):
5562 
    self.transactionId = transactionId
5563 
 
5564 
  def read(self, iprot):
5565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5567 
      return
5568 
    iprot.readStructBegin()
5569 
    while True:
5570 
      (fname, ftype, fid) = iprot.readFieldBegin()
5571 
      if ftype == TType.STOP:
5572 
        break
5573 
      if fid == 1:
5574 
        if ftype == TType.I64:
5575 
          self.transactionId = iprot.readI64();
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_args')
3431 rajveer 5588 
    if self.transactionId is not None:
94 ashish 5589 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5590 
      oprot.writeI64(self.transactionId)
5591 
      oprot.writeFieldEnd()
5592 
    oprot.writeFieldStop()
5593 
    oprot.writeStructEnd()
5594 
 
3431 rajveer 5595 
  def validate(self):
5596 
    return
5597 
 
5598 
 
94 ashish 5599 
  def __repr__(self):
5600 
    L = ['%s=%r' % (key, value)
5601 
      for key, value in self.__dict__.iteritems()]
5602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5603 
 
5604 
  def __eq__(self, other):
5605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5606 
 
5607 
  def __ne__(self, other):
5608 
    return not (self == other)
5609 
 
5610 
class getTransactionStatus_result:
5611 
  """
5612 
  Attributes:
5613 
   - success
5614 
   - ex
5615 
  """
5616 
 
5617 
  thrift_spec = (
5618 
    (0, TType.I32, 'success', None, None, ), # 0
5619 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5620 
  )
5621 
 
5622 
  def __init__(self, success=None, ex=None,):
5623 
    self.success = success
5624 
    self.ex = ex
5625 
 
5626 
  def read(self, iprot):
5627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5629 
      return
5630 
    iprot.readStructBegin()
5631 
    while True:
5632 
      (fname, ftype, fid) = iprot.readFieldBegin()
5633 
      if ftype == TType.STOP:
5634 
        break
5635 
      if fid == 0:
5636 
        if ftype == TType.I32:
5637 
          self.success = iprot.readI32();
5638 
        else:
5639 
          iprot.skip(ftype)
5640 
      elif fid == 1:
5641 
        if ftype == TType.STRUCT:
5642 
          self.ex = TransactionServiceException()
5643 
          self.ex.read(iprot)
5644 
        else:
5645 
          iprot.skip(ftype)
5646 
      else:
5647 
        iprot.skip(ftype)
5648 
      iprot.readFieldEnd()
5649 
    iprot.readStructEnd()
5650 
 
5651 
  def write(self, oprot):
5652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5654 
      return
5655 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 5656 
    if self.success is not None:
94 ashish 5657 
      oprot.writeFieldBegin('success', TType.I32, 0)
5658 
      oprot.writeI32(self.success)
5659 
      oprot.writeFieldEnd()
3431 rajveer 5660 
    if self.ex is not None:
94 ashish 5661 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5662 
      self.ex.write(oprot)
5663 
      oprot.writeFieldEnd()
5664 
    oprot.writeFieldStop()
5665 
    oprot.writeStructEnd()
5666 
 
3431 rajveer 5667 
  def validate(self):
5668 
    return
5669 
 
5670 
 
94 ashish 5671 
  def __repr__(self):
5672 
    L = ['%s=%r' % (key, value)
5673 
      for key, value in self.__dict__.iteritems()]
5674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5675 
 
5676 
  def __eq__(self, other):
5677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5678 
 
5679 
  def __ne__(self, other):
5680 
    return not (self == other)
5681 
 
5682 
class changeTransactionStatus_args:
5683 
  """
5684 
  Attributes:
5685 
   - transactionId
5686 
   - status
5687 
   - description
5688 
  """
5689 
 
5690 
  thrift_spec = (
5691 
    None, # 0
5692 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5693 
    (2, TType.I32, 'status', None, None, ), # 2
5694 
    (3, TType.STRING, 'description', None, None, ), # 3
5695 
  )
5696 
 
5697 
  def __init__(self, transactionId=None, status=None, description=None,):
5698 
    self.transactionId = transactionId
5699 
    self.status = status
5700 
    self.description = description
5701 
 
5702 
  def read(self, iprot):
5703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5705 
      return
5706 
    iprot.readStructBegin()
5707 
    while True:
5708 
      (fname, ftype, fid) = iprot.readFieldBegin()
5709 
      if ftype == TType.STOP:
5710 
        break
5711 
      if fid == 1:
5712 
        if ftype == TType.I64:
5713 
          self.transactionId = iprot.readI64();
5714 
        else:
5715 
          iprot.skip(ftype)
5716 
      elif fid == 2:
5717 
        if ftype == TType.I32:
5718 
          self.status = iprot.readI32();
5719 
        else:
5720 
          iprot.skip(ftype)
5721 
      elif fid == 3:
5722 
        if ftype == TType.STRING:
5723 
          self.description = iprot.readString();
5724 
        else:
5725 
          iprot.skip(ftype)
5726 
      else:
5727 
        iprot.skip(ftype)
5728 
      iprot.readFieldEnd()
5729 
    iprot.readStructEnd()
5730 
 
5731 
  def write(self, oprot):
5732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5734 
      return
5735 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 5736 
    if self.transactionId is not None:
94 ashish 5737 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5738 
      oprot.writeI64(self.transactionId)
5739 
      oprot.writeFieldEnd()
3431 rajveer 5740 
    if self.status is not None:
94 ashish 5741 
      oprot.writeFieldBegin('status', TType.I32, 2)
5742 
      oprot.writeI32(self.status)
5743 
      oprot.writeFieldEnd()
3431 rajveer 5744 
    if self.description is not None:
94 ashish 5745 
      oprot.writeFieldBegin('description', TType.STRING, 3)
5746 
      oprot.writeString(self.description)
5747 
      oprot.writeFieldEnd()
5748 
    oprot.writeFieldStop()
5749 
    oprot.writeStructEnd()
5750 
 
3431 rajveer 5751 
  def validate(self):
5752 
    return
5753 
 
5754 
 
94 ashish 5755 
  def __repr__(self):
5756 
    L = ['%s=%r' % (key, value)
5757 
      for key, value in self.__dict__.iteritems()]
5758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5759 
 
5760 
  def __eq__(self, other):
5761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5762 
 
5763 
  def __ne__(self, other):
5764 
    return not (self == other)
5765 
 
5766 
class changeTransactionStatus_result:
5767 
  """
5768 
  Attributes:
5769 
   - success
5770 
   - ex
5771 
  """
5772 
 
5773 
  thrift_spec = (
5774 
    (0, TType.BOOL, 'success', None, None, ), # 0
5775 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5776 
  )
5777 
 
5778 
  def __init__(self, success=None, ex=None,):
5779 
    self.success = success
5780 
    self.ex = ex
5781 
 
5782 
  def read(self, iprot):
5783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5785 
      return
5786 
    iprot.readStructBegin()
5787 
    while True:
5788 
      (fname, ftype, fid) = iprot.readFieldBegin()
5789 
      if ftype == TType.STOP:
5790 
        break
5791 
      if fid == 0:
5792 
        if ftype == TType.BOOL:
5793 
          self.success = iprot.readBool();
5794 
        else:
5795 
          iprot.skip(ftype)
5796 
      elif fid == 1:
5797 
        if ftype == TType.STRUCT:
5798 
          self.ex = TransactionServiceException()
5799 
          self.ex.read(iprot)
5800 
        else:
5801 
          iprot.skip(ftype)
5802 
      else:
5803 
        iprot.skip(ftype)
5804 
      iprot.readFieldEnd()
5805 
    iprot.readStructEnd()
5806 
 
5807 
  def write(self, oprot):
5808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5810 
      return
5811 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 5812 
    if self.success is not None:
94 ashish 5813 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5814 
      oprot.writeBool(self.success)
5815 
      oprot.writeFieldEnd()
3431 rajveer 5816 
    if self.ex is not None:
94 ashish 5817 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5818 
      self.ex.write(oprot)
5819 
      oprot.writeFieldEnd()
5820 
    oprot.writeFieldStop()
5821 
    oprot.writeStructEnd()
5822 
 
3431 rajveer 5823 
  def validate(self):
5824 
    return
5825 
 
5826 
 
94 ashish 5827 
  def __repr__(self):
5828 
    L = ['%s=%r' % (key, value)
5829 
      for key, value in self.__dict__.iteritems()]
5830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5831 
 
5832 
  def __eq__(self, other):
5833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5834 
 
5835 
  def __ne__(self, other):
5836 
    return not (self == other)
5837 
 
1398 varun.gupt 5838 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 5839 
  """
5840 
  Attributes:
5841 
   - transactionId
5842 
  """
5843 
 
5844 
  thrift_spec = (
5845 
    None, # 0
5846 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5847 
  )
5848 
 
5849 
  def __init__(self, transactionId=None,):
5850 
    self.transactionId = transactionId
5851 
 
5852 
  def read(self, iprot):
5853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5855 
      return
5856 
    iprot.readStructBegin()
5857 
    while True:
5858 
      (fname, ftype, fid) = iprot.readFieldBegin()
5859 
      if ftype == TType.STOP:
5860 
        break
5861 
      if fid == 1:
5862 
        if ftype == TType.I64:
5863 
          self.transactionId = iprot.readI64();
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_args')
3431 rajveer 5876 
    if self.transactionId is not None:
1382 varun.gupt 5877 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5878 
      oprot.writeI64(self.transactionId)
5879 
      oprot.writeFieldEnd()
5880 
    oprot.writeFieldStop()
5881 
    oprot.writeStructEnd()
5882 
 
3431 rajveer 5883 
  def validate(self):
5884 
    return
5885 
 
5886 
 
1382 varun.gupt 5887 
  def __repr__(self):
5888 
    L = ['%s=%r' % (key, value)
5889 
      for key, value in self.__dict__.iteritems()]
5890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5891 
 
5892 
  def __eq__(self, other):
5893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5894 
 
5895 
  def __ne__(self, other):
5896 
    return not (self == other)
5897 
 
1398 varun.gupt 5898 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 5899 
  """
5900 
  Attributes:
5901 
   - success
5902 
   - ex
5903 
  """
5904 
 
5905 
  thrift_spec = (
5906 
    (0, TType.BOOL, 'success', None, None, ), # 0
5907 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5908 
  )
5909 
 
5910 
  def __init__(self, success=None, ex=None,):
5911 
    self.success = success
5912 
    self.ex = ex
5913 
 
5914 
  def read(self, iprot):
5915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5917 
      return
5918 
    iprot.readStructBegin()
5919 
    while True:
5920 
      (fname, ftype, fid) = iprot.readFieldBegin()
5921 
      if ftype == TType.STOP:
5922 
        break
5923 
      if fid == 0:
5924 
        if ftype == TType.BOOL:
5925 
          self.success = iprot.readBool();
5926 
        else:
5927 
          iprot.skip(ftype)
5928 
      elif fid == 1:
5929 
        if ftype == TType.STRUCT:
5930 
          self.ex = TransactionServiceException()
5931 
          self.ex.read(iprot)
5932 
        else:
5933 
          iprot.skip(ftype)
5934 
      else:
5935 
        iprot.skip(ftype)
5936 
      iprot.readFieldEnd()
5937 
    iprot.readStructEnd()
5938 
 
5939 
  def write(self, oprot):
5940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5942 
      return
1398 varun.gupt 5943 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5944 
    if self.success is not None:
1382 varun.gupt 5945 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5946 
      oprot.writeBool(self.success)
5947 
      oprot.writeFieldEnd()
3431 rajveer 5948 
    if self.ex is not None:
1382 varun.gupt 5949 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5950 
      self.ex.write(oprot)
5951 
      oprot.writeFieldEnd()
5952 
    oprot.writeFieldStop()
5953 
    oprot.writeStructEnd()
5954 
 
3431 rajveer 5955 
  def validate(self):
5956 
    return
5957 
 
5958 
 
1382 varun.gupt 5959 
  def __repr__(self):
5960 
    L = ['%s=%r' % (key, value)
5961 
      for key, value in self.__dict__.iteritems()]
5962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5963 
 
5964 
  def __eq__(self, other):
5965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5966 
 
5967 
  def __ne__(self, other):
5968 
    return not (self == other)
5969 
 
483 rajveer 5970 
class getAllOrders_args:
94 ashish 5971 
  """
5972 
  Attributes:
483 rajveer 5973 
   - status
5974 
   - from_date
5975 
   - to_date
5976 
   - warehouse_id
94 ashish 5977 
  """
5978 
 
5979 
  thrift_spec = (
5980 
    None, # 0
483 rajveer 5981 
    (1, TType.I32, 'status', None, None, ), # 1
5982 
    (2, TType.I64, 'from_date', None, None, ), # 2
5983 
    (3, TType.I64, 'to_date', None, None, ), # 3
5984 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5985 
  )
5986 
 
483 rajveer 5987 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5988 
    self.status = status
5989 
    self.from_date = from_date
5990 
    self.to_date = to_date
5991 
    self.warehouse_id = warehouse_id
94 ashish 5992 
 
5993 
  def read(self, iprot):
5994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5996 
      return
5997 
    iprot.readStructBegin()
5998 
    while True:
5999 
      (fname, ftype, fid) = iprot.readFieldBegin()
6000 
      if ftype == TType.STOP:
6001 
        break
6002 
      if fid == 1:
483 rajveer 6003 
        if ftype == TType.I32:
6004 
          self.status = iprot.readI32();
94 ashish 6005 
        else:
6006 
          iprot.skip(ftype)
483 rajveer 6007 
      elif fid == 2:
6008 
        if ftype == TType.I64:
6009 
          self.from_date = iprot.readI64();
94 ashish 6010 
        else:
6011 
          iprot.skip(ftype)
483 rajveer 6012 
      elif fid == 3:
6013 
        if ftype == TType.I64:
6014 
          self.to_date = iprot.readI64();
94 ashish 6015 
        else:
6016 
          iprot.skip(ftype)
483 rajveer 6017 
      elif fid == 4:
94 ashish 6018 
        if ftype == TType.I64:
483 rajveer 6019 
          self.warehouse_id = iprot.readI64();
94 ashish 6020 
        else:
6021 
          iprot.skip(ftype)
6022 
      else:
6023 
        iprot.skip(ftype)
6024 
      iprot.readFieldEnd()
6025 
    iprot.readStructEnd()
6026 
 
6027 
  def write(self, oprot):
6028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6030 
      return
483 rajveer 6031 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 6032 
    if self.status is not None:
483 rajveer 6033 
      oprot.writeFieldBegin('status', TType.I32, 1)
6034 
      oprot.writeI32(self.status)
94 ashish 6035 
      oprot.writeFieldEnd()
3431 rajveer 6036 
    if self.from_date is not None:
483 rajveer 6037 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6038 
      oprot.writeI64(self.from_date)
94 ashish 6039 
      oprot.writeFieldEnd()
3431 rajveer 6040 
    if self.to_date is not None:
483 rajveer 6041 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6042 
      oprot.writeI64(self.to_date)
94 ashish 6043 
      oprot.writeFieldEnd()
3431 rajveer 6044 
    if self.warehouse_id is not None:
483 rajveer 6045 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6046 
      oprot.writeI64(self.warehouse_id)
94 ashish 6047 
      oprot.writeFieldEnd()
6048 
    oprot.writeFieldStop()
6049 
    oprot.writeStructEnd()
6050 
 
3431 rajveer 6051 
  def validate(self):
6052 
    return
6053 
 
6054 
 
94 ashish 6055 
  def __repr__(self):
6056 
    L = ['%s=%r' % (key, value)
6057 
      for key, value in self.__dict__.iteritems()]
6058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6059 
 
6060 
  def __eq__(self, other):
6061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6062 
 
6063 
  def __ne__(self, other):
6064 
    return not (self == other)
6065 
 
483 rajveer 6066 
class getAllOrders_result:
94 ashish 6067 
  """
6068 
  Attributes:
6069 
   - success
6070 
   - ex
6071 
  """
6072 
 
6073 
  thrift_spec = (
483 rajveer 6074 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6075 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6076 
  )
6077 
 
6078 
  def __init__(self, success=None, ex=None,):
6079 
    self.success = success
6080 
    self.ex = ex
6081 
 
6082 
  def read(self, iprot):
6083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6085 
      return
6086 
    iprot.readStructBegin()
6087 
    while True:
6088 
      (fname, ftype, fid) = iprot.readFieldBegin()
6089 
      if ftype == TType.STOP:
6090 
        break
6091 
      if fid == 0:
483 rajveer 6092 
        if ftype == TType.LIST:
6093 
          self.success = []
685 chandransh 6094 
          (_etype31, _size28) = iprot.readListBegin()
6095 
          for _i32 in xrange(_size28):
6096 
            _elem33 = Order()
6097 
            _elem33.read(iprot)
6098 
            self.success.append(_elem33)
483 rajveer 6099 
          iprot.readListEnd()
94 ashish 6100 
        else:
6101 
          iprot.skip(ftype)
6102 
      elif fid == 1:
6103 
        if ftype == TType.STRUCT:
6104 
          self.ex = TransactionServiceException()
6105 
          self.ex.read(iprot)
6106 
        else:
6107 
          iprot.skip(ftype)
6108 
      else:
6109 
        iprot.skip(ftype)
6110 
      iprot.readFieldEnd()
6111 
    iprot.readStructEnd()
6112 
 
6113 
  def write(self, oprot):
6114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6116 
      return
483 rajveer 6117 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 6118 
    if self.success is not None:
483 rajveer 6119 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6120 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6121 
      for iter34 in self.success:
6122 
        iter34.write(oprot)
483 rajveer 6123 
      oprot.writeListEnd()
94 ashish 6124 
      oprot.writeFieldEnd()
3431 rajveer 6125 
    if self.ex is not None:
94 ashish 6126 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6127 
      self.ex.write(oprot)
6128 
      oprot.writeFieldEnd()
6129 
    oprot.writeFieldStop()
6130 
    oprot.writeStructEnd()
6131 
 
3431 rajveer 6132 
  def validate(self):
6133 
    return
6134 
 
6135 
 
94 ashish 6136 
  def __repr__(self):
6137 
    L = ['%s=%r' % (key, value)
6138 
      for key, value in self.__dict__.iteritems()]
6139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6140 
 
6141 
  def __eq__(self, other):
6142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6143 
 
6144 
  def __ne__(self, other):
6145 
    return not (self == other)
6146 
 
4133 chandransh 6147 
class getOrdersInBatch_args:
6148 
  """
6149 
  Attributes:
6150 
   - statuses
6151 
   - offset
6152 
   - limit
6153 
   - warehouse_id
6154 
  """
6155 
 
6156 
  thrift_spec = (
6157 
    None, # 0
6158 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6159 
    (2, TType.I64, 'offset', None, None, ), # 2
6160 
    (3, TType.I64, 'limit', None, None, ), # 3
6161 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6162 
  )
6163 
 
6164 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
6165 
    self.statuses = statuses
6166 
    self.offset = offset
6167 
    self.limit = limit
6168 
    self.warehouse_id = warehouse_id
6169 
 
6170 
  def read(self, iprot):
6171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6173 
      return
6174 
    iprot.readStructBegin()
6175 
    while True:
6176 
      (fname, ftype, fid) = iprot.readFieldBegin()
6177 
      if ftype == TType.STOP:
6178 
        break
6179 
      if fid == 1:
6180 
        if ftype == TType.LIST:
6181 
          self.statuses = []
6182 
          (_etype38, _size35) = iprot.readListBegin()
6183 
          for _i39 in xrange(_size35):
6184 
            _elem40 = iprot.readI32();
6185 
            self.statuses.append(_elem40)
6186 
          iprot.readListEnd()
6187 
        else:
6188 
          iprot.skip(ftype)
6189 
      elif fid == 2:
6190 
        if ftype == TType.I64:
6191 
          self.offset = iprot.readI64();
6192 
        else:
6193 
          iprot.skip(ftype)
6194 
      elif fid == 3:
6195 
        if ftype == TType.I64:
6196 
          self.limit = iprot.readI64();
6197 
        else:
6198 
          iprot.skip(ftype)
6199 
      elif fid == 4:
6200 
        if ftype == TType.I64:
6201 
          self.warehouse_id = iprot.readI64();
6202 
        else:
6203 
          iprot.skip(ftype)
6204 
      else:
6205 
        iprot.skip(ftype)
6206 
      iprot.readFieldEnd()
6207 
    iprot.readStructEnd()
6208 
 
6209 
  def write(self, oprot):
6210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6212 
      return
6213 
    oprot.writeStructBegin('getOrdersInBatch_args')
6214 
    if self.statuses is not None:
6215 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6216 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6217 
      for iter41 in self.statuses:
6218 
        oprot.writeI32(iter41)
6219 
      oprot.writeListEnd()
6220 
      oprot.writeFieldEnd()
6221 
    if self.offset is not None:
6222 
      oprot.writeFieldBegin('offset', TType.I64, 2)
6223 
      oprot.writeI64(self.offset)
6224 
      oprot.writeFieldEnd()
6225 
    if self.limit is not None:
6226 
      oprot.writeFieldBegin('limit', TType.I64, 3)
6227 
      oprot.writeI64(self.limit)
6228 
      oprot.writeFieldEnd()
6229 
    if self.warehouse_id is not None:
6230 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6231 
      oprot.writeI64(self.warehouse_id)
6232 
      oprot.writeFieldEnd()
6233 
    oprot.writeFieldStop()
6234 
    oprot.writeStructEnd()
6235 
 
6236 
  def validate(self):
6237 
    return
6238 
 
6239 
 
6240 
  def __repr__(self):
6241 
    L = ['%s=%r' % (key, value)
6242 
      for key, value in self.__dict__.iteritems()]
6243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6244 
 
6245 
  def __eq__(self, other):
6246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6247 
 
6248 
  def __ne__(self, other):
6249 
    return not (self == other)
6250 
 
6251 
class getOrdersInBatch_result:
6252 
  """
6253 
  Attributes:
6254 
   - success
6255 
   - ex
6256 
  """
6257 
 
6258 
  thrift_spec = (
6259 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6260 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6261 
  )
6262 
 
6263 
  def __init__(self, success=None, ex=None,):
6264 
    self.success = success
6265 
    self.ex = ex
6266 
 
6267 
  def read(self, iprot):
6268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6270 
      return
6271 
    iprot.readStructBegin()
6272 
    while True:
6273 
      (fname, ftype, fid) = iprot.readFieldBegin()
6274 
      if ftype == TType.STOP:
6275 
        break
6276 
      if fid == 0:
6277 
        if ftype == TType.LIST:
6278 
          self.success = []
6279 
          (_etype45, _size42) = iprot.readListBegin()
6280 
          for _i46 in xrange(_size42):
6281 
            _elem47 = Order()
6282 
            _elem47.read(iprot)
6283 
            self.success.append(_elem47)
6284 
          iprot.readListEnd()
6285 
        else:
6286 
          iprot.skip(ftype)
6287 
      elif fid == 1:
6288 
        if ftype == TType.STRUCT:
6289 
          self.ex = TransactionServiceException()
6290 
          self.ex.read(iprot)
6291 
        else:
6292 
          iprot.skip(ftype)
6293 
      else:
6294 
        iprot.skip(ftype)
6295 
      iprot.readFieldEnd()
6296 
    iprot.readStructEnd()
6297 
 
6298 
  def write(self, oprot):
6299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6301 
      return
6302 
    oprot.writeStructBegin('getOrdersInBatch_result')
6303 
    if self.success is not None:
6304 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6305 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6306 
      for iter48 in self.success:
6307 
        iter48.write(oprot)
6308 
      oprot.writeListEnd()
6309 
      oprot.writeFieldEnd()
6310 
    if self.ex is not None:
6311 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6312 
      self.ex.write(oprot)
6313 
      oprot.writeFieldEnd()
6314 
    oprot.writeFieldStop()
6315 
    oprot.writeStructEnd()
6316 
 
6317 
  def validate(self):
6318 
    return
6319 
 
6320 
 
6321 
  def __repr__(self):
6322 
    L = ['%s=%r' % (key, value)
6323 
      for key, value in self.__dict__.iteritems()]
6324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6325 
 
6326 
  def __eq__(self, other):
6327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6328 
 
6329 
  def __ne__(self, other):
6330 
    return not (self == other)
6331 
 
6332 
class getOrderCount_args:
6333 
  """
6334 
  Attributes:
6335 
   - statuses
6336 
   - warehouseId
6337 
  """
6338 
 
6339 
  thrift_spec = (
6340 
    None, # 0
6341 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6342 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6343 
  )
6344 
 
6345 
  def __init__(self, statuses=None, warehouseId=None,):
6346 
    self.statuses = statuses
6347 
    self.warehouseId = warehouseId
6348 
 
6349 
  def read(self, iprot):
6350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6352 
      return
6353 
    iprot.readStructBegin()
6354 
    while True:
6355 
      (fname, ftype, fid) = iprot.readFieldBegin()
6356 
      if ftype == TType.STOP:
6357 
        break
6358 
      if fid == 1:
6359 
        if ftype == TType.LIST:
6360 
          self.statuses = []
6361 
          (_etype52, _size49) = iprot.readListBegin()
6362 
          for _i53 in xrange(_size49):
6363 
            _elem54 = iprot.readI32();
6364 
            self.statuses.append(_elem54)
6365 
          iprot.readListEnd()
6366 
        else:
6367 
          iprot.skip(ftype)
6368 
      elif fid == 2:
6369 
        if ftype == TType.I64:
6370 
          self.warehouseId = iprot.readI64();
6371 
        else:
6372 
          iprot.skip(ftype)
6373 
      else:
6374 
        iprot.skip(ftype)
6375 
      iprot.readFieldEnd()
6376 
    iprot.readStructEnd()
6377 
 
6378 
  def write(self, oprot):
6379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6381 
      return
6382 
    oprot.writeStructBegin('getOrderCount_args')
6383 
    if self.statuses is not None:
6384 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6385 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6386 
      for iter55 in self.statuses:
6387 
        oprot.writeI32(iter55)
6388 
      oprot.writeListEnd()
6389 
      oprot.writeFieldEnd()
6390 
    if self.warehouseId is not None:
6391 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6392 
      oprot.writeI64(self.warehouseId)
6393 
      oprot.writeFieldEnd()
6394 
    oprot.writeFieldStop()
6395 
    oprot.writeStructEnd()
6396 
 
6397 
  def validate(self):
6398 
    return
6399 
 
6400 
 
6401 
  def __repr__(self):
6402 
    L = ['%s=%r' % (key, value)
6403 
      for key, value in self.__dict__.iteritems()]
6404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6405 
 
6406 
  def __eq__(self, other):
6407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6408 
 
6409 
  def __ne__(self, other):
6410 
    return not (self == other)
6411 
 
6412 
class getOrderCount_result:
6413 
  """
6414 
  Attributes:
6415 
   - success
6416 
   - ex
6417 
  """
6418 
 
6419 
  thrift_spec = (
6420 
    (0, TType.I32, 'success', None, None, ), # 0
6421 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6422 
  )
6423 
 
6424 
  def __init__(self, success=None, ex=None,):
6425 
    self.success = success
6426 
    self.ex = ex
6427 
 
6428 
  def read(self, iprot):
6429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6431 
      return
6432 
    iprot.readStructBegin()
6433 
    while True:
6434 
      (fname, ftype, fid) = iprot.readFieldBegin()
6435 
      if ftype == TType.STOP:
6436 
        break
6437 
      if fid == 0:
6438 
        if ftype == TType.I32:
6439 
          self.success = iprot.readI32();
6440 
        else:
6441 
          iprot.skip(ftype)
6442 
      elif fid == 1:
6443 
        if ftype == TType.STRUCT:
6444 
          self.ex = TransactionServiceException()
6445 
          self.ex.read(iprot)
6446 
        else:
6447 
          iprot.skip(ftype)
6448 
      else:
6449 
        iprot.skip(ftype)
6450 
      iprot.readFieldEnd()
6451 
    iprot.readStructEnd()
6452 
 
6453 
  def write(self, oprot):
6454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6456 
      return
6457 
    oprot.writeStructBegin('getOrderCount_result')
6458 
    if self.success is not None:
6459 
      oprot.writeFieldBegin('success', TType.I32, 0)
6460 
      oprot.writeI32(self.success)
6461 
      oprot.writeFieldEnd()
6462 
    if self.ex is not None:
6463 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6464 
      self.ex.write(oprot)
6465 
      oprot.writeFieldEnd()
6466 
    oprot.writeFieldStop()
6467 
    oprot.writeStructEnd()
6468 
 
6469 
  def validate(self):
6470 
    return
6471 
 
6472 
 
6473 
  def __repr__(self):
6474 
    L = ['%s=%r' % (key, value)
6475 
      for key, value in self.__dict__.iteritems()]
6476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6477 
 
6478 
  def __eq__(self, other):
6479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6480 
 
6481 
  def __ne__(self, other):
6482 
    return not (self == other)
6483 
 
999 varun.gupt 6484 
class getOrdersByBillingDate_args:
6485 
  """
6486 
  Attributes:
6487 
   - status
6488 
   - start_billing_date
6489 
   - end_billing_date
6490 
   - warehouse_id
6491 
  """
6492 
 
6493 
  thrift_spec = (
6494 
    None, # 0
6495 
    (1, TType.I32, 'status', None, None, ), # 1
6496 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
6497 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
6498 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6499 
  )
6500 
 
6501 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
6502 
    self.status = status
6503 
    self.start_billing_date = start_billing_date
6504 
    self.end_billing_date = end_billing_date
6505 
    self.warehouse_id = warehouse_id
6506 
 
6507 
  def read(self, iprot):
6508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6510 
      return
6511 
    iprot.readStructBegin()
6512 
    while True:
6513 
      (fname, ftype, fid) = iprot.readFieldBegin()
6514 
      if ftype == TType.STOP:
6515 
        break
6516 
      if fid == 1:
6517 
        if ftype == TType.I32:
6518 
          self.status = iprot.readI32();
6519 
        else:
6520 
          iprot.skip(ftype)
6521 
      elif fid == 2:
6522 
        if ftype == TType.I64:
6523 
          self.start_billing_date = iprot.readI64();
6524 
        else:
6525 
          iprot.skip(ftype)
6526 
      elif fid == 3:
6527 
        if ftype == TType.I64:
6528 
          self.end_billing_date = iprot.readI64();
6529 
        else:
6530 
          iprot.skip(ftype)
6531 
      elif fid == 4:
6532 
        if ftype == TType.I64:
6533 
          self.warehouse_id = iprot.readI64();
6534 
        else:
6535 
          iprot.skip(ftype)
6536 
      else:
6537 
        iprot.skip(ftype)
6538 
      iprot.readFieldEnd()
6539 
    iprot.readStructEnd()
6540 
 
6541 
  def write(self, oprot):
6542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6544 
      return
6545 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 6546 
    if self.status is not None:
999 varun.gupt 6547 
      oprot.writeFieldBegin('status', TType.I32, 1)
6548 
      oprot.writeI32(self.status)
6549 
      oprot.writeFieldEnd()
3431 rajveer 6550 
    if self.start_billing_date is not None:
999 varun.gupt 6551 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
6552 
      oprot.writeI64(self.start_billing_date)
6553 
      oprot.writeFieldEnd()
3431 rajveer 6554 
    if self.end_billing_date is not None:
999 varun.gupt 6555 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
6556 
      oprot.writeI64(self.end_billing_date)
6557 
      oprot.writeFieldEnd()
3431 rajveer 6558 
    if self.warehouse_id is not None:
999 varun.gupt 6559 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6560 
      oprot.writeI64(self.warehouse_id)
6561 
      oprot.writeFieldEnd()
6562 
    oprot.writeFieldStop()
6563 
    oprot.writeStructEnd()
6564 
 
3431 rajveer 6565 
  def validate(self):
6566 
    return
6567 
 
6568 
 
999 varun.gupt 6569 
  def __repr__(self):
6570 
    L = ['%s=%r' % (key, value)
6571 
      for key, value in self.__dict__.iteritems()]
6572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6573 
 
6574 
  def __eq__(self, other):
6575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6576 
 
6577 
  def __ne__(self, other):
6578 
    return not (self == other)
6579 
 
6580 
class getOrdersByBillingDate_result:
6581 
  """
6582 
  Attributes:
6583 
   - success
6584 
   - ex
6585 
  """
6586 
 
6587 
  thrift_spec = (
6588 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6589 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6590 
  )
6591 
 
6592 
  def __init__(self, success=None, ex=None,):
6593 
    self.success = success
6594 
    self.ex = ex
6595 
 
6596 
  def read(self, iprot):
6597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6599 
      return
6600 
    iprot.readStructBegin()
6601 
    while True:
6602 
      (fname, ftype, fid) = iprot.readFieldBegin()
6603 
      if ftype == TType.STOP:
6604 
        break
6605 
      if fid == 0:
6606 
        if ftype == TType.LIST:
6607 
          self.success = []
4133 chandransh 6608 
          (_etype59, _size56) = iprot.readListBegin()
6609 
          for _i60 in xrange(_size56):
6610 
            _elem61 = Order()
6611 
            _elem61.read(iprot)
6612 
            self.success.append(_elem61)
999 varun.gupt 6613 
          iprot.readListEnd()
6614 
        else:
6615 
          iprot.skip(ftype)
6616 
      elif fid == 1:
6617 
        if ftype == TType.STRUCT:
6618 
          self.ex = TransactionServiceException()
6619 
          self.ex.read(iprot)
6620 
        else:
6621 
          iprot.skip(ftype)
6622 
      else:
6623 
        iprot.skip(ftype)
6624 
      iprot.readFieldEnd()
6625 
    iprot.readStructEnd()
6626 
 
6627 
  def write(self, oprot):
6628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6630 
      return
6631 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 6632 
    if self.success is not None:
999 varun.gupt 6633 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6634 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6635 
      for iter62 in self.success:
6636 
        iter62.write(oprot)
999 varun.gupt 6637 
      oprot.writeListEnd()
6638 
      oprot.writeFieldEnd()
3431 rajveer 6639 
    if self.ex is not None:
999 varun.gupt 6640 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6641 
      self.ex.write(oprot)
6642 
      oprot.writeFieldEnd()
6643 
    oprot.writeFieldStop()
6644 
    oprot.writeStructEnd()
6645 
 
3431 rajveer 6646 
  def validate(self):
6647 
    return
6648 
 
6649 
 
999 varun.gupt 6650 
  def __repr__(self):
6651 
    L = ['%s=%r' % (key, value)
6652 
      for key, value in self.__dict__.iteritems()]
6653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6654 
 
6655 
  def __eq__(self, other):
6656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6657 
 
6658 
  def __ne__(self, other):
6659 
    return not (self == other)
6660 
 
3427 chandransh 6661 
class getOrdersByShippingDate_args:
6662 
  """
6663 
  Attributes:
6664 
   - fromShippingDate
6665 
   - toShippingDate
6666 
   - providerId
6667 
   - warehouseId
3451 chandransh 6668 
   - cod
3427 chandransh 6669 
  """
6670 
 
6671 
  thrift_spec = (
6672 
    None, # 0
6673 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
6674 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
6675 
    (3, TType.I64, 'providerId', None, None, ), # 3
6676 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 6677 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 6678 
  )
6679 
 
3451 chandransh 6680 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 6681 
    self.fromShippingDate = fromShippingDate
6682 
    self.toShippingDate = toShippingDate
6683 
    self.providerId = providerId
6684 
    self.warehouseId = warehouseId
3451 chandransh 6685 
    self.cod = cod
3427 chandransh 6686 
 
6687 
  def read(self, iprot):
6688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6690 
      return
6691 
    iprot.readStructBegin()
6692 
    while True:
6693 
      (fname, ftype, fid) = iprot.readFieldBegin()
6694 
      if ftype == TType.STOP:
6695 
        break
6696 
      if fid == 1:
6697 
        if ftype == TType.I64:
6698 
          self.fromShippingDate = iprot.readI64();
6699 
        else:
6700 
          iprot.skip(ftype)
6701 
      elif fid == 2:
6702 
        if ftype == TType.I64:
6703 
          self.toShippingDate = iprot.readI64();
6704 
        else:
6705 
          iprot.skip(ftype)
6706 
      elif fid == 3:
6707 
        if ftype == TType.I64:
6708 
          self.providerId = iprot.readI64();
6709 
        else:
6710 
          iprot.skip(ftype)
6711 
      elif fid == 4:
6712 
        if ftype == TType.I64:
6713 
          self.warehouseId = iprot.readI64();
6714 
        else:
6715 
          iprot.skip(ftype)
3451 chandransh 6716 
      elif fid == 5:
6717 
        if ftype == TType.BOOL:
6718 
          self.cod = iprot.readBool();
6719 
        else:
6720 
          iprot.skip(ftype)
3427 chandransh 6721 
      else:
6722 
        iprot.skip(ftype)
6723 
      iprot.readFieldEnd()
6724 
    iprot.readStructEnd()
6725 
 
6726 
  def write(self, oprot):
6727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6729 
      return
6730 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 6731 
    if self.fromShippingDate is not None:
3427 chandransh 6732 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
6733 
      oprot.writeI64(self.fromShippingDate)
6734 
      oprot.writeFieldEnd()
3431 rajveer 6735 
    if self.toShippingDate is not None:
3427 chandransh 6736 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
6737 
      oprot.writeI64(self.toShippingDate)
6738 
      oprot.writeFieldEnd()
3431 rajveer 6739 
    if self.providerId is not None:
3427 chandransh 6740 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
6741 
      oprot.writeI64(self.providerId)
6742 
      oprot.writeFieldEnd()
3431 rajveer 6743 
    if self.warehouseId is not None:
3427 chandransh 6744 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
6745 
      oprot.writeI64(self.warehouseId)
6746 
      oprot.writeFieldEnd()
3451 chandransh 6747 
    if self.cod is not None:
6748 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
6749 
      oprot.writeBool(self.cod)
6750 
      oprot.writeFieldEnd()
3427 chandransh 6751 
    oprot.writeFieldStop()
6752 
    oprot.writeStructEnd()
6753 
 
3431 rajveer 6754 
  def validate(self):
6755 
    return
6756 
 
6757 
 
3427 chandransh 6758 
  def __repr__(self):
6759 
    L = ['%s=%r' % (key, value)
6760 
      for key, value in self.__dict__.iteritems()]
6761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6762 
 
6763 
  def __eq__(self, other):
6764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6765 
 
6766 
  def __ne__(self, other):
6767 
    return not (self == other)
6768 
 
6769 
class getOrdersByShippingDate_result:
6770 
  """
6771 
  Attributes:
6772 
   - success
6773 
   - ex
6774 
  """
6775 
 
6776 
  thrift_spec = (
6777 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6778 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6779 
  )
6780 
 
6781 
  def __init__(self, success=None, ex=None,):
6782 
    self.success = success
6783 
    self.ex = ex
6784 
 
6785 
  def read(self, iprot):
6786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6788 
      return
6789 
    iprot.readStructBegin()
6790 
    while True:
6791 
      (fname, ftype, fid) = iprot.readFieldBegin()
6792 
      if ftype == TType.STOP:
6793 
        break
6794 
      if fid == 0:
6795 
        if ftype == TType.LIST:
6796 
          self.success = []
4133 chandransh 6797 
          (_etype66, _size63) = iprot.readListBegin()
6798 
          for _i67 in xrange(_size63):
6799 
            _elem68 = Order()
6800 
            _elem68.read(iprot)
6801 
            self.success.append(_elem68)
3427 chandransh 6802 
          iprot.readListEnd()
6803 
        else:
6804 
          iprot.skip(ftype)
6805 
      elif fid == 1:
6806 
        if ftype == TType.STRUCT:
6807 
          self.ex = TransactionServiceException()
6808 
          self.ex.read(iprot)
6809 
        else:
6810 
          iprot.skip(ftype)
6811 
      else:
6812 
        iprot.skip(ftype)
6813 
      iprot.readFieldEnd()
6814 
    iprot.readStructEnd()
6815 
 
6816 
  def write(self, oprot):
6817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6819 
      return
6820 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 6821 
    if self.success is not None:
3427 chandransh 6822 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6823 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6824 
      for iter69 in self.success:
6825 
        iter69.write(oprot)
3427 chandransh 6826 
      oprot.writeListEnd()
6827 
      oprot.writeFieldEnd()
3431 rajveer 6828 
    if self.ex is not None:
3427 chandransh 6829 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6830 
      self.ex.write(oprot)
6831 
      oprot.writeFieldEnd()
6832 
    oprot.writeFieldStop()
6833 
    oprot.writeStructEnd()
6834 
 
3431 rajveer 6835 
  def validate(self):
6836 
    return
6837 
 
6838 
 
3427 chandransh 6839 
  def __repr__(self):
6840 
    L = ['%s=%r' % (key, value)
6841 
      for key, value in self.__dict__.iteritems()]
6842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6843 
 
6844 
  def __eq__(self, other):
6845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6846 
 
6847 
  def __ne__(self, other):
6848 
    return not (self == other)
6849 
 
1382 varun.gupt 6850 
class getReturnableOrdersForCustomer_args:
6851 
  """
6852 
  Attributes:
6853 
   - customer_id
6854 
   - limit
6855 
  """
6856 
 
6857 
  thrift_spec = (
6858 
    None, # 0
6859 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6860 
    (2, TType.I64, 'limit', None, None, ), # 2
6861 
  )
6862 
 
6863 
  def __init__(self, customer_id=None, limit=None,):
6864 
    self.customer_id = customer_id
6865 
    self.limit = limit
6866 
 
6867 
  def read(self, iprot):
6868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6870 
      return
6871 
    iprot.readStructBegin()
6872 
    while True:
6873 
      (fname, ftype, fid) = iprot.readFieldBegin()
6874 
      if ftype == TType.STOP:
6875 
        break
6876 
      if fid == 1:
6877 
        if ftype == TType.I64:
6878 
          self.customer_id = iprot.readI64();
6879 
        else:
6880 
          iprot.skip(ftype)
6881 
      elif fid == 2:
6882 
        if ftype == TType.I64:
6883 
          self.limit = iprot.readI64();
6884 
        else:
6885 
          iprot.skip(ftype)
6886 
      else:
6887 
        iprot.skip(ftype)
6888 
      iprot.readFieldEnd()
6889 
    iprot.readStructEnd()
6890 
 
6891 
  def write(self, oprot):
6892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6894 
      return
6895 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 6896 
    if self.customer_id is not None:
1382 varun.gupt 6897 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6898 
      oprot.writeI64(self.customer_id)
6899 
      oprot.writeFieldEnd()
3431 rajveer 6900 
    if self.limit is not None:
1382 varun.gupt 6901 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6902 
      oprot.writeI64(self.limit)
6903 
      oprot.writeFieldEnd()
6904 
    oprot.writeFieldStop()
6905 
    oprot.writeStructEnd()
6906 
 
3431 rajveer 6907 
  def validate(self):
6908 
    return
6909 
 
6910 
 
1382 varun.gupt 6911 
  def __repr__(self):
6912 
    L = ['%s=%r' % (key, value)
6913 
      for key, value in self.__dict__.iteritems()]
6914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6915 
 
6916 
  def __eq__(self, other):
6917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6918 
 
6919 
  def __ne__(self, other):
6920 
    return not (self == other)
6921 
 
6922 
class getReturnableOrdersForCustomer_result:
6923 
  """
6924 
  Attributes:
6925 
   - success
6926 
   - ex
6927 
  """
6928 
 
6929 
  thrift_spec = (
6930 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6931 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6932 
  )
6933 
 
6934 
  def __init__(self, success=None, ex=None,):
6935 
    self.success = success
6936 
    self.ex = ex
6937 
 
6938 
  def read(self, iprot):
6939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6941 
      return
6942 
    iprot.readStructBegin()
6943 
    while True:
6944 
      (fname, ftype, fid) = iprot.readFieldBegin()
6945 
      if ftype == TType.STOP:
6946 
        break
6947 
      if fid == 0:
6948 
        if ftype == TType.LIST:
6949 
          self.success = []
4133 chandransh 6950 
          (_etype73, _size70) = iprot.readListBegin()
6951 
          for _i74 in xrange(_size70):
6952 
            _elem75 = iprot.readI64();
6953 
            self.success.append(_elem75)
1382 varun.gupt 6954 
          iprot.readListEnd()
6955 
        else:
6956 
          iprot.skip(ftype)
6957 
      elif fid == 1:
6958 
        if ftype == TType.STRUCT:
6959 
          self.ex = TransactionServiceException()
6960 
          self.ex.read(iprot)
6961 
        else:
6962 
          iprot.skip(ftype)
6963 
      else:
6964 
        iprot.skip(ftype)
6965 
      iprot.readFieldEnd()
6966 
    iprot.readStructEnd()
6967 
 
6968 
  def write(self, oprot):
6969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6971 
      return
6972 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6973 
    if self.success is not None:
1382 varun.gupt 6974 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6975 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6976 
      for iter76 in self.success:
6977 
        oprot.writeI64(iter76)
1382 varun.gupt 6978 
      oprot.writeListEnd()
6979 
      oprot.writeFieldEnd()
3431 rajveer 6980 
    if self.ex is not None:
1382 varun.gupt 6981 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6982 
      self.ex.write(oprot)
6983 
      oprot.writeFieldEnd()
6984 
    oprot.writeFieldStop()
6985 
    oprot.writeStructEnd()
6986 
 
3431 rajveer 6987 
  def validate(self):
6988 
    return
6989 
 
6990 
 
1382 varun.gupt 6991 
  def __repr__(self):
6992 
    L = ['%s=%r' % (key, value)
6993 
      for key, value in self.__dict__.iteritems()]
6994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6995 
 
6996 
  def __eq__(self, other):
6997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6998 
 
6999 
  def __ne__(self, other):
7000 
    return not (self == other)
7001 
 
7002 
class getCancellableOrdersForCustomer_args:
7003 
  """
7004 
  Attributes:
7005 
   - customer_id
7006 
   - limit
7007 
  """
7008 
 
7009 
  thrift_spec = (
7010 
    None, # 0
7011 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7012 
    (2, TType.I64, 'limit', None, None, ), # 2
7013 
  )
7014 
 
7015 
  def __init__(self, customer_id=None, limit=None,):
7016 
    self.customer_id = customer_id
7017 
    self.limit = limit
7018 
 
7019 
  def read(self, iprot):
7020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7022 
      return
7023 
    iprot.readStructBegin()
7024 
    while True:
7025 
      (fname, ftype, fid) = iprot.readFieldBegin()
7026 
      if ftype == TType.STOP:
7027 
        break
7028 
      if fid == 1:
7029 
        if ftype == TType.I64:
7030 
          self.customer_id = iprot.readI64();
7031 
        else:
7032 
          iprot.skip(ftype)
7033 
      elif fid == 2:
7034 
        if ftype == TType.I64:
7035 
          self.limit = iprot.readI64();
7036 
        else:
7037 
          iprot.skip(ftype)
7038 
      else:
7039 
        iprot.skip(ftype)
7040 
      iprot.readFieldEnd()
7041 
    iprot.readStructEnd()
7042 
 
7043 
  def write(self, oprot):
7044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7046 
      return
7047 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7048 
    if self.customer_id is not None:
1382 varun.gupt 7049 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7050 
      oprot.writeI64(self.customer_id)
7051 
      oprot.writeFieldEnd()
3431 rajveer 7052 
    if self.limit is not None:
1382 varun.gupt 7053 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7054 
      oprot.writeI64(self.limit)
7055 
      oprot.writeFieldEnd()
7056 
    oprot.writeFieldStop()
7057 
    oprot.writeStructEnd()
7058 
 
3431 rajveer 7059 
  def validate(self):
7060 
    return
7061 
 
7062 
 
1382 varun.gupt 7063 
  def __repr__(self):
7064 
    L = ['%s=%r' % (key, value)
7065 
      for key, value in self.__dict__.iteritems()]
7066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7067 
 
7068 
  def __eq__(self, other):
7069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7070 
 
7071 
  def __ne__(self, other):
7072 
    return not (self == other)
7073 
 
7074 
class getCancellableOrdersForCustomer_result:
7075 
  """
7076 
  Attributes:
7077 
   - success
7078 
   - ex
7079 
  """
7080 
 
7081 
  thrift_spec = (
7082 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7083 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7084 
  )
7085 
 
7086 
  def __init__(self, success=None, ex=None,):
7087 
    self.success = success
7088 
    self.ex = ex
7089 
 
7090 
  def read(self, iprot):
7091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7093 
      return
7094 
    iprot.readStructBegin()
7095 
    while True:
7096 
      (fname, ftype, fid) = iprot.readFieldBegin()
7097 
      if ftype == TType.STOP:
7098 
        break
7099 
      if fid == 0:
7100 
        if ftype == TType.LIST:
7101 
          self.success = []
4133 chandransh 7102 
          (_etype80, _size77) = iprot.readListBegin()
7103 
          for _i81 in xrange(_size77):
7104 
            _elem82 = iprot.readI64();
7105 
            self.success.append(_elem82)
1382 varun.gupt 7106 
          iprot.readListEnd()
7107 
        else:
7108 
          iprot.skip(ftype)
7109 
      elif fid == 1:
7110 
        if ftype == TType.STRUCT:
7111 
          self.ex = TransactionServiceException()
7112 
          self.ex.read(iprot)
7113 
        else:
7114 
          iprot.skip(ftype)
7115 
      else:
7116 
        iprot.skip(ftype)
7117 
      iprot.readFieldEnd()
7118 
    iprot.readStructEnd()
7119 
 
7120 
  def write(self, oprot):
7121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7123 
      return
7124 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 7125 
    if self.success is not None:
1382 varun.gupt 7126 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7127 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7128 
      for iter83 in self.success:
7129 
        oprot.writeI64(iter83)
1382 varun.gupt 7130 
      oprot.writeListEnd()
7131 
      oprot.writeFieldEnd()
3431 rajveer 7132 
    if self.ex is not None:
1382 varun.gupt 7133 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7134 
      self.ex.write(oprot)
7135 
      oprot.writeFieldEnd()
7136 
    oprot.writeFieldStop()
7137 
    oprot.writeStructEnd()
7138 
 
3431 rajveer 7139 
  def validate(self):
7140 
    return
7141 
 
7142 
 
1382 varun.gupt 7143 
  def __repr__(self):
7144 
    L = ['%s=%r' % (key, value)
7145 
      for key, value in self.__dict__.iteritems()]
7146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7147 
 
7148 
  def __eq__(self, other):
7149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7150 
 
7151 
  def __ne__(self, other):
7152 
    return not (self == other)
7153 
 
483 rajveer 7154 
class changeOrderStatus_args:
94 ashish 7155 
  """
7156 
  Attributes:
483 rajveer 7157 
   - orderId
7158 
   - status
7159 
   - description
94 ashish 7160 
  """
7161 
 
7162 
  thrift_spec = (
7163 
    None, # 0
483 rajveer 7164 
    (1, TType.I64, 'orderId', None, None, ), # 1
7165 
    (2, TType.I32, 'status', None, None, ), # 2
7166 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 7167 
  )
7168 
 
483 rajveer 7169 
  def __init__(self, orderId=None, status=None, description=None,):
7170 
    self.orderId = orderId
7171 
    self.status = status
7172 
    self.description = description
94 ashish 7173 
 
7174 
  def read(self, iprot):
7175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7177 
      return
7178 
    iprot.readStructBegin()
7179 
    while True:
7180 
      (fname, ftype, fid) = iprot.readFieldBegin()
7181 
      if ftype == TType.STOP:
7182 
        break
7183 
      if fid == 1:
7184 
        if ftype == TType.I64:
483 rajveer 7185 
          self.orderId = iprot.readI64();
94 ashish 7186 
        else:
7187 
          iprot.skip(ftype)
7188 
      elif fid == 2:
483 rajveer 7189 
        if ftype == TType.I32:
7190 
          self.status = iprot.readI32();
94 ashish 7191 
        else:
7192 
          iprot.skip(ftype)
483 rajveer 7193 
      elif fid == 3:
7194 
        if ftype == TType.STRING:
7195 
          self.description = iprot.readString();
7196 
        else:
7197 
          iprot.skip(ftype)
94 ashish 7198 
      else:
7199 
        iprot.skip(ftype)
7200 
      iprot.readFieldEnd()
7201 
    iprot.readStructEnd()
7202 
 
7203 
  def write(self, oprot):
7204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7206 
      return
483 rajveer 7207 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 7208 
    if self.orderId is not None:
483 rajveer 7209 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7210 
      oprot.writeI64(self.orderId)
94 ashish 7211 
      oprot.writeFieldEnd()
3431 rajveer 7212 
    if self.status is not None:
483 rajveer 7213 
      oprot.writeFieldBegin('status', TType.I32, 2)
7214 
      oprot.writeI32(self.status)
94 ashish 7215 
      oprot.writeFieldEnd()
3431 rajveer 7216 
    if self.description is not None:
483 rajveer 7217 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7218 
      oprot.writeString(self.description)
7219 
      oprot.writeFieldEnd()
94 ashish 7220 
    oprot.writeFieldStop()
7221 
    oprot.writeStructEnd()
7222 
 
3431 rajveer 7223 
  def validate(self):
7224 
    return
7225 
 
7226 
 
94 ashish 7227 
  def __repr__(self):
7228 
    L = ['%s=%r' % (key, value)
7229 
      for key, value in self.__dict__.iteritems()]
7230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7231 
 
7232 
  def __eq__(self, other):
7233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7234 
 
7235 
  def __ne__(self, other):
7236 
    return not (self == other)
7237 
 
483 rajveer 7238 
class changeOrderStatus_result:
94 ashish 7239 
  """
7240 
  Attributes:
7241 
   - success
7242 
   - ex
7243 
  """
7244 
 
7245 
  thrift_spec = (
7246 
    (0, TType.BOOL, 'success', None, None, ), # 0
7247 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7248 
  )
7249 
 
7250 
  def __init__(self, success=None, ex=None,):
7251 
    self.success = success
7252 
    self.ex = ex
7253 
 
7254 
  def read(self, iprot):
7255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7257 
      return
7258 
    iprot.readStructBegin()
7259 
    while True:
7260 
      (fname, ftype, fid) = iprot.readFieldBegin()
7261 
      if ftype == TType.STOP:
7262 
        break
7263 
      if fid == 0:
7264 
        if ftype == TType.BOOL:
7265 
          self.success = iprot.readBool();
7266 
        else:
7267 
          iprot.skip(ftype)
7268 
      elif fid == 1:
7269 
        if ftype == TType.STRUCT:
7270 
          self.ex = TransactionServiceException()
7271 
          self.ex.read(iprot)
7272 
        else:
7273 
          iprot.skip(ftype)
7274 
      else:
7275 
        iprot.skip(ftype)
7276 
      iprot.readFieldEnd()
7277 
    iprot.readStructEnd()
7278 
 
7279 
  def write(self, oprot):
7280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7282 
      return
483 rajveer 7283 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 7284 
    if self.success is not None:
94 ashish 7285 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7286 
      oprot.writeBool(self.success)
7287 
      oprot.writeFieldEnd()
3431 rajveer 7288 
    if self.ex is not None:
94 ashish 7289 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7290 
      self.ex.write(oprot)
7291 
      oprot.writeFieldEnd()
7292 
    oprot.writeFieldStop()
7293 
    oprot.writeStructEnd()
7294 
 
3431 rajveer 7295 
  def validate(self):
7296 
    return
7297 
 
7298 
 
94 ashish 7299 
  def __repr__(self):
7300 
    L = ['%s=%r' % (key, value)
7301 
      for key, value in self.__dict__.iteritems()]
7302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7303 
 
7304 
  def __eq__(self, other):
7305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7306 
 
7307 
  def __ne__(self, other):
7308 
    return not (self == other)
7309 
 
3064 chandransh 7310 
class getOrdersForTransaction_args:
494 rajveer 7311 
  """
7312 
  Attributes:
3064 chandransh 7313 
   - transactionId
7314 
   - customerId
494 rajveer 7315 
  """
7316 
 
7317 
  thrift_spec = (
7318 
    None, # 0
3064 chandransh 7319 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7320 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 7321 
  )
7322 
 
3064 chandransh 7323 
  def __init__(self, transactionId=None, customerId=None,):
7324 
    self.transactionId = transactionId
7325 
    self.customerId = customerId
494 rajveer 7326 
 
7327 
  def read(self, iprot):
7328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7330 
      return
7331 
    iprot.readStructBegin()
7332 
    while True:
7333 
      (fname, ftype, fid) = iprot.readFieldBegin()
7334 
      if ftype == TType.STOP:
7335 
        break
7336 
      if fid == 1:
7337 
        if ftype == TType.I64:
3064 chandransh 7338 
          self.transactionId = iprot.readI64();
494 rajveer 7339 
        else:
7340 
          iprot.skip(ftype)
7341 
      elif fid == 2:
3064 chandransh 7342 
        if ftype == TType.I64:
7343 
          self.customerId = iprot.readI64();
494 rajveer 7344 
        else:
7345 
          iprot.skip(ftype)
7346 
      else:
7347 
        iprot.skip(ftype)
7348 
      iprot.readFieldEnd()
7349 
    iprot.readStructEnd()
7350 
 
7351 
  def write(self, oprot):
7352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7354 
      return
3064 chandransh 7355 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 7356 
    if self.transactionId is not None:
3064 chandransh 7357 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7358 
      oprot.writeI64(self.transactionId)
494 rajveer 7359 
      oprot.writeFieldEnd()
3431 rajveer 7360 
    if self.customerId is not None:
3064 chandransh 7361 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
7362 
      oprot.writeI64(self.customerId)
494 rajveer 7363 
      oprot.writeFieldEnd()
7364 
    oprot.writeFieldStop()
7365 
    oprot.writeStructEnd()
7366 
 
3431 rajveer 7367 
  def validate(self):
7368 
    return
7369 
 
7370 
 
494 rajveer 7371 
  def __repr__(self):
7372 
    L = ['%s=%r' % (key, value)
7373 
      for key, value in self.__dict__.iteritems()]
7374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7375 
 
7376 
  def __eq__(self, other):
7377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7378 
 
7379 
  def __ne__(self, other):
7380 
    return not (self == other)
7381 
 
3064 chandransh 7382 
class getOrdersForTransaction_result:
494 rajveer 7383 
  """
7384 
  Attributes:
7385 
   - success
7386 
   - ex
7387 
  """
7388 
 
7389 
  thrift_spec = (
3064 chandransh 7390 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 7391 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7392 
  )
7393 
 
7394 
  def __init__(self, success=None, ex=None,):
7395 
    self.success = success
7396 
    self.ex = ex
7397 
 
7398 
  def read(self, iprot):
7399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7401 
      return
7402 
    iprot.readStructBegin()
7403 
    while True:
7404 
      (fname, ftype, fid) = iprot.readFieldBegin()
7405 
      if ftype == TType.STOP:
7406 
        break
7407 
      if fid == 0:
3064 chandransh 7408 
        if ftype == TType.LIST:
7409 
          self.success = []
4133 chandransh 7410 
          (_etype87, _size84) = iprot.readListBegin()
7411 
          for _i88 in xrange(_size84):
7412 
            _elem89 = Order()
7413 
            _elem89.read(iprot)
7414 
            self.success.append(_elem89)
3064 chandransh 7415 
          iprot.readListEnd()
494 rajveer 7416 
        else:
7417 
          iprot.skip(ftype)
7418 
      elif fid == 1:
7419 
        if ftype == TType.STRUCT:
7420 
          self.ex = TransactionServiceException()
7421 
          self.ex.read(iprot)
7422 
        else:
7423 
          iprot.skip(ftype)
7424 
      else:
7425 
        iprot.skip(ftype)
7426 
      iprot.readFieldEnd()
7427 
    iprot.readStructEnd()
7428 
 
7429 
  def write(self, oprot):
7430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7432 
      return
3064 chandransh 7433 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 7434 
    if self.success is not None:
3064 chandransh 7435 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7436 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7437 
      for iter90 in self.success:
7438 
        iter90.write(oprot)
3064 chandransh 7439 
      oprot.writeListEnd()
494 rajveer 7440 
      oprot.writeFieldEnd()
3431 rajveer 7441 
    if self.ex is not None:
494 rajveer 7442 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7443 
      self.ex.write(oprot)
7444 
      oprot.writeFieldEnd()
7445 
    oprot.writeFieldStop()
7446 
    oprot.writeStructEnd()
7447 
 
3431 rajveer 7448 
  def validate(self):
7449 
    return
7450 
 
7451 
 
494 rajveer 7452 
  def __repr__(self):
7453 
    L = ['%s=%r' % (key, value)
7454 
      for key, value in self.__dict__.iteritems()]
7455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7456 
 
7457 
  def __eq__(self, other):
7458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7459 
 
7460 
  def __ne__(self, other):
7461 
    return not (self == other)
7462 
 
3064 chandransh 7463 
class getOrdersForCustomer_args:
1149 chandransh 7464 
  """
7465 
  Attributes:
3064 chandransh 7466 
   - customerId
7467 
   - from_date
7468 
   - to_date
7469 
   - statuses
1149 chandransh 7470 
  """
7471 
 
7472 
  thrift_spec = (
7473 
    None, # 0
3064 chandransh 7474 
    (1, TType.I64, 'customerId', None, None, ), # 1
7475 
    (2, TType.I64, 'from_date', None, None, ), # 2
7476 
    (3, TType.I64, 'to_date', None, None, ), # 3
7477 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 7478 
  )
7479 
 
3064 chandransh 7480 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
7481 
    self.customerId = customerId
7482 
    self.from_date = from_date
7483 
    self.to_date = to_date
7484 
    self.statuses = statuses
1149 chandransh 7485 
 
7486 
  def read(self, iprot):
7487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7489 
      return
7490 
    iprot.readStructBegin()
7491 
    while True:
7492 
      (fname, ftype, fid) = iprot.readFieldBegin()
7493 
      if ftype == TType.STOP:
7494 
        break
7495 
      if fid == 1:
7496 
        if ftype == TType.I64:
3064 chandransh 7497 
          self.customerId = iprot.readI64();
1149 chandransh 7498 
        else:
7499 
          iprot.skip(ftype)
7500 
      elif fid == 2:
7501 
        if ftype == TType.I64:
3064 chandransh 7502 
          self.from_date = iprot.readI64();
1149 chandransh 7503 
        else:
7504 
          iprot.skip(ftype)
2783 chandransh 7505 
      elif fid == 3:
7506 
        if ftype == TType.I64:
3064 chandransh 7507 
          self.to_date = iprot.readI64();
2783 chandransh 7508 
        else:
7509 
          iprot.skip(ftype)
7510 
      elif fid == 4:
3064 chandransh 7511 
        if ftype == TType.LIST:
7512 
          self.statuses = []
4133 chandransh 7513 
          (_etype94, _size91) = iprot.readListBegin()
7514 
          for _i95 in xrange(_size91):
7515 
            _elem96 = iprot.readI32();
7516 
            self.statuses.append(_elem96)
3064 chandransh 7517 
          iprot.readListEnd()
2783 chandransh 7518 
        else:
7519 
          iprot.skip(ftype)
1149 chandransh 7520 
      else:
7521 
        iprot.skip(ftype)
7522 
      iprot.readFieldEnd()
7523 
    iprot.readStructEnd()
7524 
 
7525 
  def write(self, oprot):
7526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7528 
      return
3064 chandransh 7529 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 7530 
    if self.customerId is not None:
3064 chandransh 7531 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7532 
      oprot.writeI64(self.customerId)
1149 chandransh 7533 
      oprot.writeFieldEnd()
3431 rajveer 7534 
    if self.from_date is not None:
3064 chandransh 7535 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7536 
      oprot.writeI64(self.from_date)
1149 chandransh 7537 
      oprot.writeFieldEnd()
3431 rajveer 7538 
    if self.to_date is not None:
3064 chandransh 7539 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7540 
      oprot.writeI64(self.to_date)
2783 chandransh 7541 
      oprot.writeFieldEnd()
3431 rajveer 7542 
    if self.statuses is not None:
3064 chandransh 7543 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
7544 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 7545 
      for iter97 in self.statuses:
7546 
        oprot.writeI32(iter97)
3064 chandransh 7547 
      oprot.writeListEnd()
2783 chandransh 7548 
      oprot.writeFieldEnd()
1149 chandransh 7549 
    oprot.writeFieldStop()
7550 
    oprot.writeStructEnd()
7551 
 
3431 rajveer 7552 
  def validate(self):
7553 
    return
7554 
 
7555 
 
1149 chandransh 7556 
  def __repr__(self):
7557 
    L = ['%s=%r' % (key, value)
7558 
      for key, value in self.__dict__.iteritems()]
7559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7560 
 
7561 
  def __eq__(self, other):
7562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7563 
 
7564 
  def __ne__(self, other):
7565 
    return not (self == other)
7566 
 
3064 chandransh 7567 
class getOrdersForCustomer_result:
1149 chandransh 7568 
  """
7569 
  Attributes:
7570 
   - success
7571 
   - ex
7572 
  """
7573 
 
7574 
  thrift_spec = (
3064 chandransh 7575 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 7576 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7577 
  )
7578 
 
7579 
  def __init__(self, success=None, ex=None,):
7580 
    self.success = success
7581 
    self.ex = ex
7582 
 
7583 
  def read(self, iprot):
7584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7586 
      return
7587 
    iprot.readStructBegin()
7588 
    while True:
7589 
      (fname, ftype, fid) = iprot.readFieldBegin()
7590 
      if ftype == TType.STOP:
7591 
        break
7592 
      if fid == 0:
3064 chandransh 7593 
        if ftype == TType.LIST:
7594 
          self.success = []
4133 chandransh 7595 
          (_etype101, _size98) = iprot.readListBegin()
7596 
          for _i102 in xrange(_size98):
7597 
            _elem103 = Order()
7598 
            _elem103.read(iprot)
7599 
            self.success.append(_elem103)
3064 chandransh 7600 
          iprot.readListEnd()
1149 chandransh 7601 
        else:
7602 
          iprot.skip(ftype)
7603 
      elif fid == 1:
7604 
        if ftype == TType.STRUCT:
7605 
          self.ex = TransactionServiceException()
7606 
          self.ex.read(iprot)
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('getOrdersForCustomer_result')
3431 rajveer 7619 
    if self.success is not None:
3064 chandransh 7620 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7621 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7622 
      for iter104 in self.success:
7623 
        iter104.write(oprot)
3064 chandransh 7624 
      oprot.writeListEnd()
1149 chandransh 7625 
      oprot.writeFieldEnd()
3431 rajveer 7626 
    if self.ex is not None:
1149 chandransh 7627 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7628 
      self.ex.write(oprot)
7629 
      oprot.writeFieldEnd()
7630 
    oprot.writeFieldStop()
7631 
    oprot.writeStructEnd()
7632 
 
3431 rajveer 7633 
  def validate(self):
7634 
    return
7635 
 
7636 
 
1149 chandransh 7637 
  def __repr__(self):
7638 
    L = ['%s=%r' % (key, value)
7639 
      for key, value in self.__dict__.iteritems()]
7640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7641 
 
7642 
  def __eq__(self, other):
7643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7644 
 
7645 
  def __ne__(self, other):
7646 
    return not (self == other)
7647 
 
3064 chandransh 7648 
class createOrder_args:
921 rajveer 7649 
  """
7650 
  Attributes:
3064 chandransh 7651 
   - order
921 rajveer 7652 
  """
7653 
 
7654 
  thrift_spec = (
7655 
    None, # 0
3064 chandransh 7656 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 7657 
  )
7658 
 
3064 chandransh 7659 
  def __init__(self, order=None,):
7660 
    self.order = order
921 rajveer 7661 
 
7662 
  def read(self, iprot):
7663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7665 
      return
7666 
    iprot.readStructBegin()
7667 
    while True:
7668 
      (fname, ftype, fid) = iprot.readFieldBegin()
7669 
      if ftype == TType.STOP:
7670 
        break
7671 
      if fid == 1:
3064 chandransh 7672 
        if ftype == TType.STRUCT:
7673 
          self.order = Order()
7674 
          self.order.read(iprot)
921 rajveer 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_args')
3431 rajveer 7687 
    if self.order is not None:
3064 chandransh 7688 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
7689 
      self.order.write(oprot)
921 rajveer 7690 
      oprot.writeFieldEnd()
7691 
    oprot.writeFieldStop()
7692 
    oprot.writeStructEnd()
7693 
 
3431 rajveer 7694 
  def validate(self):
7695 
    return
7696 
 
7697 
 
921 rajveer 7698 
  def __repr__(self):
7699 
    L = ['%s=%r' % (key, value)
7700 
      for key, value in self.__dict__.iteritems()]
7701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7702 
 
7703 
  def __eq__(self, other):
7704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7705 
 
7706 
  def __ne__(self, other):
7707 
    return not (self == other)
7708 
 
3064 chandransh 7709 
class createOrder_result:
921 rajveer 7710 
  """
7711 
  Attributes:
7712 
   - success
7713 
   - ex
7714 
  """
7715 
 
7716 
  thrift_spec = (
3064 chandransh 7717 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 7718 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7719 
  )
7720 
 
7721 
  def __init__(self, success=None, ex=None,):
7722 
    self.success = success
7723 
    self.ex = ex
7724 
 
7725 
  def read(self, iprot):
7726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7728 
      return
7729 
    iprot.readStructBegin()
7730 
    while True:
7731 
      (fname, ftype, fid) = iprot.readFieldBegin()
7732 
      if ftype == TType.STOP:
7733 
        break
7734 
      if fid == 0:
3064 chandransh 7735 
        if ftype == TType.I64:
7736 
          self.success = iprot.readI64();
921 rajveer 7737 
        else:
7738 
          iprot.skip(ftype)
7739 
      elif fid == 1:
7740 
        if ftype == TType.STRUCT:
7741 
          self.ex = TransactionServiceException()
7742 
          self.ex.read(iprot)
7743 
        else:
7744 
          iprot.skip(ftype)
7745 
      else:
7746 
        iprot.skip(ftype)
7747 
      iprot.readFieldEnd()
7748 
    iprot.readStructEnd()
7749 
 
7750 
  def write(self, oprot):
7751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7753 
      return
3064 chandransh 7754 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 7755 
    if self.success is not None:
3064 chandransh 7756 
      oprot.writeFieldBegin('success', TType.I64, 0)
7757 
      oprot.writeI64(self.success)
921 rajveer 7758 
      oprot.writeFieldEnd()
3431 rajveer 7759 
    if self.ex is not None:
921 rajveer 7760 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7761 
      self.ex.write(oprot)
7762 
      oprot.writeFieldEnd()
7763 
    oprot.writeFieldStop()
7764 
    oprot.writeStructEnd()
7765 
 
3431 rajveer 7766 
  def validate(self):
7767 
    return
7768 
 
7769 
 
921 rajveer 7770 
  def __repr__(self):
7771 
    L = ['%s=%r' % (key, value)
7772 
      for key, value in self.__dict__.iteritems()]
7773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7774 
 
7775 
  def __eq__(self, other):
7776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7777 
 
7778 
  def __ne__(self, other):
7779 
    return not (self == other)
7780 
 
3064 chandransh 7781 
class getOrder_args:
921 rajveer 7782 
  """
7783 
  Attributes:
3064 chandransh 7784 
   - id
921 rajveer 7785 
  """
7786 
 
7787 
  thrift_spec = (
7788 
    None, # 0
3064 chandransh 7789 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 7790 
  )
7791 
 
3064 chandransh 7792 
  def __init__(self, id=None,):
7793 
    self.id = id
921 rajveer 7794 
 
7795 
  def read(self, iprot):
7796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7798 
      return
7799 
    iprot.readStructBegin()
7800 
    while True:
7801 
      (fname, ftype, fid) = iprot.readFieldBegin()
7802 
      if ftype == TType.STOP:
7803 
        break
7804 
      if fid == 1:
7805 
        if ftype == TType.I64:
3064 chandransh 7806 
          self.id = iprot.readI64();
921 rajveer 7807 
        else:
7808 
          iprot.skip(ftype)
7809 
      else:
7810 
        iprot.skip(ftype)
7811 
      iprot.readFieldEnd()
7812 
    iprot.readStructEnd()
7813 
 
7814 
  def write(self, oprot):
7815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7817 
      return
3064 chandransh 7818 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 7819 
    if self.id is not None:
3064 chandransh 7820 
      oprot.writeFieldBegin('id', TType.I64, 1)
7821 
      oprot.writeI64(self.id)
921 rajveer 7822 
      oprot.writeFieldEnd()
7823 
    oprot.writeFieldStop()
7824 
    oprot.writeStructEnd()
7825 
 
3431 rajveer 7826 
  def validate(self):
7827 
    return
7828 
 
7829 
 
921 rajveer 7830 
  def __repr__(self):
7831 
    L = ['%s=%r' % (key, value)
7832 
      for key, value in self.__dict__.iteritems()]
7833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7834 
 
7835 
  def __eq__(self, other):
7836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7837 
 
7838 
  def __ne__(self, other):
7839 
    return not (self == other)
7840 
 
3064 chandransh 7841 
class getOrder_result:
921 rajveer 7842 
  """
7843 
  Attributes:
7844 
   - success
7845 
   - ex
7846 
  """
7847 
 
7848 
  thrift_spec = (
3064 chandransh 7849 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 7850 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7851 
  )
7852 
 
7853 
  def __init__(self, success=None, ex=None,):
7854 
    self.success = success
7855 
    self.ex = ex
7856 
 
7857 
  def read(self, iprot):
7858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7860 
      return
7861 
    iprot.readStructBegin()
7862 
    while True:
7863 
      (fname, ftype, fid) = iprot.readFieldBegin()
7864 
      if ftype == TType.STOP:
7865 
        break
7866 
      if fid == 0:
3064 chandransh 7867 
        if ftype == TType.STRUCT:
7868 
          self.success = Order()
7869 
          self.success.read(iprot)
921 rajveer 7870 
        else:
7871 
          iprot.skip(ftype)
7872 
      elif fid == 1:
7873 
        if ftype == TType.STRUCT:
7874 
          self.ex = TransactionServiceException()
7875 
          self.ex.read(iprot)
7876 
        else:
7877 
          iprot.skip(ftype)
7878 
      else:
7879 
        iprot.skip(ftype)
7880 
      iprot.readFieldEnd()
7881 
    iprot.readStructEnd()
7882 
 
7883 
  def write(self, oprot):
7884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7886 
      return
3064 chandransh 7887 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 7888 
    if self.success is not None:
3064 chandransh 7889 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7890 
      self.success.write(oprot)
921 rajveer 7891 
      oprot.writeFieldEnd()
3431 rajveer 7892 
    if self.ex is not None:
921 rajveer 7893 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7894 
      self.ex.write(oprot)
7895 
      oprot.writeFieldEnd()
7896 
    oprot.writeFieldStop()
7897 
    oprot.writeStructEnd()
7898 
 
3431 rajveer 7899 
  def validate(self):
7900 
    return
7901 
 
7902 
 
921 rajveer 7903 
  def __repr__(self):
7904 
    L = ['%s=%r' % (key, value)
7905 
      for key, value in self.__dict__.iteritems()]
7906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7907 
 
7908 
  def __eq__(self, other):
7909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7910 
 
7911 
  def __ne__(self, other):
7912 
    return not (self == other)
7913 
 
3064 chandransh 7914 
class getLineItemsForOrder_args:
94 ashish 7915 
  """
7916 
  Attributes:
3064 chandransh 7917 
   - orderId
94 ashish 7918 
  """
7919 
 
7920 
  thrift_spec = (
7921 
    None, # 0
3064 chandransh 7922 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7923 
  )
7924 
 
3064 chandransh 7925 
  def __init__(self, orderId=None,):
7926 
    self.orderId = orderId
94 ashish 7927 
 
7928 
  def read(self, iprot):
7929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7931 
      return
7932 
    iprot.readStructBegin()
7933 
    while True:
7934 
      (fname, ftype, fid) = iprot.readFieldBegin()
7935 
      if ftype == TType.STOP:
7936 
        break
7937 
      if fid == 1:
7938 
        if ftype == TType.I64:
3064 chandransh 7939 
          self.orderId = iprot.readI64();
94 ashish 7940 
        else:
7941 
          iprot.skip(ftype)
7942 
      else:
7943 
        iprot.skip(ftype)
7944 
      iprot.readFieldEnd()
7945 
    iprot.readStructEnd()
7946 
 
7947 
  def write(self, oprot):
7948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7950 
      return
3064 chandransh 7951 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7952 
    if self.orderId is not None:
3064 chandransh 7953 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7954 
      oprot.writeI64(self.orderId)
94 ashish 7955 
      oprot.writeFieldEnd()
7956 
    oprot.writeFieldStop()
7957 
    oprot.writeStructEnd()
7958 
 
3431 rajveer 7959 
  def validate(self):
7960 
    return
7961 
 
7962 
 
94 ashish 7963 
  def __repr__(self):
7964 
    L = ['%s=%r' % (key, value)
7965 
      for key, value in self.__dict__.iteritems()]
7966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7967 
 
7968 
  def __eq__(self, other):
7969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7970 
 
7971 
  def __ne__(self, other):
7972 
    return not (self == other)
7973 
 
3064 chandransh 7974 
class getLineItemsForOrder_result:
94 ashish 7975 
  """
7976 
  Attributes:
7977 
   - success
7978 
   - ex
7979 
  """
7980 
 
7981 
  thrift_spec = (
3064 chandransh 7982 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7983 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7984 
  )
7985 
 
7986 
  def __init__(self, success=None, ex=None,):
7987 
    self.success = success
7988 
    self.ex = ex
7989 
 
7990 
  def read(self, iprot):
7991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7993 
      return
7994 
    iprot.readStructBegin()
7995 
    while True:
7996 
      (fname, ftype, fid) = iprot.readFieldBegin()
7997 
      if ftype == TType.STOP:
7998 
        break
7999 
      if fid == 0:
483 rajveer 8000 
        if ftype == TType.LIST:
8001 
          self.success = []
4133 chandransh 8002 
          (_etype108, _size105) = iprot.readListBegin()
8003 
          for _i109 in xrange(_size105):
8004 
            _elem110 = LineItem()
8005 
            _elem110.read(iprot)
8006 
            self.success.append(_elem110)
483 rajveer 8007 
          iprot.readListEnd()
94 ashish 8008 
        else:
8009 
          iprot.skip(ftype)
8010 
      elif fid == 1:
8011 
        if ftype == TType.STRUCT:
8012 
          self.ex = TransactionServiceException()
8013 
          self.ex.read(iprot)
8014 
        else:
8015 
          iprot.skip(ftype)
8016 
      else:
8017 
        iprot.skip(ftype)
8018 
      iprot.readFieldEnd()
8019 
    iprot.readStructEnd()
8020 
 
8021 
  def write(self, oprot):
8022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8024 
      return
3064 chandransh 8025 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8026 
    if self.success is not None:
483 rajveer 8027 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8028 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8029 
      for iter111 in self.success:
8030 
        iter111.write(oprot)
483 rajveer 8031 
      oprot.writeListEnd()
94 ashish 8032 
      oprot.writeFieldEnd()
3431 rajveer 8033 
    if self.ex is not None:
94 ashish 8034 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8035 
      self.ex.write(oprot)
8036 
      oprot.writeFieldEnd()
8037 
    oprot.writeFieldStop()
8038 
    oprot.writeStructEnd()
8039 
 
3431 rajveer 8040 
  def validate(self):
8041 
    return
8042 
 
8043 
 
94 ashish 8044 
  def __repr__(self):
8045 
    L = ['%s=%r' % (key, value)
8046 
      for key, value in self.__dict__.iteritems()]
8047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8048 
 
8049 
  def __eq__(self, other):
8050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8051 
 
8052 
  def __ne__(self, other):
8053 
    return not (self == other)
8054 
 
3064 chandransh 8055 
class getOrderForCustomer_args:
94 ashish 8056 
  """
8057 
  Attributes:
3064 chandransh 8058 
   - orderId
483 rajveer 8059 
   - customerId
94 ashish 8060 
  """
8061 
 
8062 
  thrift_spec = (
8063 
    None, # 0
3064 chandransh 8064 
    (1, TType.I64, 'orderId', None, None, ), # 1
8065 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8066 
  )
8067 
 
3064 chandransh 8068 
  def __init__(self, orderId=None, customerId=None,):
8069 
    self.orderId = orderId
483 rajveer 8070 
    self.customerId = customerId
94 ashish 8071 
 
8072 
  def read(self, iprot):
8073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8075 
      return
8076 
    iprot.readStructBegin()
8077 
    while True:
8078 
      (fname, ftype, fid) = iprot.readFieldBegin()
8079 
      if ftype == TType.STOP:
8080 
        break
8081 
      if fid == 1:
8082 
        if ftype == TType.I64:
3064 chandransh 8083 
          self.orderId = iprot.readI64();
94 ashish 8084 
        else:
8085 
          iprot.skip(ftype)
8086 
      elif fid == 2:
8087 
        if ftype == TType.I64:
3064 chandransh 8088 
          self.customerId = iprot.readI64();
94 ashish 8089 
        else:
8090 
          iprot.skip(ftype)
8091 
      else:
8092 
        iprot.skip(ftype)
8093 
      iprot.readFieldEnd()
8094 
    iprot.readStructEnd()
8095 
 
8096 
  def write(self, oprot):
8097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8099 
      return
3064 chandransh 8100 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 8101 
    if self.orderId is not None:
3064 chandransh 8102 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8103 
      oprot.writeI64(self.orderId)
8104 
      oprot.writeFieldEnd()
3431 rajveer 8105 
    if self.customerId is not None:
3064 chandransh 8106 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 8107 
      oprot.writeI64(self.customerId)
94 ashish 8108 
      oprot.writeFieldEnd()
8109 
    oprot.writeFieldStop()
8110 
    oprot.writeStructEnd()
8111 
 
3431 rajveer 8112 
  def validate(self):
8113 
    return
8114 
 
8115 
 
94 ashish 8116 
  def __repr__(self):
8117 
    L = ['%s=%r' % (key, value)
8118 
      for key, value in self.__dict__.iteritems()]
8119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8120 
 
8121 
  def __eq__(self, other):
8122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8123 
 
8124 
  def __ne__(self, other):
8125 
    return not (self == other)
8126 
 
3064 chandransh 8127 
class getOrderForCustomer_result:
94 ashish 8128 
  """
8129 
  Attributes:
8130 
   - success
8131 
   - ex
8132 
  """
8133 
 
8134 
  thrift_spec = (
3064 chandransh 8135 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 8136 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8137 
  )
8138 
 
8139 
  def __init__(self, success=None, ex=None,):
8140 
    self.success = success
8141 
    self.ex = ex
8142 
 
8143 
  def read(self, iprot):
8144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8146 
      return
8147 
    iprot.readStructBegin()
8148 
    while True:
8149 
      (fname, ftype, fid) = iprot.readFieldBegin()
8150 
      if ftype == TType.STOP:
8151 
        break
8152 
      if fid == 0:
3064 chandransh 8153 
        if ftype == TType.STRUCT:
8154 
          self.success = Order()
8155 
          self.success.read(iprot)
94 ashish 8156 
        else:
8157 
          iprot.skip(ftype)
8158 
      elif fid == 1:
8159 
        if ftype == TType.STRUCT:
8160 
          self.ex = TransactionServiceException()
8161 
          self.ex.read(iprot)
8162 
        else:
8163 
          iprot.skip(ftype)
8164 
      else:
8165 
        iprot.skip(ftype)
8166 
      iprot.readFieldEnd()
8167 
    iprot.readStructEnd()
8168 
 
8169 
  def write(self, oprot):
8170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8172 
      return
3064 chandransh 8173 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 8174 
    if self.success is not None:
3064 chandransh 8175 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8176 
      self.success.write(oprot)
94 ashish 8177 
      oprot.writeFieldEnd()
3431 rajveer 8178 
    if self.ex is not None:
94 ashish 8179 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8180 
      self.ex.write(oprot)
8181 
      oprot.writeFieldEnd()
8182 
    oprot.writeFieldStop()
8183 
    oprot.writeStructEnd()
8184 
 
3431 rajveer 8185 
  def validate(self):
8186 
    return
8187 
 
8188 
 
94 ashish 8189 
  def __repr__(self):
8190 
    L = ['%s=%r' % (key, value)
8191 
      for key, value in self.__dict__.iteritems()]
8192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8193 
 
8194 
  def __eq__(self, other):
8195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8196 
 
8197 
  def __ne__(self, other):
8198 
    return not (self == other)
8199 
 
3064 chandransh 8200 
class getAlerts_args:
94 ashish 8201 
  """
8202 
  Attributes:
4394 rajveer 8203 
   - type
4444 rajveer 8204 
   - warehouseId
4394 rajveer 8205 
   - status
8206 
   - timestamp
94 ashish 8207 
  """
8208 
 
8209 
  thrift_spec = (
8210 
    None, # 0
4394 rajveer 8211 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8212 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8213 
    (3, TType.I64, 'status', None, None, ), # 3
8214 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 8215 
  )
8216 
 
4444 rajveer 8217 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 8218 
    self.type = type
4444 rajveer 8219 
    self.warehouseId = warehouseId
4394 rajveer 8220 
    self.status = status
8221 
    self.timestamp = timestamp
94 ashish 8222 
 
8223 
  def read(self, iprot):
8224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8226 
      return
8227 
    iprot.readStructBegin()
8228 
    while True:
8229 
      (fname, ftype, fid) = iprot.readFieldBegin()
8230 
      if ftype == TType.STOP:
8231 
        break
8232 
      if fid == 1:
3064 chandransh 8233 
        if ftype == TType.I64:
4394 rajveer 8234 
          self.type = iprot.readI64();
94 ashish 8235 
        else:
8236 
          iprot.skip(ftype)
3064 chandransh 8237 
      elif fid == 2:
4394 rajveer 8238 
        if ftype == TType.I64:
4444 rajveer 8239 
          self.warehouseId = iprot.readI64();
3064 chandransh 8240 
        else:
8241 
          iprot.skip(ftype)
4394 rajveer 8242 
      elif fid == 3:
8243 
        if ftype == TType.I64:
4444 rajveer 8244 
          self.status = iprot.readI64();
8245 
        else:
8246 
          iprot.skip(ftype)
8247 
      elif fid == 4:
8248 
        if ftype == TType.I64:
4394 rajveer 8249 
          self.timestamp = iprot.readI64();
8250 
        else:
8251 
          iprot.skip(ftype)
94 ashish 8252 
      else:
8253 
        iprot.skip(ftype)
8254 
      iprot.readFieldEnd()
8255 
    iprot.readStructEnd()
8256 
 
8257 
  def write(self, oprot):
8258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8260 
      return
3064 chandransh 8261 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 8262 
    if self.type is not None:
8263 
      oprot.writeFieldBegin('type', TType.I64, 1)
8264 
      oprot.writeI64(self.type)
94 ashish 8265 
      oprot.writeFieldEnd()
4444 rajveer 8266 
    if self.warehouseId is not None:
8267 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8268 
      oprot.writeI64(self.warehouseId)
8269 
      oprot.writeFieldEnd()
4394 rajveer 8270 
    if self.status is not None:
4444 rajveer 8271 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 8272 
      oprot.writeI64(self.status)
3064 chandransh 8273 
      oprot.writeFieldEnd()
4394 rajveer 8274 
    if self.timestamp is not None:
4444 rajveer 8275 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 8276 
      oprot.writeI64(self.timestamp)
8277 
      oprot.writeFieldEnd()
94 ashish 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 
 
3064 chandransh 8296 
class getAlerts_result:
94 ashish 8297 
  """
8298 
  Attributes:
8299 
   - success
8300 
  """
8301 
 
8302 
  thrift_spec = (
3064 chandransh 8303 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 8304 
  )
8305 
 
3064 chandransh 8306 
  def __init__(self, success=None,):
94 ashish 8307 
    self.success = success
8308 
 
8309 
  def read(self, iprot):
8310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8312 
      return
8313 
    iprot.readStructBegin()
8314 
    while True:
8315 
      (fname, ftype, fid) = iprot.readFieldBegin()
8316 
      if ftype == TType.STOP:
8317 
        break
8318 
      if fid == 0:
3064 chandransh 8319 
        if ftype == TType.LIST:
8320 
          self.success = []
4133 chandransh 8321 
          (_etype115, _size112) = iprot.readListBegin()
8322 
          for _i116 in xrange(_size112):
8323 
            _elem117 = Alert()
8324 
            _elem117.read(iprot)
8325 
            self.success.append(_elem117)
3064 chandransh 8326 
          iprot.readListEnd()
94 ashish 8327 
        else:
8328 
          iprot.skip(ftype)
8329 
      else:
8330 
        iprot.skip(ftype)
8331 
      iprot.readFieldEnd()
8332 
    iprot.readStructEnd()
8333 
 
8334 
  def write(self, oprot):
8335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8337 
      return
3064 chandransh 8338 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 8339 
    if self.success is not None:
3064 chandransh 8340 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8341 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8342 
      for iter118 in self.success:
8343 
        iter118.write(oprot)
3064 chandransh 8344 
      oprot.writeListEnd()
94 ashish 8345 
      oprot.writeFieldEnd()
8346 
    oprot.writeFieldStop()
8347 
    oprot.writeStructEnd()
8348 
 
3431 rajveer 8349 
  def validate(self):
8350 
    return
8351 
 
8352 
 
94 ashish 8353 
  def __repr__(self):
8354 
    L = ['%s=%r' % (key, value)
8355 
      for key, value in self.__dict__.iteritems()]
8356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8357 
 
8358 
  def __eq__(self, other):
8359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8360 
 
8361 
  def __ne__(self, other):
8362 
    return not (self == other)
8363 
 
4394 rajveer 8364 
class addAlert_args:
94 ashish 8365 
  """
8366 
  Attributes:
3064 chandransh 8367 
   - type
4444 rajveer 8368 
   - warehouseId
4394 rajveer 8369 
   - description
94 ashish 8370 
  """
8371 
 
8372 
  thrift_spec = (
8373 
    None, # 0
4394 rajveer 8374 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8375 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8376 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8377 
  )
8378 
 
4444 rajveer 8379 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 8380 
    self.type = type
4444 rajveer 8381 
    self.warehouseId = warehouseId
4394 rajveer 8382 
    self.description = description
94 ashish 8383 
 
8384 
  def read(self, iprot):
8385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8387 
      return
8388 
    iprot.readStructBegin()
8389 
    while True:
8390 
      (fname, ftype, fid) = iprot.readFieldBegin()
8391 
      if ftype == TType.STOP:
8392 
        break
8393 
      if fid == 1:
8394 
        if ftype == TType.I64:
4394 rajveer 8395 
          self.type = iprot.readI64();
94 ashish 8396 
        else:
8397 
          iprot.skip(ftype)
3064 chandransh 8398 
      elif fid == 2:
4444 rajveer 8399 
        if ftype == TType.I64:
8400 
          self.warehouseId = iprot.readI64();
8401 
        else:
8402 
          iprot.skip(ftype)
8403 
      elif fid == 3:
3064 chandransh 8404 
        if ftype == TType.STRING:
4394 rajveer 8405 
          self.description = iprot.readString();
3064 chandransh 8406 
        else:
8407 
          iprot.skip(ftype)
94 ashish 8408 
      else:
8409 
        iprot.skip(ftype)
8410 
      iprot.readFieldEnd()
8411 
    iprot.readStructEnd()
8412 
 
8413 
  def write(self, oprot):
8414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8416 
      return
4394 rajveer 8417 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 8418 
    if self.type is not None:
4394 rajveer 8419 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 8420 
      oprot.writeI64(self.type)
8421 
      oprot.writeFieldEnd()
4444 rajveer 8422 
    if self.warehouseId is not None:
8423 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8424 
      oprot.writeI64(self.warehouseId)
8425 
      oprot.writeFieldEnd()
4394 rajveer 8426 
    if self.description is not None:
4444 rajveer 8427 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 8428 
      oprot.writeString(self.description)
3064 chandransh 8429 
      oprot.writeFieldEnd()
94 ashish 8430 
    oprot.writeFieldStop()
8431 
    oprot.writeStructEnd()
8432 
 
3431 rajveer 8433 
  def validate(self):
8434 
    return
8435 
 
8436 
 
94 ashish 8437 
  def __repr__(self):
8438 
    L = ['%s=%r' % (key, value)
8439 
      for key, value in self.__dict__.iteritems()]
8440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8441 
 
8442 
  def __eq__(self, other):
8443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8444 
 
8445 
  def __ne__(self, other):
8446 
    return not (self == other)
8447 
 
4394 rajveer 8448 
class addAlert_result:
3064 chandransh 8449 
 
8450 
  thrift_spec = (
8451 
  )
8452 
 
8453 
  def read(self, iprot):
8454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8456 
      return
8457 
    iprot.readStructBegin()
8458 
    while True:
8459 
      (fname, ftype, fid) = iprot.readFieldBegin()
8460 
      if ftype == TType.STOP:
8461 
        break
8462 
      else:
8463 
        iprot.skip(ftype)
8464 
      iprot.readFieldEnd()
8465 
    iprot.readStructEnd()
8466 
 
8467 
  def write(self, oprot):
8468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8470 
      return
4394 rajveer 8471 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 8472 
    oprot.writeFieldStop()
8473 
    oprot.writeStructEnd()
8474 
 
3431 rajveer 8475 
  def validate(self):
8476 
    return
8477 
 
8478 
 
3064 chandransh 8479 
  def __repr__(self):
8480 
    L = ['%s=%r' % (key, value)
8481 
      for key, value in self.__dict__.iteritems()]
8482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8483 
 
8484 
  def __eq__(self, other):
8485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8486 
 
8487 
  def __ne__(self, other):
8488 
    return not (self == other)
8489 
 
4444 rajveer 8490 
class markAlertsAsSeen_args:
8491 
  """
8492 
  Attributes:
8493 
   - warehouseId
8494 
  """
8495 
 
8496 
  thrift_spec = (
8497 
    None, # 0
8498 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8499 
  )
8500 
 
8501 
  def __init__(self, warehouseId=None,):
8502 
    self.warehouseId = warehouseId
8503 
 
8504 
  def read(self, iprot):
8505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8507 
      return
8508 
    iprot.readStructBegin()
8509 
    while True:
8510 
      (fname, ftype, fid) = iprot.readFieldBegin()
8511 
      if ftype == TType.STOP:
8512 
        break
8513 
      if fid == 1:
8514 
        if ftype == TType.I64:
8515 
          self.warehouseId = iprot.readI64();
8516 
        else:
8517 
          iprot.skip(ftype)
8518 
      else:
8519 
        iprot.skip(ftype)
8520 
      iprot.readFieldEnd()
8521 
    iprot.readStructEnd()
8522 
 
8523 
  def write(self, oprot):
8524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8526 
      return
8527 
    oprot.writeStructBegin('markAlertsAsSeen_args')
8528 
    if self.warehouseId is not None:
8529 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8530 
      oprot.writeI64(self.warehouseId)
8531 
      oprot.writeFieldEnd()
8532 
    oprot.writeFieldStop()
8533 
    oprot.writeStructEnd()
8534 
 
8535 
  def validate(self):
8536 
    return
8537 
 
8538 
 
8539 
  def __repr__(self):
8540 
    L = ['%s=%r' % (key, value)
8541 
      for key, value in self.__dict__.iteritems()]
8542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8543 
 
8544 
  def __eq__(self, other):
8545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8546 
 
8547 
  def __ne__(self, other):
8548 
    return not (self == other)
8549 
 
8550 
class markAlertsAsSeen_result:
8551 
 
8552 
  thrift_spec = (
8553 
  )
8554 
 
8555 
  def read(self, iprot):
8556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8558 
      return
8559 
    iprot.readStructBegin()
8560 
    while True:
8561 
      (fname, ftype, fid) = iprot.readFieldBegin()
8562 
      if ftype == TType.STOP:
8563 
        break
8564 
      else:
8565 
        iprot.skip(ftype)
8566 
      iprot.readFieldEnd()
8567 
    iprot.readStructEnd()
8568 
 
8569 
  def write(self, oprot):
8570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8572 
      return
8573 
    oprot.writeStructBegin('markAlertsAsSeen_result')
8574 
    oprot.writeFieldStop()
8575 
    oprot.writeStructEnd()
8576 
 
8577 
  def validate(self):
8578 
    return
8579 
 
8580 
 
8581 
  def __repr__(self):
8582 
    L = ['%s=%r' % (key, value)
8583 
      for key, value in self.__dict__.iteritems()]
8584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8585 
 
8586 
  def __eq__(self, other):
8587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8588 
 
8589 
  def __ne__(self, other):
8590 
    return not (self == other)
8591 
 
3064 chandransh 8592 
class getValidOrderCount_args:
8593 
 
8594 
  thrift_spec = (
8595 
  )
8596 
 
8597 
  def read(self, iprot):
8598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8600 
      return
8601 
    iprot.readStructBegin()
8602 
    while True:
8603 
      (fname, ftype, fid) = iprot.readFieldBegin()
8604 
      if ftype == TType.STOP:
8605 
        break
8606 
      else:
8607 
        iprot.skip(ftype)
8608 
      iprot.readFieldEnd()
8609 
    iprot.readStructEnd()
8610 
 
8611 
  def write(self, oprot):
8612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8614 
      return
8615 
    oprot.writeStructBegin('getValidOrderCount_args')
8616 
    oprot.writeFieldStop()
8617 
    oprot.writeStructEnd()
8618 
 
3431 rajveer 8619 
  def validate(self):
8620 
    return
8621 
 
8622 
 
3064 chandransh 8623 
  def __repr__(self):
8624 
    L = ['%s=%r' % (key, value)
8625 
      for key, value in self.__dict__.iteritems()]
8626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8627 
 
8628 
  def __eq__(self, other):
8629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8630 
 
8631 
  def __ne__(self, other):
8632 
    return not (self == other)
8633 
 
8634 
class getValidOrderCount_result:
94 ashish 8635 
  """
8636 
  Attributes:
8637 
   - success
8638 
  """
8639 
 
8640 
  thrift_spec = (
3064 chandransh 8641 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8642 
  )
8643 
 
3064 chandransh 8644 
  def __init__(self, success=None,):
94 ashish 8645 
    self.success = success
8646 
 
8647 
  def read(self, iprot):
8648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8650 
      return
8651 
    iprot.readStructBegin()
8652 
    while True:
8653 
      (fname, ftype, fid) = iprot.readFieldBegin()
8654 
      if ftype == TType.STOP:
8655 
        break
8656 
      if fid == 0:
3064 chandransh 8657 
        if ftype == TType.I64:
8658 
          self.success = iprot.readI64();
94 ashish 8659 
        else:
8660 
          iprot.skip(ftype)
8661 
      else:
8662 
        iprot.skip(ftype)
8663 
      iprot.readFieldEnd()
8664 
    iprot.readStructEnd()
8665 
 
8666 
  def write(self, oprot):
8667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8669 
      return
3064 chandransh 8670 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 8671 
    if self.success is not None:
3064 chandransh 8672 
      oprot.writeFieldBegin('success', TType.I64, 0)
8673 
      oprot.writeI64(self.success)
94 ashish 8674 
      oprot.writeFieldEnd()
8675 
    oprot.writeFieldStop()
8676 
    oprot.writeStructEnd()
8677 
 
3431 rajveer 8678 
  def validate(self):
8679 
    return
8680 
 
8681 
 
94 ashish 8682 
  def __repr__(self):
8683 
    L = ['%s=%r' % (key, value)
8684 
      for key, value in self.__dict__.iteritems()]
8685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8686 
 
8687 
  def __eq__(self, other):
8688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8689 
 
8690 
  def __ne__(self, other):
8691 
    return not (self == other)
8692 
 
3064 chandransh 8693 
class getNoOfCustomersWithSuccessfulTransaction_args:
8694 
 
8695 
  thrift_spec = (
8696 
  )
8697 
 
8698 
  def read(self, iprot):
8699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8701 
      return
8702 
    iprot.readStructBegin()
8703 
    while True:
8704 
      (fname, ftype, fid) = iprot.readFieldBegin()
8705 
      if ftype == TType.STOP:
8706 
        break
8707 
      else:
8708 
        iprot.skip(ftype)
8709 
      iprot.readFieldEnd()
8710 
    iprot.readStructEnd()
8711 
 
8712 
  def write(self, oprot):
8713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8715 
      return
8716 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
8717 
    oprot.writeFieldStop()
8718 
    oprot.writeStructEnd()
8719 
 
3431 rajveer 8720 
  def validate(self):
8721 
    return
8722 
 
8723 
 
3064 chandransh 8724 
  def __repr__(self):
8725 
    L = ['%s=%r' % (key, value)
8726 
      for key, value in self.__dict__.iteritems()]
8727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8728 
 
8729 
  def __eq__(self, other):
8730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8731 
 
8732 
  def __ne__(self, other):
8733 
    return not (self == other)
8734 
 
8735 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 8736 
  """
8737 
  Attributes:
3064 chandransh 8738 
   - success
94 ashish 8739 
  """
8740 
 
8741 
  thrift_spec = (
3064 chandransh 8742 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8743 
  )
8744 
 
3064 chandransh 8745 
  def __init__(self, success=None,):
8746 
    self.success = success
94 ashish 8747 
 
8748 
  def read(self, iprot):
8749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8751 
      return
8752 
    iprot.readStructBegin()
8753 
    while True:
8754 
      (fname, ftype, fid) = iprot.readFieldBegin()
8755 
      if ftype == TType.STOP:
8756 
        break
3064 chandransh 8757 
      if fid == 0:
94 ashish 8758 
        if ftype == TType.I64:
3064 chandransh 8759 
          self.success = iprot.readI64();
94 ashish 8760 
        else:
8761 
          iprot.skip(ftype)
8762 
      else:
8763 
        iprot.skip(ftype)
8764 
      iprot.readFieldEnd()
8765 
    iprot.readStructEnd()
8766 
 
8767 
  def write(self, oprot):
8768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8770 
      return
3064 chandransh 8771 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 8772 
    if self.success is not None:
3064 chandransh 8773 
      oprot.writeFieldBegin('success', TType.I64, 0)
8774 
      oprot.writeI64(self.success)
94 ashish 8775 
      oprot.writeFieldEnd()
8776 
    oprot.writeFieldStop()
8777 
    oprot.writeStructEnd()
8778 
 
3431 rajveer 8779 
  def validate(self):
8780 
    return
8781 
 
8782 
 
94 ashish 8783 
  def __repr__(self):
8784 
    L = ['%s=%r' % (key, value)
8785 
      for key, value in self.__dict__.iteritems()]
8786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8787 
 
8788 
  def __eq__(self, other):
8789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8790 
 
8791 
  def __ne__(self, other):
8792 
    return not (self == other)
8793 
 
3064 chandransh 8794 
class getValidOrdersAmountRange_args:
8795 
 
8796 
  thrift_spec = (
8797 
  )
8798 
 
8799 
  def read(self, iprot):
8800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8802 
      return
8803 
    iprot.readStructBegin()
8804 
    while True:
8805 
      (fname, ftype, fid) = iprot.readFieldBegin()
8806 
      if ftype == TType.STOP:
8807 
        break
8808 
      else:
8809 
        iprot.skip(ftype)
8810 
      iprot.readFieldEnd()
8811 
    iprot.readStructEnd()
8812 
 
8813 
  def write(self, oprot):
8814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8816 
      return
8817 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
8818 
    oprot.writeFieldStop()
8819 
    oprot.writeStructEnd()
8820 
 
3431 rajveer 8821 
  def validate(self):
8822 
    return
8823 
 
8824 
 
3064 chandransh 8825 
  def __repr__(self):
8826 
    L = ['%s=%r' % (key, value)
8827 
      for key, value in self.__dict__.iteritems()]
8828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8829 
 
8830 
  def __eq__(self, other):
8831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8832 
 
8833 
  def __ne__(self, other):
8834 
    return not (self == other)
8835 
 
8836 
class getValidOrdersAmountRange_result:
94 ashish 8837 
  """
8838 
  Attributes:
8839 
   - success
8840 
  """
8841 
 
8842 
  thrift_spec = (
3064 chandransh 8843 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 8844 
  )
8845 
 
3064 chandransh 8846 
  def __init__(self, success=None,):
94 ashish 8847 
    self.success = success
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 == 0:
483 rajveer 8859 
        if ftype == TType.LIST:
8860 
          self.success = []
4133 chandransh 8861 
          (_etype122, _size119) = iprot.readListBegin()
8862 
          for _i123 in xrange(_size119):
8863 
            _elem124 = iprot.readDouble();
8864 
            self.success.append(_elem124)
483 rajveer 8865 
          iprot.readListEnd()
94 ashish 8866 
        else:
8867 
          iprot.skip(ftype)
8868 
      else:
8869 
        iprot.skip(ftype)
8870 
      iprot.readFieldEnd()
8871 
    iprot.readStructEnd()
8872 
 
8873 
  def write(self, oprot):
8874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8876 
      return
3064 chandransh 8877 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 8878 
    if self.success is not None:
483 rajveer 8879 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 8880 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 8881 
      for iter125 in self.success:
8882 
        oprot.writeDouble(iter125)
483 rajveer 8883 
      oprot.writeListEnd()
94 ashish 8884 
      oprot.writeFieldEnd()
8885 
    oprot.writeFieldStop()
8886 
    oprot.writeStructEnd()
8887 
 
3431 rajveer 8888 
  def validate(self):
8889 
    return
8890 
 
8891 
 
94 ashish 8892 
  def __repr__(self):
8893 
    L = ['%s=%r' % (key, value)
8894 
      for key, value in self.__dict__.iteritems()]
8895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8896 
 
8897 
  def __eq__(self, other):
8898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8899 
 
8900 
  def __ne__(self, other):
8901 
    return not (self == other)
8902 
 
3064 chandransh 8903 
class getValidOrders_args:
1528 ankur.sing 8904 
  """
8905 
  Attributes:
3064 chandransh 8906 
   - limit
1528 ankur.sing 8907 
  """
8908 
 
8909 
  thrift_spec = (
8910 
    None, # 0
3064 chandransh 8911 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 8912 
  )
8913 
 
3064 chandransh 8914 
  def __init__(self, limit=None,):
8915 
    self.limit = limit
1528 ankur.sing 8916 
 
8917 
  def read(self, iprot):
8918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8920 
      return
8921 
    iprot.readStructBegin()
8922 
    while True:
8923 
      (fname, ftype, fid) = iprot.readFieldBegin()
8924 
      if ftype == TType.STOP:
8925 
        break
8926 
      if fid == 1:
8927 
        if ftype == TType.I64:
3064 chandransh 8928 
          self.limit = iprot.readI64();
1528 ankur.sing 8929 
        else:
8930 
          iprot.skip(ftype)
8931 
      else:
8932 
        iprot.skip(ftype)
8933 
      iprot.readFieldEnd()
8934 
    iprot.readStructEnd()
8935 
 
8936 
  def write(self, oprot):
8937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8939 
      return
3064 chandransh 8940 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 8941 
    if self.limit is not None:
3064 chandransh 8942 
      oprot.writeFieldBegin('limit', TType.I64, 1)
8943 
      oprot.writeI64(self.limit)
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 
 
3064 chandransh 8963 
class getValidOrders_result:
1528 ankur.sing 8964 
  """
8965 
  Attributes:
8966 
   - success
8967 
  """
8968 
 
8969 
  thrift_spec = (
3064 chandransh 8970 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 8971 
  )
8972 
 
3064 chandransh 8973 
  def __init__(self, success=None,):
1528 ankur.sing 8974 
    self.success = success
8975 
 
8976 
  def read(self, iprot):
8977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8979 
      return
8980 
    iprot.readStructBegin()
8981 
    while True:
8982 
      (fname, ftype, fid) = iprot.readFieldBegin()
8983 
      if ftype == TType.STOP:
8984 
        break
8985 
      if fid == 0:
3064 chandransh 8986 
        if ftype == TType.LIST:
8987 
          self.success = []
4133 chandransh 8988 
          (_etype129, _size126) = iprot.readListBegin()
8989 
          for _i130 in xrange(_size126):
8990 
            _elem131 = Order()
8991 
            _elem131.read(iprot)
8992 
            self.success.append(_elem131)
3064 chandransh 8993 
          iprot.readListEnd()
1528 ankur.sing 8994 
        else:
8995 
          iprot.skip(ftype)
8996 
      else:
8997 
        iprot.skip(ftype)
8998 
      iprot.readFieldEnd()
8999 
    iprot.readStructEnd()
9000 
 
9001 
  def write(self, oprot):
9002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9004 
      return
3064 chandransh 9005 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9006 
    if self.success is not None:
3064 chandransh 9007 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9008 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9009 
      for iter132 in self.success:
9010 
        iter132.write(oprot)
3064 chandransh 9011 
      oprot.writeListEnd()
1528 ankur.sing 9012 
      oprot.writeFieldEnd()
9013 
    oprot.writeFieldStop()
9014 
    oprot.writeStructEnd()
9015 
 
3431 rajveer 9016 
  def validate(self):
9017 
    return
9018 
 
9019 
 
1528 ankur.sing 9020 
  def __repr__(self):
9021 
    L = ['%s=%r' % (key, value)
9022 
      for key, value in self.__dict__.iteritems()]
9023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9024 
 
9025 
  def __eq__(self, other):
9026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9027 
 
9028 
  def __ne__(self, other):
9029 
    return not (self == other)
9030 
 
1220 chandransh 9031 
class batchOrders_args:
9032 
  """
9033 
  Attributes:
9034 
   - warehouseId
9035 
  """
9036 
 
9037 
  thrift_spec = (
9038 
    None, # 0
9039 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9040 
  )
9041 
 
9042 
  def __init__(self, warehouseId=None,):
9043 
    self.warehouseId = warehouseId
9044 
 
9045 
  def read(self, iprot):
9046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9048 
      return
9049 
    iprot.readStructBegin()
9050 
    while True:
9051 
      (fname, ftype, fid) = iprot.readFieldBegin()
9052 
      if ftype == TType.STOP:
9053 
        break
9054 
      if fid == 1:
9055 
        if ftype == TType.I64:
9056 
          self.warehouseId = iprot.readI64();
9057 
        else:
9058 
          iprot.skip(ftype)
9059 
      else:
9060 
        iprot.skip(ftype)
9061 
      iprot.readFieldEnd()
9062 
    iprot.readStructEnd()
9063 
 
9064 
  def write(self, oprot):
9065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9067 
      return
9068 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9069 
    if self.warehouseId is not None:
1220 chandransh 9070 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9071 
      oprot.writeI64(self.warehouseId)
9072 
      oprot.writeFieldEnd()
9073 
    oprot.writeFieldStop()
9074 
    oprot.writeStructEnd()
9075 
 
3431 rajveer 9076 
  def validate(self):
9077 
    return
9078 
 
9079 
 
1220 chandransh 9080 
  def __repr__(self):
9081 
    L = ['%s=%r' % (key, value)
9082 
      for key, value in self.__dict__.iteritems()]
9083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9084 
 
9085 
  def __eq__(self, other):
9086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9087 
 
9088 
  def __ne__(self, other):
9089 
    return not (self == other)
9090 
 
9091 
class batchOrders_result:
9092 
  """
9093 
  Attributes:
9094 
   - success
9095 
   - ex
9096 
  """
9097 
 
9098 
  thrift_spec = (
9099 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9100 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9101 
  )
9102 
 
9103 
  def __init__(self, success=None, ex=None,):
9104 
    self.success = success
9105 
    self.ex = ex
9106 
 
9107 
  def read(self, iprot):
9108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9110 
      return
9111 
    iprot.readStructBegin()
9112 
    while True:
9113 
      (fname, ftype, fid) = iprot.readFieldBegin()
9114 
      if ftype == TType.STOP:
9115 
        break
9116 
      if fid == 0:
9117 
        if ftype == TType.LIST:
9118 
          self.success = []
4133 chandransh 9119 
          (_etype136, _size133) = iprot.readListBegin()
9120 
          for _i137 in xrange(_size133):
9121 
            _elem138 = Order()
9122 
            _elem138.read(iprot)
9123 
            self.success.append(_elem138)
1220 chandransh 9124 
          iprot.readListEnd()
9125 
        else:
9126 
          iprot.skip(ftype)
9127 
      elif fid == 1:
9128 
        if ftype == TType.STRUCT:
9129 
          self.ex = TransactionServiceException()
9130 
          self.ex.read(iprot)
9131 
        else:
9132 
          iprot.skip(ftype)
9133 
      else:
9134 
        iprot.skip(ftype)
9135 
      iprot.readFieldEnd()
9136 
    iprot.readStructEnd()
9137 
 
9138 
  def write(self, oprot):
9139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9141 
      return
9142 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 9143 
    if self.success is not None:
1220 chandransh 9144 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9145 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9146 
      for iter139 in self.success:
9147 
        iter139.write(oprot)
1220 chandransh 9148 
      oprot.writeListEnd()
9149 
      oprot.writeFieldEnd()
3431 rajveer 9150 
    if self.ex is not None:
1220 chandransh 9151 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9152 
      self.ex.write(oprot)
9153 
      oprot.writeFieldEnd()
9154 
    oprot.writeFieldStop()
9155 
    oprot.writeStructEnd()
9156 
 
3431 rajveer 9157 
  def validate(self):
9158 
    return
9159 
 
9160 
 
1220 chandransh 9161 
  def __repr__(self):
9162 
    L = ['%s=%r' % (key, value)
9163 
      for key, value in self.__dict__.iteritems()]
9164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9165 
 
9166 
  def __eq__(self, other):
9167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9168 
 
9169 
  def __ne__(self, other):
9170 
    return not (self == other)
9171 
 
1208 chandransh 9172 
class markOrderAsOutOfStock_args:
9173 
  """
9174 
  Attributes:
9175 
   - orderId
9176 
  """
9177 
 
9178 
  thrift_spec = (
9179 
    None, # 0
9180 
    (1, TType.I64, 'orderId', None, None, ), # 1
9181 
  )
9182 
 
9183 
  def __init__(self, orderId=None,):
9184 
    self.orderId = orderId
9185 
 
9186 
  def read(self, iprot):
9187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9189 
      return
9190 
    iprot.readStructBegin()
9191 
    while True:
9192 
      (fname, ftype, fid) = iprot.readFieldBegin()
9193 
      if ftype == TType.STOP:
9194 
        break
9195 
      if fid == 1:
9196 
        if ftype == TType.I64:
9197 
          self.orderId = iprot.readI64();
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_args')
3431 rajveer 9210 
    if self.orderId is not None:
1208 chandransh 9211 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9212 
      oprot.writeI64(self.orderId)
9213 
      oprot.writeFieldEnd()
9214 
    oprot.writeFieldStop()
9215 
    oprot.writeStructEnd()
9216 
 
3431 rajveer 9217 
  def validate(self):
9218 
    return
9219 
 
9220 
 
1208 chandransh 9221 
  def __repr__(self):
9222 
    L = ['%s=%r' % (key, value)
9223 
      for key, value in self.__dict__.iteritems()]
9224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9225 
 
9226 
  def __eq__(self, other):
9227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9228 
 
9229 
  def __ne__(self, other):
9230 
    return not (self == other)
9231 
 
9232 
class markOrderAsOutOfStock_result:
9233 
  """
9234 
  Attributes:
9235 
   - success
9236 
   - ex
9237 
  """
9238 
 
9239 
  thrift_spec = (
9240 
    (0, TType.BOOL, 'success', None, None, ), # 0
9241 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9242 
  )
9243 
 
9244 
  def __init__(self, success=None, ex=None,):
9245 
    self.success = success
9246 
    self.ex = ex
9247 
 
9248 
  def read(self, iprot):
9249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9251 
      return
9252 
    iprot.readStructBegin()
9253 
    while True:
9254 
      (fname, ftype, fid) = iprot.readFieldBegin()
9255 
      if ftype == TType.STOP:
9256 
        break
9257 
      if fid == 0:
9258 
        if ftype == TType.BOOL:
9259 
          self.success = iprot.readBool();
9260 
        else:
9261 
          iprot.skip(ftype)
9262 
      elif fid == 1:
9263 
        if ftype == TType.STRUCT:
9264 
          self.ex = TransactionServiceException()
9265 
          self.ex.read(iprot)
9266 
        else:
9267 
          iprot.skip(ftype)
9268 
      else:
9269 
        iprot.skip(ftype)
9270 
      iprot.readFieldEnd()
9271 
    iprot.readStructEnd()
9272 
 
9273 
  def write(self, oprot):
9274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9276 
      return
9277 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 9278 
    if self.success is not None:
1208 chandransh 9279 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9280 
      oprot.writeBool(self.success)
9281 
      oprot.writeFieldEnd()
3431 rajveer 9282 
    if self.ex is not None:
1208 chandransh 9283 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9284 
      self.ex.write(oprot)
9285 
      oprot.writeFieldEnd()
9286 
    oprot.writeFieldStop()
9287 
    oprot.writeStructEnd()
9288 
 
3431 rajveer 9289 
  def validate(self):
9290 
    return
9291 
 
9292 
 
1208 chandransh 9293 
  def __repr__(self):
9294 
    L = ['%s=%r' % (key, value)
9295 
      for key, value in self.__dict__.iteritems()]
9296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9297 
 
9298 
  def __eq__(self, other):
9299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9300 
 
9301 
  def __ne__(self, other):
9302 
    return not (self == other)
9303 
 
3064 chandransh 9304 
class verifyOrder_args:
759 chandransh 9305 
  """
9306 
  Attributes:
3064 chandransh 9307 
   - orderId
759 chandransh 9308 
  """
9309 
 
9310 
  thrift_spec = (
9311 
    None, # 0
3064 chandransh 9312 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 9313 
  )
9314 
 
3064 chandransh 9315 
  def __init__(self, orderId=None,):
9316 
    self.orderId = orderId
759 chandransh 9317 
 
9318 
  def read(self, iprot):
9319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9321 
      return
9322 
    iprot.readStructBegin()
9323 
    while True:
9324 
      (fname, ftype, fid) = iprot.readFieldBegin()
9325 
      if ftype == TType.STOP:
9326 
        break
9327 
      if fid == 1:
9328 
        if ftype == TType.I64:
3064 chandransh 9329 
          self.orderId = iprot.readI64();
759 chandransh 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_args')
3431 rajveer 9342 
    if self.orderId is not None:
3064 chandransh 9343 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9344 
      oprot.writeI64(self.orderId)
759 chandransh 9345 
      oprot.writeFieldEnd()
9346 
    oprot.writeFieldStop()
9347 
    oprot.writeStructEnd()
9348 
 
3431 rajveer 9349 
  def validate(self):
9350 
    return
9351 
 
9352 
 
759 chandransh 9353 
  def __repr__(self):
9354 
    L = ['%s=%r' % (key, value)
9355 
      for key, value in self.__dict__.iteritems()]
9356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9357 
 
9358 
  def __eq__(self, other):
9359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9360 
 
9361 
  def __ne__(self, other):
9362 
    return not (self == other)
9363 
 
3064 chandransh 9364 
class verifyOrder_result:
759 chandransh 9365 
  """
9366 
  Attributes:
9367 
   - success
9368 
   - ex
9369 
  """
9370 
 
9371 
  thrift_spec = (
9372 
    (0, TType.BOOL, 'success', None, None, ), # 0
9373 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9374 
  )
9375 
 
9376 
  def __init__(self, success=None, ex=None,):
9377 
    self.success = success
9378 
    self.ex = ex
9379 
 
9380 
  def read(self, iprot):
9381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9383 
      return
9384 
    iprot.readStructBegin()
9385 
    while True:
9386 
      (fname, ftype, fid) = iprot.readFieldBegin()
9387 
      if ftype == TType.STOP:
9388 
        break
9389 
      if fid == 0:
9390 
        if ftype == TType.BOOL:
9391 
          self.success = iprot.readBool();
9392 
        else:
9393 
          iprot.skip(ftype)
9394 
      elif fid == 1:
9395 
        if ftype == TType.STRUCT:
9396 
          self.ex = TransactionServiceException()
9397 
          self.ex.read(iprot)
9398 
        else:
9399 
          iprot.skip(ftype)
9400 
      else:
9401 
        iprot.skip(ftype)
9402 
      iprot.readFieldEnd()
9403 
    iprot.readStructEnd()
9404 
 
9405 
  def write(self, oprot):
9406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9408 
      return
3064 chandransh 9409 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 9410 
    if self.success is not None:
759 chandransh 9411 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9412 
      oprot.writeBool(self.success)
9413 
      oprot.writeFieldEnd()
3431 rajveer 9414 
    if self.ex is not None:
759 chandransh 9415 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9416 
      self.ex.write(oprot)
9417 
      oprot.writeFieldEnd()
9418 
    oprot.writeFieldStop()
9419 
    oprot.writeStructEnd()
9420 
 
3431 rajveer 9421 
  def validate(self):
9422 
    return
9423 
 
9424 
 
759 chandransh 9425 
  def __repr__(self):
9426 
    L = ['%s=%r' % (key, value)
9427 
      for key, value in self.__dict__.iteritems()]
9428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9429 
 
9430 
  def __eq__(self, other):
9431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9432 
 
9433 
  def __ne__(self, other):
9434 
    return not (self == other)
9435 
 
3064 chandransh 9436 
class acceptOrder_args:
1113 chandransh 9437 
  """
9438 
  Attributes:
3064 chandransh 9439 
   - orderId
1113 chandransh 9440 
  """
9441 
 
9442 
  thrift_spec = (
9443 
    None, # 0
3064 chandransh 9444 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 9445 
  )
9446 
 
3064 chandransh 9447 
  def __init__(self, orderId=None,):
9448 
    self.orderId = orderId
1113 chandransh 9449 
 
9450 
  def read(self, iprot):
9451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9453 
      return
9454 
    iprot.readStructBegin()
9455 
    while True:
9456 
      (fname, ftype, fid) = iprot.readFieldBegin()
9457 
      if ftype == TType.STOP:
9458 
        break
9459 
      if fid == 1:
9460 
        if ftype == TType.I64:
3064 chandransh 9461 
          self.orderId = iprot.readI64();
1113 chandransh 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_args')
3431 rajveer 9474 
    if self.orderId is not None:
3064 chandransh 9475 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9476 
      oprot.writeI64(self.orderId)
1113 chandransh 9477 
      oprot.writeFieldEnd()
9478 
    oprot.writeFieldStop()
9479 
    oprot.writeStructEnd()
9480 
 
3431 rajveer 9481 
  def validate(self):
9482 
    return
9483 
 
9484 
 
1113 chandransh 9485 
  def __repr__(self):
9486 
    L = ['%s=%r' % (key, value)
9487 
      for key, value in self.__dict__.iteritems()]
9488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9489 
 
9490 
  def __eq__(self, other):
9491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9492 
 
9493 
  def __ne__(self, other):
9494 
    return not (self == other)
9495 
 
3064 chandransh 9496 
class acceptOrder_result:
1113 chandransh 9497 
  """
9498 
  Attributes:
9499 
   - success
9500 
   - ex
9501 
  """
9502 
 
9503 
  thrift_spec = (
3064 chandransh 9504 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 9505 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9506 
  )
9507 
 
9508 
  def __init__(self, success=None, ex=None,):
9509 
    self.success = success
9510 
    self.ex = ex
9511 
 
9512 
  def read(self, iprot):
9513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9515 
      return
9516 
    iprot.readStructBegin()
9517 
    while True:
9518 
      (fname, ftype, fid) = iprot.readFieldBegin()
9519 
      if ftype == TType.STOP:
9520 
        break
9521 
      if fid == 0:
3064 chandransh 9522 
        if ftype == TType.BOOL:
9523 
          self.success = iprot.readBool();
1113 chandransh 9524 
        else:
9525 
          iprot.skip(ftype)
9526 
      elif fid == 1:
9527 
        if ftype == TType.STRUCT:
9528 
          self.ex = TransactionServiceException()
9529 
          self.ex.read(iprot)
9530 
        else:
9531 
          iprot.skip(ftype)
9532 
      else:
9533 
        iprot.skip(ftype)
9534 
      iprot.readFieldEnd()
9535 
    iprot.readStructEnd()
9536 
 
9537 
  def write(self, oprot):
9538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9540 
      return
3064 chandransh 9541 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 9542 
    if self.success is not None:
3064 chandransh 9543 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9544 
      oprot.writeBool(self.success)
1113 chandransh 9545 
      oprot.writeFieldEnd()
3431 rajveer 9546 
    if self.ex is not None:
1113 chandransh 9547 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9548 
      self.ex.write(oprot)
9549 
      oprot.writeFieldEnd()
9550 
    oprot.writeFieldStop()
9551 
    oprot.writeStructEnd()
9552 
 
3431 rajveer 9553 
  def validate(self):
9554 
    return
9555 
 
9556 
 
1113 chandransh 9557 
  def __repr__(self):
9558 
    L = ['%s=%r' % (key, value)
9559 
      for key, value in self.__dict__.iteritems()]
9560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9561 
 
9562 
  def __eq__(self, other):
9563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9564 
 
9565 
  def __ne__(self, other):
9566 
    return not (self == other)
9567 
 
3064 chandransh 9568 
class addBillingDetails_args:
1135 chandransh 9569 
  """
9570 
  Attributes:
3064 chandransh 9571 
   - orderId
9572 
   - invoice_number
4283 anupam.sin 9573 
   - imeiNumber
9574 
   - itemNumber
3064 chandransh 9575 
   - billed_by
4264 rajveer 9576 
   - jacketNumber
4283 anupam.sin 9577 
   - billingType
9578 
   - vendorId
1135 chandransh 9579 
  """
9580 
 
9581 
  thrift_spec = (
9582 
    None, # 0
3064 chandransh 9583 
    (1, TType.I64, 'orderId', None, None, ), # 1
9584 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 9585 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
9586 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
9587 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
9588 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
9589 
    (7, TType.I64, 'billingType', None, None, ), # 7
9590 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 9591 
  )
9592 
 
4283 anupam.sin 9593 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 9594 
    self.orderId = orderId
9595 
    self.invoice_number = invoice_number
4283 anupam.sin 9596 
    self.imeiNumber = imeiNumber
9597 
    self.itemNumber = itemNumber
3064 chandransh 9598 
    self.billed_by = billed_by
4264 rajveer 9599 
    self.jacketNumber = jacketNumber
4283 anupam.sin 9600 
    self.billingType = billingType
9601 
    self.vendorId = vendorId
1135 chandransh 9602 
 
9603 
  def read(self, iprot):
9604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9606 
      return
9607 
    iprot.readStructBegin()
9608 
    while True:
9609 
      (fname, ftype, fid) = iprot.readFieldBegin()
9610 
      if ftype == TType.STOP:
9611 
        break
9612 
      if fid == 1:
9613 
        if ftype == TType.I64:
3064 chandransh 9614 
          self.orderId = iprot.readI64();
1135 chandransh 9615 
        else:
9616 
          iprot.skip(ftype)
9617 
      elif fid == 2:
3064 chandransh 9618 
        if ftype == TType.STRING:
9619 
          self.invoice_number = iprot.readString();
1135 chandransh 9620 
        else:
9621 
          iprot.skip(ftype)
3064 chandransh 9622 
      elif fid == 3:
4264 rajveer 9623 
        if ftype == TType.I64:
3064 chandransh 9624 
          self.imeiNumber = iprot.readI64();
9625 
        else:
9626 
          iprot.skip(ftype)
9627 
      elif fid == 4:
9628 
        if ftype == TType.STRING:
9629 
          self.itemNumber = iprot.readString();
9630 
        else:
9631 
          iprot.skip(ftype)
9632 
      elif fid == 5:
9633 
        if ftype == TType.STRING:
4283 anupam.sin 9634 
          self.billed_by = iprot.readString();
3064 chandransh 9635 
        else:
9636 
          iprot.skip(ftype)
9637 
      elif fid == 6:
9638 
        if ftype == TType.I64:
4283 anupam.sin 9639 
          self.jacketNumber = iprot.readI64();
9640 
        else:
9641 
          iprot.skip(ftype)
9642 
      elif fid == 7:
9643 
        if ftype == TType.I64:
3064 chandransh 9644 
          self.billingType = iprot.readI64();
9645 
        else:
9646 
          iprot.skip(ftype)
4283 anupam.sin 9647 
      elif fid == 8:
9648 
        if ftype == TType.I64:
9649 
          self.vendorId = iprot.readI64();
9650 
        else:
9651 
          iprot.skip(ftype)
1246 chandransh 9652 
      else:
9653 
        iprot.skip(ftype)
9654 
      iprot.readFieldEnd()
9655 
    iprot.readStructEnd()
9656 
 
9657 
  def write(self, oprot):
9658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9660 
      return
4283 anupam.sin 9661 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 9662 
    if self.orderId is not None:
3064 chandransh 9663 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9664 
      oprot.writeI64(self.orderId)
1246 chandransh 9665 
      oprot.writeFieldEnd()
4283 anupam.sin 9666 
    if self.invoice_number is not None:
9667 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
9668 
      oprot.writeString(self.invoice_number)
1246 chandransh 9669 
      oprot.writeFieldEnd()
3431 rajveer 9670 
    if self.imeiNumber is not None:
3064 chandransh 9671 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
9672 
      oprot.writeI64(self.imeiNumber)
9673 
      oprot.writeFieldEnd()
3431 rajveer 9674 
    if self.itemNumber is not None:
3064 chandransh 9675 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
9676 
      oprot.writeString(self.itemNumber)
9677 
      oprot.writeFieldEnd()
4283 anupam.sin 9678 
    if self.billed_by is not None:
9679 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
9680 
      oprot.writeString(self.billed_by)
3064 chandransh 9681 
      oprot.writeFieldEnd()
4283 anupam.sin 9682 
    if self.jacketNumber is not None:
9683 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
9684 
      oprot.writeI64(self.jacketNumber)
9685 
      oprot.writeFieldEnd()
3431 rajveer 9686 
    if self.billingType is not None:
4283 anupam.sin 9687 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 9688 
      oprot.writeI64(self.billingType)
9689 
      oprot.writeFieldEnd()
4283 anupam.sin 9690 
    if self.vendorId is not None:
9691 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
9692 
      oprot.writeI64(self.vendorId)
9693 
      oprot.writeFieldEnd()
1246 chandransh 9694 
    oprot.writeFieldStop()
9695 
    oprot.writeStructEnd()
9696 
 
3431 rajveer 9697 
  def validate(self):
9698 
    return
9699 
 
9700 
 
1246 chandransh 9701 
  def __repr__(self):
9702 
    L = ['%s=%r' % (key, value)
9703 
      for key, value in self.__dict__.iteritems()]
9704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9705 
 
9706 
  def __eq__(self, other):
9707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9708 
 
9709 
  def __ne__(self, other):
9710 
    return not (self == other)
9711 
 
4283 anupam.sin 9712 
class addBillingDetails_result:
1246 chandransh 9713 
  """
9714 
  Attributes:
3064 chandransh 9715 
   - success
1246 chandransh 9716 
   - ex
9717 
  """
9718 
 
9719 
  thrift_spec = (
3064 chandransh 9720 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 9721 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9722 
  )
9723 
 
3064 chandransh 9724 
  def __init__(self, success=None, ex=None,):
9725 
    self.success = success
1246 chandransh 9726 
    self.ex = ex
9727 
 
9728 
  def read(self, iprot):
9729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9731 
      return
9732 
    iprot.readStructBegin()
9733 
    while True:
9734 
      (fname, ftype, fid) = iprot.readFieldBegin()
9735 
      if ftype == TType.STOP:
9736 
        break
3064 chandransh 9737 
      if fid == 0:
9738 
        if ftype == TType.BOOL:
9739 
          self.success = iprot.readBool();
9740 
        else:
9741 
          iprot.skip(ftype)
9742 
      elif fid == 1:
1246 chandransh 9743 
        if ftype == TType.STRUCT:
9744 
          self.ex = TransactionServiceException()
9745 
          self.ex.read(iprot)
9746 
        else:
9747 
          iprot.skip(ftype)
9748 
      else:
9749 
        iprot.skip(ftype)
9750 
      iprot.readFieldEnd()
9751 
    iprot.readStructEnd()
9752 
 
9753 
  def write(self, oprot):
9754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9756 
      return
4283 anupam.sin 9757 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 9758 
    if self.success is not None:
3064 chandransh 9759 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9760 
      oprot.writeBool(self.success)
9761 
      oprot.writeFieldEnd()
3431 rajveer 9762 
    if self.ex is not None:
1246 chandransh 9763 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9764 
      self.ex.write(oprot)
9765 
      oprot.writeFieldEnd()
9766 
    oprot.writeFieldStop()
9767 
    oprot.writeStructEnd()
9768 
 
3431 rajveer 9769 
  def validate(self):
9770 
    return
9771 
 
9772 
 
1246 chandransh 9773 
  def __repr__(self):
9774 
    L = ['%s=%r' % (key, value)
9775 
      for key, value in self.__dict__.iteritems()]
9776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9777 
 
9778 
  def __eq__(self, other):
9779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9780 
 
9781 
  def __ne__(self, other):
9782 
    return not (self == other)
9783 
 
4579 rajveer 9784 
class addInvoiceNumber_args:
9785 
  """
9786 
  Attributes:
9787 
   - orderId
9788 
   - invoiceNumber
9789 
  """
9790 
 
9791 
  thrift_spec = (
9792 
    None, # 0
9793 
    (1, TType.I64, 'orderId', None, None, ), # 1
9794 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
9795 
  )
9796 
 
9797 
  def __init__(self, orderId=None, invoiceNumber=None,):
9798 
    self.orderId = orderId
9799 
    self.invoiceNumber = invoiceNumber
9800 
 
9801 
  def read(self, iprot):
9802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9804 
      return
9805 
    iprot.readStructBegin()
9806 
    while True:
9807 
      (fname, ftype, fid) = iprot.readFieldBegin()
9808 
      if ftype == TType.STOP:
9809 
        break
9810 
      if fid == 1:
9811 
        if ftype == TType.I64:
9812 
          self.orderId = iprot.readI64();
9813 
        else:
9814 
          iprot.skip(ftype)
9815 
      elif fid == 2:
9816 
        if ftype == TType.STRING:
9817 
          self.invoiceNumber = iprot.readString();
9818 
        else:
9819 
          iprot.skip(ftype)
9820 
      else:
9821 
        iprot.skip(ftype)
9822 
      iprot.readFieldEnd()
9823 
    iprot.readStructEnd()
9824 
 
9825 
  def write(self, oprot):
9826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9828 
      return
9829 
    oprot.writeStructBegin('addInvoiceNumber_args')
9830 
    if self.orderId is not None:
9831 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9832 
      oprot.writeI64(self.orderId)
9833 
      oprot.writeFieldEnd()
9834 
    if self.invoiceNumber is not None:
9835 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
9836 
      oprot.writeString(self.invoiceNumber)
9837 
      oprot.writeFieldEnd()
9838 
    oprot.writeFieldStop()
9839 
    oprot.writeStructEnd()
9840 
 
9841 
  def validate(self):
9842 
    return
9843 
 
9844 
 
9845 
  def __repr__(self):
9846 
    L = ['%s=%r' % (key, value)
9847 
      for key, value in self.__dict__.iteritems()]
9848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9849 
 
9850 
  def __eq__(self, other):
9851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9852 
 
9853 
  def __ne__(self, other):
9854 
    return not (self == other)
9855 
 
9856 
class addInvoiceNumber_result:
9857 
  """
9858 
  Attributes:
9859 
   - ex
9860 
  """
9861 
 
9862 
  thrift_spec = (
9863 
    None, # 0
9864 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9865 
  )
9866 
 
9867 
  def __init__(self, ex=None,):
9868 
    self.ex = ex
9869 
 
9870 
  def read(self, iprot):
9871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9873 
      return
9874 
    iprot.readStructBegin()
9875 
    while True:
9876 
      (fname, ftype, fid) = iprot.readFieldBegin()
9877 
      if ftype == TType.STOP:
9878 
        break
9879 
      if fid == 1:
9880 
        if ftype == TType.STRUCT:
9881 
          self.ex = TransactionServiceException()
9882 
          self.ex.read(iprot)
9883 
        else:
9884 
          iprot.skip(ftype)
9885 
      else:
9886 
        iprot.skip(ftype)
9887 
      iprot.readFieldEnd()
9888 
    iprot.readStructEnd()
9889 
 
9890 
  def write(self, oprot):
9891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9893 
      return
9894 
    oprot.writeStructBegin('addInvoiceNumber_result')
9895 
    if self.ex is not None:
9896 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9897 
      self.ex.write(oprot)
9898 
      oprot.writeFieldEnd()
9899 
    oprot.writeFieldStop()
9900 
    oprot.writeStructEnd()
9901 
 
9902 
  def validate(self):
9903 
    return
9904 
 
9905 
 
9906 
  def __repr__(self):
9907 
    L = ['%s=%r' % (key, value)
9908 
      for key, value in self.__dict__.iteritems()]
9909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9910 
 
9911 
  def __eq__(self, other):
9912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9913 
 
9914 
  def __ne__(self, other):
9915 
    return not (self == other)
9916 
 
3064 chandransh 9917 
class markOrdersAsManifested_args:
1408 ankur.sing 9918 
  """
9919 
  Attributes:
3064 chandransh 9920 
   - warehouseId
1408 ankur.sing 9921 
   - providerId
3064 chandransh 9922 
   - cod
1408 ankur.sing 9923 
  """
9924 
 
9925 
  thrift_spec = (
9926 
    None, # 0
3064 chandransh 9927 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9928 
    (2, TType.I64, 'providerId', None, None, ), # 2
9929 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 9930 
  )
9931 
 
3064 chandransh 9932 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9933 
    self.warehouseId = warehouseId
1408 ankur.sing 9934 
    self.providerId = providerId
3064 chandransh 9935 
    self.cod = cod
1408 ankur.sing 9936 
 
9937 
  def read(self, iprot):
9938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9940 
      return
9941 
    iprot.readStructBegin()
9942 
    while True:
9943 
      (fname, ftype, fid) = iprot.readFieldBegin()
9944 
      if ftype == TType.STOP:
9945 
        break
9946 
      if fid == 1:
9947 
        if ftype == TType.I64:
3064 chandransh 9948 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 9949 
        else:
9950 
          iprot.skip(ftype)
9951 
      elif fid == 2:
9952 
        if ftype == TType.I64:
3064 chandransh 9953 
          self.providerId = iprot.readI64();
1408 ankur.sing 9954 
        else:
9955 
          iprot.skip(ftype)
3064 chandransh 9956 
      elif fid == 3:
9957 
        if ftype == TType.BOOL:
9958 
          self.cod = iprot.readBool();
9959 
        else:
9960 
          iprot.skip(ftype)
1408 ankur.sing 9961 
      else:
9962 
        iprot.skip(ftype)
9963 
      iprot.readFieldEnd()
9964 
    iprot.readStructEnd()
9965 
 
9966 
  def write(self, oprot):
9967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9969 
      return
3064 chandransh 9970 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 9971 
    if self.warehouseId is not None:
3064 chandransh 9972 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9973 
      oprot.writeI64(self.warehouseId)
9974 
      oprot.writeFieldEnd()
3431 rajveer 9975 
    if self.providerId is not None:
3064 chandransh 9976 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9977 
      oprot.writeI64(self.providerId)
9978 
      oprot.writeFieldEnd()
3431 rajveer 9979 
    if self.cod is not None:
3064 chandransh 9980 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9981 
      oprot.writeBool(self.cod)
1408 ankur.sing 9982 
      oprot.writeFieldEnd()
9983 
    oprot.writeFieldStop()
9984 
    oprot.writeStructEnd()
9985 
 
3431 rajveer 9986 
  def validate(self):
9987 
    return
9988 
 
9989 
 
1408 ankur.sing 9990 
  def __repr__(self):
9991 
    L = ['%s=%r' % (key, value)
9992 
      for key, value in self.__dict__.iteritems()]
9993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9994 
 
9995 
  def __eq__(self, other):
9996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9997 
 
9998 
  def __ne__(self, other):
9999 
    return not (self == other)
10000 
 
3064 chandransh 10001 
class markOrdersAsManifested_result:
1408 ankur.sing 10002 
  """
10003 
  Attributes:
10004 
   - success
3064 chandransh 10005 
   - ex
1408 ankur.sing 10006 
  """
10007 
 
10008 
  thrift_spec = (
3064 chandransh 10009 
    (0, TType.BOOL, 'success', None, None, ), # 0
10010 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10011 
  )
10012 
 
3064 chandransh 10013 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10014 
    self.success = success
3064 chandransh 10015 
    self.ex = ex
1408 ankur.sing 10016 
 
10017 
  def read(self, iprot):
10018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10020 
      return
10021 
    iprot.readStructBegin()
10022 
    while True:
10023 
      (fname, ftype, fid) = iprot.readFieldBegin()
10024 
      if ftype == TType.STOP:
10025 
        break
10026 
      if fid == 0:
3064 chandransh 10027 
        if ftype == TType.BOOL:
10028 
          self.success = iprot.readBool();
1408 ankur.sing 10029 
        else:
10030 
          iprot.skip(ftype)
3064 chandransh 10031 
      elif fid == 1:
10032 
        if ftype == TType.STRUCT:
10033 
          self.ex = TransactionServiceException()
10034 
          self.ex.read(iprot)
10035 
        else:
10036 
          iprot.skip(ftype)
1408 ankur.sing 10037 
      else:
10038 
        iprot.skip(ftype)
10039 
      iprot.readFieldEnd()
10040 
    iprot.readStructEnd()
10041 
 
10042 
  def write(self, oprot):
10043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10045 
      return
3064 chandransh 10046 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10047 
    if self.success is not None:
3064 chandransh 10048 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10049 
      oprot.writeBool(self.success)
1408 ankur.sing 10050 
      oprot.writeFieldEnd()
3431 rajveer 10051 
    if self.ex is not None:
3064 chandransh 10052 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10053 
      self.ex.write(oprot)
10054 
      oprot.writeFieldEnd()
1408 ankur.sing 10055 
    oprot.writeFieldStop()
10056 
    oprot.writeStructEnd()
10057 
 
3431 rajveer 10058 
  def validate(self):
10059 
    return
10060 
 
10061 
 
1408 ankur.sing 10062 
  def __repr__(self):
10063 
    L = ['%s=%r' % (key, value)
10064 
      for key, value in self.__dict__.iteritems()]
10065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10066 
 
10067 
  def __eq__(self, other):
10068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10069 
 
10070 
  def __ne__(self, other):
10071 
    return not (self == other)
10072 
 
4410 rajveer 10073 
class markOrdersAsShippedFromWarehouse_args:
10074 
  """
10075 
  Attributes:
10076 
   - warehouseId
10077 
   - providerId
10078 
   - cod
10079 
  """
10080 
 
10081 
  thrift_spec = (
10082 
    None, # 0
10083 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10084 
    (2, TType.I64, 'providerId', None, None, ), # 2
10085 
    (3, TType.BOOL, 'cod', None, None, ), # 3
10086 
  )
10087 
 
10088 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10089 
    self.warehouseId = warehouseId
10090 
    self.providerId = providerId
10091 
    self.cod = cod
10092 
 
10093 
  def read(self, iprot):
10094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10096 
      return
10097 
    iprot.readStructBegin()
10098 
    while True:
10099 
      (fname, ftype, fid) = iprot.readFieldBegin()
10100 
      if ftype == TType.STOP:
10101 
        break
10102 
      if fid == 1:
10103 
        if ftype == TType.I64:
10104 
          self.warehouseId = iprot.readI64();
10105 
        else:
10106 
          iprot.skip(ftype)
10107 
      elif fid == 2:
10108 
        if ftype == TType.I64:
10109 
          self.providerId = iprot.readI64();
10110 
        else:
10111 
          iprot.skip(ftype)
10112 
      elif fid == 3:
10113 
        if ftype == TType.BOOL:
10114 
          self.cod = iprot.readBool();
10115 
        else:
10116 
          iprot.skip(ftype)
10117 
      else:
10118 
        iprot.skip(ftype)
10119 
      iprot.readFieldEnd()
10120 
    iprot.readStructEnd()
10121 
 
10122 
  def write(self, oprot):
10123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10125 
      return
10126 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
10127 
    if self.warehouseId is not None:
10128 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10129 
      oprot.writeI64(self.warehouseId)
10130 
      oprot.writeFieldEnd()
10131 
    if self.providerId is not None:
10132 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
10133 
      oprot.writeI64(self.providerId)
10134 
      oprot.writeFieldEnd()
10135 
    if self.cod is not None:
10136 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10137 
      oprot.writeBool(self.cod)
10138 
      oprot.writeFieldEnd()
10139 
    oprot.writeFieldStop()
10140 
    oprot.writeStructEnd()
10141 
 
10142 
  def validate(self):
10143 
    return
10144 
 
10145 
 
10146 
  def __repr__(self):
10147 
    L = ['%s=%r' % (key, value)
10148 
      for key, value in self.__dict__.iteritems()]
10149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10150 
 
10151 
  def __eq__(self, other):
10152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10153 
 
10154 
  def __ne__(self, other):
10155 
    return not (self == other)
10156 
 
10157 
class markOrdersAsShippedFromWarehouse_result:
10158 
  """
10159 
  Attributes:
10160 
   - success
10161 
   - ex
10162 
  """
10163 
 
10164 
  thrift_spec = (
10165 
    (0, TType.BOOL, 'success', None, None, ), # 0
10166 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10167 
  )
10168 
 
10169 
  def __init__(self, success=None, ex=None,):
10170 
    self.success = success
10171 
    self.ex = ex
10172 
 
10173 
  def read(self, iprot):
10174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10176 
      return
10177 
    iprot.readStructBegin()
10178 
    while True:
10179 
      (fname, ftype, fid) = iprot.readFieldBegin()
10180 
      if ftype == TType.STOP:
10181 
        break
10182 
      if fid == 0:
10183 
        if ftype == TType.BOOL:
10184 
          self.success = iprot.readBool();
10185 
        else:
10186 
          iprot.skip(ftype)
10187 
      elif fid == 1:
10188 
        if ftype == TType.STRUCT:
10189 
          self.ex = TransactionServiceException()
10190 
          self.ex.read(iprot)
10191 
        else:
10192 
          iprot.skip(ftype)
10193 
      else:
10194 
        iprot.skip(ftype)
10195 
      iprot.readFieldEnd()
10196 
    iprot.readStructEnd()
10197 
 
10198 
  def write(self, oprot):
10199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10201 
      return
10202 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
10203 
    if self.success is not None:
10204 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10205 
      oprot.writeBool(self.success)
10206 
      oprot.writeFieldEnd()
10207 
    if self.ex is not None:
10208 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10209 
      self.ex.write(oprot)
10210 
      oprot.writeFieldEnd()
10211 
    oprot.writeFieldStop()
10212 
    oprot.writeStructEnd()
10213 
 
10214 
  def validate(self):
10215 
    return
10216 
 
10217 
 
10218 
  def __repr__(self):
10219 
    L = ['%s=%r' % (key, value)
10220 
      for key, value in self.__dict__.iteritems()]
10221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10222 
 
10223 
  def __eq__(self, other):
10224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10225 
 
10226 
  def __ne__(self, other):
10227 
    return not (self == other)
10228 
 
3064 chandransh 10229 
class markOrdersAsPickedUp_args:
304 ashish 10230 
  """
10231 
  Attributes:
3064 chandransh 10232 
   - providerId
10233 
   - pickupDetails
304 ashish 10234 
  """
94 ashish 10235 
 
304 ashish 10236 
  thrift_spec = (
10237 
    None, # 0
3064 chandransh 10238 
    (1, TType.I64, 'providerId', None, None, ), # 1
10239 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10240 
  )
10241 
 
3064 chandransh 10242 
  def __init__(self, providerId=None, pickupDetails=None,):
10243 
    self.providerId = providerId
10244 
    self.pickupDetails = pickupDetails
304 ashish 10245 
 
10246 
  def read(self, iprot):
10247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10249 
      return
10250 
    iprot.readStructBegin()
10251 
    while True:
10252 
      (fname, ftype, fid) = iprot.readFieldBegin()
10253 
      if ftype == TType.STOP:
10254 
        break
10255 
      if fid == 1:
10256 
        if ftype == TType.I64:
3064 chandransh 10257 
          self.providerId = iprot.readI64();
304 ashish 10258 
        else:
10259 
          iprot.skip(ftype)
10260 
      elif fid == 2:
3064 chandransh 10261 
        if ftype == TType.MAP:
10262 
          self.pickupDetails = {}
4133 chandransh 10263 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
10264 
          for _i144 in xrange(_size140):
10265 
            _key145 = iprot.readString();
10266 
            _val146 = iprot.readString();
10267 
            self.pickupDetails[_key145] = _val146
3064 chandransh 10268 
          iprot.readMapEnd()
304 ashish 10269 
        else:
10270 
          iprot.skip(ftype)
10271 
      else:
10272 
        iprot.skip(ftype)
10273 
      iprot.readFieldEnd()
10274 
    iprot.readStructEnd()
10275 
 
10276 
  def write(self, oprot):
10277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10279 
      return
3064 chandransh 10280 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 10281 
    if self.providerId is not None:
3064 chandransh 10282 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10283 
      oprot.writeI64(self.providerId)
304 ashish 10284 
      oprot.writeFieldEnd()
3431 rajveer 10285 
    if self.pickupDetails is not None:
3064 chandransh 10286 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10287 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10288 
      for kiter147,viter148 in self.pickupDetails.items():
10289 
        oprot.writeString(kiter147)
10290 
        oprot.writeString(viter148)
3064 chandransh 10291 
      oprot.writeMapEnd()
304 ashish 10292 
      oprot.writeFieldEnd()
10293 
    oprot.writeFieldStop()
10294 
    oprot.writeStructEnd()
10295 
 
3431 rajveer 10296 
  def validate(self):
10297 
    return
10298 
 
10299 
 
304 ashish 10300 
  def __repr__(self):
10301 
    L = ['%s=%r' % (key, value)
10302 
      for key, value in self.__dict__.iteritems()]
10303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10304 
 
10305 
  def __eq__(self, other):
10306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10307 
 
10308 
  def __ne__(self, other):
10309 
    return not (self == other)
10310 
 
3064 chandransh 10311 
class markOrdersAsPickedUp_result:
304 ashish 10312 
  """
10313 
  Attributes:
10314 
   - success
3064 chandransh 10315 
   - ex
304 ashish 10316 
  """
10317 
 
10318 
  thrift_spec = (
3064 chandransh 10319 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10320 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10321 
  )
10322 
 
3064 chandransh 10323 
  def __init__(self, success=None, ex=None,):
304 ashish 10324 
    self.success = success
3064 chandransh 10325 
    self.ex = ex
304 ashish 10326 
 
10327 
  def read(self, iprot):
10328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10330 
      return
10331 
    iprot.readStructBegin()
10332 
    while True:
10333 
      (fname, ftype, fid) = iprot.readFieldBegin()
10334 
      if ftype == TType.STOP:
10335 
        break
10336 
      if fid == 0:
10337 
        if ftype == TType.LIST:
10338 
          self.success = []
4133 chandransh 10339 
          (_etype152, _size149) = iprot.readListBegin()
10340 
          for _i153 in xrange(_size149):
10341 
            _elem154 = Order()
10342 
            _elem154.read(iprot)
10343 
            self.success.append(_elem154)
304 ashish 10344 
          iprot.readListEnd()
10345 
        else:
10346 
          iprot.skip(ftype)
3064 chandransh 10347 
      elif fid == 1:
10348 
        if ftype == TType.STRUCT:
10349 
          self.ex = TransactionServiceException()
10350 
          self.ex.read(iprot)
10351 
        else:
10352 
          iprot.skip(ftype)
304 ashish 10353 
      else:
10354 
        iprot.skip(ftype)
10355 
      iprot.readFieldEnd()
10356 
    iprot.readStructEnd()
10357 
 
10358 
  def write(self, oprot):
10359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10361 
      return
3064 chandransh 10362 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 10363 
    if self.success is not None:
304 ashish 10364 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10365 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10366 
      for iter155 in self.success:
10367 
        iter155.write(oprot)
304 ashish 10368 
      oprot.writeListEnd()
10369 
      oprot.writeFieldEnd()
3431 rajveer 10370 
    if self.ex is not None:
3064 chandransh 10371 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10372 
      self.ex.write(oprot)
10373 
      oprot.writeFieldEnd()
304 ashish 10374 
    oprot.writeFieldStop()
10375 
    oprot.writeStructEnd()
10376 
 
3431 rajveer 10377 
  def validate(self):
10378 
    return
10379 
 
10380 
 
304 ashish 10381 
  def __repr__(self):
10382 
    L = ['%s=%r' % (key, value)
10383 
      for key, value in self.__dict__.iteritems()]
10384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10385 
 
10386 
  def __eq__(self, other):
10387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10388 
 
10389 
  def __ne__(self, other):
10390 
    return not (self == other)
10391 
 
3064 chandransh 10392 
class markOrdersAsDelivered_args:
304 ashish 10393 
  """
10394 
  Attributes:
3064 chandransh 10395 
   - providerId
10396 
   - deliveredOrders
304 ashish 10397 
  """
10398 
 
10399 
  thrift_spec = (
10400 
    None, # 0
3064 chandransh 10401 
    (1, TType.I64, 'providerId', None, None, ), # 1
10402 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10403 
  )
10404 
 
3064 chandransh 10405 
  def __init__(self, providerId=None, deliveredOrders=None,):
10406 
    self.providerId = providerId
10407 
    self.deliveredOrders = deliveredOrders
304 ashish 10408 
 
10409 
  def read(self, iprot):
10410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10412 
      return
10413 
    iprot.readStructBegin()
10414 
    while True:
10415 
      (fname, ftype, fid) = iprot.readFieldBegin()
10416 
      if ftype == TType.STOP:
10417 
        break
10418 
      if fid == 1:
10419 
        if ftype == TType.I64:
3064 chandransh 10420 
          self.providerId = iprot.readI64();
304 ashish 10421 
        else:
10422 
          iprot.skip(ftype)
10423 
      elif fid == 2:
3064 chandransh 10424 
        if ftype == TType.MAP:
10425 
          self.deliveredOrders = {}
4133 chandransh 10426 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
10427 
          for _i160 in xrange(_size156):
10428 
            _key161 = iprot.readString();
10429 
            _val162 = iprot.readString();
10430 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 10431 
          iprot.readMapEnd()
304 ashish 10432 
        else:
10433 
          iprot.skip(ftype)
10434 
      else:
10435 
        iprot.skip(ftype)
10436 
      iprot.readFieldEnd()
10437 
    iprot.readStructEnd()
10438 
 
10439 
  def write(self, oprot):
10440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10442 
      return
3064 chandransh 10443 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 10444 
    if self.providerId is not None:
3064 chandransh 10445 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10446 
      oprot.writeI64(self.providerId)
304 ashish 10447 
      oprot.writeFieldEnd()
3431 rajveer 10448 
    if self.deliveredOrders is not None:
3064 chandransh 10449 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
10450 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 10451 
      for kiter163,viter164 in self.deliveredOrders.items():
10452 
        oprot.writeString(kiter163)
10453 
        oprot.writeString(viter164)
3064 chandransh 10454 
      oprot.writeMapEnd()
304 ashish 10455 
      oprot.writeFieldEnd()
10456 
    oprot.writeFieldStop()
10457 
    oprot.writeStructEnd()
10458 
 
3431 rajveer 10459 
  def validate(self):
10460 
    return
10461 
 
10462 
 
304 ashish 10463 
  def __repr__(self):
10464 
    L = ['%s=%r' % (key, value)
10465 
      for key, value in self.__dict__.iteritems()]
10466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10467 
 
10468 
  def __eq__(self, other):
10469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10470 
 
10471 
  def __ne__(self, other):
10472 
    return not (self == other)
10473 
 
3064 chandransh 10474 
class markOrdersAsDelivered_result:
10475 
  """
10476 
  Attributes:
10477 
   - ex
10478 
  """
304 ashish 10479 
 
10480 
  thrift_spec = (
3064 chandransh 10481 
    None, # 0
10482 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10483 
  )
10484 
 
3064 chandransh 10485 
  def __init__(self, ex=None,):
10486 
    self.ex = ex
304 ashish 10487 
 
1596 ankur.sing 10488 
  def read(self, iprot):
10489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10491 
      return
10492 
    iprot.readStructBegin()
10493 
    while True:
10494 
      (fname, ftype, fid) = iprot.readFieldBegin()
10495 
      if ftype == TType.STOP:
10496 
        break
3064 chandransh 10497 
      if fid == 1:
10498 
        if ftype == TType.STRUCT:
10499 
          self.ex = TransactionServiceException()
10500 
          self.ex.read(iprot)
10501 
        else:
10502 
          iprot.skip(ftype)
1596 ankur.sing 10503 
      else:
10504 
        iprot.skip(ftype)
10505 
      iprot.readFieldEnd()
10506 
    iprot.readStructEnd()
10507 
 
10508 
  def write(self, oprot):
10509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10511 
      return
3064 chandransh 10512 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 10513 
    if self.ex is not None:
3064 chandransh 10514 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10515 
      self.ex.write(oprot)
10516 
      oprot.writeFieldEnd()
1596 ankur.sing 10517 
    oprot.writeFieldStop()
10518 
    oprot.writeStructEnd()
10519 
 
3431 rajveer 10520 
  def validate(self):
10521 
    return
10522 
 
10523 
 
1596 ankur.sing 10524 
  def __repr__(self):
10525 
    L = ['%s=%r' % (key, value)
10526 
      for key, value in self.__dict__.iteritems()]
10527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10528 
 
10529 
  def __eq__(self, other):
10530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10531 
 
10532 
  def __ne__(self, other):
10533 
    return not (self == other)
10534 
 
3064 chandransh 10535 
class markOrdersAsFailed_args:
1596 ankur.sing 10536 
  """
10537 
  Attributes:
3064 chandransh 10538 
   - providerId
10539 
   - returnedOrders
1596 ankur.sing 10540 
  """
10541 
 
10542 
  thrift_spec = (
3064 chandransh 10543 
    None, # 0
10544 
    (1, TType.I64, 'providerId', None, None, ), # 1
10545 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 10546 
  )
10547 
 
3064 chandransh 10548 
  def __init__(self, providerId=None, returnedOrders=None,):
10549 
    self.providerId = providerId
10550 
    self.returnedOrders = returnedOrders
1596 ankur.sing 10551 
 
10552 
  def read(self, iprot):
10553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10555 
      return
10556 
    iprot.readStructBegin()
10557 
    while True:
10558 
      (fname, ftype, fid) = iprot.readFieldBegin()
10559 
      if ftype == TType.STOP:
10560 
        break
3064 chandransh 10561 
      if fid == 1:
1596 ankur.sing 10562 
        if ftype == TType.I64:
3064 chandransh 10563 
          self.providerId = iprot.readI64();
1596 ankur.sing 10564 
        else:
10565 
          iprot.skip(ftype)
3064 chandransh 10566 
      elif fid == 2:
10567 
        if ftype == TType.MAP:
10568 
          self.returnedOrders = {}
4133 chandransh 10569 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
10570 
          for _i169 in xrange(_size165):
10571 
            _key170 = iprot.readString();
10572 
            _val171 = iprot.readString();
10573 
            self.returnedOrders[_key170] = _val171
3064 chandransh 10574 
          iprot.readMapEnd()
10575 
        else:
10576 
          iprot.skip(ftype)
1596 ankur.sing 10577 
      else:
10578 
        iprot.skip(ftype)
10579 
      iprot.readFieldEnd()
10580 
    iprot.readStructEnd()
10581 
 
10582 
  def write(self, oprot):
10583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10585 
      return
3064 chandransh 10586 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 10587 
    if self.providerId is not None:
3064 chandransh 10588 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10589 
      oprot.writeI64(self.providerId)
1596 ankur.sing 10590 
      oprot.writeFieldEnd()
3431 rajveer 10591 
    if self.returnedOrders is not None:
3064 chandransh 10592 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
10593 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 10594 
      for kiter172,viter173 in self.returnedOrders.items():
10595 
        oprot.writeString(kiter172)
10596 
        oprot.writeString(viter173)
3064 chandransh 10597 
      oprot.writeMapEnd()
10598 
      oprot.writeFieldEnd()
1596 ankur.sing 10599 
    oprot.writeFieldStop()
10600 
    oprot.writeStructEnd()
10601 
 
3431 rajveer 10602 
  def validate(self):
10603 
    return
10604 
 
10605 
 
1596 ankur.sing 10606 
  def __repr__(self):
10607 
    L = ['%s=%r' % (key, value)
10608 
      for key, value in self.__dict__.iteritems()]
10609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10610 
 
10611 
  def __eq__(self, other):
10612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10613 
 
10614 
  def __ne__(self, other):
10615 
    return not (self == other)
10616 
 
3064 chandransh 10617 
class markOrdersAsFailed_result:
10618 
  """
10619 
  Attributes:
10620 
   - ex
10621 
  """
1596 ankur.sing 10622 
 
1627 ankur.sing 10623 
  thrift_spec = (
3064 chandransh 10624 
    None, # 0
10625 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10626 
  )
10627 
 
3064 chandransh 10628 
  def __init__(self, ex=None,):
10629 
    self.ex = ex
10630 
 
1627 ankur.sing 10631 
  def read(self, iprot):
10632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10634 
      return
10635 
    iprot.readStructBegin()
10636 
    while True:
10637 
      (fname, ftype, fid) = iprot.readFieldBegin()
10638 
      if ftype == TType.STOP:
10639 
        break
3064 chandransh 10640 
      if fid == 1:
10641 
        if ftype == TType.STRUCT:
10642 
          self.ex = TransactionServiceException()
10643 
          self.ex.read(iprot)
10644 
        else:
10645 
          iprot.skip(ftype)
1627 ankur.sing 10646 
      else:
10647 
        iprot.skip(ftype)
10648 
      iprot.readFieldEnd()
10649 
    iprot.readStructEnd()
10650 
 
10651 
  def write(self, oprot):
10652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10654 
      return
3064 chandransh 10655 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 10656 
    if self.ex is not None:
3064 chandransh 10657 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10658 
      self.ex.write(oprot)
10659 
      oprot.writeFieldEnd()
1627 ankur.sing 10660 
    oprot.writeFieldStop()
10661 
    oprot.writeStructEnd()
10662 
 
3431 rajveer 10663 
  def validate(self):
10664 
    return
10665 
 
10666 
 
1627 ankur.sing 10667 
  def __repr__(self):
10668 
    L = ['%s=%r' % (key, value)
10669 
      for key, value in self.__dict__.iteritems()]
10670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10671 
 
10672 
  def __eq__(self, other):
10673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10674 
 
10675 
  def __ne__(self, other):
10676 
    return not (self == other)
10677 
 
3064 chandransh 10678 
class updateNonDeliveryReason_args:
1627 ankur.sing 10679 
  """
10680 
  Attributes:
3064 chandransh 10681 
   - providerId
10682 
   - undeliveredOrders
1627 ankur.sing 10683 
  """
10684 
 
10685 
  thrift_spec = (
3064 chandransh 10686 
    None, # 0
10687 
    (1, TType.I64, 'providerId', None, None, ), # 1
10688 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 10689 
  )
10690 
 
3064 chandransh 10691 
  def __init__(self, providerId=None, undeliveredOrders=None,):
10692 
    self.providerId = providerId
10693 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 10694 
 
10695 
  def read(self, iprot):
10696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10698 
      return
10699 
    iprot.readStructBegin()
10700 
    while True:
10701 
      (fname, ftype, fid) = iprot.readFieldBegin()
10702 
      if ftype == TType.STOP:
10703 
        break
3064 chandransh 10704 
      if fid == 1:
1627 ankur.sing 10705 
        if ftype == TType.I64:
3064 chandransh 10706 
          self.providerId = iprot.readI64();
1627 ankur.sing 10707 
        else:
10708 
          iprot.skip(ftype)
3064 chandransh 10709 
      elif fid == 2:
10710 
        if ftype == TType.MAP:
10711 
          self.undeliveredOrders = {}
4133 chandransh 10712 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
10713 
          for _i178 in xrange(_size174):
10714 
            _key179 = iprot.readString();
10715 
            _val180 = iprot.readString();
10716 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 10717 
          iprot.readMapEnd()
10718 
        else:
10719 
          iprot.skip(ftype)
1627 ankur.sing 10720 
      else:
10721 
        iprot.skip(ftype)
10722 
      iprot.readFieldEnd()
10723 
    iprot.readStructEnd()
10724 
 
10725 
  def write(self, oprot):
10726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10728 
      return
3064 chandransh 10729 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 10730 
    if self.providerId is not None:
3064 chandransh 10731 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10732 
      oprot.writeI64(self.providerId)
1627 ankur.sing 10733 
      oprot.writeFieldEnd()
3431 rajveer 10734 
    if self.undeliveredOrders is not None:
3064 chandransh 10735 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
10736 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 10737 
      for kiter181,viter182 in self.undeliveredOrders.items():
10738 
        oprot.writeString(kiter181)
10739 
        oprot.writeString(viter182)
3064 chandransh 10740 
      oprot.writeMapEnd()
10741 
      oprot.writeFieldEnd()
1627 ankur.sing 10742 
    oprot.writeFieldStop()
10743 
    oprot.writeStructEnd()
10744 
 
3431 rajveer 10745 
  def validate(self):
10746 
    return
10747 
 
10748 
 
1627 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 
 
3064 chandransh 10760 
class updateNonDeliveryReason_result:
1627 ankur.sing 10761 
  """
10762 
  Attributes:
4581 phani.kuma 10763 
   - success
3064 chandransh 10764 
   - ex
1627 ankur.sing 10765 
  """
10766 
 
10767 
  thrift_spec = (
4581 phani.kuma 10768 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 10769 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10770 
  )
10771 
 
4581 phani.kuma 10772 
  def __init__(self, success=None, ex=None,):
10773 
    self.success = success
3064 chandransh 10774 
    self.ex = ex
1627 ankur.sing 10775 
 
10776 
  def read(self, iprot):
10777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10779 
      return
10780 
    iprot.readStructBegin()
10781 
    while True:
10782 
      (fname, ftype, fid) = iprot.readFieldBegin()
10783 
      if ftype == TType.STOP:
10784 
        break
4581 phani.kuma 10785 
      if fid == 0:
10786 
        if ftype == TType.LIST:
10787 
          self.success = []
10788 
          (_etype186, _size183) = iprot.readListBegin()
10789 
          for _i187 in xrange(_size183):
10790 
            _elem188 = Order()
10791 
            _elem188.read(iprot)
10792 
            self.success.append(_elem188)
10793 
          iprot.readListEnd()
10794 
        else:
10795 
          iprot.skip(ftype)
10796 
      elif fid == 1:
3064 chandransh 10797 
        if ftype == TType.STRUCT:
10798 
          self.ex = TransactionServiceException()
10799 
          self.ex.read(iprot)
1627 ankur.sing 10800 
        else:
10801 
          iprot.skip(ftype)
10802 
      else:
10803 
        iprot.skip(ftype)
10804 
      iprot.readFieldEnd()
10805 
    iprot.readStructEnd()
10806 
 
10807 
  def write(self, oprot):
10808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10810 
      return
3064 chandransh 10811 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 10812 
    if self.success is not None:
10813 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10814 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10815 
      for iter189 in self.success:
10816 
        iter189.write(oprot)
10817 
      oprot.writeListEnd()
10818 
      oprot.writeFieldEnd()
3431 rajveer 10819 
    if self.ex is not None:
3064 chandransh 10820 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10821 
      self.ex.write(oprot)
1627 ankur.sing 10822 
      oprot.writeFieldEnd()
10823 
    oprot.writeFieldStop()
10824 
    oprot.writeStructEnd()
10825 
 
3431 rajveer 10826 
  def validate(self):
10827 
    return
10828 
 
10829 
 
1627 ankur.sing 10830 
  def __repr__(self):
10831 
    L = ['%s=%r' % (key, value)
10832 
      for key, value in self.__dict__.iteritems()]
10833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10834 
 
10835 
  def __eq__(self, other):
10836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10837 
 
10838 
  def __ne__(self, other):
10839 
    return not (self == other)
10840 
 
3064 chandransh 10841 
class getUndeliveredOrders_args:
1886 ankur.sing 10842 
  """
10843 
  Attributes:
3064 chandransh 10844 
   - providerId
10845 
   - warehouseId
1886 ankur.sing 10846 
  """
1627 ankur.sing 10847 
 
1886 ankur.sing 10848 
  thrift_spec = (
10849 
    None, # 0
3064 chandransh 10850 
    (1, TType.I64, 'providerId', None, None, ), # 1
10851 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 10852 
  )
10853 
 
3064 chandransh 10854 
  def __init__(self, providerId=None, warehouseId=None,):
10855 
    self.providerId = providerId
10856 
    self.warehouseId = warehouseId
1886 ankur.sing 10857 
 
10858 
  def read(self, iprot):
10859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10861 
      return
10862 
    iprot.readStructBegin()
10863 
    while True:
10864 
      (fname, ftype, fid) = iprot.readFieldBegin()
10865 
      if ftype == TType.STOP:
10866 
        break
10867 
      if fid == 1:
10868 
        if ftype == TType.I64:
3064 chandransh 10869 
          self.providerId = iprot.readI64();
1886 ankur.sing 10870 
        else:
10871 
          iprot.skip(ftype)
3064 chandransh 10872 
      elif fid == 2:
10873 
        if ftype == TType.I64:
10874 
          self.warehouseId = iprot.readI64();
10875 
        else:
10876 
          iprot.skip(ftype)
1886 ankur.sing 10877 
      else:
10878 
        iprot.skip(ftype)
10879 
      iprot.readFieldEnd()
10880 
    iprot.readStructEnd()
10881 
 
10882 
  def write(self, oprot):
10883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10885 
      return
3064 chandransh 10886 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 10887 
    if self.providerId is not None:
3064 chandransh 10888 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10889 
      oprot.writeI64(self.providerId)
1886 ankur.sing 10890 
      oprot.writeFieldEnd()
3431 rajveer 10891 
    if self.warehouseId is not None:
3064 chandransh 10892 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10893 
      oprot.writeI64(self.warehouseId)
10894 
      oprot.writeFieldEnd()
1886 ankur.sing 10895 
    oprot.writeFieldStop()
10896 
    oprot.writeStructEnd()
10897 
 
3431 rajveer 10898 
  def validate(self):
10899 
    return
10900 
 
10901 
 
1886 ankur.sing 10902 
  def __repr__(self):
10903 
    L = ['%s=%r' % (key, value)
10904 
      for key, value in self.__dict__.iteritems()]
10905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10906 
 
10907 
  def __eq__(self, other):
10908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10909 
 
10910 
  def __ne__(self, other):
10911 
    return not (self == other)
10912 
 
3064 chandransh 10913 
class getUndeliveredOrders_result:
1886 ankur.sing 10914 
  """
10915 
  Attributes:
10916 
   - success
10917 
  """
10918 
 
10919 
  thrift_spec = (
10920 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10921 
  )
10922 
 
10923 
  def __init__(self, success=None,):
10924 
    self.success = success
10925 
 
10926 
  def read(self, iprot):
10927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10929 
      return
10930 
    iprot.readStructBegin()
10931 
    while True:
10932 
      (fname, ftype, fid) = iprot.readFieldBegin()
10933 
      if ftype == TType.STOP:
10934 
        break
10935 
      if fid == 0:
10936 
        if ftype == TType.LIST:
10937 
          self.success = []
4581 phani.kuma 10938 
          (_etype193, _size190) = iprot.readListBegin()
10939 
          for _i194 in xrange(_size190):
10940 
            _elem195 = Order()
10941 
            _elem195.read(iprot)
10942 
            self.success.append(_elem195)
1886 ankur.sing 10943 
          iprot.readListEnd()
10944 
        else:
10945 
          iprot.skip(ftype)
10946 
      else:
10947 
        iprot.skip(ftype)
10948 
      iprot.readFieldEnd()
10949 
    iprot.readStructEnd()
10950 
 
10951 
  def write(self, oprot):
10952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10954 
      return
3064 chandransh 10955 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 10956 
    if self.success is not None:
1886 ankur.sing 10957 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10958 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 10959 
      for iter196 in self.success:
10960 
        iter196.write(oprot)
1886 ankur.sing 10961 
      oprot.writeListEnd()
10962 
      oprot.writeFieldEnd()
10963 
    oprot.writeFieldStop()
10964 
    oprot.writeStructEnd()
10965 
 
3431 rajveer 10966 
  def validate(self):
10967 
    return
10968 
 
10969 
 
1886 ankur.sing 10970 
  def __repr__(self):
10971 
    L = ['%s=%r' % (key, value)
10972 
      for key, value in self.__dict__.iteritems()]
10973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10974 
 
10975 
  def __eq__(self, other):
10976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10977 
 
10978 
  def __ne__(self, other):
10979 
    return not (self == other)
10980 
 
2536 chandransh 10981 
class toggleDOAFlag_args:
10982 
  """
10983 
  Attributes:
10984 
   - orderId
10985 
  """
1886 ankur.sing 10986 
 
2536 chandransh 10987 
  thrift_spec = (
10988 
    None, # 0
10989 
    (1, TType.I64, 'orderId', None, None, ), # 1
10990 
  )
10991 
 
10992 
  def __init__(self, orderId=None,):
10993 
    self.orderId = orderId
10994 
 
10995 
  def read(self, iprot):
10996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10998 
      return
10999 
    iprot.readStructBegin()
11000 
    while True:
11001 
      (fname, ftype, fid) = iprot.readFieldBegin()
11002 
      if ftype == TType.STOP:
11003 
        break
11004 
      if fid == 1:
11005 
        if ftype == TType.I64:
11006 
          self.orderId = iprot.readI64();
11007 
        else:
11008 
          iprot.skip(ftype)
11009 
      else:
11010 
        iprot.skip(ftype)
11011 
      iprot.readFieldEnd()
11012 
    iprot.readStructEnd()
11013 
 
11014 
  def write(self, oprot):
11015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11017 
      return
11018 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 11019 
    if self.orderId is not None:
2536 chandransh 11020 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11021 
      oprot.writeI64(self.orderId)
11022 
      oprot.writeFieldEnd()
11023 
    oprot.writeFieldStop()
11024 
    oprot.writeStructEnd()
11025 
 
3431 rajveer 11026 
  def validate(self):
11027 
    return
11028 
 
11029 
 
2536 chandransh 11030 
  def __repr__(self):
11031 
    L = ['%s=%r' % (key, value)
11032 
      for key, value in self.__dict__.iteritems()]
11033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11034 
 
11035 
  def __eq__(self, other):
11036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11037 
 
11038 
  def __ne__(self, other):
11039 
    return not (self == other)
11040 
 
11041 
class toggleDOAFlag_result:
11042 
  """
11043 
  Attributes:
11044 
   - success
11045 
   - ex
11046 
  """
11047 
 
11048 
  thrift_spec = (
11049 
    (0, TType.BOOL, 'success', None, None, ), # 0
11050 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11051 
  )
11052 
 
11053 
  def __init__(self, success=None, ex=None,):
11054 
    self.success = success
11055 
    self.ex = ex
11056 
 
11057 
  def read(self, iprot):
11058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11060 
      return
11061 
    iprot.readStructBegin()
11062 
    while True:
11063 
      (fname, ftype, fid) = iprot.readFieldBegin()
11064 
      if ftype == TType.STOP:
11065 
        break
11066 
      if fid == 0:
11067 
        if ftype == TType.BOOL:
11068 
          self.success = iprot.readBool();
11069 
        else:
11070 
          iprot.skip(ftype)
11071 
      elif fid == 1:
11072 
        if ftype == TType.STRUCT:
11073 
          self.ex = TransactionServiceException()
11074 
          self.ex.read(iprot)
11075 
        else:
11076 
          iprot.skip(ftype)
11077 
      else:
11078 
        iprot.skip(ftype)
11079 
      iprot.readFieldEnd()
11080 
    iprot.readStructEnd()
11081 
 
11082 
  def write(self, oprot):
11083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11085 
      return
11086 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 11087 
    if self.success is not None:
2536 chandransh 11088 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11089 
      oprot.writeBool(self.success)
11090 
      oprot.writeFieldEnd()
3431 rajveer 11091 
    if self.ex is not None:
2536 chandransh 11092 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11093 
      self.ex.write(oprot)
11094 
      oprot.writeFieldEnd()
11095 
    oprot.writeFieldStop()
11096 
    oprot.writeStructEnd()
11097 
 
3431 rajveer 11098 
  def validate(self):
11099 
    return
11100 
 
11101 
 
2536 chandransh 11102 
  def __repr__(self):
11103 
    L = ['%s=%r' % (key, value)
11104 
      for key, value in self.__dict__.iteritems()]
11105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11106 
 
11107 
  def __eq__(self, other):
11108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11109 
 
11110 
  def __ne__(self, other):
11111 
    return not (self == other)
11112 
 
4454 rajveer 11113 
class markOrderDoaRequestReceived_args:
11114 
  """
11115 
  Attributes:
11116 
   - orderId
11117 
  """
11118 
 
11119 
  thrift_spec = (
11120 
    None, # 0
11121 
    (1, TType.I64, 'orderId', None, None, ), # 1
11122 
  )
11123 
 
11124 
  def __init__(self, orderId=None,):
11125 
    self.orderId = orderId
11126 
 
11127 
  def read(self, iprot):
11128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11130 
      return
11131 
    iprot.readStructBegin()
11132 
    while True:
11133 
      (fname, ftype, fid) = iprot.readFieldBegin()
11134 
      if ftype == TType.STOP:
11135 
        break
11136 
      if fid == 1:
11137 
        if ftype == TType.I64:
11138 
          self.orderId = iprot.readI64();
11139 
        else:
11140 
          iprot.skip(ftype)
11141 
      else:
11142 
        iprot.skip(ftype)
11143 
      iprot.readFieldEnd()
11144 
    iprot.readStructEnd()
11145 
 
11146 
  def write(self, oprot):
11147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11149 
      return
11150 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
11151 
    if self.orderId is not None:
11152 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11153 
      oprot.writeI64(self.orderId)
11154 
      oprot.writeFieldEnd()
11155 
    oprot.writeFieldStop()
11156 
    oprot.writeStructEnd()
11157 
 
11158 
  def validate(self):
11159 
    return
11160 
 
11161 
 
11162 
  def __repr__(self):
11163 
    L = ['%s=%r' % (key, value)
11164 
      for key, value in self.__dict__.iteritems()]
11165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11166 
 
11167 
  def __eq__(self, other):
11168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11169 
 
11170 
  def __ne__(self, other):
11171 
    return not (self == other)
11172 
 
11173 
class markOrderDoaRequestReceived_result:
11174 
  """
11175 
  Attributes:
11176 
   - success
11177 
   - ex
11178 
  """
11179 
 
11180 
  thrift_spec = (
11181 
    (0, TType.BOOL, 'success', None, None, ), # 0
11182 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11183 
  )
11184 
 
11185 
  def __init__(self, success=None, ex=None,):
11186 
    self.success = success
11187 
    self.ex = ex
11188 
 
11189 
  def read(self, iprot):
11190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11192 
      return
11193 
    iprot.readStructBegin()
11194 
    while True:
11195 
      (fname, ftype, fid) = iprot.readFieldBegin()
11196 
      if ftype == TType.STOP:
11197 
        break
11198 
      if fid == 0:
11199 
        if ftype == TType.BOOL:
11200 
          self.success = iprot.readBool();
11201 
        else:
11202 
          iprot.skip(ftype)
11203 
      elif fid == 1:
11204 
        if ftype == TType.STRUCT:
11205 
          self.ex = TransactionServiceException()
11206 
          self.ex.read(iprot)
11207 
        else:
11208 
          iprot.skip(ftype)
11209 
      else:
11210 
        iprot.skip(ftype)
11211 
      iprot.readFieldEnd()
11212 
    iprot.readStructEnd()
11213 
 
11214 
  def write(self, oprot):
11215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11217 
      return
11218 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
11219 
    if self.success is not None:
11220 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11221 
      oprot.writeBool(self.success)
11222 
      oprot.writeFieldEnd()
11223 
    if self.ex is not None:
11224 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11225 
      self.ex.write(oprot)
11226 
      oprot.writeFieldEnd()
11227 
    oprot.writeFieldStop()
11228 
    oprot.writeStructEnd()
11229 
 
11230 
  def validate(self):
11231 
    return
11232 
 
11233 
 
11234 
  def __repr__(self):
11235 
    L = ['%s=%r' % (key, value)
11236 
      for key, value in self.__dict__.iteritems()]
11237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11238 
 
11239 
  def __eq__(self, other):
11240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11241 
 
11242 
  def __ne__(self, other):
11243 
    return not (self == other)
11244 
 
11245 
class markOrderDoaRequestAuthorized_args:
11246 
  """
11247 
  Attributes:
11248 
   - orderId
11249 
   - isAuthorized
11250 
  """
11251 
 
11252 
  thrift_spec = (
11253 
    None, # 0
11254 
    (1, TType.I64, 'orderId', None, None, ), # 1
11255 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11256 
  )
11257 
 
11258 
  def __init__(self, orderId=None, isAuthorized=None,):
11259 
    self.orderId = orderId
11260 
    self.isAuthorized = isAuthorized
11261 
 
11262 
  def read(self, iprot):
11263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11265 
      return
11266 
    iprot.readStructBegin()
11267 
    while True:
11268 
      (fname, ftype, fid) = iprot.readFieldBegin()
11269 
      if ftype == TType.STOP:
11270 
        break
11271 
      if fid == 1:
11272 
        if ftype == TType.I64:
11273 
          self.orderId = iprot.readI64();
11274 
        else:
11275 
          iprot.skip(ftype)
11276 
      elif fid == 2:
11277 
        if ftype == TType.BOOL:
11278 
          self.isAuthorized = iprot.readBool();
11279 
        else:
11280 
          iprot.skip(ftype)
11281 
      else:
11282 
        iprot.skip(ftype)
11283 
      iprot.readFieldEnd()
11284 
    iprot.readStructEnd()
11285 
 
11286 
  def write(self, oprot):
11287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11289 
      return
11290 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
11291 
    if self.orderId is not None:
11292 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11293 
      oprot.writeI64(self.orderId)
11294 
      oprot.writeFieldEnd()
11295 
    if self.isAuthorized is not None:
11296 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11297 
      oprot.writeBool(self.isAuthorized)
11298 
      oprot.writeFieldEnd()
11299 
    oprot.writeFieldStop()
11300 
    oprot.writeStructEnd()
11301 
 
11302 
  def validate(self):
11303 
    return
11304 
 
11305 
 
11306 
  def __repr__(self):
11307 
    L = ['%s=%r' % (key, value)
11308 
      for key, value in self.__dict__.iteritems()]
11309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11310 
 
11311 
  def __eq__(self, other):
11312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11313 
 
11314 
  def __ne__(self, other):
11315 
    return not (self == other)
11316 
 
11317 
class markOrderDoaRequestAuthorized_result:
11318 
  """
11319 
  Attributes:
11320 
   - success
11321 
   - ex
11322 
  """
11323 
 
11324 
  thrift_spec = (
11325 
    (0, TType.BOOL, 'success', None, None, ), # 0
11326 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11327 
  )
11328 
 
11329 
  def __init__(self, success=None, ex=None,):
11330 
    self.success = success
11331 
    self.ex = ex
11332 
 
11333 
  def read(self, iprot):
11334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11336 
      return
11337 
    iprot.readStructBegin()
11338 
    while True:
11339 
      (fname, ftype, fid) = iprot.readFieldBegin()
11340 
      if ftype == TType.STOP:
11341 
        break
11342 
      if fid == 0:
11343 
        if ftype == TType.BOOL:
11344 
          self.success = iprot.readBool();
11345 
        else:
11346 
          iprot.skip(ftype)
11347 
      elif fid == 1:
11348 
        if ftype == TType.STRUCT:
11349 
          self.ex = TransactionServiceException()
11350 
          self.ex.read(iprot)
11351 
        else:
11352 
          iprot.skip(ftype)
11353 
      else:
11354 
        iprot.skip(ftype)
11355 
      iprot.readFieldEnd()
11356 
    iprot.readStructEnd()
11357 
 
11358 
  def write(self, oprot):
11359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11361 
      return
11362 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
11363 
    if self.success is not None:
11364 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11365 
      oprot.writeBool(self.success)
11366 
      oprot.writeFieldEnd()
11367 
    if self.ex is not None:
11368 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11369 
      self.ex.write(oprot)
11370 
      oprot.writeFieldEnd()
11371 
    oprot.writeFieldStop()
11372 
    oprot.writeStructEnd()
11373 
 
11374 
  def validate(self):
11375 
    return
11376 
 
11377 
 
11378 
  def __repr__(self):
11379 
    L = ['%s=%r' % (key, value)
11380 
      for key, value in self.__dict__.iteritems()]
11381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11382 
 
11383 
  def __eq__(self, other):
11384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11385 
 
11386 
  def __ne__(self, other):
11387 
    return not (self == other)
11388 
 
4488 rajveer 11389 
class markOrderReturnRequestReceived_args:
11390 
  """
11391 
  Attributes:
11392 
   - orderId
11393 
  """
11394 
 
11395 
  thrift_spec = (
11396 
    None, # 0
11397 
    (1, TType.I64, 'orderId', None, None, ), # 1
11398 
  )
11399 
 
11400 
  def __init__(self, orderId=None,):
11401 
    self.orderId = orderId
11402 
 
11403 
  def read(self, iprot):
11404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11406 
      return
11407 
    iprot.readStructBegin()
11408 
    while True:
11409 
      (fname, ftype, fid) = iprot.readFieldBegin()
11410 
      if ftype == TType.STOP:
11411 
        break
11412 
      if fid == 1:
11413 
        if ftype == TType.I64:
11414 
          self.orderId = iprot.readI64();
11415 
        else:
11416 
          iprot.skip(ftype)
11417 
      else:
11418 
        iprot.skip(ftype)
11419 
      iprot.readFieldEnd()
11420 
    iprot.readStructEnd()
11421 
 
11422 
  def write(self, oprot):
11423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11425 
      return
11426 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
11427 
    if self.orderId is not None:
11428 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11429 
      oprot.writeI64(self.orderId)
11430 
      oprot.writeFieldEnd()
11431 
    oprot.writeFieldStop()
11432 
    oprot.writeStructEnd()
11433 
 
11434 
  def validate(self):
11435 
    return
11436 
 
11437 
 
11438 
  def __repr__(self):
11439 
    L = ['%s=%r' % (key, value)
11440 
      for key, value in self.__dict__.iteritems()]
11441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11442 
 
11443 
  def __eq__(self, other):
11444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11445 
 
11446 
  def __ne__(self, other):
11447 
    return not (self == other)
11448 
 
11449 
class markOrderReturnRequestReceived_result:
11450 
  """
11451 
  Attributes:
11452 
   - success
11453 
   - ex
11454 
  """
11455 
 
11456 
  thrift_spec = (
11457 
    (0, TType.BOOL, 'success', None, None, ), # 0
11458 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11459 
  )
11460 
 
11461 
  def __init__(self, success=None, ex=None,):
11462 
    self.success = success
11463 
    self.ex = ex
11464 
 
11465 
  def read(self, iprot):
11466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11468 
      return
11469 
    iprot.readStructBegin()
11470 
    while True:
11471 
      (fname, ftype, fid) = iprot.readFieldBegin()
11472 
      if ftype == TType.STOP:
11473 
        break
11474 
      if fid == 0:
11475 
        if ftype == TType.BOOL:
11476 
          self.success = iprot.readBool();
11477 
        else:
11478 
          iprot.skip(ftype)
11479 
      elif fid == 1:
11480 
        if ftype == TType.STRUCT:
11481 
          self.ex = TransactionServiceException()
11482 
          self.ex.read(iprot)
11483 
        else:
11484 
          iprot.skip(ftype)
11485 
      else:
11486 
        iprot.skip(ftype)
11487 
      iprot.readFieldEnd()
11488 
    iprot.readStructEnd()
11489 
 
11490 
  def write(self, oprot):
11491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11493 
      return
11494 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
11495 
    if self.success is not None:
11496 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11497 
      oprot.writeBool(self.success)
11498 
      oprot.writeFieldEnd()
11499 
    if self.ex is not None:
11500 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11501 
      self.ex.write(oprot)
11502 
      oprot.writeFieldEnd()
11503 
    oprot.writeFieldStop()
11504 
    oprot.writeStructEnd()
11505 
 
11506 
  def validate(self):
11507 
    return
11508 
 
11509 
 
11510 
  def __repr__(self):
11511 
    L = ['%s=%r' % (key, value)
11512 
      for key, value in self.__dict__.iteritems()]
11513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11514 
 
11515 
  def __eq__(self, other):
11516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11517 
 
11518 
  def __ne__(self, other):
11519 
    return not (self == other)
11520 
 
11521 
class markOrderReturnRequestAuthorized_args:
11522 
  """
11523 
  Attributes:
11524 
   - orderId
11525 
   - isAuthorized
11526 
  """
11527 
 
11528 
  thrift_spec = (
11529 
    None, # 0
11530 
    (1, TType.I64, 'orderId', None, None, ), # 1
11531 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11532 
  )
11533 
 
11534 
  def __init__(self, orderId=None, isAuthorized=None,):
11535 
    self.orderId = orderId
11536 
    self.isAuthorized = isAuthorized
11537 
 
11538 
  def read(self, iprot):
11539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11541 
      return
11542 
    iprot.readStructBegin()
11543 
    while True:
11544 
      (fname, ftype, fid) = iprot.readFieldBegin()
11545 
      if ftype == TType.STOP:
11546 
        break
11547 
      if fid == 1:
11548 
        if ftype == TType.I64:
11549 
          self.orderId = iprot.readI64();
11550 
        else:
11551 
          iprot.skip(ftype)
11552 
      elif fid == 2:
11553 
        if ftype == TType.BOOL:
11554 
          self.isAuthorized = iprot.readBool();
11555 
        else:
11556 
          iprot.skip(ftype)
11557 
      else:
11558 
        iprot.skip(ftype)
11559 
      iprot.readFieldEnd()
11560 
    iprot.readStructEnd()
11561 
 
11562 
  def write(self, oprot):
11563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11565 
      return
11566 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
11567 
    if self.orderId is not None:
11568 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11569 
      oprot.writeI64(self.orderId)
11570 
      oprot.writeFieldEnd()
11571 
    if self.isAuthorized is not None:
11572 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11573 
      oprot.writeBool(self.isAuthorized)
11574 
      oprot.writeFieldEnd()
11575 
    oprot.writeFieldStop()
11576 
    oprot.writeStructEnd()
11577 
 
11578 
  def validate(self):
11579 
    return
11580 
 
11581 
 
11582 
  def __repr__(self):
11583 
    L = ['%s=%r' % (key, value)
11584 
      for key, value in self.__dict__.iteritems()]
11585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11586 
 
11587 
  def __eq__(self, other):
11588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11589 
 
11590 
  def __ne__(self, other):
11591 
    return not (self == other)
11592 
 
11593 
class markOrderReturnRequestAuthorized_result:
11594 
  """
11595 
  Attributes:
11596 
   - success
11597 
   - ex
11598 
  """
11599 
 
11600 
  thrift_spec = (
11601 
    (0, TType.BOOL, 'success', None, None, ), # 0
11602 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11603 
  )
11604 
 
11605 
  def __init__(self, success=None, ex=None,):
11606 
    self.success = success
11607 
    self.ex = ex
11608 
 
11609 
  def read(self, iprot):
11610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11612 
      return
11613 
    iprot.readStructBegin()
11614 
    while True:
11615 
      (fname, ftype, fid) = iprot.readFieldBegin()
11616 
      if ftype == TType.STOP:
11617 
        break
11618 
      if fid == 0:
11619 
        if ftype == TType.BOOL:
11620 
          self.success = iprot.readBool();
11621 
        else:
11622 
          iprot.skip(ftype)
11623 
      elif fid == 1:
11624 
        if ftype == TType.STRUCT:
11625 
          self.ex = TransactionServiceException()
11626 
          self.ex.read(iprot)
11627 
        else:
11628 
          iprot.skip(ftype)
11629 
      else:
11630 
        iprot.skip(ftype)
11631 
      iprot.readFieldEnd()
11632 
    iprot.readStructEnd()
11633 
 
11634 
  def write(self, oprot):
11635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11637 
      return
11638 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
11639 
    if self.success is not None:
11640 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11641 
      oprot.writeBool(self.success)
11642 
      oprot.writeFieldEnd()
11643 
    if self.ex is not None:
11644 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11645 
      self.ex.write(oprot)
11646 
      oprot.writeFieldEnd()
11647 
    oprot.writeFieldStop()
11648 
    oprot.writeStructEnd()
11649 
 
11650 
  def validate(self):
11651 
    return
11652 
 
11653 
 
11654 
  def __repr__(self):
11655 
    L = ['%s=%r' % (key, value)
11656 
      for key, value in self.__dict__.iteritems()]
11657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11658 
 
11659 
  def __eq__(self, other):
11660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11661 
 
11662 
  def __ne__(self, other):
11663 
    return not (self == other)
11664 
 
2536 chandransh 11665 
class requestPickupNumber_args:
11666 
  """
11667 
  Attributes:
11668 
   - orderId
4579 rajveer 11669 
   - providerId
2536 chandransh 11670 
  """
11671 
 
11672 
  thrift_spec = (
11673 
    None, # 0
11674 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 11675 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 11676 
  )
11677 
 
4579 rajveer 11678 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 11679 
    self.orderId = orderId
4579 rajveer 11680 
    self.providerId = providerId
2536 chandransh 11681 
 
11682 
  def read(self, iprot):
11683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11685 
      return
11686 
    iprot.readStructBegin()
11687 
    while True:
11688 
      (fname, ftype, fid) = iprot.readFieldBegin()
11689 
      if ftype == TType.STOP:
11690 
        break
11691 
      if fid == 1:
11692 
        if ftype == TType.I64:
11693 
          self.orderId = iprot.readI64();
11694 
        else:
11695 
          iprot.skip(ftype)
4579 rajveer 11696 
      elif fid == 2:
11697 
        if ftype == TType.I64:
11698 
          self.providerId = iprot.readI64();
11699 
        else:
11700 
          iprot.skip(ftype)
2536 chandransh 11701 
      else:
11702 
        iprot.skip(ftype)
11703 
      iprot.readFieldEnd()
11704 
    iprot.readStructEnd()
11705 
 
11706 
  def write(self, oprot):
11707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11709 
      return
11710 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 11711 
    if self.orderId is not None:
2536 chandransh 11712 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11713 
      oprot.writeI64(self.orderId)
11714 
      oprot.writeFieldEnd()
4579 rajveer 11715 
    if self.providerId is not None:
11716 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
11717 
      oprot.writeI64(self.providerId)
11718 
      oprot.writeFieldEnd()
2536 chandransh 11719 
    oprot.writeFieldStop()
11720 
    oprot.writeStructEnd()
11721 
 
3431 rajveer 11722 
  def validate(self):
11723 
    return
11724 
 
11725 
 
2536 chandransh 11726 
  def __repr__(self):
11727 
    L = ['%s=%r' % (key, value)
11728 
      for key, value in self.__dict__.iteritems()]
11729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11730 
 
11731 
  def __eq__(self, other):
11732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11733 
 
11734 
  def __ne__(self, other):
11735 
    return not (self == other)
11736 
 
11737 
class requestPickupNumber_result:
11738 
  """
11739 
  Attributes:
11740 
   - success
11741 
   - ex
11742 
  """
11743 
 
11744 
  thrift_spec = (
11745 
    (0, TType.BOOL, 'success', None, None, ), # 0
11746 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11747 
  )
11748 
 
11749 
  def __init__(self, success=None, ex=None,):
11750 
    self.success = success
11751 
    self.ex = ex
11752 
 
11753 
  def read(self, iprot):
11754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11756 
      return
11757 
    iprot.readStructBegin()
11758 
    while True:
11759 
      (fname, ftype, fid) = iprot.readFieldBegin()
11760 
      if ftype == TType.STOP:
11761 
        break
11762 
      if fid == 0:
11763 
        if ftype == TType.BOOL:
11764 
          self.success = iprot.readBool();
11765 
        else:
11766 
          iprot.skip(ftype)
11767 
      elif fid == 1:
11768 
        if ftype == TType.STRUCT:
11769 
          self.ex = TransactionServiceException()
11770 
          self.ex.read(iprot)
11771 
        else:
11772 
          iprot.skip(ftype)
11773 
      else:
11774 
        iprot.skip(ftype)
11775 
      iprot.readFieldEnd()
11776 
    iprot.readStructEnd()
11777 
 
11778 
  def write(self, oprot):
11779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11781 
      return
11782 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 11783 
    if self.success is not None:
2536 chandransh 11784 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11785 
      oprot.writeBool(self.success)
11786 
      oprot.writeFieldEnd()
3431 rajveer 11787 
    if self.ex is not None:
2536 chandransh 11788 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11789 
      self.ex.write(oprot)
11790 
      oprot.writeFieldEnd()
11791 
    oprot.writeFieldStop()
11792 
    oprot.writeStructEnd()
11793 
 
3431 rajveer 11794 
  def validate(self):
11795 
    return
11796 
 
11797 
 
2536 chandransh 11798 
  def __repr__(self):
11799 
    L = ['%s=%r' % (key, value)
11800 
      for key, value in self.__dict__.iteritems()]
11801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11802 
 
11803 
  def __eq__(self, other):
11804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11805 
 
11806 
  def __ne__(self, other):
11807 
    return not (self == other)
11808 
 
11809 
class authorizePickup_args:
11810 
  """
11811 
  Attributes:
11812 
   - orderId
11813 
   - pickupNumber
11814 
  """
11815 
 
11816 
  thrift_spec = (
11817 
    None, # 0
11818 
    (1, TType.I64, 'orderId', None, None, ), # 1
11819 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
11820 
  )
11821 
 
11822 
  def __init__(self, orderId=None, pickupNumber=None,):
11823 
    self.orderId = orderId
11824 
    self.pickupNumber = pickupNumber
11825 
 
11826 
  def read(self, iprot):
11827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11829 
      return
11830 
    iprot.readStructBegin()
11831 
    while True:
11832 
      (fname, ftype, fid) = iprot.readFieldBegin()
11833 
      if ftype == TType.STOP:
11834 
        break
11835 
      if fid == 1:
11836 
        if ftype == TType.I64:
11837 
          self.orderId = iprot.readI64();
11838 
        else:
11839 
          iprot.skip(ftype)
11840 
      elif fid == 2:
11841 
        if ftype == TType.STRING:
11842 
          self.pickupNumber = iprot.readString();
11843 
        else:
11844 
          iprot.skip(ftype)
11845 
      else:
11846 
        iprot.skip(ftype)
11847 
      iprot.readFieldEnd()
11848 
    iprot.readStructEnd()
11849 
 
11850 
  def write(self, oprot):
11851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11853 
      return
11854 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 11855 
    if self.orderId is not None:
2536 chandransh 11856 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11857 
      oprot.writeI64(self.orderId)
11858 
      oprot.writeFieldEnd()
3431 rajveer 11859 
    if self.pickupNumber is not None:
2536 chandransh 11860 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
11861 
      oprot.writeString(self.pickupNumber)
11862 
      oprot.writeFieldEnd()
11863 
    oprot.writeFieldStop()
11864 
    oprot.writeStructEnd()
11865 
 
3431 rajveer 11866 
  def validate(self):
11867 
    return
11868 
 
11869 
 
2536 chandransh 11870 
  def __repr__(self):
11871 
    L = ['%s=%r' % (key, value)
11872 
      for key, value in self.__dict__.iteritems()]
11873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11874 
 
11875 
  def __eq__(self, other):
11876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11877 
 
11878 
  def __ne__(self, other):
11879 
    return not (self == other)
11880 
 
11881 
class authorizePickup_result:
11882 
  """
11883 
  Attributes:
11884 
   - success
11885 
   - ex
11886 
  """
11887 
 
11888 
  thrift_spec = (
11889 
    (0, TType.BOOL, 'success', None, None, ), # 0
11890 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11891 
  )
11892 
 
11893 
  def __init__(self, success=None, ex=None,):
11894 
    self.success = success
11895 
    self.ex = ex
11896 
 
11897 
  def read(self, iprot):
11898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11900 
      return
11901 
    iprot.readStructBegin()
11902 
    while True:
11903 
      (fname, ftype, fid) = iprot.readFieldBegin()
11904 
      if ftype == TType.STOP:
11905 
        break
11906 
      if fid == 0:
11907 
        if ftype == TType.BOOL:
11908 
          self.success = iprot.readBool();
11909 
        else:
11910 
          iprot.skip(ftype)
11911 
      elif fid == 1:
11912 
        if ftype == TType.STRUCT:
11913 
          self.ex = TransactionServiceException()
11914 
          self.ex.read(iprot)
11915 
        else:
11916 
          iprot.skip(ftype)
11917 
      else:
11918 
        iprot.skip(ftype)
11919 
      iprot.readFieldEnd()
11920 
    iprot.readStructEnd()
11921 
 
11922 
  def write(self, oprot):
11923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11925 
      return
11926 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 11927 
    if self.success is not None:
2536 chandransh 11928 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11929 
      oprot.writeBool(self.success)
11930 
      oprot.writeFieldEnd()
3431 rajveer 11931 
    if self.ex is not None:
2536 chandransh 11932 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11933 
      self.ex.write(oprot)
11934 
      oprot.writeFieldEnd()
11935 
    oprot.writeFieldStop()
11936 
    oprot.writeStructEnd()
11937 
 
3431 rajveer 11938 
  def validate(self):
11939 
    return
11940 
 
11941 
 
2536 chandransh 11942 
  def __repr__(self):
11943 
    L = ['%s=%r' % (key, value)
11944 
      for key, value in self.__dict__.iteritems()]
11945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11946 
 
11947 
  def __eq__(self, other):
11948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11949 
 
11950 
  def __ne__(self, other):
11951 
    return not (self == other)
11952 
 
2764 chandransh 11953 
class markDoasAsPickedUp_args:
11954 
  """
11955 
  Attributes:
11956 
   - providerId
11957 
   - pickupDetails
11958 
  """
11959 
 
11960 
  thrift_spec = (
11961 
    None, # 0
11962 
    (1, TType.I64, 'providerId', None, None, ), # 1
11963 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
11964 
  )
11965 
 
11966 
  def __init__(self, providerId=None, pickupDetails=None,):
11967 
    self.providerId = providerId
11968 
    self.pickupDetails = pickupDetails
11969 
 
11970 
  def read(self, iprot):
11971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11973 
      return
11974 
    iprot.readStructBegin()
11975 
    while True:
11976 
      (fname, ftype, fid) = iprot.readFieldBegin()
11977 
      if ftype == TType.STOP:
11978 
        break
11979 
      if fid == 1:
11980 
        if ftype == TType.I64:
11981 
          self.providerId = iprot.readI64();
11982 
        else:
11983 
          iprot.skip(ftype)
11984 
      elif fid == 2:
11985 
        if ftype == TType.MAP:
11986 
          self.pickupDetails = {}
4581 phani.kuma 11987 
          (_ktype198, _vtype199, _size197 ) = iprot.readMapBegin()
11988 
          for _i201 in xrange(_size197):
11989 
            _key202 = iprot.readString();
11990 
            _val203 = iprot.readString();
11991 
            self.pickupDetails[_key202] = _val203
2764 chandransh 11992 
          iprot.readMapEnd()
11993 
        else:
11994 
          iprot.skip(ftype)
11995 
      else:
11996 
        iprot.skip(ftype)
11997 
      iprot.readFieldEnd()
11998 
    iprot.readStructEnd()
11999 
 
12000 
  def write(self, oprot):
12001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12003 
      return
12004 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 12005 
    if self.providerId is not None:
2764 chandransh 12006 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12007 
      oprot.writeI64(self.providerId)
12008 
      oprot.writeFieldEnd()
3431 rajveer 12009 
    if self.pickupDetails is not None:
2764 chandransh 12010 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12011 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4581 phani.kuma 12012 
      for kiter204,viter205 in self.pickupDetails.items():
12013 
        oprot.writeString(kiter204)
12014 
        oprot.writeString(viter205)
2764 chandransh 12015 
      oprot.writeMapEnd()
12016 
      oprot.writeFieldEnd()
12017 
    oprot.writeFieldStop()
12018 
    oprot.writeStructEnd()
12019 
 
3431 rajveer 12020 
  def validate(self):
12021 
    return
12022 
 
12023 
 
2764 chandransh 12024 
  def __repr__(self):
12025 
    L = ['%s=%r' % (key, value)
12026 
      for key, value in self.__dict__.iteritems()]
12027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12028 
 
12029 
  def __eq__(self, other):
12030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12031 
 
12032 
  def __ne__(self, other):
12033 
    return not (self == other)
12034 
 
12035 
class markDoasAsPickedUp_result:
12036 
  """
12037 
  Attributes:
12038 
   - success
12039 
  """
12040 
 
12041 
  thrift_spec = (
12042 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12043 
  )
12044 
 
12045 
  def __init__(self, success=None,):
12046 
    self.success = success
12047 
 
12048 
  def read(self, iprot):
12049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12051 
      return
12052 
    iprot.readStructBegin()
12053 
    while True:
12054 
      (fname, ftype, fid) = iprot.readFieldBegin()
12055 
      if ftype == TType.STOP:
12056 
        break
12057 
      if fid == 0:
12058 
        if ftype == TType.LIST:
12059 
          self.success = []
4581 phani.kuma 12060 
          (_etype209, _size206) = iprot.readListBegin()
12061 
          for _i210 in xrange(_size206):
12062 
            _elem211 = Order()
12063 
            _elem211.read(iprot)
12064 
            self.success.append(_elem211)
2764 chandransh 12065 
          iprot.readListEnd()
12066 
        else:
12067 
          iprot.skip(ftype)
12068 
      else:
12069 
        iprot.skip(ftype)
12070 
      iprot.readFieldEnd()
12071 
    iprot.readStructEnd()
12072 
 
12073 
  def write(self, oprot):
12074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12076 
      return
12077 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 12078 
    if self.success is not None:
2764 chandransh 12079 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12080 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 12081 
      for iter212 in self.success:
12082 
        iter212.write(oprot)
2764 chandransh 12083 
      oprot.writeListEnd()
12084 
      oprot.writeFieldEnd()
12085 
    oprot.writeFieldStop()
12086 
    oprot.writeStructEnd()
12087 
 
3431 rajveer 12088 
  def validate(self):
12089 
    return
12090 
 
12091 
 
2764 chandransh 12092 
  def __repr__(self):
12093 
    L = ['%s=%r' % (key, value)
12094 
      for key, value in self.__dict__.iteritems()]
12095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12096 
 
12097 
  def __eq__(self, other):
12098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12099 
 
12100 
  def __ne__(self, other):
12101 
    return not (self == other)
12102 
 
2616 chandransh 12103 
class receiveReturn_args:
2591 chandransh 12104 
  """
12105 
  Attributes:
12106 
   - orderId
4479 rajveer 12107 
   - receiveCondition
2591 chandransh 12108 
  """
2536 chandransh 12109 
 
2591 chandransh 12110 
  thrift_spec = (
12111 
    None, # 0
12112 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 12113 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 12114 
  )
12115 
 
4479 rajveer 12116 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 12117 
    self.orderId = orderId
4479 rajveer 12118 
    self.receiveCondition = receiveCondition
2591 chandransh 12119 
 
12120 
  def read(self, iprot):
12121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12123 
      return
12124 
    iprot.readStructBegin()
12125 
    while True:
12126 
      (fname, ftype, fid) = iprot.readFieldBegin()
12127 
      if ftype == TType.STOP:
12128 
        break
12129 
      if fid == 1:
12130 
        if ftype == TType.I64:
12131 
          self.orderId = iprot.readI64();
12132 
        else:
12133 
          iprot.skip(ftype)
4479 rajveer 12134 
      elif fid == 2:
12135 
        if ftype == TType.I64:
12136 
          self.receiveCondition = iprot.readI64();
12137 
        else:
12138 
          iprot.skip(ftype)
2591 chandransh 12139 
      else:
12140 
        iprot.skip(ftype)
12141 
      iprot.readFieldEnd()
12142 
    iprot.readStructEnd()
12143 
 
12144 
  def write(self, oprot):
12145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12147 
      return
2616 chandransh 12148 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 12149 
    if self.orderId is not None:
2591 chandransh 12150 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12151 
      oprot.writeI64(self.orderId)
12152 
      oprot.writeFieldEnd()
4479 rajveer 12153 
    if self.receiveCondition is not None:
12154 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
12155 
      oprot.writeI64(self.receiveCondition)
12156 
      oprot.writeFieldEnd()
2591 chandransh 12157 
    oprot.writeFieldStop()
12158 
    oprot.writeStructEnd()
12159 
 
3431 rajveer 12160 
  def validate(self):
12161 
    return
12162 
 
12163 
 
2591 chandransh 12164 
  def __repr__(self):
12165 
    L = ['%s=%r' % (key, value)
12166 
      for key, value in self.__dict__.iteritems()]
12167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12168 
 
12169 
  def __eq__(self, other):
12170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12171 
 
12172 
  def __ne__(self, other):
12173 
    return not (self == other)
12174 
 
2616 chandransh 12175 
class receiveReturn_result:
2591 chandransh 12176 
  """
12177 
  Attributes:
12178 
   - success
12179 
   - ex
12180 
  """
12181 
 
12182 
  thrift_spec = (
12183 
    (0, TType.BOOL, 'success', None, None, ), # 0
12184 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12185 
  )
12186 
 
12187 
  def __init__(self, success=None, ex=None,):
12188 
    self.success = success
12189 
    self.ex = ex
12190 
 
12191 
  def read(self, iprot):
12192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12194 
      return
12195 
    iprot.readStructBegin()
12196 
    while True:
12197 
      (fname, ftype, fid) = iprot.readFieldBegin()
12198 
      if ftype == TType.STOP:
12199 
        break
12200 
      if fid == 0:
12201 
        if ftype == TType.BOOL:
12202 
          self.success = iprot.readBool();
12203 
        else:
12204 
          iprot.skip(ftype)
12205 
      elif fid == 1:
12206 
        if ftype == TType.STRUCT:
12207 
          self.ex = TransactionServiceException()
12208 
          self.ex.read(iprot)
12209 
        else:
12210 
          iprot.skip(ftype)
12211 
      else:
12212 
        iprot.skip(ftype)
12213 
      iprot.readFieldEnd()
12214 
    iprot.readStructEnd()
12215 
 
12216 
  def write(self, oprot):
12217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12219 
      return
2616 chandransh 12220 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 12221 
    if self.success is not None:
2591 chandransh 12222 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12223 
      oprot.writeBool(self.success)
12224 
      oprot.writeFieldEnd()
3431 rajveer 12225 
    if self.ex is not None:
2591 chandransh 12226 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12227 
      self.ex.write(oprot)
12228 
      oprot.writeFieldEnd()
12229 
    oprot.writeFieldStop()
12230 
    oprot.writeStructEnd()
12231 
 
3431 rajveer 12232 
  def validate(self):
12233 
    return
12234 
 
12235 
 
2591 chandransh 12236 
  def __repr__(self):
12237 
    L = ['%s=%r' % (key, value)
12238 
      for key, value in self.__dict__.iteritems()]
12239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12240 
 
12241 
  def __eq__(self, other):
12242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12243 
 
12244 
  def __ne__(self, other):
12245 
    return not (self == other)
12246 
 
12247 
class validateDoa_args:
12248 
  """
12249 
  Attributes:
12250 
   - orderId
12251 
   - isValid
12252 
  """
12253 
 
12254 
  thrift_spec = (
12255 
    None, # 0
12256 
    (1, TType.I64, 'orderId', None, None, ), # 1
12257 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
12258 
  )
12259 
 
12260 
  def __init__(self, orderId=None, isValid=None,):
12261 
    self.orderId = orderId
12262 
    self.isValid = isValid
12263 
 
12264 
  def read(self, iprot):
12265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12267 
      return
12268 
    iprot.readStructBegin()
12269 
    while True:
12270 
      (fname, ftype, fid) = iprot.readFieldBegin()
12271 
      if ftype == TType.STOP:
12272 
        break
12273 
      if fid == 1:
12274 
        if ftype == TType.I64:
12275 
          self.orderId = iprot.readI64();
12276 
        else:
12277 
          iprot.skip(ftype)
12278 
      elif fid == 2:
12279 
        if ftype == TType.BOOL:
12280 
          self.isValid = iprot.readBool();
12281 
        else:
12282 
          iprot.skip(ftype)
12283 
      else:
12284 
        iprot.skip(ftype)
12285 
      iprot.readFieldEnd()
12286 
    iprot.readStructEnd()
12287 
 
12288 
  def write(self, oprot):
12289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12291 
      return
12292 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 12293 
    if self.orderId is not None:
2591 chandransh 12294 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12295 
      oprot.writeI64(self.orderId)
12296 
      oprot.writeFieldEnd()
3431 rajveer 12297 
    if self.isValid is not None:
2591 chandransh 12298 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
12299 
      oprot.writeBool(self.isValid)
12300 
      oprot.writeFieldEnd()
12301 
    oprot.writeFieldStop()
12302 
    oprot.writeStructEnd()
12303 
 
3431 rajveer 12304 
  def validate(self):
12305 
    return
12306 
 
12307 
 
2591 chandransh 12308 
  def __repr__(self):
12309 
    L = ['%s=%r' % (key, value)
12310 
      for key, value in self.__dict__.iteritems()]
12311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12312 
 
12313 
  def __eq__(self, other):
12314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12315 
 
12316 
  def __ne__(self, other):
12317 
    return not (self == other)
12318 
 
12319 
class validateDoa_result:
12320 
  """
12321 
  Attributes:
12322 
   - success
12323 
   - ex
12324 
  """
12325 
 
12326 
  thrift_spec = (
12327 
    (0, TType.BOOL, 'success', None, None, ), # 0
12328 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12329 
  )
12330 
 
12331 
  def __init__(self, success=None, ex=None,):
12332 
    self.success = success
12333 
    self.ex = ex
12334 
 
12335 
  def read(self, iprot):
12336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12338 
      return
12339 
    iprot.readStructBegin()
12340 
    while True:
12341 
      (fname, ftype, fid) = iprot.readFieldBegin()
12342 
      if ftype == TType.STOP:
12343 
        break
12344 
      if fid == 0:
12345 
        if ftype == TType.BOOL:
12346 
          self.success = iprot.readBool();
12347 
        else:
12348 
          iprot.skip(ftype)
12349 
      elif fid == 1:
12350 
        if ftype == TType.STRUCT:
12351 
          self.ex = TransactionServiceException()
12352 
          self.ex.read(iprot)
12353 
        else:
12354 
          iprot.skip(ftype)
12355 
      else:
12356 
        iprot.skip(ftype)
12357 
      iprot.readFieldEnd()
12358 
    iprot.readStructEnd()
12359 
 
12360 
  def write(self, oprot):
12361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12363 
      return
12364 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 12365 
    if self.success is not None:
2591 chandransh 12366 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12367 
      oprot.writeBool(self.success)
12368 
      oprot.writeFieldEnd()
3431 rajveer 12369 
    if self.ex is not None:
2591 chandransh 12370 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12371 
      self.ex.write(oprot)
12372 
      oprot.writeFieldEnd()
12373 
    oprot.writeFieldStop()
12374 
    oprot.writeStructEnd()
12375 
 
3431 rajveer 12376 
  def validate(self):
12377 
    return
12378 
 
12379 
 
2591 chandransh 12380 
  def __repr__(self):
12381 
    L = ['%s=%r' % (key, value)
12382 
      for key, value in self.__dict__.iteritems()]
12383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12384 
 
12385 
  def __eq__(self, other):
12386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12387 
 
12388 
  def __ne__(self, other):
12389 
    return not (self == other)
12390 
 
4495 rajveer 12391 
class validateReturnProduct_args:
12392 
  """
12393 
  Attributes:
12394 
   - orderId
12395 
   - isUsable
12396 
  """
12397 
 
12398 
  thrift_spec = (
12399 
    None, # 0
12400 
    (1, TType.I64, 'orderId', None, None, ), # 1
12401 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
12402 
  )
12403 
 
12404 
  def __init__(self, orderId=None, isUsable=None,):
12405 
    self.orderId = orderId
12406 
    self.isUsable = isUsable
12407 
 
12408 
  def read(self, iprot):
12409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12411 
      return
12412 
    iprot.readStructBegin()
12413 
    while True:
12414 
      (fname, ftype, fid) = iprot.readFieldBegin()
12415 
      if ftype == TType.STOP:
12416 
        break
12417 
      if fid == 1:
12418 
        if ftype == TType.I64:
12419 
          self.orderId = iprot.readI64();
12420 
        else:
12421 
          iprot.skip(ftype)
12422 
      elif fid == 2:
12423 
        if ftype == TType.BOOL:
12424 
          self.isUsable = iprot.readBool();
12425 
        else:
12426 
          iprot.skip(ftype)
12427 
      else:
12428 
        iprot.skip(ftype)
12429 
      iprot.readFieldEnd()
12430 
    iprot.readStructEnd()
12431 
 
12432 
  def write(self, oprot):
12433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12435 
      return
12436 
    oprot.writeStructBegin('validateReturnProduct_args')
12437 
    if self.orderId is not None:
12438 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12439 
      oprot.writeI64(self.orderId)
12440 
      oprot.writeFieldEnd()
12441 
    if self.isUsable is not None:
12442 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
12443 
      oprot.writeBool(self.isUsable)
12444 
      oprot.writeFieldEnd()
12445 
    oprot.writeFieldStop()
12446 
    oprot.writeStructEnd()
12447 
 
12448 
  def validate(self):
12449 
    return
12450 
 
12451 
 
12452 
  def __repr__(self):
12453 
    L = ['%s=%r' % (key, value)
12454 
      for key, value in self.__dict__.iteritems()]
12455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12456 
 
12457 
  def __eq__(self, other):
12458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12459 
 
12460 
  def __ne__(self, other):
12461 
    return not (self == other)
12462 
 
12463 
class validateReturnProduct_result:
12464 
  """
12465 
  Attributes:
12466 
   - success
12467 
   - ex
12468 
  """
12469 
 
12470 
  thrift_spec = (
12471 
    (0, TType.BOOL, 'success', None, None, ), # 0
12472 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12473 
  )
12474 
 
12475 
  def __init__(self, success=None, ex=None,):
12476 
    self.success = success
12477 
    self.ex = ex
12478 
 
12479 
  def read(self, iprot):
12480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12482 
      return
12483 
    iprot.readStructBegin()
12484 
    while True:
12485 
      (fname, ftype, fid) = iprot.readFieldBegin()
12486 
      if ftype == TType.STOP:
12487 
        break
12488 
      if fid == 0:
12489 
        if ftype == TType.BOOL:
12490 
          self.success = iprot.readBool();
12491 
        else:
12492 
          iprot.skip(ftype)
12493 
      elif fid == 1:
12494 
        if ftype == TType.STRUCT:
12495 
          self.ex = TransactionServiceException()
12496 
          self.ex.read(iprot)
12497 
        else:
12498 
          iprot.skip(ftype)
12499 
      else:
12500 
        iprot.skip(ftype)
12501 
      iprot.readFieldEnd()
12502 
    iprot.readStructEnd()
12503 
 
12504 
  def write(self, oprot):
12505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12507 
      return
12508 
    oprot.writeStructBegin('validateReturnProduct_result')
12509 
    if self.success is not None:
12510 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12511 
      oprot.writeBool(self.success)
12512 
      oprot.writeFieldEnd()
12513 
    if self.ex is not None:
12514 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12515 
      self.ex.write(oprot)
12516 
      oprot.writeFieldEnd()
12517 
    oprot.writeFieldStop()
12518 
    oprot.writeStructEnd()
12519 
 
12520 
  def validate(self):
12521 
    return
12522 
 
12523 
 
12524 
  def __repr__(self):
12525 
    L = ['%s=%r' % (key, value)
12526 
      for key, value in self.__dict__.iteritems()]
12527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12528 
 
12529 
  def __eq__(self, other):
12530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12531 
 
12532 
  def __ne__(self, other):
12533 
    return not (self == other)
12534 
 
2616 chandransh 12535 
class reshipOrder_args:
12536 
  """
12537 
  Attributes:
12538 
   - orderId
12539 
  """
2591 chandransh 12540 
 
2616 chandransh 12541 
  thrift_spec = (
12542 
    None, # 0
12543 
    (1, TType.I64, 'orderId', None, None, ), # 1
12544 
  )
12545 
 
12546 
  def __init__(self, orderId=None,):
12547 
    self.orderId = orderId
12548 
 
12549 
  def read(self, iprot):
12550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12552 
      return
12553 
    iprot.readStructBegin()
12554 
    while True:
12555 
      (fname, ftype, fid) = iprot.readFieldBegin()
12556 
      if ftype == TType.STOP:
12557 
        break
12558 
      if fid == 1:
12559 
        if ftype == TType.I64:
12560 
          self.orderId = iprot.readI64();
12561 
        else:
12562 
          iprot.skip(ftype)
12563 
      else:
12564 
        iprot.skip(ftype)
12565 
      iprot.readFieldEnd()
12566 
    iprot.readStructEnd()
12567 
 
12568 
  def write(self, oprot):
12569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12571 
      return
12572 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 12573 
    if self.orderId is not None:
2616 chandransh 12574 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12575 
      oprot.writeI64(self.orderId)
12576 
      oprot.writeFieldEnd()
12577 
    oprot.writeFieldStop()
12578 
    oprot.writeStructEnd()
12579 
 
3431 rajveer 12580 
  def validate(self):
12581 
    return
12582 
 
12583 
 
2616 chandransh 12584 
  def __repr__(self):
12585 
    L = ['%s=%r' % (key, value)
12586 
      for key, value in self.__dict__.iteritems()]
12587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12588 
 
12589 
  def __eq__(self, other):
12590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12591 
 
12592 
  def __ne__(self, other):
12593 
    return not (self == other)
12594 
 
12595 
class reshipOrder_result:
12596 
  """
12597 
  Attributes:
12598 
   - success
12599 
   - ex
12600 
  """
12601 
 
12602 
  thrift_spec = (
12603 
    (0, TType.I64, 'success', None, None, ), # 0
12604 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12605 
  )
12606 
 
12607 
  def __init__(self, success=None, ex=None,):
12608 
    self.success = success
12609 
    self.ex = ex
12610 
 
12611 
  def read(self, iprot):
12612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12614 
      return
12615 
    iprot.readStructBegin()
12616 
    while True:
12617 
      (fname, ftype, fid) = iprot.readFieldBegin()
12618 
      if ftype == TType.STOP:
12619 
        break
12620 
      if fid == 0:
12621 
        if ftype == TType.I64:
12622 
          self.success = iprot.readI64();
12623 
        else:
12624 
          iprot.skip(ftype)
12625 
      elif fid == 1:
12626 
        if ftype == TType.STRUCT:
12627 
          self.ex = TransactionServiceException()
12628 
          self.ex.read(iprot)
12629 
        else:
12630 
          iprot.skip(ftype)
12631 
      else:
12632 
        iprot.skip(ftype)
12633 
      iprot.readFieldEnd()
12634 
    iprot.readStructEnd()
12635 
 
12636 
  def write(self, oprot):
12637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12639 
      return
12640 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 12641 
    if self.success is not None:
2616 chandransh 12642 
      oprot.writeFieldBegin('success', TType.I64, 0)
12643 
      oprot.writeI64(self.success)
12644 
      oprot.writeFieldEnd()
3431 rajveer 12645 
    if self.ex is not None:
2616 chandransh 12646 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12647 
      self.ex.write(oprot)
12648 
      oprot.writeFieldEnd()
12649 
    oprot.writeFieldStop()
12650 
    oprot.writeStructEnd()
12651 
 
3431 rajveer 12652 
  def validate(self):
12653 
    return
12654 
 
12655 
 
2616 chandransh 12656 
  def __repr__(self):
12657 
    L = ['%s=%r' % (key, value)
12658 
      for key, value in self.__dict__.iteritems()]
12659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12660 
 
12661 
  def __eq__(self, other):
12662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12663 
 
12664 
  def __ne__(self, other):
12665 
    return not (self == other)
12666 
 
12667 
class refundOrder_args:
12668 
  """
12669 
  Attributes:
12670 
   - orderId
3226 chandransh 12671 
   - refundedBy
12672 
   - reason
2616 chandransh 12673 
  """
12674 
 
12675 
  thrift_spec = (
12676 
    None, # 0
12677 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 12678 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
12679 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 12680 
  )
12681 
 
3226 chandransh 12682 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 12683 
    self.orderId = orderId
3226 chandransh 12684 
    self.refundedBy = refundedBy
12685 
    self.reason = reason
2616 chandransh 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 == 1:
12697 
        if ftype == TType.I64:
12698 
          self.orderId = iprot.readI64();
12699 
        else:
12700 
          iprot.skip(ftype)
3226 chandransh 12701 
      elif fid == 2:
12702 
        if ftype == TType.STRING:
12703 
          self.refundedBy = iprot.readString();
12704 
        else:
12705 
          iprot.skip(ftype)
12706 
      elif fid == 3:
12707 
        if ftype == TType.STRING:
12708 
          self.reason = iprot.readString();
12709 
        else:
12710 
          iprot.skip(ftype)
2616 chandransh 12711 
      else:
12712 
        iprot.skip(ftype)
12713 
      iprot.readFieldEnd()
12714 
    iprot.readStructEnd()
12715 
 
12716 
  def write(self, oprot):
12717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12719 
      return
12720 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 12721 
    if self.orderId is not None:
2616 chandransh 12722 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12723 
      oprot.writeI64(self.orderId)
12724 
      oprot.writeFieldEnd()
3431 rajveer 12725 
    if self.refundedBy is not None:
3226 chandransh 12726 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
12727 
      oprot.writeString(self.refundedBy)
12728 
      oprot.writeFieldEnd()
3431 rajveer 12729 
    if self.reason is not None:
3226 chandransh 12730 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
12731 
      oprot.writeString(self.reason)
12732 
      oprot.writeFieldEnd()
2616 chandransh 12733 
    oprot.writeFieldStop()
12734 
    oprot.writeStructEnd()
12735 
 
3431 rajveer 12736 
  def validate(self):
12737 
    return
12738 
 
12739 
 
2616 chandransh 12740 
  def __repr__(self):
12741 
    L = ['%s=%r' % (key, value)
12742 
      for key, value in self.__dict__.iteritems()]
12743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12744 
 
12745 
  def __eq__(self, other):
12746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12747 
 
12748 
  def __ne__(self, other):
12749 
    return not (self == other)
12750 
 
12751 
class refundOrder_result:
12752 
  """
12753 
  Attributes:
12754 
   - success
12755 
   - ex
12756 
  """
12757 
 
12758 
  thrift_spec = (
12759 
    (0, TType.BOOL, 'success', None, None, ), # 0
12760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12761 
  )
12762 
 
12763 
  def __init__(self, success=None, ex=None,):
12764 
    self.success = success
12765 
    self.ex = ex
12766 
 
12767 
  def read(self, iprot):
12768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12770 
      return
12771 
    iprot.readStructBegin()
12772 
    while True:
12773 
      (fname, ftype, fid) = iprot.readFieldBegin()
12774 
      if ftype == TType.STOP:
12775 
        break
12776 
      if fid == 0:
12777 
        if ftype == TType.BOOL:
12778 
          self.success = iprot.readBool();
12779 
        else:
12780 
          iprot.skip(ftype)
12781 
      elif fid == 1:
12782 
        if ftype == TType.STRUCT:
12783 
          self.ex = TransactionServiceException()
12784 
          self.ex.read(iprot)
12785 
        else:
12786 
          iprot.skip(ftype)
12787 
      else:
12788 
        iprot.skip(ftype)
12789 
      iprot.readFieldEnd()
12790 
    iprot.readStructEnd()
12791 
 
12792 
  def write(self, oprot):
12793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12795 
      return
12796 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 12797 
    if self.success is not None:
2616 chandransh 12798 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12799 
      oprot.writeBool(self.success)
12800 
      oprot.writeFieldEnd()
3431 rajveer 12801 
    if self.ex is not None:
2616 chandransh 12802 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12803 
      self.ex.write(oprot)
12804 
      oprot.writeFieldEnd()
12805 
    oprot.writeFieldStop()
12806 
    oprot.writeStructEnd()
12807 
 
3431 rajveer 12808 
  def validate(self):
12809 
    return
12810 
 
12811 
 
2616 chandransh 12812 
  def __repr__(self):
12813 
    L = ['%s=%r' % (key, value)
12814 
      for key, value in self.__dict__.iteritems()]
12815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12816 
 
12817 
  def __eq__(self, other):
12818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12819 
 
12820 
  def __ne__(self, other):
12821 
    return not (self == other)
12822 
 
2690 chandransh 12823 
class getReturnOrders_args:
12824 
  """
12825 
  Attributes:
12826 
   - warehouseId
12827 
   - fromDate
12828 
   - toDate
12829 
  """
2616 chandransh 12830 
 
2690 chandransh 12831 
  thrift_spec = (
12832 
    None, # 0
12833 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12834 
    (2, TType.I64, 'fromDate', None, None, ), # 2
12835 
    (3, TType.I64, 'toDate', None, None, ), # 3
12836 
  )
12837 
 
12838 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
12839 
    self.warehouseId = warehouseId
12840 
    self.fromDate = fromDate
12841 
    self.toDate = toDate
12842 
 
12843 
  def read(self, iprot):
12844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12846 
      return
12847 
    iprot.readStructBegin()
12848 
    while True:
12849 
      (fname, ftype, fid) = iprot.readFieldBegin()
12850 
      if ftype == TType.STOP:
12851 
        break
12852 
      if fid == 1:
12853 
        if ftype == TType.I64:
12854 
          self.warehouseId = iprot.readI64();
12855 
        else:
12856 
          iprot.skip(ftype)
12857 
      elif fid == 2:
12858 
        if ftype == TType.I64:
12859 
          self.fromDate = iprot.readI64();
12860 
        else:
12861 
          iprot.skip(ftype)
12862 
      elif fid == 3:
12863 
        if ftype == TType.I64:
12864 
          self.toDate = iprot.readI64();
12865 
        else:
12866 
          iprot.skip(ftype)
12867 
      else:
12868 
        iprot.skip(ftype)
12869 
      iprot.readFieldEnd()
12870 
    iprot.readStructEnd()
12871 
 
12872 
  def write(self, oprot):
12873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12875 
      return
12876 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 12877 
    if self.warehouseId is not None:
2690 chandransh 12878 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12879 
      oprot.writeI64(self.warehouseId)
12880 
      oprot.writeFieldEnd()
3431 rajveer 12881 
    if self.fromDate is not None:
2690 chandransh 12882 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
12883 
      oprot.writeI64(self.fromDate)
12884 
      oprot.writeFieldEnd()
3431 rajveer 12885 
    if self.toDate is not None:
2690 chandransh 12886 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
12887 
      oprot.writeI64(self.toDate)
12888 
      oprot.writeFieldEnd()
12889 
    oprot.writeFieldStop()
12890 
    oprot.writeStructEnd()
12891 
 
3431 rajveer 12892 
  def validate(self):
12893 
    return
12894 
 
12895 
 
2690 chandransh 12896 
  def __repr__(self):
12897 
    L = ['%s=%r' % (key, value)
12898 
      for key, value in self.__dict__.iteritems()]
12899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12900 
 
12901 
  def __eq__(self, other):
12902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12903 
 
12904 
  def __ne__(self, other):
12905 
    return not (self == other)
12906 
 
12907 
class getReturnOrders_result:
12908 
  """
12909 
  Attributes:
12910 
   - success
12911 
  """
12912 
 
12913 
  thrift_spec = (
12914 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
12915 
  )
12916 
 
12917 
  def __init__(self, success=None,):
12918 
    self.success = success
12919 
 
12920 
  def read(self, iprot):
12921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12923 
      return
12924 
    iprot.readStructBegin()
12925 
    while True:
12926 
      (fname, ftype, fid) = iprot.readFieldBegin()
12927 
      if ftype == TType.STOP:
12928 
        break
12929 
      if fid == 0:
12930 
        if ftype == TType.LIST:
12931 
          self.success = []
4581 phani.kuma 12932 
          (_etype216, _size213) = iprot.readListBegin()
12933 
          for _i217 in xrange(_size213):
12934 
            _elem218 = ReturnOrder()
12935 
            _elem218.read(iprot)
12936 
            self.success.append(_elem218)
2690 chandransh 12937 
          iprot.readListEnd()
12938 
        else:
12939 
          iprot.skip(ftype)
12940 
      else:
12941 
        iprot.skip(ftype)
12942 
      iprot.readFieldEnd()
12943 
    iprot.readStructEnd()
12944 
 
12945 
  def write(self, oprot):
12946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12948 
      return
12949 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 12950 
    if self.success is not None:
2690 chandransh 12951 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12952 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 12953 
      for iter219 in self.success:
12954 
        iter219.write(oprot)
2690 chandransh 12955 
      oprot.writeListEnd()
12956 
      oprot.writeFieldEnd()
12957 
    oprot.writeFieldStop()
12958 
    oprot.writeStructEnd()
12959 
 
3431 rajveer 12960 
  def validate(self):
12961 
    return
12962 
 
12963 
 
2690 chandransh 12964 
  def __repr__(self):
12965 
    L = ['%s=%r' % (key, value)
12966 
      for key, value in self.__dict__.iteritems()]
12967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12968 
 
12969 
  def __eq__(self, other):
12970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12971 
 
12972 
  def __ne__(self, other):
12973 
    return not (self == other)
12974 
 
2700 chandransh 12975 
class getReturnOrder_args:
12976 
  """
12977 
  Attributes:
12978 
   - id
12979 
  """
12980 
 
12981 
  thrift_spec = (
12982 
    None, # 0
12983 
    (1, TType.I64, 'id', None, None, ), # 1
12984 
  )
12985 
 
12986 
  def __init__(self, id=None,):
12987 
    self.id = id
12988 
 
12989 
  def read(self, iprot):
12990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12992 
      return
12993 
    iprot.readStructBegin()
12994 
    while True:
12995 
      (fname, ftype, fid) = iprot.readFieldBegin()
12996 
      if ftype == TType.STOP:
12997 
        break
12998 
      if fid == 1:
12999 
        if ftype == TType.I64:
13000 
          self.id = iprot.readI64();
13001 
        else:
13002 
          iprot.skip(ftype)
13003 
      else:
13004 
        iprot.skip(ftype)
13005 
      iprot.readFieldEnd()
13006 
    iprot.readStructEnd()
13007 
 
13008 
  def write(self, oprot):
13009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13011 
      return
13012 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 13013 
    if self.id is not None:
2700 chandransh 13014 
      oprot.writeFieldBegin('id', TType.I64, 1)
13015 
      oprot.writeI64(self.id)
13016 
      oprot.writeFieldEnd()
13017 
    oprot.writeFieldStop()
13018 
    oprot.writeStructEnd()
13019 
 
3431 rajveer 13020 
  def validate(self):
13021 
    return
13022 
 
13023 
 
2700 chandransh 13024 
  def __repr__(self):
13025 
    L = ['%s=%r' % (key, value)
13026 
      for key, value in self.__dict__.iteritems()]
13027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13028 
 
13029 
  def __eq__(self, other):
13030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13031 
 
13032 
  def __ne__(self, other):
13033 
    return not (self == other)
13034 
 
13035 
class getReturnOrder_result:
13036 
  """
13037 
  Attributes:
13038 
   - success
13039 
   - ex
13040 
  """
13041 
 
13042 
  thrift_spec = (
13043 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
13044 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13045 
  )
13046 
 
13047 
  def __init__(self, success=None, ex=None,):
13048 
    self.success = success
13049 
    self.ex = ex
13050 
 
13051 
  def read(self, iprot):
13052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13054 
      return
13055 
    iprot.readStructBegin()
13056 
    while True:
13057 
      (fname, ftype, fid) = iprot.readFieldBegin()
13058 
      if ftype == TType.STOP:
13059 
        break
13060 
      if fid == 0:
13061 
        if ftype == TType.STRUCT:
13062 
          self.success = ReturnOrder()
13063 
          self.success.read(iprot)
13064 
        else:
13065 
          iprot.skip(ftype)
13066 
      elif fid == 1:
13067 
        if ftype == TType.STRUCT:
13068 
          self.ex = TransactionServiceException()
13069 
          self.ex.read(iprot)
13070 
        else:
13071 
          iprot.skip(ftype)
13072 
      else:
13073 
        iprot.skip(ftype)
13074 
      iprot.readFieldEnd()
13075 
    iprot.readStructEnd()
13076 
 
13077 
  def write(self, oprot):
13078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13080 
      return
13081 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 13082 
    if self.success is not None:
2700 chandransh 13083 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13084 
      self.success.write(oprot)
13085 
      oprot.writeFieldEnd()
3431 rajveer 13086 
    if self.ex is not None:
2700 chandransh 13087 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13088 
      self.ex.write(oprot)
13089 
      oprot.writeFieldEnd()
13090 
    oprot.writeFieldStop()
13091 
    oprot.writeStructEnd()
13092 
 
3431 rajveer 13093 
  def validate(self):
13094 
    return
13095 
 
13096 
 
2700 chandransh 13097 
  def __repr__(self):
13098 
    L = ['%s=%r' % (key, value)
13099 
      for key, value in self.__dict__.iteritems()]
13100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13101 
 
13102 
  def __eq__(self, other):
13103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13104 
 
13105 
  def __ne__(self, other):
13106 
    return not (self == other)
13107 
 
2690 chandransh 13108 
class processReturn_args:
13109 
  """
13110 
  Attributes:
13111 
   - returnOrderId
13112 
  """
13113 
 
13114 
  thrift_spec = (
13115 
    None, # 0
13116 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
13117 
  )
13118 
 
13119 
  def __init__(self, returnOrderId=None,):
13120 
    self.returnOrderId = returnOrderId
13121 
 
13122 
  def read(self, iprot):
13123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13125 
      return
13126 
    iprot.readStructBegin()
13127 
    while True:
13128 
      (fname, ftype, fid) = iprot.readFieldBegin()
13129 
      if ftype == TType.STOP:
13130 
        break
13131 
      if fid == 1:
13132 
        if ftype == TType.I64:
13133 
          self.returnOrderId = iprot.readI64();
13134 
        else:
13135 
          iprot.skip(ftype)
13136 
      else:
13137 
        iprot.skip(ftype)
13138 
      iprot.readFieldEnd()
13139 
    iprot.readStructEnd()
13140 
 
13141 
  def write(self, oprot):
13142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13144 
      return
13145 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 13146 
    if self.returnOrderId is not None:
2690 chandransh 13147 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
13148 
      oprot.writeI64(self.returnOrderId)
13149 
      oprot.writeFieldEnd()
13150 
    oprot.writeFieldStop()
13151 
    oprot.writeStructEnd()
13152 
 
3431 rajveer 13153 
  def validate(self):
13154 
    return
13155 
 
13156 
 
2690 chandransh 13157 
  def __repr__(self):
13158 
    L = ['%s=%r' % (key, value)
13159 
      for key, value in self.__dict__.iteritems()]
13160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13161 
 
13162 
  def __eq__(self, other):
13163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13164 
 
13165 
  def __ne__(self, other):
13166 
    return not (self == other)
13167 
 
13168 
class processReturn_result:
13169 
  """
13170 
  Attributes:
13171 
   - ex
13172 
  """
13173 
 
13174 
  thrift_spec = (
13175 
    None, # 0
13176 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13177 
  )
13178 
 
13179 
  def __init__(self, ex=None,):
13180 
    self.ex = ex
13181 
 
13182 
  def read(self, iprot):
13183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13185 
      return
13186 
    iprot.readStructBegin()
13187 
    while True:
13188 
      (fname, ftype, fid) = iprot.readFieldBegin()
13189 
      if ftype == TType.STOP:
13190 
        break
13191 
      if fid == 1:
13192 
        if ftype == TType.STRUCT:
13193 
          self.ex = TransactionServiceException()
13194 
          self.ex.read(iprot)
13195 
        else:
13196 
          iprot.skip(ftype)
13197 
      else:
13198 
        iprot.skip(ftype)
13199 
      iprot.readFieldEnd()
13200 
    iprot.readStructEnd()
13201 
 
13202 
  def write(self, oprot):
13203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13205 
      return
13206 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 13207 
    if self.ex is not None:
2690 chandransh 13208 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13209 
      self.ex.write(oprot)
13210 
      oprot.writeFieldEnd()
13211 
    oprot.writeFieldStop()
13212 
    oprot.writeStructEnd()
13213 
 
3431 rajveer 13214 
  def validate(self):
13215 
    return
13216 
 
13217 
 
2690 chandransh 13218 
  def __repr__(self):
13219 
    L = ['%s=%r' % (key, value)
13220 
      for key, value in self.__dict__.iteritems()]
13221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13222 
 
13223 
  def __eq__(self, other):
13224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13225 
 
13226 
  def __ne__(self, other):
13227 
    return not (self == other)
13228 
 
2819 chandransh 13229 
class createPurchaseOrder_args:
13230 
  """
13231 
  Attributes:
13232 
   - warehouseId
13233 
  """
2690 chandransh 13234 
 
2819 chandransh 13235 
  thrift_spec = (
13236 
    None, # 0
13237 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13238 
  )
13239 
 
13240 
  def __init__(self, warehouseId=None,):
13241 
    self.warehouseId = warehouseId
13242 
 
13243 
  def read(self, iprot):
13244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13246 
      return
13247 
    iprot.readStructBegin()
13248 
    while True:
13249 
      (fname, ftype, fid) = iprot.readFieldBegin()
13250 
      if ftype == TType.STOP:
13251 
        break
13252 
      if fid == 1:
13253 
        if ftype == TType.I64:
13254 
          self.warehouseId = iprot.readI64();
13255 
        else:
13256 
          iprot.skip(ftype)
13257 
      else:
13258 
        iprot.skip(ftype)
13259 
      iprot.readFieldEnd()
13260 
    iprot.readStructEnd()
13261 
 
13262 
  def write(self, oprot):
13263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13265 
      return
13266 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 13267 
    if self.warehouseId is not None:
2819 chandransh 13268 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13269 
      oprot.writeI64(self.warehouseId)
13270 
      oprot.writeFieldEnd()
13271 
    oprot.writeFieldStop()
13272 
    oprot.writeStructEnd()
13273 
 
3431 rajveer 13274 
  def validate(self):
13275 
    return
13276 
 
13277 
 
2819 chandransh 13278 
  def __repr__(self):
13279 
    L = ['%s=%r' % (key, value)
13280 
      for key, value in self.__dict__.iteritems()]
13281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13282 
 
13283 
  def __eq__(self, other):
13284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13285 
 
13286 
  def __ne__(self, other):
13287 
    return not (self == other)
13288 
 
13289 
class createPurchaseOrder_result:
13290 
  """
13291 
  Attributes:
13292 
   - success
13293 
   - ex
13294 
  """
13295 
 
13296 
  thrift_spec = (
4586 mandeep.dh 13297 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
2819 chandransh 13298 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13299 
  )
13300 
 
13301 
  def __init__(self, success=None, ex=None,):
13302 
    self.success = success
13303 
    self.ex = ex
13304 
 
13305 
  def read(self, iprot):
13306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13308 
      return
13309 
    iprot.readStructBegin()
13310 
    while True:
13311 
      (fname, ftype, fid) = iprot.readFieldBegin()
13312 
      if ftype == TType.STOP:
13313 
        break
13314 
      if fid == 0:
4586 mandeep.dh 13315 
        if ftype == TType.LIST:
13316 
          self.success = []
13317 
          (_etype223, _size220) = iprot.readListBegin()
13318 
          for _i224 in xrange(_size220):
13319 
            _elem225 = iprot.readI64();
13320 
            self.success.append(_elem225)
13321 
          iprot.readListEnd()
2819 chandransh 13322 
        else:
13323 
          iprot.skip(ftype)
13324 
      elif fid == 1:
13325 
        if ftype == TType.STRUCT:
13326 
          self.ex = TransactionServiceException()
13327 
          self.ex.read(iprot)
13328 
        else:
13329 
          iprot.skip(ftype)
13330 
      else:
13331 
        iprot.skip(ftype)
13332 
      iprot.readFieldEnd()
13333 
    iprot.readStructEnd()
13334 
 
13335 
  def write(self, oprot):
13336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13338 
      return
13339 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 13340 
    if self.success is not None:
4586 mandeep.dh 13341 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13342 
      oprot.writeListBegin(TType.I64, len(self.success))
13343 
      for iter226 in self.success:
13344 
        oprot.writeI64(iter226)
13345 
      oprot.writeListEnd()
2819 chandransh 13346 
      oprot.writeFieldEnd()
3431 rajveer 13347 
    if self.ex is not None:
2819 chandransh 13348 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13349 
      self.ex.write(oprot)
13350 
      oprot.writeFieldEnd()
13351 
    oprot.writeFieldStop()
13352 
    oprot.writeStructEnd()
13353 
 
3431 rajveer 13354 
  def validate(self):
13355 
    return
13356 
 
13357 
 
2819 chandransh 13358 
  def __repr__(self):
13359 
    L = ['%s=%r' % (key, value)
13360 
      for key, value in self.__dict__.iteritems()]
13361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13362 
 
13363 
  def __eq__(self, other):
13364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13365 
 
13366 
  def __ne__(self, other):
13367 
    return not (self == other)
3451 chandransh 13368 
 
13369 
class updateWeight_args:
13370 
  """
13371 
  Attributes:
13372 
   - orderId
13373 
   - weight
13374 
  """
13375 
 
13376 
  thrift_spec = (
13377 
    None, # 0
13378 
    (1, TType.I64, 'orderId', None, None, ), # 1
13379 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
13380 
  )
13381 
 
13382 
  def __init__(self, orderId=None, weight=None,):
13383 
    self.orderId = orderId
13384 
    self.weight = weight
13385 
 
13386 
  def read(self, iprot):
13387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13389 
      return
13390 
    iprot.readStructBegin()
13391 
    while True:
13392 
      (fname, ftype, fid) = iprot.readFieldBegin()
13393 
      if ftype == TType.STOP:
13394 
        break
13395 
      if fid == 1:
13396 
        if ftype == TType.I64:
13397 
          self.orderId = iprot.readI64();
13398 
        else:
13399 
          iprot.skip(ftype)
13400 
      elif fid == 2:
13401 
        if ftype == TType.DOUBLE:
13402 
          self.weight = iprot.readDouble();
13403 
        else:
13404 
          iprot.skip(ftype)
13405 
      else:
13406 
        iprot.skip(ftype)
13407 
      iprot.readFieldEnd()
13408 
    iprot.readStructEnd()
13409 
 
13410 
  def write(self, oprot):
13411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13413 
      return
13414 
    oprot.writeStructBegin('updateWeight_args')
13415 
    if self.orderId is not None:
13416 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13417 
      oprot.writeI64(self.orderId)
13418 
      oprot.writeFieldEnd()
13419 
    if self.weight is not None:
13420 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
13421 
      oprot.writeDouble(self.weight)
13422 
      oprot.writeFieldEnd()
13423 
    oprot.writeFieldStop()
13424 
    oprot.writeStructEnd()
13425 
 
13426 
  def validate(self):
13427 
    return
13428 
 
13429 
 
13430 
  def __repr__(self):
13431 
    L = ['%s=%r' % (key, value)
13432 
      for key, value in self.__dict__.iteritems()]
13433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13434 
 
13435 
  def __eq__(self, other):
13436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13437 
 
13438 
  def __ne__(self, other):
13439 
    return not (self == other)
13440 
 
13441 
class updateWeight_result:
13442 
  """
13443 
  Attributes:
13444 
   - success
13445 
   - ex
13446 
  """
13447 
 
13448 
  thrift_spec = (
13449 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13450 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13451 
  )
13452 
 
13453 
  def __init__(self, success=None, ex=None,):
13454 
    self.success = success
13455 
    self.ex = ex
13456 
 
13457 
  def read(self, iprot):
13458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13460 
      return
13461 
    iprot.readStructBegin()
13462 
    while True:
13463 
      (fname, ftype, fid) = iprot.readFieldBegin()
13464 
      if ftype == TType.STOP:
13465 
        break
13466 
      if fid == 0:
13467 
        if ftype == TType.STRUCT:
13468 
          self.success = Order()
13469 
          self.success.read(iprot)
13470 
        else:
13471 
          iprot.skip(ftype)
13472 
      elif fid == 1:
13473 
        if ftype == TType.STRUCT:
13474 
          self.ex = TransactionServiceException()
13475 
          self.ex.read(iprot)
13476 
        else:
13477 
          iprot.skip(ftype)
13478 
      else:
13479 
        iprot.skip(ftype)
13480 
      iprot.readFieldEnd()
13481 
    iprot.readStructEnd()
13482 
 
13483 
  def write(self, oprot):
13484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13486 
      return
13487 
    oprot.writeStructBegin('updateWeight_result')
13488 
    if self.success is not None:
13489 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13490 
      self.success.write(oprot)
13491 
      oprot.writeFieldEnd()
13492 
    if self.ex is not None:
13493 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13494 
      self.ex.write(oprot)
13495 
      oprot.writeFieldEnd()
13496 
    oprot.writeFieldStop()
13497 
    oprot.writeStructEnd()
13498 
 
13499 
  def validate(self):
13500 
    return
13501 
 
13502 
 
13503 
  def __repr__(self):
13504 
    L = ['%s=%r' % (key, value)
13505 
      for key, value in self.__dict__.iteritems()]
13506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13507 
 
13508 
  def __eq__(self, other):
13509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13510 
 
13511 
  def __ne__(self, other):
13512 
    return not (self == other)
3469 chandransh 13513 
 
13514 
class changeItem_args:
13515 
  """
13516 
  Attributes:
13517 
   - orderId
13518 
   - itemId
13519 
  """
13520 
 
13521 
  thrift_spec = (
13522 
    None, # 0
13523 
    (1, TType.I64, 'orderId', None, None, ), # 1
13524 
    (2, TType.I64, 'itemId', None, None, ), # 2
13525 
  )
13526 
 
13527 
  def __init__(self, orderId=None, itemId=None,):
13528 
    self.orderId = orderId
13529 
    self.itemId = itemId
13530 
 
13531 
  def read(self, iprot):
13532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13534 
      return
13535 
    iprot.readStructBegin()
13536 
    while True:
13537 
      (fname, ftype, fid) = iprot.readFieldBegin()
13538 
      if ftype == TType.STOP:
13539 
        break
13540 
      if fid == 1:
13541 
        if ftype == TType.I64:
13542 
          self.orderId = iprot.readI64();
13543 
        else:
13544 
          iprot.skip(ftype)
13545 
      elif fid == 2:
13546 
        if ftype == TType.I64:
13547 
          self.itemId = iprot.readI64();
13548 
        else:
13549 
          iprot.skip(ftype)
13550 
      else:
13551 
        iprot.skip(ftype)
13552 
      iprot.readFieldEnd()
13553 
    iprot.readStructEnd()
13554 
 
13555 
  def write(self, oprot):
13556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13558 
      return
13559 
    oprot.writeStructBegin('changeItem_args')
13560 
    if self.orderId is not None:
13561 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13562 
      oprot.writeI64(self.orderId)
13563 
      oprot.writeFieldEnd()
13564 
    if self.itemId is not None:
13565 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13566 
      oprot.writeI64(self.itemId)
13567 
      oprot.writeFieldEnd()
13568 
    oprot.writeFieldStop()
13569 
    oprot.writeStructEnd()
13570 
 
13571 
  def validate(self):
13572 
    return
13573 
 
13574 
 
13575 
  def __repr__(self):
13576 
    L = ['%s=%r' % (key, value)
13577 
      for key, value in self.__dict__.iteritems()]
13578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13579 
 
13580 
  def __eq__(self, other):
13581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13582 
 
13583 
  def __ne__(self, other):
13584 
    return not (self == other)
13585 
 
13586 
class changeItem_result:
13587 
  """
13588 
  Attributes:
13589 
   - success
13590 
   - ex
13591 
  """
13592 
 
13593 
  thrift_spec = (
13594 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13595 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13596 
  )
13597 
 
13598 
  def __init__(self, success=None, ex=None,):
13599 
    self.success = success
13600 
    self.ex = ex
13601 
 
13602 
  def read(self, iprot):
13603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13605 
      return
13606 
    iprot.readStructBegin()
13607 
    while True:
13608 
      (fname, ftype, fid) = iprot.readFieldBegin()
13609 
      if ftype == TType.STOP:
13610 
        break
13611 
      if fid == 0:
13612 
        if ftype == TType.STRUCT:
13613 
          self.success = Order()
13614 
          self.success.read(iprot)
13615 
        else:
13616 
          iprot.skip(ftype)
13617 
      elif fid == 1:
13618 
        if ftype == TType.STRUCT:
13619 
          self.ex = TransactionServiceException()
13620 
          self.ex.read(iprot)
13621 
        else:
13622 
          iprot.skip(ftype)
13623 
      else:
13624 
        iprot.skip(ftype)
13625 
      iprot.readFieldEnd()
13626 
    iprot.readStructEnd()
13627 
 
13628 
  def write(self, oprot):
13629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13631 
      return
13632 
    oprot.writeStructBegin('changeItem_result')
13633 
    if self.success is not None:
13634 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13635 
      self.success.write(oprot)
13636 
      oprot.writeFieldEnd()
13637 
    if self.ex is not None:
13638 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13639 
      self.ex.write(oprot)
13640 
      oprot.writeFieldEnd()
13641 
    oprot.writeFieldStop()
13642 
    oprot.writeStructEnd()
13643 
 
13644 
  def validate(self):
13645 
    return
13646 
 
13647 
 
13648 
  def __repr__(self):
13649 
    L = ['%s=%r' % (key, value)
13650 
      for key, value in self.__dict__.iteritems()]
13651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13652 
 
13653 
  def __eq__(self, other):
13654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13655 
 
13656 
  def __ne__(self, other):
13657 
    return not (self == other)
13658 
 
13659 
class shiftToWarehouse_args:
13660 
  """
13661 
  Attributes:
13662 
   - orderId
13663 
   - warehouseId
13664 
  """
13665 
 
13666 
  thrift_spec = (
13667 
    None, # 0
13668 
    (1, TType.I64, 'orderId', None, None, ), # 1
13669 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13670 
  )
13671 
 
13672 
  def __init__(self, orderId=None, warehouseId=None,):
13673 
    self.orderId = orderId
13674 
    self.warehouseId = warehouseId
13675 
 
13676 
  def read(self, iprot):
13677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13679 
      return
13680 
    iprot.readStructBegin()
13681 
    while True:
13682 
      (fname, ftype, fid) = iprot.readFieldBegin()
13683 
      if ftype == TType.STOP:
13684 
        break
13685 
      if fid == 1:
13686 
        if ftype == TType.I64:
13687 
          self.orderId = iprot.readI64();
13688 
        else:
13689 
          iprot.skip(ftype)
13690 
      elif fid == 2:
13691 
        if ftype == TType.I64:
13692 
          self.warehouseId = iprot.readI64();
13693 
        else:
13694 
          iprot.skip(ftype)
13695 
      else:
13696 
        iprot.skip(ftype)
13697 
      iprot.readFieldEnd()
13698 
    iprot.readStructEnd()
13699 
 
13700 
  def write(self, oprot):
13701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13703 
      return
13704 
    oprot.writeStructBegin('shiftToWarehouse_args')
13705 
    if self.orderId is not None:
13706 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13707 
      oprot.writeI64(self.orderId)
13708 
      oprot.writeFieldEnd()
13709 
    if self.warehouseId is not None:
13710 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13711 
      oprot.writeI64(self.warehouseId)
13712 
      oprot.writeFieldEnd()
13713 
    oprot.writeFieldStop()
13714 
    oprot.writeStructEnd()
13715 
 
13716 
  def validate(self):
13717 
    return
13718 
 
13719 
 
13720 
  def __repr__(self):
13721 
    L = ['%s=%r' % (key, value)
13722 
      for key, value in self.__dict__.iteritems()]
13723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13724 
 
13725 
  def __eq__(self, other):
13726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13727 
 
13728 
  def __ne__(self, other):
13729 
    return not (self == other)
13730 
 
13731 
class shiftToWarehouse_result:
13732 
  """
13733 
  Attributes:
13734 
   - success
13735 
   - ex
13736 
  """
13737 
 
13738 
  thrift_spec = (
13739 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13740 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13741 
  )
13742 
 
13743 
  def __init__(self, success=None, ex=None,):
13744 
    self.success = success
13745 
    self.ex = ex
13746 
 
13747 
  def read(self, iprot):
13748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13750 
      return
13751 
    iprot.readStructBegin()
13752 
    while True:
13753 
      (fname, ftype, fid) = iprot.readFieldBegin()
13754 
      if ftype == TType.STOP:
13755 
        break
13756 
      if fid == 0:
13757 
        if ftype == TType.STRUCT:
13758 
          self.success = Order()
13759 
          self.success.read(iprot)
13760 
        else:
13761 
          iprot.skip(ftype)
13762 
      elif fid == 1:
13763 
        if ftype == TType.STRUCT:
13764 
          self.ex = TransactionServiceException()
13765 
          self.ex.read(iprot)
13766 
        else:
13767 
          iprot.skip(ftype)
13768 
      else:
13769 
        iprot.skip(ftype)
13770 
      iprot.readFieldEnd()
13771 
    iprot.readStructEnd()
13772 
 
13773 
  def write(self, oprot):
13774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13776 
      return
13777 
    oprot.writeStructBegin('shiftToWarehouse_result')
13778 
    if self.success is not None:
13779 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13780 
      self.success.write(oprot)
13781 
      oprot.writeFieldEnd()
13782 
    if self.ex is not None:
13783 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13784 
      self.ex.write(oprot)
13785 
      oprot.writeFieldEnd()
13786 
    oprot.writeFieldStop()
13787 
    oprot.writeStructEnd()
13788 
 
13789 
  def validate(self):
13790 
    return
13791 
 
13792 
 
13793 
  def __repr__(self):
13794 
    L = ['%s=%r' % (key, value)
13795 
      for key, value in self.__dict__.iteritems()]
13796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13797 
 
13798 
  def __eq__(self, other):
13799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13800 
 
13801 
  def __ne__(self, other):
13802 
    return not (self == other)
3553 chandransh 13803 
 
13804 
class addDelayReason_args:
13805 
  """
13806 
  Attributes:
13807 
   - orderId
13808 
   - delayReason
3986 chandransh 13809 
   - furtherDelay
3553 chandransh 13810 
  """
13811 
 
13812 
  thrift_spec = (
13813 
    None, # 0
13814 
    (1, TType.I64, 'orderId', None, None, ), # 1
13815 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 13816 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 13817 
  )
13818 
 
3986 chandransh 13819 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 13820 
    self.orderId = orderId
13821 
    self.delayReason = delayReason
3986 chandransh 13822 
    self.furtherDelay = furtherDelay
3553 chandransh 13823 
 
13824 
  def read(self, iprot):
13825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13827 
      return
13828 
    iprot.readStructBegin()
13829 
    while True:
13830 
      (fname, ftype, fid) = iprot.readFieldBegin()
13831 
      if ftype == TType.STOP:
13832 
        break
13833 
      if fid == 1:
13834 
        if ftype == TType.I64:
13835 
          self.orderId = iprot.readI64();
13836 
        else:
13837 
          iprot.skip(ftype)
13838 
      elif fid == 2:
13839 
        if ftype == TType.I32:
13840 
          self.delayReason = iprot.readI32();
13841 
        else:
13842 
          iprot.skip(ftype)
3986 chandransh 13843 
      elif fid == 3:
13844 
        if ftype == TType.I64:
13845 
          self.furtherDelay = iprot.readI64();
13846 
        else:
13847 
          iprot.skip(ftype)
3553 chandransh 13848 
      else:
13849 
        iprot.skip(ftype)
13850 
      iprot.readFieldEnd()
13851 
    iprot.readStructEnd()
13852 
 
13853 
  def write(self, oprot):
13854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13856 
      return
13857 
    oprot.writeStructBegin('addDelayReason_args')
13858 
    if self.orderId is not None:
13859 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13860 
      oprot.writeI64(self.orderId)
13861 
      oprot.writeFieldEnd()
13862 
    if self.delayReason is not None:
13863 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
13864 
      oprot.writeI32(self.delayReason)
13865 
      oprot.writeFieldEnd()
3986 chandransh 13866 
    if self.furtherDelay is not None:
13867 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
13868 
      oprot.writeI64(self.furtherDelay)
13869 
      oprot.writeFieldEnd()
3553 chandransh 13870 
    oprot.writeFieldStop()
13871 
    oprot.writeStructEnd()
13872 
 
13873 
  def validate(self):
13874 
    return
13875 
 
13876 
 
13877 
  def __repr__(self):
13878 
    L = ['%s=%r' % (key, value)
13879 
      for key, value in self.__dict__.iteritems()]
13880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13881 
 
13882 
  def __eq__(self, other):
13883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13884 
 
13885 
  def __ne__(self, other):
13886 
    return not (self == other)
13887 
 
13888 
class addDelayReason_result:
13889 
  """
13890 
  Attributes:
13891 
   - success
13892 
   - ex
13893 
  """
13894 
 
13895 
  thrift_spec = (
13896 
    (0, TType.BOOL, 'success', None, None, ), # 0
13897 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13898 
  )
13899 
 
13900 
  def __init__(self, success=None, ex=None,):
13901 
    self.success = success
13902 
    self.ex = ex
13903 
 
13904 
  def read(self, iprot):
13905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13907 
      return
13908 
    iprot.readStructBegin()
13909 
    while True:
13910 
      (fname, ftype, fid) = iprot.readFieldBegin()
13911 
      if ftype == TType.STOP:
13912 
        break
13913 
      if fid == 0:
13914 
        if ftype == TType.BOOL:
13915 
          self.success = iprot.readBool();
13916 
        else:
13917 
          iprot.skip(ftype)
13918 
      elif fid == 1:
13919 
        if ftype == TType.STRUCT:
13920 
          self.ex = TransactionServiceException()
13921 
          self.ex.read(iprot)
13922 
        else:
13923 
          iprot.skip(ftype)
13924 
      else:
13925 
        iprot.skip(ftype)
13926 
      iprot.readFieldEnd()
13927 
    iprot.readStructEnd()
13928 
 
13929 
  def write(self, oprot):
13930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13932 
      return
13933 
    oprot.writeStructBegin('addDelayReason_result')
13934 
    if self.success is not None:
13935 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13936 
      oprot.writeBool(self.success)
13937 
      oprot.writeFieldEnd()
13938 
    if self.ex is not None:
13939 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13940 
      self.ex.write(oprot)
13941 
      oprot.writeFieldEnd()
13942 
    oprot.writeFieldStop()
13943 
    oprot.writeStructEnd()
13944 
 
13945 
  def validate(self):
13946 
    return
13947 
 
13948 
 
13949 
  def __repr__(self):
13950 
    L = ['%s=%r' % (key, value)
13951 
      for key, value in self.__dict__.iteritems()]
13952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13953 
 
13954 
  def __eq__(self, other):
13955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13956 
 
13957 
  def __ne__(self, other):
13958 
    return not (self == other)
3956 chandransh 13959 
 
13960 
class reconcileCodCollection_args:
13961 
  """
13962 
  Attributes:
13963 
   - collectedAmountMap
13964 
   - xferBy
13965 
   - xferTxnId
13966 
   - xferDate
13967 
  """
13968 
 
13969 
  thrift_spec = (
13970 
    None, # 0
13971 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
13972 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
13973 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
13974 
    (4, TType.I64, 'xferDate', None, None, ), # 4
13975 
  )
13976 
 
13977 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
13978 
    self.collectedAmountMap = collectedAmountMap
13979 
    self.xferBy = xferBy
13980 
    self.xferTxnId = xferTxnId
13981 
    self.xferDate = xferDate
13982 
 
13983 
  def read(self, iprot):
13984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13986 
      return
13987 
    iprot.readStructBegin()
13988 
    while True:
13989 
      (fname, ftype, fid) = iprot.readFieldBegin()
13990 
      if ftype == TType.STOP:
13991 
        break
13992 
      if fid == 1:
13993 
        if ftype == TType.MAP:
13994 
          self.collectedAmountMap = {}
4586 mandeep.dh 13995 
          (_ktype228, _vtype229, _size227 ) = iprot.readMapBegin()
13996 
          for _i231 in xrange(_size227):
13997 
            _key232 = iprot.readString();
13998 
            _val233 = iprot.readDouble();
13999 
            self.collectedAmountMap[_key232] = _val233
3956 chandransh 14000 
          iprot.readMapEnd()
14001 
        else:
14002 
          iprot.skip(ftype)
14003 
      elif fid == 2:
14004 
        if ftype == TType.STRING:
14005 
          self.xferBy = iprot.readString();
14006 
        else:
14007 
          iprot.skip(ftype)
14008 
      elif fid == 3:
14009 
        if ftype == TType.STRING:
14010 
          self.xferTxnId = iprot.readString();
14011 
        else:
14012 
          iprot.skip(ftype)
14013 
      elif fid == 4:
14014 
        if ftype == TType.I64:
14015 
          self.xferDate = iprot.readI64();
14016 
        else:
14017 
          iprot.skip(ftype)
14018 
      else:
14019 
        iprot.skip(ftype)
14020 
      iprot.readFieldEnd()
14021 
    iprot.readStructEnd()
14022 
 
14023 
  def write(self, oprot):
14024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14026 
      return
14027 
    oprot.writeStructBegin('reconcileCodCollection_args')
14028 
    if self.collectedAmountMap is not None:
14029 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
14030 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4586 mandeep.dh 14031 
      for kiter234,viter235 in self.collectedAmountMap.items():
14032 
        oprot.writeString(kiter234)
14033 
        oprot.writeDouble(viter235)
3956 chandransh 14034 
      oprot.writeMapEnd()
14035 
      oprot.writeFieldEnd()
14036 
    if self.xferBy is not None:
14037 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
14038 
      oprot.writeString(self.xferBy)
14039 
      oprot.writeFieldEnd()
14040 
    if self.xferTxnId is not None:
14041 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
14042 
      oprot.writeString(self.xferTxnId)
14043 
      oprot.writeFieldEnd()
14044 
    if self.xferDate is not None:
14045 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
14046 
      oprot.writeI64(self.xferDate)
14047 
      oprot.writeFieldEnd()
14048 
    oprot.writeFieldStop()
14049 
    oprot.writeStructEnd()
14050 
 
14051 
  def validate(self):
14052 
    return
14053 
 
14054 
 
14055 
  def __repr__(self):
14056 
    L = ['%s=%r' % (key, value)
14057 
      for key, value in self.__dict__.iteritems()]
14058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14059 
 
14060 
  def __eq__(self, other):
14061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14062 
 
14063 
  def __ne__(self, other):
14064 
    return not (self == other)
14065 
 
14066 
class reconcileCodCollection_result:
14067 
  """
14068 
  Attributes:
14069 
   - success
14070 
   - ex
14071 
  """
14072 
 
14073 
  thrift_spec = (
14074 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
14075 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14076 
  )
14077 
 
14078 
  def __init__(self, success=None, ex=None,):
14079 
    self.success = success
14080 
    self.ex = ex
14081 
 
14082 
  def read(self, iprot):
14083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14085 
      return
14086 
    iprot.readStructBegin()
14087 
    while True:
14088 
      (fname, ftype, fid) = iprot.readFieldBegin()
14089 
      if ftype == TType.STOP:
14090 
        break
14091 
      if fid == 0:
14092 
        if ftype == TType.MAP:
14093 
          self.success = {}
4586 mandeep.dh 14094 
          (_ktype237, _vtype238, _size236 ) = iprot.readMapBegin()
14095 
          for _i240 in xrange(_size236):
14096 
            _key241 = iprot.readString();
14097 
            _val242 = iprot.readString();
14098 
            self.success[_key241] = _val242
3956 chandransh 14099 
          iprot.readMapEnd()
14100 
        else:
14101 
          iprot.skip(ftype)
14102 
      elif fid == 1:
14103 
        if ftype == TType.STRUCT:
14104 
          self.ex = TransactionServiceException()
14105 
          self.ex.read(iprot)
14106 
        else:
14107 
          iprot.skip(ftype)
14108 
      else:
14109 
        iprot.skip(ftype)
14110 
      iprot.readFieldEnd()
14111 
    iprot.readStructEnd()
14112 
 
14113 
  def write(self, oprot):
14114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14116 
      return
14117 
    oprot.writeStructBegin('reconcileCodCollection_result')
14118 
    if self.success is not None:
14119 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14120 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4586 mandeep.dh 14121 
      for kiter243,viter244 in self.success.items():
14122 
        oprot.writeString(kiter243)
14123 
        oprot.writeString(viter244)
3956 chandransh 14124 
      oprot.writeMapEnd()
14125 
      oprot.writeFieldEnd()
14126 
    if self.ex is not None:
14127 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14128 
      self.ex.write(oprot)
14129 
      oprot.writeFieldEnd()
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)
4008 mandeep.dh 14147 
 
14148 
class getTransactionsRequiringExtraProcessing_args:
14149 
  """
14150 
  Attributes:
14151 
   - category
14152 
  """
14153 
 
14154 
  thrift_spec = (
14155 
    None, # 0
14156 
    (1, TType.I32, 'category', None, None, ), # 1
14157 
  )
14158 
 
14159 
  def __init__(self, category=None,):
14160 
    self.category = category
14161 
 
14162 
  def read(self, iprot):
14163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14165 
      return
14166 
    iprot.readStructBegin()
14167 
    while True:
14168 
      (fname, ftype, fid) = iprot.readFieldBegin()
14169 
      if ftype == TType.STOP:
14170 
        break
14171 
      if fid == 1:
14172 
        if ftype == TType.I32:
14173 
          self.category = iprot.readI32();
14174 
        else:
14175 
          iprot.skip(ftype)
14176 
      else:
14177 
        iprot.skip(ftype)
14178 
      iprot.readFieldEnd()
14179 
    iprot.readStructEnd()
14180 
 
14181 
  def write(self, oprot):
14182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14184 
      return
14185 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
14186 
    if self.category is not None:
14187 
      oprot.writeFieldBegin('category', TType.I32, 1)
14188 
      oprot.writeI32(self.category)
14189 
      oprot.writeFieldEnd()
14190 
    oprot.writeFieldStop()
14191 
    oprot.writeStructEnd()
14192 
 
14193 
  def validate(self):
14194 
    return
14195 
 
14196 
 
14197 
  def __repr__(self):
14198 
    L = ['%s=%r' % (key, value)
14199 
      for key, value in self.__dict__.iteritems()]
14200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14201 
 
14202 
  def __eq__(self, other):
14203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14204 
 
14205 
  def __ne__(self, other):
14206 
    return not (self == other)
14207 
 
14208 
class getTransactionsRequiringExtraProcessing_result:
14209 
  """
14210 
  Attributes:
14211 
   - success
14212 
  """
14213 
 
14214 
  thrift_spec = (
14215 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14216 
  )
14217 
 
14218 
  def __init__(self, success=None,):
14219 
    self.success = success
14220 
 
14221 
  def read(self, iprot):
14222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14224 
      return
14225 
    iprot.readStructBegin()
14226 
    while True:
14227 
      (fname, ftype, fid) = iprot.readFieldBegin()
14228 
      if ftype == TType.STOP:
14229 
        break
14230 
      if fid == 0:
14231 
        if ftype == TType.LIST:
14232 
          self.success = []
4586 mandeep.dh 14233 
          (_etype248, _size245) = iprot.readListBegin()
14234 
          for _i249 in xrange(_size245):
14235 
            _elem250 = iprot.readI64();
14236 
            self.success.append(_elem250)
4008 mandeep.dh 14237 
          iprot.readListEnd()
14238 
        else:
14239 
          iprot.skip(ftype)
14240 
      else:
14241 
        iprot.skip(ftype)
14242 
      iprot.readFieldEnd()
14243 
    iprot.readStructEnd()
14244 
 
14245 
  def write(self, oprot):
14246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14248 
      return
14249 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
14250 
    if self.success is not None:
14251 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14252 
      oprot.writeListBegin(TType.I64, len(self.success))
4586 mandeep.dh 14253 
      for iter251 in self.success:
14254 
        oprot.writeI64(iter251)
4008 mandeep.dh 14255 
      oprot.writeListEnd()
14256 
      oprot.writeFieldEnd()
14257 
    oprot.writeFieldStop()
14258 
    oprot.writeStructEnd()
14259 
 
14260 
  def validate(self):
14261 
    return
14262 
 
14263 
 
14264 
  def __repr__(self):
14265 
    L = ['%s=%r' % (key, value)
14266 
      for key, value in self.__dict__.iteritems()]
14267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14268 
 
14269 
  def __eq__(self, other):
14270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14271 
 
14272 
  def __ne__(self, other):
14273 
    return not (self == other)
14274 
 
14275 
class markTransactionAsProcessed_args:
14276 
  """
14277 
  Attributes:
14278 
   - transactionId
14279 
   - category
14280 
  """
14281 
 
14282 
  thrift_spec = (
14283 
    None, # 0
14284 
    (1, TType.I64, 'transactionId', None, None, ), # 1
14285 
    (2, TType.I32, 'category', None, None, ), # 2
14286 
  )
14287 
 
14288 
  def __init__(self, transactionId=None, category=None,):
14289 
    self.transactionId = transactionId
14290 
    self.category = category
14291 
 
14292 
  def read(self, iprot):
14293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14295 
      return
14296 
    iprot.readStructBegin()
14297 
    while True:
14298 
      (fname, ftype, fid) = iprot.readFieldBegin()
14299 
      if ftype == TType.STOP:
14300 
        break
14301 
      if fid == 1:
14302 
        if ftype == TType.I64:
14303 
          self.transactionId = iprot.readI64();
14304 
        else:
14305 
          iprot.skip(ftype)
14306 
      elif fid == 2:
14307 
        if ftype == TType.I32:
14308 
          self.category = iprot.readI32();
14309 
        else:
14310 
          iprot.skip(ftype)
14311 
      else:
14312 
        iprot.skip(ftype)
14313 
      iprot.readFieldEnd()
14314 
    iprot.readStructEnd()
14315 
 
14316 
  def write(self, oprot):
14317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14319 
      return
14320 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
14321 
    if self.transactionId is not None:
14322 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14323 
      oprot.writeI64(self.transactionId)
14324 
      oprot.writeFieldEnd()
14325 
    if self.category is not None:
14326 
      oprot.writeFieldBegin('category', TType.I32, 2)
14327 
      oprot.writeI32(self.category)
14328 
      oprot.writeFieldEnd()
14329 
    oprot.writeFieldStop()
14330 
    oprot.writeStructEnd()
14331 
 
14332 
  def validate(self):
14333 
    return
14334 
 
14335 
 
14336 
  def __repr__(self):
14337 
    L = ['%s=%r' % (key, value)
14338 
      for key, value in self.__dict__.iteritems()]
14339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14340 
 
14341 
  def __eq__(self, other):
14342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14343 
 
14344 
  def __ne__(self, other):
14345 
    return not (self == other)
14346 
 
14347 
class markTransactionAsProcessed_result:
14348 
 
14349 
  thrift_spec = (
14350 
  )
14351 
 
14352 
  def read(self, iprot):
14353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14355 
      return
14356 
    iprot.readStructBegin()
14357 
    while True:
14358 
      (fname, ftype, fid) = iprot.readFieldBegin()
14359 
      if ftype == TType.STOP:
14360 
        break
14361 
      else:
14362 
        iprot.skip(ftype)
14363 
      iprot.readFieldEnd()
14364 
    iprot.readStructEnd()
14365 
 
14366 
  def write(self, oprot):
14367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14369 
      return
14370 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
14371 
    oprot.writeFieldStop()
14372 
    oprot.writeStructEnd()
14373 
 
14374 
  def validate(self):
14375 
    return
14376 
 
14377 
 
14378 
  def __repr__(self):
14379 
    L = ['%s=%r' % (key, value)
14380 
      for key, value in self.__dict__.iteritems()]
14381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14382 
 
14383 
  def __eq__(self, other):
14384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14385 
 
14386 
  def __ne__(self, other):
14387 
    return not (self == other)
4018 chandransh 14388 
 
14389 
class getItemWiseRiskyOrdersCount_args:
14390 
 
14391 
  thrift_spec = (
14392 
  )
14393 
 
14394 
  def read(self, iprot):
14395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14397 
      return
14398 
    iprot.readStructBegin()
14399 
    while True:
14400 
      (fname, ftype, fid) = iprot.readFieldBegin()
14401 
      if ftype == TType.STOP:
14402 
        break
14403 
      else:
14404 
        iprot.skip(ftype)
14405 
      iprot.readFieldEnd()
14406 
    iprot.readStructEnd()
14407 
 
14408 
  def write(self, oprot):
14409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14411 
      return
14412 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
14413 
    oprot.writeFieldStop()
14414 
    oprot.writeStructEnd()
14415 
 
14416 
  def validate(self):
14417 
    return
14418 
 
14419 
 
14420 
  def __repr__(self):
14421 
    L = ['%s=%r' % (key, value)
14422 
      for key, value in self.__dict__.iteritems()]
14423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14424 
 
14425 
  def __eq__(self, other):
14426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14427 
 
14428 
  def __ne__(self, other):
14429 
    return not (self == other)
14430 
 
14431 
class getItemWiseRiskyOrdersCount_result:
14432 
  """
14433 
  Attributes:
14434 
   - success
14435 
  """
14436 
 
14437 
  thrift_spec = (
14438 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
14439 
  )
14440 
 
14441 
  def __init__(self, success=None,):
14442 
    self.success = success
14443 
 
14444 
  def read(self, iprot):
14445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14447 
      return
14448 
    iprot.readStructBegin()
14449 
    while True:
14450 
      (fname, ftype, fid) = iprot.readFieldBegin()
14451 
      if ftype == TType.STOP:
14452 
        break
14453 
      if fid == 0:
14454 
        if ftype == TType.MAP:
14455 
          self.success = {}
4586 mandeep.dh 14456 
          (_ktype253, _vtype254, _size252 ) = iprot.readMapBegin()
14457 
          for _i256 in xrange(_size252):
14458 
            _key257 = iprot.readI64();
14459 
            _val258 = iprot.readI64();
14460 
            self.success[_key257] = _val258
4018 chandransh 14461 
          iprot.readMapEnd()
14462 
        else:
14463 
          iprot.skip(ftype)
14464 
      else:
14465 
        iprot.skip(ftype)
14466 
      iprot.readFieldEnd()
14467 
    iprot.readStructEnd()
14468 
 
14469 
  def write(self, oprot):
14470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14472 
      return
14473 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
14474 
    if self.success is not None:
14475 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14476 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4586 mandeep.dh 14477 
      for kiter259,viter260 in self.success.items():
14478 
        oprot.writeI64(kiter259)
14479 
        oprot.writeI64(viter260)
4018 chandransh 14480 
      oprot.writeMapEnd()
14481 
      oprot.writeFieldEnd()
14482 
    oprot.writeFieldStop()
14483 
    oprot.writeStructEnd()
14484 
 
14485 
  def validate(self):
14486 
    return
14487 
 
14488 
 
14489 
  def __repr__(self):
14490 
    L = ['%s=%r' % (key, value)
14491 
      for key, value in self.__dict__.iteritems()]
14492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14493 
 
14494 
  def __eq__(self, other):
14495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14496 
 
14497 
  def __ne__(self, other):
14498 
    return not (self == other)
4247 rajveer 14499 
 
4295 varun.gupt 14500 
class getOrdersForItemIds_args:
14501 
  """
14502 
  Attributes:
14503 
   - itemIds
14504 
  """
14505 
 
14506 
  thrift_spec = (
14507 
    None, # 0
14508 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
14509 
  )
14510 
 
14511 
  def __init__(self, itemIds=None,):
14512 
    self.itemIds = itemIds
14513 
 
14514 
  def read(self, iprot):
14515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14517 
      return
14518 
    iprot.readStructBegin()
14519 
    while True:
14520 
      (fname, ftype, fid) = iprot.readFieldBegin()
14521 
      if ftype == TType.STOP:
14522 
        break
14523 
      if fid == 1:
14524 
        if ftype == TType.LIST:
14525 
          self.itemIds = []
4586 mandeep.dh 14526 
          (_etype264, _size261) = iprot.readListBegin()
14527 
          for _i265 in xrange(_size261):
14528 
            _elem266 = iprot.readI64();
14529 
            self.itemIds.append(_elem266)
4295 varun.gupt 14530 
          iprot.readListEnd()
14531 
        else:
14532 
          iprot.skip(ftype)
14533 
      else:
14534 
        iprot.skip(ftype)
14535 
      iprot.readFieldEnd()
14536 
    iprot.readStructEnd()
14537 
 
14538 
  def write(self, oprot):
14539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14541 
      return
14542 
    oprot.writeStructBegin('getOrdersForItemIds_args')
14543 
    if self.itemIds is not None:
14544 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
14545 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4586 mandeep.dh 14546 
      for iter267 in self.itemIds:
14547 
        oprot.writeI64(iter267)
4295 varun.gupt 14548 
      oprot.writeListEnd()
14549 
      oprot.writeFieldEnd()
14550 
    oprot.writeFieldStop()
14551 
    oprot.writeStructEnd()
14552 
 
14553 
  def validate(self):
14554 
    return
14555 
 
14556 
 
14557 
  def __repr__(self):
14558 
    L = ['%s=%r' % (key, value)
14559 
      for key, value in self.__dict__.iteritems()]
14560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14561 
 
14562 
  def __eq__(self, other):
14563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14564 
 
14565 
  def __ne__(self, other):
14566 
    return not (self == other)
14567 
 
14568 
class getOrdersForItemIds_result:
14569 
  """
14570 
  Attributes:
14571 
   - success
14572 
  """
14573 
 
14574 
  thrift_spec = (
14575 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14576 
  )
14577 
 
14578 
  def __init__(self, success=None,):
14579 
    self.success = success
14580 
 
14581 
  def read(self, iprot):
14582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14584 
      return
14585 
    iprot.readStructBegin()
14586 
    while True:
14587 
      (fname, ftype, fid) = iprot.readFieldBegin()
14588 
      if ftype == TType.STOP:
14589 
        break
14590 
      if fid == 0:
14591 
        if ftype == TType.LIST:
14592 
          self.success = []
4586 mandeep.dh 14593 
          (_etype271, _size268) = iprot.readListBegin()
14594 
          for _i272 in xrange(_size268):
14595 
            _elem273 = Order()
14596 
            _elem273.read(iprot)
14597 
            self.success.append(_elem273)
4295 varun.gupt 14598 
          iprot.readListEnd()
14599 
        else:
14600 
          iprot.skip(ftype)
14601 
      else:
14602 
        iprot.skip(ftype)
14603 
      iprot.readFieldEnd()
14604 
    iprot.readStructEnd()
14605 
 
14606 
  def write(self, oprot):
14607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14609 
      return
14610 
    oprot.writeStructBegin('getOrdersForItemIds_result')
14611 
    if self.success is not None:
14612 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14613 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 14614 
      for iter274 in self.success:
14615 
        iter274.write(oprot)
4295 varun.gupt 14616 
      oprot.writeListEnd()
14617 
      oprot.writeFieldEnd()
14618 
    oprot.writeFieldStop()
14619 
    oprot.writeStructEnd()
14620 
 
14621 
  def validate(self):
14622 
    return
14623 
 
14624 
 
14625 
  def __repr__(self):
14626 
    L = ['%s=%r' % (key, value)
14627 
      for key, value in self.__dict__.iteritems()]
14628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14629 
 
14630 
  def __eq__(self, other):
14631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14632 
 
14633 
  def __ne__(self, other):
14634 
    return not (self == other)
14635 
 
4247 rajveer 14636 
class markOrderCancellationRequestReceived_args:
14637 
  """
14638 
  Attributes:
14639 
   - orderId
14640 
  """
14641 
 
14642 
  thrift_spec = (
14643 
    None, # 0
14644 
    (1, TType.I64, 'orderId', None, None, ), # 1
14645 
  )
14646 
 
14647 
  def __init__(self, orderId=None,):
14648 
    self.orderId = orderId
14649 
 
14650 
  def read(self, iprot):
14651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14653 
      return
14654 
    iprot.readStructBegin()
14655 
    while True:
14656 
      (fname, ftype, fid) = iprot.readFieldBegin()
14657 
      if ftype == TType.STOP:
14658 
        break
14659 
      if fid == 1:
14660 
        if ftype == TType.I64:
14661 
          self.orderId = iprot.readI64();
14662 
        else:
14663 
          iprot.skip(ftype)
14664 
      else:
14665 
        iprot.skip(ftype)
14666 
      iprot.readFieldEnd()
14667 
    iprot.readStructEnd()
14668 
 
14669 
  def write(self, oprot):
14670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14672 
      return
14673 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
14674 
    if self.orderId is not None:
14675 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14676 
      oprot.writeI64(self.orderId)
14677 
      oprot.writeFieldEnd()
14678 
    oprot.writeFieldStop()
14679 
    oprot.writeStructEnd()
14680 
 
14681 
  def validate(self):
14682 
    return
14683 
 
14684 
 
14685 
  def __repr__(self):
14686 
    L = ['%s=%r' % (key, value)
14687 
      for key, value in self.__dict__.iteritems()]
14688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14689 
 
14690 
  def __eq__(self, other):
14691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14692 
 
14693 
  def __ne__(self, other):
14694 
    return not (self == other)
14695 
 
14696 
class markOrderCancellationRequestReceived_result:
14697 
  """
14698 
  Attributes:
14699 
   - ex
14700 
  """
14701 
 
14702 
  thrift_spec = (
14703 
    None, # 0
14704 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14705 
  )
14706 
 
14707 
  def __init__(self, ex=None,):
14708 
    self.ex = ex
14709 
 
14710 
  def read(self, iprot):
14711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14713 
      return
14714 
    iprot.readStructBegin()
14715 
    while True:
14716 
      (fname, ftype, fid) = iprot.readFieldBegin()
14717 
      if ftype == TType.STOP:
14718 
        break
14719 
      if fid == 1:
14720 
        if ftype == TType.STRUCT:
14721 
          self.ex = TransactionServiceException()
14722 
          self.ex.read(iprot)
14723 
        else:
14724 
          iprot.skip(ftype)
14725 
      else:
14726 
        iprot.skip(ftype)
14727 
      iprot.readFieldEnd()
14728 
    iprot.readStructEnd()
14729 
 
14730 
  def write(self, oprot):
14731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14733 
      return
14734 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
14735 
    if self.ex is not None:
14736 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14737 
      self.ex.write(oprot)
14738 
      oprot.writeFieldEnd()
14739 
    oprot.writeFieldStop()
14740 
    oprot.writeStructEnd()
14741 
 
14742 
  def validate(self):
14743 
    return
14744 
 
14745 
 
14746 
  def __repr__(self):
14747 
    L = ['%s=%r' % (key, value)
14748 
      for key, value in self.__dict__.iteritems()]
14749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14750 
 
14751 
  def __eq__(self, other):
14752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14753 
 
14754 
  def __ne__(self, other):
14755 
    return not (self == other)
14756 
 
14757 
class markOrderCancellationRequestConfirmed_args:
14758 
  """
14759 
  Attributes:
14760 
   - orderId
14761 
  """
14762 
 
14763 
  thrift_spec = (
14764 
    None, # 0
14765 
    (1, TType.I64, 'orderId', None, None, ), # 1
14766 
  )
14767 
 
14768 
  def __init__(self, orderId=None,):
14769 
    self.orderId = orderId
14770 
 
14771 
  def read(self, iprot):
14772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14774 
      return
14775 
    iprot.readStructBegin()
14776 
    while True:
14777 
      (fname, ftype, fid) = iprot.readFieldBegin()
14778 
      if ftype == TType.STOP:
14779 
        break
14780 
      if fid == 1:
14781 
        if ftype == TType.I64:
14782 
          self.orderId = iprot.readI64();
14783 
        else:
14784 
          iprot.skip(ftype)
14785 
      else:
14786 
        iprot.skip(ftype)
14787 
      iprot.readFieldEnd()
14788 
    iprot.readStructEnd()
14789 
 
14790 
  def write(self, oprot):
14791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14793 
      return
14794 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
14795 
    if self.orderId is not None:
14796 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14797 
      oprot.writeI64(self.orderId)
14798 
      oprot.writeFieldEnd()
14799 
    oprot.writeFieldStop()
14800 
    oprot.writeStructEnd()
14801 
 
14802 
  def validate(self):
14803 
    return
14804 
 
14805 
 
14806 
  def __repr__(self):
14807 
    L = ['%s=%r' % (key, value)
14808 
      for key, value in self.__dict__.iteritems()]
14809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14810 
 
14811 
  def __eq__(self, other):
14812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14813 
 
14814 
  def __ne__(self, other):
14815 
    return not (self == other)
14816 
 
14817 
class markOrderCancellationRequestConfirmed_result:
14818 
  """
14819 
  Attributes:
14820 
   - ex
14821 
  """
14822 
 
14823 
  thrift_spec = (
14824 
    None, # 0
14825 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14826 
  )
14827 
 
14828 
  def __init__(self, ex=None,):
14829 
    self.ex = ex
14830 
 
14831 
  def read(self, iprot):
14832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14834 
      return
14835 
    iprot.readStructBegin()
14836 
    while True:
14837 
      (fname, ftype, fid) = iprot.readFieldBegin()
14838 
      if ftype == TType.STOP:
14839 
        break
14840 
      if fid == 1:
14841 
        if ftype == TType.STRUCT:
14842 
          self.ex = TransactionServiceException()
14843 
          self.ex.read(iprot)
14844 
        else:
14845 
          iprot.skip(ftype)
14846 
      else:
14847 
        iprot.skip(ftype)
14848 
      iprot.readFieldEnd()
14849 
    iprot.readStructEnd()
14850 
 
14851 
  def write(self, oprot):
14852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14854 
      return
14855 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
14856 
    if self.ex is not None:
14857 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14858 
      self.ex.write(oprot)
14859 
      oprot.writeFieldEnd()
14860 
    oprot.writeFieldStop()
14861 
    oprot.writeStructEnd()
14862 
 
14863 
  def validate(self):
14864 
    return
14865 
 
14866 
 
14867 
  def __repr__(self):
14868 
    L = ['%s=%r' % (key, value)
14869 
      for key, value in self.__dict__.iteritems()]
14870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14871 
 
14872 
  def __eq__(self, other):
14873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14874 
 
14875 
  def __ne__(self, other):
14876 
    return not (self == other)
14877 
 
14878 
class markOrderCancellationRequestDenied_args:
14879 
  """
14880 
  Attributes:
14881 
   - orderId
14882 
  """
14883 
 
14884 
  thrift_spec = (
14885 
    None, # 0
14886 
    (1, TType.I64, 'orderId', None, None, ), # 1
14887 
  )
14888 
 
14889 
  def __init__(self, orderId=None,):
14890 
    self.orderId = orderId
14891 
 
14892 
  def read(self, iprot):
14893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14895 
      return
14896 
    iprot.readStructBegin()
14897 
    while True:
14898 
      (fname, ftype, fid) = iprot.readFieldBegin()
14899 
      if ftype == TType.STOP:
14900 
        break
14901 
      if fid == 1:
14902 
        if ftype == TType.I64:
14903 
          self.orderId = iprot.readI64();
14904 
        else:
14905 
          iprot.skip(ftype)
14906 
      else:
14907 
        iprot.skip(ftype)
14908 
      iprot.readFieldEnd()
14909 
    iprot.readStructEnd()
14910 
 
14911 
  def write(self, oprot):
14912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14914 
      return
14915 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
14916 
    if self.orderId is not None:
14917 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14918 
      oprot.writeI64(self.orderId)
14919 
      oprot.writeFieldEnd()
14920 
    oprot.writeFieldStop()
14921 
    oprot.writeStructEnd()
14922 
 
14923 
  def validate(self):
14924 
    return
14925 
 
14926 
 
14927 
  def __repr__(self):
14928 
    L = ['%s=%r' % (key, value)
14929 
      for key, value in self.__dict__.iteritems()]
14930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14931 
 
14932 
  def __eq__(self, other):
14933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14934 
 
14935 
  def __ne__(self, other):
14936 
    return not (self == other)
14937 
 
14938 
class markOrderCancellationRequestDenied_result:
14939 
  """
14940 
  Attributes:
14941 
   - ex
14942 
  """
14943 
 
14944 
  thrift_spec = (
14945 
    None, # 0
14946 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14947 
  )
14948 
 
14949 
  def __init__(self, ex=None,):
14950 
    self.ex = ex
14951 
 
14952 
  def read(self, iprot):
14953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14955 
      return
14956 
    iprot.readStructBegin()
14957 
    while True:
14958 
      (fname, ftype, fid) = iprot.readFieldBegin()
14959 
      if ftype == TType.STOP:
14960 
        break
14961 
      if fid == 1:
14962 
        if ftype == TType.STRUCT:
14963 
          self.ex = TransactionServiceException()
14964 
          self.ex.read(iprot)
14965 
        else:
14966 
          iprot.skip(ftype)
14967 
      else:
14968 
        iprot.skip(ftype)
14969 
      iprot.readFieldEnd()
14970 
    iprot.readStructEnd()
14971 
 
14972 
  def write(self, oprot):
14973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14975 
      return
14976 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
14977 
    if self.ex is not None:
14978 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14979 
      self.ex.write(oprot)
14980 
      oprot.writeFieldEnd()
14981 
    oprot.writeFieldStop()
14982 
    oprot.writeStructEnd()
14983 
 
14984 
  def validate(self):
14985 
    return
14986 
 
14987 
 
14988 
  def __repr__(self):
14989 
    L = ['%s=%r' % (key, value)
14990 
      for key, value in self.__dict__.iteritems()]
14991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14992 
 
14993 
  def __eq__(self, other):
14994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14995 
 
14996 
  def __ne__(self, other):
14997 
    return not (self == other)
14998 
 
4258 rajveer 14999 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 15000 
  """
15001 
  Attributes:
4258 rajveer 15002 
   - transactionId
4247 rajveer 15003 
  """
15004 
 
15005 
  thrift_spec = (
15006 
    None, # 0
4258 rajveer 15007 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 15008 
  )
15009 
 
4258 rajveer 15010 
  def __init__(self, transactionId=None,):
15011 
    self.transactionId = transactionId
4247 rajveer 15012 
 
15013 
  def read(self, iprot):
15014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15016 
      return
15017 
    iprot.readStructBegin()
15018 
    while True:
15019 
      (fname, ftype, fid) = iprot.readFieldBegin()
15020 
      if ftype == TType.STOP:
15021 
        break
15022 
      if fid == 1:
15023 
        if ftype == TType.I64:
4258 rajveer 15024 
          self.transactionId = iprot.readI64();
4247 rajveer 15025 
        else:
15026 
          iprot.skip(ftype)
15027 
      else:
15028 
        iprot.skip(ftype)
15029 
      iprot.readFieldEnd()
15030 
    iprot.readStructEnd()
15031 
 
15032 
  def write(self, oprot):
15033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15035 
      return
4258 rajveer 15036 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
15037 
    if self.transactionId is not None:
15038 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15039 
      oprot.writeI64(self.transactionId)
4247 rajveer 15040 
      oprot.writeFieldEnd()
15041 
    oprot.writeFieldStop()
15042 
    oprot.writeStructEnd()
15043 
 
15044 
  def validate(self):
15045 
    return
15046 
 
15047 
 
15048 
  def __repr__(self):
15049 
    L = ['%s=%r' % (key, value)
15050 
      for key, value in self.__dict__.iteritems()]
15051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15052 
 
15053 
  def __eq__(self, other):
15054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15055 
 
15056 
  def __ne__(self, other):
15057 
    return not (self == other)
15058 
 
4258 rajveer 15059 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 15060 
  """
15061 
  Attributes:
15062 
   - ex
15063 
  """
15064 
 
15065 
  thrift_spec = (
15066 
    None, # 0
15067 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15068 
  )
15069 
 
15070 
  def __init__(self, ex=None,):
15071 
    self.ex = ex
15072 
 
15073 
  def read(self, iprot):
15074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15076 
      return
15077 
    iprot.readStructBegin()
15078 
    while True:
15079 
      (fname, ftype, fid) = iprot.readFieldBegin()
15080 
      if ftype == TType.STOP:
15081 
        break
15082 
      if fid == 1:
15083 
        if ftype == TType.STRUCT:
15084 
          self.ex = TransactionServiceException()
15085 
          self.ex.read(iprot)
15086 
        else:
15087 
          iprot.skip(ftype)
15088 
      else:
15089 
        iprot.skip(ftype)
15090 
      iprot.readFieldEnd()
15091 
    iprot.readStructEnd()
15092 
 
15093 
  def write(self, oprot):
15094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15096 
      return
4258 rajveer 15097 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 15098 
    if self.ex is not None:
15099 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15100 
      self.ex.write(oprot)
15101 
      oprot.writeFieldEnd()
15102 
    oprot.writeFieldStop()
15103 
    oprot.writeStructEnd()
15104 
 
15105 
  def validate(self):
15106 
    return
15107 
 
15108 
 
15109 
  def __repr__(self):
15110 
    L = ['%s=%r' % (key, value)
15111 
      for key, value in self.__dict__.iteritems()]
15112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15113 
 
15114 
  def __eq__(self, other):
15115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15116 
 
15117 
  def __ne__(self, other):
15118 
    return not (self == other)
4259 anupam.sin 15119 
 
15120 
class refundTransaction_args:
15121 
  """
15122 
  Attributes:
15123 
   - transactionId
15124 
   - refundedBy
15125 
   - reason
15126 
  """
15127 
 
15128 
  thrift_spec = (
15129 
    None, # 0
15130 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15131 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15132 
    (3, TType.STRING, 'reason', None, None, ), # 3
15133 
  )
15134 
 
15135 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
15136 
    self.transactionId = transactionId
15137 
    self.refundedBy = refundedBy
15138 
    self.reason = reason
15139 
 
15140 
  def read(self, iprot):
15141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15143 
      return
15144 
    iprot.readStructBegin()
15145 
    while True:
15146 
      (fname, ftype, fid) = iprot.readFieldBegin()
15147 
      if ftype == TType.STOP:
15148 
        break
15149 
      if fid == 1:
15150 
        if ftype == TType.I64:
15151 
          self.transactionId = iprot.readI64();
15152 
        else:
15153 
          iprot.skip(ftype)
15154 
      elif fid == 2:
15155 
        if ftype == TType.STRING:
15156 
          self.refundedBy = iprot.readString();
15157 
        else:
15158 
          iprot.skip(ftype)
15159 
      elif fid == 3:
15160 
        if ftype == TType.STRING:
15161 
          self.reason = iprot.readString();
15162 
        else:
15163 
          iprot.skip(ftype)
15164 
      else:
15165 
        iprot.skip(ftype)
15166 
      iprot.readFieldEnd()
15167 
    iprot.readStructEnd()
15168 
 
15169 
  def write(self, oprot):
15170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15172 
      return
15173 
    oprot.writeStructBegin('refundTransaction_args')
15174 
    if self.transactionId is not None:
15175 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15176 
      oprot.writeI64(self.transactionId)
15177 
      oprot.writeFieldEnd()
15178 
    if self.refundedBy is not None:
15179 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15180 
      oprot.writeString(self.refundedBy)
15181 
      oprot.writeFieldEnd()
15182 
    if self.reason is not None:
15183 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15184 
      oprot.writeString(self.reason)
15185 
      oprot.writeFieldEnd()
15186 
    oprot.writeFieldStop()
15187 
    oprot.writeStructEnd()
15188 
 
15189 
  def validate(self):
15190 
    return
15191 
 
15192 
 
15193 
  def __repr__(self):
15194 
    L = ['%s=%r' % (key, value)
15195 
      for key, value in self.__dict__.iteritems()]
15196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15197 
 
15198 
  def __eq__(self, other):
15199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15200 
 
15201 
  def __ne__(self, other):
15202 
    return not (self == other)
15203 
 
15204 
class refundTransaction_result:
15205 
  """
15206 
  Attributes:
15207 
   - ex
15208 
  """
15209 
 
15210 
  thrift_spec = (
15211 
    None, # 0
15212 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15213 
  )
15214 
 
15215 
  def __init__(self, ex=None,):
15216 
    self.ex = ex
15217 
 
15218 
  def read(self, iprot):
15219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15221 
      return
15222 
    iprot.readStructBegin()
15223 
    while True:
15224 
      (fname, ftype, fid) = iprot.readFieldBegin()
15225 
      if ftype == TType.STOP:
15226 
        break
15227 
      if fid == 1:
15228 
        if ftype == TType.STRUCT:
15229 
          self.ex = TransactionServiceException()
15230 
          self.ex.read(iprot)
15231 
        else:
15232 
          iprot.skip(ftype)
15233 
      else:
15234 
        iprot.skip(ftype)
15235 
      iprot.readFieldEnd()
15236 
    iprot.readStructEnd()
15237 
 
15238 
  def write(self, oprot):
15239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15241 
      return
15242 
    oprot.writeStructBegin('refundTransaction_result')
15243 
    if self.ex is not None:
15244 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15245 
      self.ex.write(oprot)
15246 
      oprot.writeFieldEnd()
15247 
    oprot.writeFieldStop()
15248 
    oprot.writeStructEnd()
15249 
 
15250 
  def validate(self):
15251 
    return
15252 
 
15253 
 
15254 
  def __repr__(self):
15255 
    L = ['%s=%r' % (key, value)
15256 
      for key, value in self.__dict__.iteritems()]
15257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15258 
 
15259 
  def __eq__(self, other):
15260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15261 
 
15262 
  def __ne__(self, other):
15263 
    return not (self == other)
4285 rajveer 15264 
 
4324 mandeep.dh 15265 
class updateShipmentAddress_args:
15266 
  """
15267 
  Attributes:
15268 
   - orderId
15269 
   - addressId
15270 
  """
15271 
 
15272 
  thrift_spec = (
15273 
    None, # 0
15274 
    (1, TType.I64, 'orderId', None, None, ), # 1
15275 
    (2, TType.I64, 'addressId', None, None, ), # 2
15276 
  )
15277 
 
15278 
  def __init__(self, orderId=None, addressId=None,):
15279 
    self.orderId = orderId
15280 
    self.addressId = addressId
15281 
 
15282 
  def read(self, iprot):
15283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15285 
      return
15286 
    iprot.readStructBegin()
15287 
    while True:
15288 
      (fname, ftype, fid) = iprot.readFieldBegin()
15289 
      if ftype == TType.STOP:
15290 
        break
15291 
      if fid == 1:
15292 
        if ftype == TType.I64:
15293 
          self.orderId = iprot.readI64();
15294 
        else:
15295 
          iprot.skip(ftype)
15296 
      elif fid == 2:
15297 
        if ftype == TType.I64:
15298 
          self.addressId = iprot.readI64();
15299 
        else:
15300 
          iprot.skip(ftype)
15301 
      else:
15302 
        iprot.skip(ftype)
15303 
      iprot.readFieldEnd()
15304 
    iprot.readStructEnd()
15305 
 
15306 
  def write(self, oprot):
15307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15309 
      return
15310 
    oprot.writeStructBegin('updateShipmentAddress_args')
15311 
    if self.orderId is not None:
15312 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15313 
      oprot.writeI64(self.orderId)
15314 
      oprot.writeFieldEnd()
15315 
    if self.addressId is not None:
15316 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
15317 
      oprot.writeI64(self.addressId)
15318 
      oprot.writeFieldEnd()
15319 
    oprot.writeFieldStop()
15320 
    oprot.writeStructEnd()
15321 
 
15322 
  def validate(self):
15323 
    return
15324 
 
15325 
 
15326 
  def __repr__(self):
15327 
    L = ['%s=%r' % (key, value)
15328 
      for key, value in self.__dict__.iteritems()]
15329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15330 
 
15331 
  def __eq__(self, other):
15332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15333 
 
15334 
  def __ne__(self, other):
15335 
    return not (self == other)
15336 
 
15337 
class updateShipmentAddress_result:
15338 
  """
15339 
  Attributes:
15340 
   - ex
15341 
  """
15342 
 
15343 
  thrift_spec = (
15344 
    None, # 0
15345 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15346 
  )
15347 
 
15348 
  def __init__(self, ex=None,):
15349 
    self.ex = ex
15350 
 
15351 
  def read(self, iprot):
15352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15354 
      return
15355 
    iprot.readStructBegin()
15356 
    while True:
15357 
      (fname, ftype, fid) = iprot.readFieldBegin()
15358 
      if ftype == TType.STOP:
15359 
        break
15360 
      if fid == 1:
15361 
        if ftype == TType.STRUCT:
15362 
          self.ex = TransactionServiceException()
15363 
          self.ex.read(iprot)
15364 
        else:
15365 
          iprot.skip(ftype)
15366 
      else:
15367 
        iprot.skip(ftype)
15368 
      iprot.readFieldEnd()
15369 
    iprot.readStructEnd()
15370 
 
15371 
  def write(self, oprot):
15372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15374 
      return
15375 
    oprot.writeStructBegin('updateShipmentAddress_result')
15376 
    if self.ex is not None:
15377 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15378 
      self.ex.write(oprot)
15379 
      oprot.writeFieldEnd()
15380 
    oprot.writeFieldStop()
15381 
    oprot.writeStructEnd()
15382 
 
15383 
  def validate(self):
15384 
    return
15385 
 
15386 
 
15387 
  def __repr__(self):
15388 
    L = ['%s=%r' % (key, value)
15389 
      for key, value in self.__dict__.iteritems()]
15390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15391 
 
15392 
  def __eq__(self, other):
15393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15394 
 
15395 
  def __ne__(self, other):
15396 
    return not (self == other)
15397 
 
4285 rajveer 15398 
class acceptOrdersForItemId_args:
15399 
  """
15400 
  Attributes:
15401 
   - itemId
15402 
   - inventory
15403 
  """
15404 
 
15405 
  thrift_spec = (
15406 
    None, # 0
15407 
    (1, TType.I64, 'itemId', None, None, ), # 1
15408 
    (2, TType.I64, 'inventory', None, None, ), # 2
15409 
  )
15410 
 
15411 
  def __init__(self, itemId=None, inventory=None,):
15412 
    self.itemId = itemId
15413 
    self.inventory = inventory
15414 
 
15415 
  def read(self, iprot):
15416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15418 
      return
15419 
    iprot.readStructBegin()
15420 
    while True:
15421 
      (fname, ftype, fid) = iprot.readFieldBegin()
15422 
      if ftype == TType.STOP:
15423 
        break
15424 
      if fid == 1:
15425 
        if ftype == TType.I64:
15426 
          self.itemId = iprot.readI64();
15427 
        else:
15428 
          iprot.skip(ftype)
15429 
      elif fid == 2:
15430 
        if ftype == TType.I64:
15431 
          self.inventory = iprot.readI64();
15432 
        else:
15433 
          iprot.skip(ftype)
15434 
      else:
15435 
        iprot.skip(ftype)
15436 
      iprot.readFieldEnd()
15437 
    iprot.readStructEnd()
15438 
 
15439 
  def write(self, oprot):
15440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15442 
      return
15443 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
15444 
    if self.itemId is not None:
15445 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15446 
      oprot.writeI64(self.itemId)
15447 
      oprot.writeFieldEnd()
15448 
    if self.inventory is not None:
15449 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
15450 
      oprot.writeI64(self.inventory)
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 acceptOrdersForItemId_result:
15471 
  """
15472 
  Attributes:
15473 
   - success
15474 
   - ex
15475 
  """
15476 
 
15477 
  thrift_spec = (
15478 
    (0, TType.BOOL, 'success', None, None, ), # 0
15479 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15480 
  )
15481 
 
15482 
  def __init__(self, success=None, ex=None,):
15483 
    self.success = success
15484 
    self.ex = ex
15485 
 
15486 
  def read(self, iprot):
15487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15489 
      return
15490 
    iprot.readStructBegin()
15491 
    while True:
15492 
      (fname, ftype, fid) = iprot.readFieldBegin()
15493 
      if ftype == TType.STOP:
15494 
        break
15495 
      if fid == 0:
15496 
        if ftype == TType.BOOL:
15497 
          self.success = iprot.readBool();
15498 
        else:
15499 
          iprot.skip(ftype)
15500 
      elif fid == 1:
15501 
        if ftype == TType.STRUCT:
15502 
          self.ex = TransactionServiceException()
15503 
          self.ex.read(iprot)
15504 
        else:
15505 
          iprot.skip(ftype)
15506 
      else:
15507 
        iprot.skip(ftype)
15508 
      iprot.readFieldEnd()
15509 
    iprot.readStructEnd()
15510 
 
15511 
  def write(self, oprot):
15512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15514 
      return
15515 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
15516 
    if self.success is not None:
15517 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15518 
      oprot.writeBool(self.success)
15519 
      oprot.writeFieldEnd()
15520 
    if self.ex is not None:
15521 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15522 
      self.ex.write(oprot)
15523 
      oprot.writeFieldEnd()
15524 
    oprot.writeFieldStop()
15525 
    oprot.writeStructEnd()
15526 
 
15527 
  def validate(self):
15528 
    return
15529 
 
15530 
 
15531 
  def __repr__(self):
15532 
    L = ['%s=%r' % (key, value)
15533 
      for key, value in self.__dict__.iteritems()]
15534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15535 
 
15536 
  def __eq__(self, other):
15537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15538 
 
15539 
  def __ne__(self, other):
15540 
    return not (self == other)
4303 rajveer 15541 
 
15542 
class markOrdersAsPORaised_args:
15543 
  """
15544 
  Attributes:
15545 
   - vendorId
15546 
   - itemId
15547 
   - quantity
15548 
   - estimate
4369 rajveer 15549 
   - isReminder
4303 rajveer 15550 
  """
15551 
 
15552 
  thrift_spec = (
15553 
    None, # 0
15554 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15555 
    (2, TType.I64, 'itemId', None, None, ), # 2
15556 
    (3, TType.I64, 'quantity', None, None, ), # 3
15557 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15558 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15559 
  )
15560 
 
4369 rajveer 15561 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15562 
    self.vendorId = vendorId
15563 
    self.itemId = itemId
15564 
    self.quantity = quantity
15565 
    self.estimate = estimate
4369 rajveer 15566 
    self.isReminder = isReminder
4303 rajveer 15567 
 
15568 
  def read(self, iprot):
15569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15571 
      return
15572 
    iprot.readStructBegin()
15573 
    while True:
15574 
      (fname, ftype, fid) = iprot.readFieldBegin()
15575 
      if ftype == TType.STOP:
15576 
        break
15577 
      if fid == 1:
15578 
        if ftype == TType.I64:
15579 
          self.vendorId = iprot.readI64();
15580 
        else:
15581 
          iprot.skip(ftype)
15582 
      elif fid == 2:
15583 
        if ftype == TType.I64:
15584 
          self.itemId = iprot.readI64();
15585 
        else:
15586 
          iprot.skip(ftype)
15587 
      elif fid == 3:
15588 
        if ftype == TType.I64:
15589 
          self.quantity = iprot.readI64();
15590 
        else:
15591 
          iprot.skip(ftype)
15592 
      elif fid == 4:
15593 
        if ftype == TType.I64:
15594 
          self.estimate = iprot.readI64();
15595 
        else:
15596 
          iprot.skip(ftype)
4369 rajveer 15597 
      elif fid == 5:
15598 
        if ftype == TType.BOOL:
15599 
          self.isReminder = iprot.readBool();
15600 
        else:
15601 
          iprot.skip(ftype)
4303 rajveer 15602 
      else:
15603 
        iprot.skip(ftype)
15604 
      iprot.readFieldEnd()
15605 
    iprot.readStructEnd()
15606 
 
15607 
  def write(self, oprot):
15608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15610 
      return
15611 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
15612 
    if self.vendorId is not None:
15613 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15614 
      oprot.writeI64(self.vendorId)
15615 
      oprot.writeFieldEnd()
15616 
    if self.itemId is not None:
15617 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15618 
      oprot.writeI64(self.itemId)
15619 
      oprot.writeFieldEnd()
15620 
    if self.quantity is not None:
15621 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15622 
      oprot.writeI64(self.quantity)
15623 
      oprot.writeFieldEnd()
15624 
    if self.estimate is not None:
15625 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15626 
      oprot.writeI64(self.estimate)
15627 
      oprot.writeFieldEnd()
4369 rajveer 15628 
    if self.isReminder is not None:
15629 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15630 
      oprot.writeBool(self.isReminder)
15631 
      oprot.writeFieldEnd()
4303 rajveer 15632 
    oprot.writeFieldStop()
15633 
    oprot.writeStructEnd()
15634 
 
15635 
  def validate(self):
15636 
    return
15637 
 
15638 
 
15639 
  def __repr__(self):
15640 
    L = ['%s=%r' % (key, value)
15641 
      for key, value in self.__dict__.iteritems()]
15642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15643 
 
15644 
  def __eq__(self, other):
15645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15646 
 
15647 
  def __ne__(self, other):
15648 
    return not (self == other)
15649 
 
15650 
class markOrdersAsPORaised_result:
15651 
  """
15652 
  Attributes:
15653 
   - ex
15654 
  """
15655 
 
15656 
  thrift_spec = (
15657 
    None, # 0
15658 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15659 
  )
15660 
 
15661 
  def __init__(self, ex=None,):
15662 
    self.ex = ex
15663 
 
15664 
  def read(self, iprot):
15665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15667 
      return
15668 
    iprot.readStructBegin()
15669 
    while True:
15670 
      (fname, ftype, fid) = iprot.readFieldBegin()
15671 
      if ftype == TType.STOP:
15672 
        break
15673 
      if fid == 1:
15674 
        if ftype == TType.STRUCT:
15675 
          self.ex = TransactionServiceException()
15676 
          self.ex.read(iprot)
15677 
        else:
15678 
          iprot.skip(ftype)
15679 
      else:
15680 
        iprot.skip(ftype)
15681 
      iprot.readFieldEnd()
15682 
    iprot.readStructEnd()
15683 
 
15684 
  def write(self, oprot):
15685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15687 
      return
15688 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
15689 
    if self.ex is not None:
15690 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15691 
      self.ex.write(oprot)
15692 
      oprot.writeFieldEnd()
15693 
    oprot.writeFieldStop()
15694 
    oprot.writeStructEnd()
15695 
 
15696 
  def validate(self):
15697 
    return
15698 
 
15699 
 
15700 
  def __repr__(self):
15701 
    L = ['%s=%r' % (key, value)
15702 
      for key, value in self.__dict__.iteritems()]
15703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15704 
 
15705 
  def __eq__(self, other):
15706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15707 
 
15708 
  def __ne__(self, other):
15709 
    return not (self == other)
15710 
 
15711 
class markOrdersAsReversalInitiated_args:
15712 
  """
15713 
  Attributes:
15714 
   - vendorId
15715 
   - itemId
15716 
   - quantity
15717 
   - estimate
4369 rajveer 15718 
   - isReminder
4303 rajveer 15719 
  """
15720 
 
15721 
  thrift_spec = (
15722 
    None, # 0
15723 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15724 
    (2, TType.I64, 'itemId', None, None, ), # 2
15725 
    (3, TType.I64, 'quantity', None, None, ), # 3
15726 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15727 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15728 
  )
15729 
 
4369 rajveer 15730 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15731 
    self.vendorId = vendorId
15732 
    self.itemId = itemId
15733 
    self.quantity = quantity
15734 
    self.estimate = estimate
4369 rajveer 15735 
    self.isReminder = isReminder
4303 rajveer 15736 
 
15737 
  def read(self, iprot):
15738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15740 
      return
15741 
    iprot.readStructBegin()
15742 
    while True:
15743 
      (fname, ftype, fid) = iprot.readFieldBegin()
15744 
      if ftype == TType.STOP:
15745 
        break
15746 
      if fid == 1:
15747 
        if ftype == TType.I64:
15748 
          self.vendorId = iprot.readI64();
15749 
        else:
15750 
          iprot.skip(ftype)
15751 
      elif fid == 2:
15752 
        if ftype == TType.I64:
15753 
          self.itemId = iprot.readI64();
15754 
        else:
15755 
          iprot.skip(ftype)
15756 
      elif fid == 3:
15757 
        if ftype == TType.I64:
15758 
          self.quantity = iprot.readI64();
15759 
        else:
15760 
          iprot.skip(ftype)
15761 
      elif fid == 4:
15762 
        if ftype == TType.I64:
15763 
          self.estimate = iprot.readI64();
15764 
        else:
15765 
          iprot.skip(ftype)
4369 rajveer 15766 
      elif fid == 5:
15767 
        if ftype == TType.BOOL:
15768 
          self.isReminder = iprot.readBool();
15769 
        else:
15770 
          iprot.skip(ftype)
4303 rajveer 15771 
      else:
15772 
        iprot.skip(ftype)
15773 
      iprot.readFieldEnd()
15774 
    iprot.readStructEnd()
15775 
 
15776 
  def write(self, oprot):
15777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15779 
      return
15780 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
15781 
    if self.vendorId is not None:
15782 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15783 
      oprot.writeI64(self.vendorId)
15784 
      oprot.writeFieldEnd()
15785 
    if self.itemId is not None:
15786 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15787 
      oprot.writeI64(self.itemId)
15788 
      oprot.writeFieldEnd()
15789 
    if self.quantity is not None:
15790 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15791 
      oprot.writeI64(self.quantity)
15792 
      oprot.writeFieldEnd()
15793 
    if self.estimate is not None:
15794 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15795 
      oprot.writeI64(self.estimate)
15796 
      oprot.writeFieldEnd()
4369 rajveer 15797 
    if self.isReminder is not None:
15798 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15799 
      oprot.writeBool(self.isReminder)
15800 
      oprot.writeFieldEnd()
4303 rajveer 15801 
    oprot.writeFieldStop()
15802 
    oprot.writeStructEnd()
15803 
 
15804 
  def validate(self):
15805 
    return
15806 
 
15807 
 
15808 
  def __repr__(self):
15809 
    L = ['%s=%r' % (key, value)
15810 
      for key, value in self.__dict__.iteritems()]
15811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15812 
 
15813 
  def __eq__(self, other):
15814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15815 
 
15816 
  def __ne__(self, other):
15817 
    return not (self == other)
15818 
 
15819 
class markOrdersAsReversalInitiated_result:
15820 
  """
15821 
  Attributes:
15822 
   - ex
15823 
  """
15824 
 
15825 
  thrift_spec = (
15826 
    None, # 0
15827 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15828 
  )
15829 
 
15830 
  def __init__(self, ex=None,):
15831 
    self.ex = ex
15832 
 
15833 
  def read(self, iprot):
15834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15836 
      return
15837 
    iprot.readStructBegin()
15838 
    while True:
15839 
      (fname, ftype, fid) = iprot.readFieldBegin()
15840 
      if ftype == TType.STOP:
15841 
        break
15842 
      if fid == 1:
15843 
        if ftype == TType.STRUCT:
15844 
          self.ex = TransactionServiceException()
15845 
          self.ex.read(iprot)
15846 
        else:
15847 
          iprot.skip(ftype)
15848 
      else:
15849 
        iprot.skip(ftype)
15850 
      iprot.readFieldEnd()
15851 
    iprot.readStructEnd()
15852 
 
15853 
  def write(self, oprot):
15854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15856 
      return
15857 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
15858 
    if self.ex is not None:
15859 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15860 
      self.ex.write(oprot)
15861 
      oprot.writeFieldEnd()
15862 
    oprot.writeFieldStop()
15863 
    oprot.writeStructEnd()
15864 
 
15865 
  def validate(self):
15866 
    return
15867 
 
15868 
 
15869 
  def __repr__(self):
15870 
    L = ['%s=%r' % (key, value)
15871 
      for key, value in self.__dict__.iteritems()]
15872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15873 
 
15874 
  def __eq__(self, other):
15875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15876 
 
15877 
  def __ne__(self, other):
15878 
    return not (self == other)
15879 
 
15880 
class markOrdersAsNotAvailabke_args:
15881 
  """
15882 
  Attributes:
15883 
   - vendorId
15884 
   - itemId
15885 
   - quantity
15886 
   - estimate
4369 rajveer 15887 
   - isReminder
4303 rajveer 15888 
  """
15889 
 
15890 
  thrift_spec = (
15891 
    None, # 0
15892 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15893 
    (2, TType.I64, 'itemId', None, None, ), # 2
15894 
    (3, TType.I64, 'quantity', None, None, ), # 3
15895 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15896 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15897 
  )
15898 
 
4369 rajveer 15899 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15900 
    self.vendorId = vendorId
15901 
    self.itemId = itemId
15902 
    self.quantity = quantity
15903 
    self.estimate = estimate
4369 rajveer 15904 
    self.isReminder = isReminder
4303 rajveer 15905 
 
15906 
  def read(self, iprot):
15907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15909 
      return
15910 
    iprot.readStructBegin()
15911 
    while True:
15912 
      (fname, ftype, fid) = iprot.readFieldBegin()
15913 
      if ftype == TType.STOP:
15914 
        break
15915 
      if fid == 1:
15916 
        if ftype == TType.I64:
15917 
          self.vendorId = iprot.readI64();
15918 
        else:
15919 
          iprot.skip(ftype)
15920 
      elif fid == 2:
15921 
        if ftype == TType.I64:
15922 
          self.itemId = iprot.readI64();
15923 
        else:
15924 
          iprot.skip(ftype)
15925 
      elif fid == 3:
15926 
        if ftype == TType.I64:
15927 
          self.quantity = iprot.readI64();
15928 
        else:
15929 
          iprot.skip(ftype)
15930 
      elif fid == 4:
15931 
        if ftype == TType.I64:
15932 
          self.estimate = iprot.readI64();
15933 
        else:
15934 
          iprot.skip(ftype)
4369 rajveer 15935 
      elif fid == 5:
15936 
        if ftype == TType.BOOL:
15937 
          self.isReminder = iprot.readBool();
15938 
        else:
15939 
          iprot.skip(ftype)
4303 rajveer 15940 
      else:
15941 
        iprot.skip(ftype)
15942 
      iprot.readFieldEnd()
15943 
    iprot.readStructEnd()
15944 
 
15945 
  def write(self, oprot):
15946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15948 
      return
15949 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
15950 
    if self.vendorId is not None:
15951 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15952 
      oprot.writeI64(self.vendorId)
15953 
      oprot.writeFieldEnd()
15954 
    if self.itemId is not None:
15955 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15956 
      oprot.writeI64(self.itemId)
15957 
      oprot.writeFieldEnd()
15958 
    if self.quantity is not None:
15959 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15960 
      oprot.writeI64(self.quantity)
15961 
      oprot.writeFieldEnd()
15962 
    if self.estimate is not None:
15963 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15964 
      oprot.writeI64(self.estimate)
15965 
      oprot.writeFieldEnd()
4369 rajveer 15966 
    if self.isReminder is not None:
15967 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15968 
      oprot.writeBool(self.isReminder)
15969 
      oprot.writeFieldEnd()
4303 rajveer 15970 
    oprot.writeFieldStop()
15971 
    oprot.writeStructEnd()
15972 
 
15973 
  def validate(self):
15974 
    return
15975 
 
15976 
 
15977 
  def __repr__(self):
15978 
    L = ['%s=%r' % (key, value)
15979 
      for key, value in self.__dict__.iteritems()]
15980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15981 
 
15982 
  def __eq__(self, other):
15983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15984 
 
15985 
  def __ne__(self, other):
15986 
    return not (self == other)
15987 
 
15988 
class markOrdersAsNotAvailabke_result:
15989 
  """
15990 
  Attributes:
15991 
   - ex
15992 
  """
15993 
 
15994 
  thrift_spec = (
15995 
    None, # 0
15996 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15997 
  )
15998 
 
15999 
  def __init__(self, ex=None,):
16000 
    self.ex = ex
16001 
 
16002 
  def read(self, iprot):
16003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16005 
      return
16006 
    iprot.readStructBegin()
16007 
    while True:
16008 
      (fname, ftype, fid) = iprot.readFieldBegin()
16009 
      if ftype == TType.STOP:
16010 
        break
16011 
      if fid == 1:
16012 
        if ftype == TType.STRUCT:
16013 
          self.ex = TransactionServiceException()
16014 
          self.ex.read(iprot)
16015 
        else:
16016 
          iprot.skip(ftype)
16017 
      else:
16018 
        iprot.skip(ftype)
16019 
      iprot.readFieldEnd()
16020 
    iprot.readStructEnd()
16021 
 
16022 
  def write(self, oprot):
16023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16025 
      return
16026 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
16027 
    if self.ex is not None:
16028 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16029 
      self.ex.write(oprot)
16030 
      oprot.writeFieldEnd()
16031 
    oprot.writeFieldStop()
16032 
    oprot.writeStructEnd()
16033 
 
16034 
  def validate(self):
16035 
    return
16036 
 
16037 
 
16038 
  def __repr__(self):
16039 
    L = ['%s=%r' % (key, value)
16040 
      for key, value in self.__dict__.iteritems()]
16041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16042 
 
16043 
  def __eq__(self, other):
16044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16045 
 
16046 
  def __ne__(self, other):
16047 
    return not (self == other)
4369 rajveer 16048 
 
16049 
class markOrdersAsTimeout_args:
16050 
  """
16051 
  Attributes:
16052 
   - vendorId
16053 
  """
16054 
 
16055 
  thrift_spec = (
16056 
    None, # 0
16057 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16058 
  )
16059 
 
16060 
  def __init__(self, vendorId=None,):
16061 
    self.vendorId = vendorId
16062 
 
16063 
  def read(self, iprot):
16064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16066 
      return
16067 
    iprot.readStructBegin()
16068 
    while True:
16069 
      (fname, ftype, fid) = iprot.readFieldBegin()
16070 
      if ftype == TType.STOP:
16071 
        break
16072 
      if fid == 1:
16073 
        if ftype == TType.I64:
16074 
          self.vendorId = iprot.readI64();
16075 
        else:
16076 
          iprot.skip(ftype)
16077 
      else:
16078 
        iprot.skip(ftype)
16079 
      iprot.readFieldEnd()
16080 
    iprot.readStructEnd()
16081 
 
16082 
  def write(self, oprot):
16083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16085 
      return
16086 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
16087 
    if self.vendorId is not None:
16088 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16089 
      oprot.writeI64(self.vendorId)
16090 
      oprot.writeFieldEnd()
16091 
    oprot.writeFieldStop()
16092 
    oprot.writeStructEnd()
16093 
 
16094 
  def validate(self):
16095 
    return
16096 
 
16097 
 
16098 
  def __repr__(self):
16099 
    L = ['%s=%r' % (key, value)
16100 
      for key, value in self.__dict__.iteritems()]
16101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16102 
 
16103 
  def __eq__(self, other):
16104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16105 
 
16106 
  def __ne__(self, other):
16107 
    return not (self == other)
16108 
 
16109 
class markOrdersAsTimeout_result:
16110 
  """
16111 
  Attributes:
16112 
   - success
16113 
   - ex
16114 
  """
16115 
 
16116 
  thrift_spec = (
16117 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
16118 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16119 
  )
16120 
 
16121 
  def __init__(self, success=None, ex=None,):
16122 
    self.success = success
16123 
    self.ex = ex
16124 
 
16125 
  def read(self, iprot):
16126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16128 
      return
16129 
    iprot.readStructBegin()
16130 
    while True:
16131 
      (fname, ftype, fid) = iprot.readFieldBegin()
16132 
      if ftype == TType.STOP:
16133 
        break
16134 
      if fid == 0:
16135 
        if ftype == TType.MAP:
16136 
          self.success = {}
4586 mandeep.dh 16137 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
16138 
          for _i279 in xrange(_size275):
16139 
            _key280 = iprot.readI32();
16140 
            _val281 = TimeoutSummary()
16141 
            _val281.read(iprot)
16142 
            self.success[_key280] = _val281
4369 rajveer 16143 
          iprot.readMapEnd()
16144 
        else:
16145 
          iprot.skip(ftype)
16146 
      elif fid == 1:
16147 
        if ftype == TType.STRUCT:
16148 
          self.ex = TransactionServiceException()
16149 
          self.ex.read(iprot)
16150 
        else:
16151 
          iprot.skip(ftype)
16152 
      else:
16153 
        iprot.skip(ftype)
16154 
      iprot.readFieldEnd()
16155 
    iprot.readStructEnd()
16156 
 
16157 
  def write(self, oprot):
16158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16160 
      return
16161 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
16162 
    if self.success is not None:
16163 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16164 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4586 mandeep.dh 16165 
      for kiter282,viter283 in self.success.items():
16166 
        oprot.writeI32(kiter282)
16167 
        viter283.write(oprot)
4369 rajveer 16168 
      oprot.writeMapEnd()
16169 
      oprot.writeFieldEnd()
16170 
    if self.ex is not None:
16171 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16172 
      self.ex.write(oprot)
16173 
      oprot.writeFieldEnd()
16174 
    oprot.writeFieldStop()
16175 
    oprot.writeStructEnd()
16176 
 
16177 
  def validate(self):
16178 
    return
16179 
 
16180 
 
16181 
  def __repr__(self):
16182 
    L = ['%s=%r' % (key, value)
16183 
      for key, value in self.__dict__.iteritems()]
16184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16185 
 
16186 
  def __eq__(self, other):
16187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16188 
 
16189 
  def __ne__(self, other):
16190 
    return not (self == other)
4386 anupam.sin 16191 
 
16192 
class getOrderForAwb_args:
16193 
  """
16194 
  Attributes:
16195 
   - awb
16196 
  """
16197 
 
16198 
  thrift_spec = (
16199 
    None, # 0
16200 
    (1, TType.STRING, 'awb', None, None, ), # 1
16201 
  )
16202 
 
16203 
  def __init__(self, awb=None,):
16204 
    self.awb = awb
16205 
 
16206 
  def read(self, iprot):
16207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16209 
      return
16210 
    iprot.readStructBegin()
16211 
    while True:
16212 
      (fname, ftype, fid) = iprot.readFieldBegin()
16213 
      if ftype == TType.STOP:
16214 
        break
16215 
      if fid == 1:
16216 
        if ftype == TType.STRING:
16217 
          self.awb = iprot.readString();
16218 
        else:
16219 
          iprot.skip(ftype)
16220 
      else:
16221 
        iprot.skip(ftype)
16222 
      iprot.readFieldEnd()
16223 
    iprot.readStructEnd()
16224 
 
16225 
  def write(self, oprot):
16226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16228 
      return
16229 
    oprot.writeStructBegin('getOrderForAwb_args')
16230 
    if self.awb is not None:
16231 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
16232 
      oprot.writeString(self.awb)
16233 
      oprot.writeFieldEnd()
16234 
    oprot.writeFieldStop()
16235 
    oprot.writeStructEnd()
16236 
 
16237 
  def validate(self):
16238 
    return
16239 
 
16240 
 
16241 
  def __repr__(self):
16242 
    L = ['%s=%r' % (key, value)
16243 
      for key, value in self.__dict__.iteritems()]
16244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16245 
 
16246 
  def __eq__(self, other):
16247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16248 
 
16249 
  def __ne__(self, other):
16250 
    return not (self == other)
16251 
 
16252 
class getOrderForAwb_result:
16253 
  """
16254 
  Attributes:
16255 
   - success
16256 
   - ex
16257 
  """
16258 
 
16259 
  thrift_spec = (
16260 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16261 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16262 
  )
16263 
 
16264 
  def __init__(self, success=None, ex=None,):
16265 
    self.success = success
16266 
    self.ex = ex
16267 
 
16268 
  def read(self, iprot):
16269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16271 
      return
16272 
    iprot.readStructBegin()
16273 
    while True:
16274 
      (fname, ftype, fid) = iprot.readFieldBegin()
16275 
      if ftype == TType.STOP:
16276 
        break
16277 
      if fid == 0:
16278 
        if ftype == TType.STRUCT:
16279 
          self.success = Order()
16280 
          self.success.read(iprot)
16281 
        else:
16282 
          iprot.skip(ftype)
16283 
      elif fid == 1:
16284 
        if ftype == TType.STRUCT:
16285 
          self.ex = TransactionServiceException()
16286 
          self.ex.read(iprot)
16287 
        else:
16288 
          iprot.skip(ftype)
16289 
      else:
16290 
        iprot.skip(ftype)
16291 
      iprot.readFieldEnd()
16292 
    iprot.readStructEnd()
16293 
 
16294 
  def write(self, oprot):
16295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16297 
      return
16298 
    oprot.writeStructBegin('getOrderForAwb_result')
16299 
    if self.success is not None:
16300 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16301 
      self.success.write(oprot)
16302 
      oprot.writeFieldEnd()
16303 
    if self.ex is not None:
16304 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16305 
      self.ex.write(oprot)
16306 
      oprot.writeFieldEnd()
16307 
    oprot.writeFieldStop()
16308 
    oprot.writeStructEnd()
16309 
 
16310 
  def validate(self):
16311 
    return
16312 
 
16313 
 
16314 
  def __repr__(self):
16315 
    L = ['%s=%r' % (key, value)
16316 
      for key, value in self.__dict__.iteritems()]
16317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16318 
 
16319 
  def __eq__(self, other):
16320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16321 
 
16322 
  def __ne__(self, other):
16323 
    return not (self == other)
4506 phani.kuma 16324 
 
16325 
class getOrdersForProviderForStatus_args:
16326 
  """
16327 
  Attributes:
16328 
   - logistics_provider_id
16329 
   - order_status
16330 
  """
16331 
 
16332 
  thrift_spec = (
16333 
    None, # 0
16334 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
16335 
    (2, TType.I32, 'order_status', None, None, ), # 2
16336 
  )
16337 
 
16338 
  def __init__(self, logistics_provider_id=None, order_status=None,):
16339 
    self.logistics_provider_id = logistics_provider_id
16340 
    self.order_status = order_status
16341 
 
16342 
  def read(self, iprot):
16343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16345 
      return
16346 
    iprot.readStructBegin()
16347 
    while True:
16348 
      (fname, ftype, fid) = iprot.readFieldBegin()
16349 
      if ftype == TType.STOP:
16350 
        break
16351 
      if fid == 1:
16352 
        if ftype == TType.I64:
16353 
          self.logistics_provider_id = iprot.readI64();
16354 
        else:
16355 
          iprot.skip(ftype)
16356 
      elif fid == 2:
16357 
        if ftype == TType.I32:
16358 
          self.order_status = iprot.readI32();
16359 
        else:
16360 
          iprot.skip(ftype)
16361 
      else:
16362 
        iprot.skip(ftype)
16363 
      iprot.readFieldEnd()
16364 
    iprot.readStructEnd()
16365 
 
16366 
  def write(self, oprot):
16367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16369 
      return
16370 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
16371 
    if self.logistics_provider_id is not None:
16372 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
16373 
      oprot.writeI64(self.logistics_provider_id)
16374 
      oprot.writeFieldEnd()
16375 
    if self.order_status is not None:
16376 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
16377 
      oprot.writeI32(self.order_status)
16378 
      oprot.writeFieldEnd()
16379 
    oprot.writeFieldStop()
16380 
    oprot.writeStructEnd()
16381 
 
16382 
  def validate(self):
16383 
    return
16384 
 
16385 
 
16386 
  def __repr__(self):
16387 
    L = ['%s=%r' % (key, value)
16388 
      for key, value in self.__dict__.iteritems()]
16389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16390 
 
16391 
  def __eq__(self, other):
16392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16393 
 
16394 
  def __ne__(self, other):
16395 
    return not (self == other)
16396 
 
16397 
class getOrdersForProviderForStatus_result:
16398 
  """
16399 
  Attributes:
16400 
   - success
16401 
   - ex
16402 
  """
16403 
 
16404 
  thrift_spec = (
16405 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16406 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16407 
  )
16408 
 
16409 
  def __init__(self, success=None, ex=None,):
16410 
    self.success = success
16411 
    self.ex = ex
16412 
 
16413 
  def read(self, iprot):
16414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16416 
      return
16417 
    iprot.readStructBegin()
16418 
    while True:
16419 
      (fname, ftype, fid) = iprot.readFieldBegin()
16420 
      if ftype == TType.STOP:
16421 
        break
16422 
      if fid == 0:
16423 
        if ftype == TType.LIST:
16424 
          self.success = []
4586 mandeep.dh 16425 
          (_etype287, _size284) = iprot.readListBegin()
16426 
          for _i288 in xrange(_size284):
16427 
            _elem289 = Order()
16428 
            _elem289.read(iprot)
16429 
            self.success.append(_elem289)
4506 phani.kuma 16430 
          iprot.readListEnd()
16431 
        else:
16432 
          iprot.skip(ftype)
16433 
      elif fid == 1:
16434 
        if ftype == TType.STRUCT:
16435 
          self.ex = TransactionServiceException()
16436 
          self.ex.read(iprot)
16437 
        else:
16438 
          iprot.skip(ftype)
16439 
      else:
16440 
        iprot.skip(ftype)
16441 
      iprot.readFieldEnd()
16442 
    iprot.readStructEnd()
16443 
 
16444 
  def write(self, oprot):
16445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16447 
      return
16448 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
16449 
    if self.success is not None:
16450 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16451 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 16452 
      for iter290 in self.success:
16453 
        iter290.write(oprot)
4506 phani.kuma 16454 
      oprot.writeListEnd()
16455 
      oprot.writeFieldEnd()
16456 
    if self.ex is not None:
16457 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16458 
      self.ex.write(oprot)
16459 
      oprot.writeFieldEnd()
16460 
    oprot.writeFieldStop()
16461 
    oprot.writeStructEnd()
16462 
 
16463 
  def validate(self):
16464 
    return
16465 
 
16466 
 
16467 
  def __repr__(self):
16468 
    L = ['%s=%r' % (key, value)
16469 
      for key, value in self.__dict__.iteritems()]
16470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16471 
 
16472 
  def __eq__(self, other):
16473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16474 
 
16475 
  def __ne__(self, other):
16476 
    return not (self == other)