Subversion Repositories SmartDukaan

Rev

Rev 4579 | Rev 4586 | 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 
    """
639 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 640 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 641 
 
2819 chandransh 642 
    Parameters:
643 
     - warehouseId
644 
    """
645 
    pass
2690 chandransh 646 
 
3451 chandransh 647 
  def updateWeight(self, orderId, weight):
648 
    """
649 
    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 650 
 
3451 chandransh 651 
    Parameters:
652 
     - orderId
653 
     - weight
654 
    """
655 
    pass
656 
 
3469 chandransh 657 
  def changeItem(self, orderId, itemId):
658 
    """
659 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
660 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 661 
 
3469 chandransh 662 
    Parameters:
663 
     - orderId
664 
     - itemId
665 
    """
666 
    pass
667 
 
668 
  def shiftToWarehouse(self, orderId, warehouseId):
669 
    """
670 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
671 
 
672 
    Parameters:
673 
     - orderId
674 
     - warehouseId
675 
    """
676 
    pass
677 
 
3986 chandransh 678 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 679 
    """
680 
    Adds the given delay reason to the given order.
3986 chandransh 681 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 682 
    Raises an exception if no order with the given id can be found.
3469 chandransh 683 
 
3553 chandransh 684 
    Parameters:
685 
     - orderId
686 
     - delayReason
3986 chandransh 687 
     - furtherDelay
3553 chandransh 688 
    """
689 
    pass
690 
 
3956 chandransh 691 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
692 
    """
693 
    Marks the COD orders with given AWB nos. as having been processed.
694 
    Updates the captured amount for the corresponding payment.
3553 chandransh 695 
 
3956 chandransh 696 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
697 
    1. There is no order corresponding to an AWB number.
698 
    2. The captured amount for a payment exceeds the total payment.
699 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
700 
 
701 
    Parameters:
702 
     - collectedAmountMap
703 
     - xferBy
704 
     - xferTxnId
705 
     - xferDate
706 
    """
707 
    pass
708 
 
4008 mandeep.dh 709 
  def getTransactionsRequiringExtraProcessing(self, category):
710 
    """
4065 mandeep.dh 711 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 712 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 713 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 714 
 
4008 mandeep.dh 715 
    Parameters:
716 
     - category
717 
    """
718 
    pass
719 
 
720 
  def markTransactionAsProcessed(self, transactionId, category):
721 
    """
722 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 723 
    It essentially deletes the transaction id record for a particular
724 
    processing type category (if present) from DB.
725 
    This is currently used by CRM application.
4008 mandeep.dh 726 
 
727 
    Parameters:
728 
     - transactionId
729 
     - category
730 
    """
731 
    pass
732 
 
4018 chandransh 733 
  def getItemWiseRiskyOrdersCount(self, ):
734 
    """
735 
    Returns a map containing the number of risky orders keyed by item id. A risky order
736 
    is defined as one whose shipping date is about to expire.
737 
    """
738 
    pass
4008 mandeep.dh 739 
 
4295 varun.gupt 740 
  def getOrdersForItemIds(self, itemIds):
741 
    """
742 
    Returns a list of all orders which have items with given id
743 
 
744 
    Parameters:
745 
     - itemIds
746 
    """
747 
    pass
748 
 
4247 rajveer 749 
  def markOrderCancellationRequestReceived(self, orderId):
750 
    """
751 
    Mark order as cancellation request received. If customer sends request of cancellation of
752 
    a particular order, this method will be called. It will just change status of the order
753 
    depending on its current status. It also records the previous status, so that we can move
754 
    back to that status if cancellation request is denied.
4018 chandransh 755 
 
4247 rajveer 756 
    Parameters:
757 
     - orderId
758 
    """
759 
    pass
760 
 
761 
  def markOrderCancellationRequestConfirmed(self, orderId):
762 
    """
763 
    If we decide to to cancel order, CRM will call this method to move the status of order to
764 
    cancellation request confirmed. After this OM will be able to cancel the order.
765 
 
766 
    Parameters:
767 
     - orderId
768 
    """
769 
    pass
770 
 
771 
  def markOrderCancellationRequestDenied(self, orderId):
772 
    """
773 
    If we decide to not to cancel order, we will move the order ro previous status.
774 
 
775 
    Parameters:
776 
     - orderId
777 
    """
778 
    pass
779 
 
4258 rajveer 780 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 781 
    """
4258 rajveer 782 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
783 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 784 
 
785 
    Parameters:
4258 rajveer 786 
     - transactionId
4247 rajveer 787 
    """
788 
    pass
789 
 
4259 anupam.sin 790 
  def refundTransaction(self, transactionId, refundedBy, reason):
791 
    """
792 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
793 
    need to be cancelled
4247 rajveer 794 
 
4259 anupam.sin 795 
    Parameters:
796 
     - transactionId
797 
     - refundedBy
798 
     - reason
799 
    """
800 
    pass
801 
 
4324 mandeep.dh 802 
  def updateShipmentAddress(self, orderId, addressId):
803 
    """
804 
    Updates shipment address of an order. Delivery and shipping date estimates
805 
    etc. are also updated here.
806 
 
807 
    Throws TransactionServiceException in case address change is not
808 
    possible due to certain reasons such as new pincode in address is
809 
    not serviceable etc.
810 
 
811 
    Parameters:
812 
     - orderId
813 
     - addressId
814 
    """
815 
    pass
816 
 
4285 rajveer 817 
  def acceptOrdersForItemId(self, itemId, inventory):
818 
    """
819 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
820 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 821 
 
4285 rajveer 822 
    Parameters:
823 
     - itemId
824 
     - inventory
825 
    """
826 
    pass
827 
 
4369 rajveer 828 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 829 
    """
830 
    Parameters:
831 
     - vendorId
832 
     - itemId
833 
     - quantity
834 
     - estimate
4369 rajveer 835 
     - isReminder
4303 rajveer 836 
    """
837 
    pass
4285 rajveer 838 
 
4369 rajveer 839 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 840 
    """
841 
    Parameters:
842 
     - vendorId
843 
     - itemId
844 
     - quantity
845 
     - estimate
4369 rajveer 846 
     - isReminder
4303 rajveer 847 
    """
848 
    pass
849 
 
4369 rajveer 850 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 851 
    """
852 
    Parameters:
853 
     - vendorId
854 
     - itemId
855 
     - quantity
856 
     - estimate
4369 rajveer 857 
     - isReminder
4303 rajveer 858 
    """
859 
    pass
860 
 
4369 rajveer 861 
  def markOrdersAsTimeout(self, vendorId):
862 
    """
863 
    Parameters:
864 
     - vendorId
865 
    """
866 
    pass
4303 rajveer 867 
 
4386 anupam.sin 868 
  def getOrderForAwb(self, awb):
869 
    """
870 
    Returns the order corresponding to an AWB number
4369 rajveer 871 
 
4386 anupam.sin 872 
    Parameters:
873 
     - awb
874 
    """
875 
    pass
876 
 
4506 phani.kuma 877 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
878 
    """
879 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 880 
 
4506 phani.kuma 881 
    Parameters:
882 
     - logistics_provider_id
883 
     - order_status
884 
    """
885 
    pass
886 
 
887 
 
3376 rajveer 888 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 889 
  def __init__(self, iprot, oprot=None):
3376 rajveer 890 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 891 
 
892 
  def createTransaction(self, transaction):
893 
    """
894 
    Parameters:
895 
     - transaction
896 
    """
897 
    self.send_createTransaction(transaction)
132 ashish 898 
    return self.recv_createTransaction()
94 ashish 899 
 
900 
  def send_createTransaction(self, transaction):
901 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
902 
    args = createTransaction_args()
903 
    args.transaction = transaction
904 
    args.write(self._oprot)
905 
    self._oprot.writeMessageEnd()
906 
    self._oprot.trans.flush()
907 
 
908 
  def recv_createTransaction(self, ):
909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
910 
    if mtype == TMessageType.EXCEPTION:
911 
      x = TApplicationException()
912 
      x.read(self._iprot)
913 
      self._iprot.readMessageEnd()
914 
      raise x
915 
    result = createTransaction_result()
916 
    result.read(self._iprot)
917 
    self._iprot.readMessageEnd()
3431 rajveer 918 
    if result.success is not None:
132 ashish 919 
      return result.success
3431 rajveer 920 
    if result.ex is not None:
94 ashish 921 
      raise result.ex
132 ashish 922 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 923 
 
924 
  def getTransaction(self, id):
925 
    """
926 
    Parameters:
927 
     - id
928 
    """
929 
    self.send_getTransaction(id)
930 
    return self.recv_getTransaction()
931 
 
932 
  def send_getTransaction(self, id):
933 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
934 
    args = getTransaction_args()
935 
    args.id = id
936 
    args.write(self._oprot)
937 
    self._oprot.writeMessageEnd()
938 
    self._oprot.trans.flush()
939 
 
940 
  def recv_getTransaction(self, ):
941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
942 
    if mtype == TMessageType.EXCEPTION:
943 
      x = TApplicationException()
944 
      x.read(self._iprot)
945 
      self._iprot.readMessageEnd()
946 
      raise x
947 
    result = getTransaction_result()
948 
    result.read(self._iprot)
949 
    self._iprot.readMessageEnd()
3431 rajveer 950 
    if result.success is not None:
94 ashish 951 
      return result.success
3431 rajveer 952 
    if result.ex is not None:
94 ashish 953 
      raise result.ex
954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
955 
 
956 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
957 
    """
958 
    Parameters:
959 
     - customerId
960 
     - from_date
961 
     - to_date
962 
     - status
963 
    """
964 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
965 
    return self.recv_getTransactionsForCustomer()
966 
 
967 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
968 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
969 
    args = getTransactionsForCustomer_args()
970 
    args.customerId = customerId
971 
    args.from_date = from_date
972 
    args.to_date = to_date
973 
    args.status = status
974 
    args.write(self._oprot)
975 
    self._oprot.writeMessageEnd()
976 
    self._oprot.trans.flush()
977 
 
978 
  def recv_getTransactionsForCustomer(self, ):
979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
980 
    if mtype == TMessageType.EXCEPTION:
981 
      x = TApplicationException()
982 
      x.read(self._iprot)
983 
      self._iprot.readMessageEnd()
984 
      raise x
985 
    result = getTransactionsForCustomer_result()
986 
    result.read(self._iprot)
987 
    self._iprot.readMessageEnd()
3431 rajveer 988 
    if result.success is not None:
94 ashish 989 
      return result.success
3431 rajveer 990 
    if result.ex is not None:
94 ashish 991 
      raise result.ex
992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
993 
 
132 ashish 994 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
995 
    """
996 
    Parameters:
997 
     - shoppingCartId
998 
    """
999 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1000 
    return self.recv_getTransactionsForShoppingCartId()
1001 
 
1002 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1003 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1004 
    args = getTransactionsForShoppingCartId_args()
1005 
    args.shoppingCartId = shoppingCartId
1006 
    args.write(self._oprot)
1007 
    self._oprot.writeMessageEnd()
1008 
    self._oprot.trans.flush()
1009 
 
1010 
  def recv_getTransactionsForShoppingCartId(self, ):
1011 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1012 
    if mtype == TMessageType.EXCEPTION:
1013 
      x = TApplicationException()
1014 
      x.read(self._iprot)
1015 
      self._iprot.readMessageEnd()
1016 
      raise x
1017 
    result = getTransactionsForShoppingCartId_result()
1018 
    result.read(self._iprot)
1019 
    self._iprot.readMessageEnd()
3431 rajveer 1020 
    if result.success is not None:
132 ashish 1021 
      return result.success
3431 rajveer 1022 
    if result.ex is not None:
132 ashish 1023 
      raise result.ex
1024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1025 
 
94 ashish 1026 
  def getTransactionStatus(self, transactionId):
1027 
    """
1028 
    Parameters:
1029 
     - transactionId
1030 
    """
1031 
    self.send_getTransactionStatus(transactionId)
1032 
    return self.recv_getTransactionStatus()
1033 
 
1034 
  def send_getTransactionStatus(self, transactionId):
1035 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1036 
    args = getTransactionStatus_args()
1037 
    args.transactionId = transactionId
1038 
    args.write(self._oprot)
1039 
    self._oprot.writeMessageEnd()
1040 
    self._oprot.trans.flush()
1041 
 
1042 
  def recv_getTransactionStatus(self, ):
1043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1044 
    if mtype == TMessageType.EXCEPTION:
1045 
      x = TApplicationException()
1046 
      x.read(self._iprot)
1047 
      self._iprot.readMessageEnd()
1048 
      raise x
1049 
    result = getTransactionStatus_result()
1050 
    result.read(self._iprot)
1051 
    self._iprot.readMessageEnd()
3431 rajveer 1052 
    if result.success is not None:
94 ashish 1053 
      return result.success
3431 rajveer 1054 
    if result.ex is not None:
94 ashish 1055 
      raise result.ex
1056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1057 
 
1058 
  def changeTransactionStatus(self, transactionId, status, description):
1059 
    """
1060 
    Parameters:
1061 
     - transactionId
1062 
     - status
1063 
     - description
1064 
    """
1065 
    self.send_changeTransactionStatus(transactionId, status, description)
1066 
    return self.recv_changeTransactionStatus()
1067 
 
1068 
  def send_changeTransactionStatus(self, transactionId, status, description):
1069 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1070 
    args = changeTransactionStatus_args()
1071 
    args.transactionId = transactionId
1072 
    args.status = status
1073 
    args.description = description
1074 
    args.write(self._oprot)
1075 
    self._oprot.writeMessageEnd()
1076 
    self._oprot.trans.flush()
1077 
 
1078 
  def recv_changeTransactionStatus(self, ):
1079 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1080 
    if mtype == TMessageType.EXCEPTION:
1081 
      x = TApplicationException()
1082 
      x.read(self._iprot)
1083 
      self._iprot.readMessageEnd()
1084 
      raise x
1085 
    result = changeTransactionStatus_result()
1086 
    result.read(self._iprot)
1087 
    self._iprot.readMessageEnd()
3431 rajveer 1088 
    if result.success is not None:
94 ashish 1089 
      return result.success
3431 rajveer 1090 
    if result.ex is not None:
94 ashish 1091 
      raise result.ex
1092 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1093 
 
1398 varun.gupt 1094 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1095 
    """
1096 
    Parameters:
1097 
     - transactionId
1098 
    """
1398 varun.gupt 1099 
    self.send_enqueueTransactionInfoEmail(transactionId)
1100 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1101 
 
1398 varun.gupt 1102 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1103 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1104 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1105 
    args.transactionId = transactionId
1106 
    args.write(self._oprot)
1107 
    self._oprot.writeMessageEnd()
1108 
    self._oprot.trans.flush()
1109 
 
1398 varun.gupt 1110 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1111 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1112 
    if mtype == TMessageType.EXCEPTION:
1113 
      x = TApplicationException()
1114 
      x.read(self._iprot)
1115 
      self._iprot.readMessageEnd()
1116 
      raise x
1398 varun.gupt 1117 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1118 
    result.read(self._iprot)
1119 
    self._iprot.readMessageEnd()
3431 rajveer 1120 
    if result.success is not None:
1382 varun.gupt 1121 
      return result.success
3431 rajveer 1122 
    if result.ex is not None:
1382 varun.gupt 1123 
      raise result.ex
1398 varun.gupt 1124 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1125 
 
483 rajveer 1126 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1127 
    """
1128 
    Parameters:
483 rajveer 1129 
     - status
1130 
     - from_date
1131 
     - to_date
1132 
     - warehouse_id
94 ashish 1133 
    """
483 rajveer 1134 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1135 
    return self.recv_getAllOrders()
94 ashish 1136 
 
483 rajveer 1137 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1138 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1139 
    args = getAllOrders_args()
1140 
    args.status = status
1141 
    args.from_date = from_date
1142 
    args.to_date = to_date
1143 
    args.warehouse_id = warehouse_id
94 ashish 1144 
    args.write(self._oprot)
1145 
    self._oprot.writeMessageEnd()
1146 
    self._oprot.trans.flush()
1147 
 
483 rajveer 1148 
  def recv_getAllOrders(self, ):
94 ashish 1149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1150 
    if mtype == TMessageType.EXCEPTION:
1151 
      x = TApplicationException()
1152 
      x.read(self._iprot)
1153 
      self._iprot.readMessageEnd()
1154 
      raise x
483 rajveer 1155 
    result = getAllOrders_result()
94 ashish 1156 
    result.read(self._iprot)
1157 
    self._iprot.readMessageEnd()
3431 rajveer 1158 
    if result.success is not None:
94 ashish 1159 
      return result.success
3431 rajveer 1160 
    if result.ex is not None:
94 ashish 1161 
      raise result.ex
483 rajveer 1162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1163 
 
4133 chandransh 1164 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1165 
    """
1166 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1167 
    Pass the status as null and the limit as 0 to ignore them.
1168 
 
1169 
    Parameters:
1170 
     - statuses
1171 
     - offset
1172 
     - limit
1173 
     - warehouse_id
1174 
    """
1175 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1176 
    return self.recv_getOrdersInBatch()
1177 
 
1178 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1179 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1180 
    args = getOrdersInBatch_args()
1181 
    args.statuses = statuses
1182 
    args.offset = offset
1183 
    args.limit = limit
1184 
    args.warehouse_id = warehouse_id
1185 
    args.write(self._oprot)
1186 
    self._oprot.writeMessageEnd()
1187 
    self._oprot.trans.flush()
1188 
 
1189 
  def recv_getOrdersInBatch(self, ):
1190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1191 
    if mtype == TMessageType.EXCEPTION:
1192 
      x = TApplicationException()
1193 
      x.read(self._iprot)
1194 
      self._iprot.readMessageEnd()
1195 
      raise x
1196 
    result = getOrdersInBatch_result()
1197 
    result.read(self._iprot)
1198 
    self._iprot.readMessageEnd()
1199 
    if result.success is not None:
1200 
      return result.success
1201 
    if result.ex is not None:
1202 
      raise result.ex
1203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1204 
 
1205 
  def getOrderCount(self, statuses, warehouseId):
1206 
    """
1207 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1208 
 
1209 
    Parameters:
1210 
     - statuses
1211 
     - warehouseId
1212 
    """
1213 
    self.send_getOrderCount(statuses, warehouseId)
1214 
    return self.recv_getOrderCount()
1215 
 
1216 
  def send_getOrderCount(self, statuses, warehouseId):
1217 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1218 
    args = getOrderCount_args()
1219 
    args.statuses = statuses
1220 
    args.warehouseId = warehouseId
1221 
    args.write(self._oprot)
1222 
    self._oprot.writeMessageEnd()
1223 
    self._oprot.trans.flush()
1224 
 
1225 
  def recv_getOrderCount(self, ):
1226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1227 
    if mtype == TMessageType.EXCEPTION:
1228 
      x = TApplicationException()
1229 
      x.read(self._iprot)
1230 
      self._iprot.readMessageEnd()
1231 
      raise x
1232 
    result = getOrderCount_result()
1233 
    result.read(self._iprot)
1234 
    self._iprot.readMessageEnd()
1235 
    if result.success is not None:
1236 
      return result.success
1237 
    if result.ex is not None:
1238 
      raise result.ex
1239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1240 
 
999 varun.gupt 1241 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1242 
    """
1132 chandransh 1243 
    Returns orders within a range of their billing dates
3431 rajveer 1244 
 
999 varun.gupt 1245 
    Parameters:
1246 
     - status
1247 
     - start_billing_date
1248 
     - end_billing_date
1249 
     - warehouse_id
1250 
    """
1251 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1252 
    return self.recv_getOrdersByBillingDate()
1253 
 
1254 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1255 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1256 
    args = getOrdersByBillingDate_args()
1257 
    args.status = status
1258 
    args.start_billing_date = start_billing_date
1259 
    args.end_billing_date = end_billing_date
1260 
    args.warehouse_id = warehouse_id
1261 
    args.write(self._oprot)
1262 
    self._oprot.writeMessageEnd()
1263 
    self._oprot.trans.flush()
1264 
 
1265 
  def recv_getOrdersByBillingDate(self, ):
1266 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1267 
    if mtype == TMessageType.EXCEPTION:
1268 
      x = TApplicationException()
1269 
      x.read(self._iprot)
1270 
      self._iprot.readMessageEnd()
1271 
      raise x
1272 
    result = getOrdersByBillingDate_result()
1273 
    result.read(self._iprot)
1274 
    self._iprot.readMessageEnd()
3431 rajveer 1275 
    if result.success is not None:
999 varun.gupt 1276 
      return result.success
3431 rajveer 1277 
    if result.ex is not None:
999 varun.gupt 1278 
      raise result.ex
1279 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1280 
 
3451 chandransh 1281 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1282 
    """
1283 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1284 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1285 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1286 
 
3427 chandransh 1287 
    Parameters:
1288 
     - fromShippingDate
1289 
     - toShippingDate
1290 
     - providerId
1291 
     - warehouseId
3451 chandransh 1292 
     - cod
3427 chandransh 1293 
    """
3451 chandransh 1294 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1295 
    return self.recv_getOrdersByShippingDate()
1296 
 
3451 chandransh 1297 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1298 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1299 
    args = getOrdersByShippingDate_args()
1300 
    args.fromShippingDate = fromShippingDate
1301 
    args.toShippingDate = toShippingDate
1302 
    args.providerId = providerId
1303 
    args.warehouseId = warehouseId
3451 chandransh 1304 
    args.cod = cod
3427 chandransh 1305 
    args.write(self._oprot)
1306 
    self._oprot.writeMessageEnd()
1307 
    self._oprot.trans.flush()
1308 
 
1309 
  def recv_getOrdersByShippingDate(self, ):
1310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1311 
    if mtype == TMessageType.EXCEPTION:
1312 
      x = TApplicationException()
1313 
      x.read(self._iprot)
1314 
      self._iprot.readMessageEnd()
1315 
      raise x
1316 
    result = getOrdersByShippingDate_result()
1317 
    result.read(self._iprot)
1318 
    self._iprot.readMessageEnd()
3431 rajveer 1319 
    if result.success is not None:
3427 chandransh 1320 
      return result.success
3431 rajveer 1321 
    if result.ex is not None:
3427 chandransh 1322 
      raise result.ex
1323 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1324 
 
1382 varun.gupt 1325 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1326 
    """
1327 
    Returns order ids for orders which can be returned
3431 rajveer 1328 
 
1382 varun.gupt 1329 
    Parameters:
1330 
     - customer_id
1331 
     - limit
1332 
    """
1333 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1334 
    return self.recv_getReturnableOrdersForCustomer()
1335 
 
1336 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1337 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1338 
    args = getReturnableOrdersForCustomer_args()
1339 
    args.customer_id = customer_id
1340 
    args.limit = limit
1341 
    args.write(self._oprot)
1342 
    self._oprot.writeMessageEnd()
1343 
    self._oprot.trans.flush()
1344 
 
1345 
  def recv_getReturnableOrdersForCustomer(self, ):
1346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1347 
    if mtype == TMessageType.EXCEPTION:
1348 
      x = TApplicationException()
1349 
      x.read(self._iprot)
1350 
      self._iprot.readMessageEnd()
1351 
      raise x
1352 
    result = getReturnableOrdersForCustomer_result()
1353 
    result.read(self._iprot)
1354 
    self._iprot.readMessageEnd()
3431 rajveer 1355 
    if result.success is not None:
1382 varun.gupt 1356 
      return result.success
3431 rajveer 1357 
    if result.ex is not None:
1382 varun.gupt 1358 
      raise result.ex
1359 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1360 
 
1361 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1362 
    """
1363 
    Returns order ids for orders which can be cancelled
3431 rajveer 1364 
 
1382 varun.gupt 1365 
    Parameters:
1366 
     - customer_id
1367 
     - limit
1368 
    """
1369 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1370 
    return self.recv_getCancellableOrdersForCustomer()
1371 
 
1372 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1373 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1374 
    args = getCancellableOrdersForCustomer_args()
1375 
    args.customer_id = customer_id
1376 
    args.limit = limit
1377 
    args.write(self._oprot)
1378 
    self._oprot.writeMessageEnd()
1379 
    self._oprot.trans.flush()
1380 
 
1381 
  def recv_getCancellableOrdersForCustomer(self, ):
1382 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1383 
    if mtype == TMessageType.EXCEPTION:
1384 
      x = TApplicationException()
1385 
      x.read(self._iprot)
1386 
      self._iprot.readMessageEnd()
1387 
      raise x
1388 
    result = getCancellableOrdersForCustomer_result()
1389 
    result.read(self._iprot)
1390 
    self._iprot.readMessageEnd()
3431 rajveer 1391 
    if result.success is not None:
1382 varun.gupt 1392 
      return result.success
3431 rajveer 1393 
    if result.ex is not None:
1382 varun.gupt 1394 
      raise result.ex
1395 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1396 
 
483 rajveer 1397 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1398 
    """
1399 
    Parameters:
483 rajveer 1400 
     - orderId
1401 
     - status
1402 
     - description
94 ashish 1403 
    """
483 rajveer 1404 
    self.send_changeOrderStatus(orderId, status, description)
1405 
    return self.recv_changeOrderStatus()
94 ashish 1406 
 
483 rajveer 1407 
  def send_changeOrderStatus(self, orderId, status, description):
1408 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1409 
    args = changeOrderStatus_args()
1410 
    args.orderId = orderId
1411 
    args.status = status
1412 
    args.description = description
94 ashish 1413 
    args.write(self._oprot)
1414 
    self._oprot.writeMessageEnd()
1415 
    self._oprot.trans.flush()
1416 
 
483 rajveer 1417 
  def recv_changeOrderStatus(self, ):
94 ashish 1418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1419 
    if mtype == TMessageType.EXCEPTION:
1420 
      x = TApplicationException()
1421 
      x.read(self._iprot)
1422 
      self._iprot.readMessageEnd()
1423 
      raise x
483 rajveer 1424 
    result = changeOrderStatus_result()
94 ashish 1425 
    result.read(self._iprot)
1426 
    self._iprot.readMessageEnd()
3431 rajveer 1427 
    if result.success is not None:
94 ashish 1428 
      return result.success
3431 rajveer 1429 
    if result.ex is not None:
94 ashish 1430 
      raise result.ex
483 rajveer 1431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1432 
 
1528 ankur.sing 1433 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1434 
    """
1528 ankur.sing 1435 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1436 
    only user who owns the transaction can view its order details.
3431 rajveer 1437 
 
94 ashish 1438 
    Parameters:
1439 
     - transactionId
1528 ankur.sing 1440 
     - customerId
94 ashish 1441 
    """
1528 ankur.sing 1442 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1443 
    return self.recv_getOrdersForTransaction()
94 ashish 1444 
 
1528 ankur.sing 1445 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1446 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1447 
    args = getOrdersForTransaction_args()
94 ashish 1448 
    args.transactionId = transactionId
1528 ankur.sing 1449 
    args.customerId = customerId
94 ashish 1450 
    args.write(self._oprot)
1451 
    self._oprot.writeMessageEnd()
1452 
    self._oprot.trans.flush()
1453 
 
483 rajveer 1454 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1455 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1456 
    if mtype == TMessageType.EXCEPTION:
1457 
      x = TApplicationException()
1458 
      x.read(self._iprot)
1459 
      self._iprot.readMessageEnd()
1460 
      raise x
483 rajveer 1461 
    result = getOrdersForTransaction_result()
94 ashish 1462 
    result.read(self._iprot)
1463 
    self._iprot.readMessageEnd()
3431 rajveer 1464 
    if result.success is not None:
94 ashish 1465 
      return result.success
3431 rajveer 1466 
    if result.ex is not None:
94 ashish 1467 
      raise result.ex
483 rajveer 1468 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1469 
 
3014 chandransh 1470 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1471 
    """
3014 chandransh 1472 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1473 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1474 
 
94 ashish 1475 
    Parameters:
483 rajveer 1476 
     - customerId
1477 
     - from_date
1478 
     - to_date
3014 chandransh 1479 
     - statuses
94 ashish 1480 
    """
3014 chandransh 1481 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1482 
    return self.recv_getOrdersForCustomer()
94 ashish 1483 
 
3014 chandransh 1484 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1485 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1486 
    args = getOrdersForCustomer_args()
1487 
    args.customerId = customerId
1488 
    args.from_date = from_date
1489 
    args.to_date = to_date
3014 chandransh 1490 
    args.statuses = statuses
94 ashish 1491 
    args.write(self._oprot)
1492 
    self._oprot.writeMessageEnd()
1493 
    self._oprot.trans.flush()
1494 
 
483 rajveer 1495 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1497 
    if mtype == TMessageType.EXCEPTION:
1498 
      x = TApplicationException()
1499 
      x.read(self._iprot)
1500 
      self._iprot.readMessageEnd()
1501 
      raise x
483 rajveer 1502 
    result = getOrdersForCustomer_result()
94 ashish 1503 
    result.read(self._iprot)
1504 
    self._iprot.readMessageEnd()
3431 rajveer 1505 
    if result.success is not None:
94 ashish 1506 
      return result.success
3431 rajveer 1507 
    if result.ex is not None:
94 ashish 1508 
      raise result.ex
483 rajveer 1509 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1510 
 
483 rajveer 1511 
  def createOrder(self, order):
94 ashish 1512 
    """
1513 
    Parameters:
483 rajveer 1514 
     - order
94 ashish 1515 
    """
483 rajveer 1516 
    self.send_createOrder(order)
1517 
    return self.recv_createOrder()
94 ashish 1518 
 
483 rajveer 1519 
  def send_createOrder(self, order):
1520 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1521 
    args = createOrder_args()
1522 
    args.order = order
94 ashish 1523 
    args.write(self._oprot)
1524 
    self._oprot.writeMessageEnd()
1525 
    self._oprot.trans.flush()
1526 
 
483 rajveer 1527 
  def recv_createOrder(self, ):
94 ashish 1528 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1529 
    if mtype == TMessageType.EXCEPTION:
1530 
      x = TApplicationException()
1531 
      x.read(self._iprot)
1532 
      self._iprot.readMessageEnd()
1533 
      raise x
483 rajveer 1534 
    result = createOrder_result()
94 ashish 1535 
    result.read(self._iprot)
1536 
    self._iprot.readMessageEnd()
3431 rajveer 1537 
    if result.success is not None:
94 ashish 1538 
      return result.success
3431 rajveer 1539 
    if result.ex is not None:
94 ashish 1540 
      raise result.ex
483 rajveer 1541 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1542 
 
483 rajveer 1543 
  def getOrder(self, id):
94 ashish 1544 
    """
1545 
    Parameters:
483 rajveer 1546 
     - id
94 ashish 1547 
    """
483 rajveer 1548 
    self.send_getOrder(id)
1549 
    return self.recv_getOrder()
94 ashish 1550 
 
483 rajveer 1551 
  def send_getOrder(self, id):
1552 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1553 
    args = getOrder_args()
1554 
    args.id = id
94 ashish 1555 
    args.write(self._oprot)
1556 
    self._oprot.writeMessageEnd()
1557 
    self._oprot.trans.flush()
1558 
 
483 rajveer 1559 
  def recv_getOrder(self, ):
94 ashish 1560 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1561 
    if mtype == TMessageType.EXCEPTION:
1562 
      x = TApplicationException()
1563 
      x.read(self._iprot)
1564 
      self._iprot.readMessageEnd()
1565 
      raise x
483 rajveer 1566 
    result = getOrder_result()
94 ashish 1567 
    result.read(self._iprot)
1568 
    self._iprot.readMessageEnd()
3431 rajveer 1569 
    if result.success is not None:
94 ashish 1570 
      return result.success
3431 rajveer 1571 
    if result.ex is not None:
94 ashish 1572 
      raise result.ex
483 rajveer 1573 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1574 
 
483 rajveer 1575 
  def getLineItemsForOrder(self, orderId):
94 ashish 1576 
    """
1577 
    Parameters:
483 rajveer 1578 
     - orderId
94 ashish 1579 
    """
483 rajveer 1580 
    self.send_getLineItemsForOrder(orderId)
1581 
    return self.recv_getLineItemsForOrder()
94 ashish 1582 
 
483 rajveer 1583 
  def send_getLineItemsForOrder(self, orderId):
1584 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1585 
    args = getLineItemsForOrder_args()
1586 
    args.orderId = orderId
94 ashish 1587 
    args.write(self._oprot)
1588 
    self._oprot.writeMessageEnd()
1589 
    self._oprot.trans.flush()
1590 
 
483 rajveer 1591 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1592 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1593 
    if mtype == TMessageType.EXCEPTION:
1594 
      x = TApplicationException()
1595 
      x.read(self._iprot)
1596 
      self._iprot.readMessageEnd()
1597 
      raise x
483 rajveer 1598 
    result = getLineItemsForOrder_result()
94 ashish 1599 
    result.read(self._iprot)
1600 
    self._iprot.readMessageEnd()
3431 rajveer 1601 
    if result.success is not None:
94 ashish 1602 
      return result.success
3431 rajveer 1603 
    if result.ex is not None:
94 ashish 1604 
      raise result.ex
483 rajveer 1605 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1606 
 
1528 ankur.sing 1607 
  def getOrderForCustomer(self, orderId, customerId):
1608 
    """
1609 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1610 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1611 
 
1528 ankur.sing 1612 
    Parameters:
1613 
     - orderId
1614 
     - customerId
1615 
    """
1616 
    self.send_getOrderForCustomer(orderId, customerId)
1617 
    return self.recv_getOrderForCustomer()
1618 
 
1619 
  def send_getOrderForCustomer(self, orderId, customerId):
1620 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1621 
    args = getOrderForCustomer_args()
1622 
    args.orderId = orderId
1623 
    args.customerId = customerId
1624 
    args.write(self._oprot)
1625 
    self._oprot.writeMessageEnd()
1626 
    self._oprot.trans.flush()
1627 
 
1628 
  def recv_getOrderForCustomer(self, ):
1629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1630 
    if mtype == TMessageType.EXCEPTION:
1631 
      x = TApplicationException()
1632 
      x.read(self._iprot)
1633 
      self._iprot.readMessageEnd()
1634 
      raise x
1635 
    result = getOrderForCustomer_result()
1636 
    result.read(self._iprot)
1637 
    self._iprot.readMessageEnd()
3431 rajveer 1638 
    if result.success is not None:
1528 ankur.sing 1639 
      return result.success
3431 rajveer 1640 
    if result.ex is not None:
1528 ankur.sing 1641 
      raise result.ex
1642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1643 
 
4444 rajveer 1644 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1645 
    """
1646 
    Parameters:
4394 rajveer 1647 
     - type
4444 rajveer 1648 
     - warehouseId
4394 rajveer 1649 
     - status
1650 
     - timestamp
3064 chandransh 1651 
    """
4444 rajveer 1652 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1653 
    return self.recv_getAlerts()
1654 
 
4444 rajveer 1655 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1656 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1657 
    args = getAlerts_args()
4394 rajveer 1658 
    args.type = type
4444 rajveer 1659 
    args.warehouseId = warehouseId
4394 rajveer 1660 
    args.status = status
1661 
    args.timestamp = timestamp
3064 chandransh 1662 
    args.write(self._oprot)
1663 
    self._oprot.writeMessageEnd()
1664 
    self._oprot.trans.flush()
1665 
 
1666 
  def recv_getAlerts(self, ):
1667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1668 
    if mtype == TMessageType.EXCEPTION:
1669 
      x = TApplicationException()
1670 
      x.read(self._iprot)
1671 
      self._iprot.readMessageEnd()
1672 
      raise x
1673 
    result = getAlerts_result()
1674 
    result.read(self._iprot)
1675 
    self._iprot.readMessageEnd()
3431 rajveer 1676 
    if result.success is not None:
3064 chandransh 1677 
      return result.success
1678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1679 
 
4444 rajveer 1680 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1681 
    """
1682 
    Parameters:
1683 
     - type
4444 rajveer 1684 
     - warehouseId
4394 rajveer 1685 
     - description
3064 chandransh 1686 
    """
4444 rajveer 1687 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1688 
    self.recv_addAlert()
3064 chandransh 1689 
 
4444 rajveer 1690 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1691 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1692 
    args = addAlert_args()
3064 chandransh 1693 
    args.type = type
4444 rajveer 1694 
    args.warehouseId = warehouseId
4394 rajveer 1695 
    args.description = description
3064 chandransh 1696 
    args.write(self._oprot)
1697 
    self._oprot.writeMessageEnd()
1698 
    self._oprot.trans.flush()
1699 
 
4394 rajveer 1700 
  def recv_addAlert(self, ):
3064 chandransh 1701 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1702 
    if mtype == TMessageType.EXCEPTION:
1703 
      x = TApplicationException()
1704 
      x.read(self._iprot)
1705 
      self._iprot.readMessageEnd()
1706 
      raise x
4394 rajveer 1707 
    result = addAlert_result()
3064 chandransh 1708 
    result.read(self._iprot)
1709 
    self._iprot.readMessageEnd()
1710 
    return
1711 
 
4444 rajveer 1712 
  def markAlertsAsSeen(self, warehouseId):
1713 
    """
1714 
    Parameters:
1715 
     - warehouseId
1716 
    """
1717 
    self.send_markAlertsAsSeen(warehouseId)
1718 
    self.recv_markAlertsAsSeen()
1719 
 
1720 
  def send_markAlertsAsSeen(self, warehouseId):
1721 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1722 
    args = markAlertsAsSeen_args()
1723 
    args.warehouseId = warehouseId
1724 
    args.write(self._oprot)
1725 
    self._oprot.writeMessageEnd()
1726 
    self._oprot.trans.flush()
1727 
 
1728 
  def recv_markAlertsAsSeen(self, ):
1729 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1730 
    if mtype == TMessageType.EXCEPTION:
1731 
      x = TApplicationException()
1732 
      x.read(self._iprot)
1733 
      self._iprot.readMessageEnd()
1734 
      raise x
1735 
    result = markAlertsAsSeen_result()
1736 
    result.read(self._iprot)
1737 
    self._iprot.readMessageEnd()
1738 
    return
1739 
 
3064 chandransh 1740 
  def getValidOrderCount(self, ):
1741 
    """
1742 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1743 
    """
1744 
    self.send_getValidOrderCount()
1745 
    return self.recv_getValidOrderCount()
1746 
 
1747 
  def send_getValidOrderCount(self, ):
1748 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1749 
    args = getValidOrderCount_args()
1750 
    args.write(self._oprot)
1751 
    self._oprot.writeMessageEnd()
1752 
    self._oprot.trans.flush()
1753 
 
1754 
  def recv_getValidOrderCount(self, ):
1755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1756 
    if mtype == TMessageType.EXCEPTION:
1757 
      x = TApplicationException()
1758 
      x.read(self._iprot)
1759 
      self._iprot.readMessageEnd()
1760 
      raise x
1761 
    result = getValidOrderCount_result()
1762 
    result.read(self._iprot)
1763 
    self._iprot.readMessageEnd()
3431 rajveer 1764 
    if result.success is not None:
3064 chandransh 1765 
      return result.success
1766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1767 
 
1768 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1769 
    """
1770 
    Returns the number of distinct customers who have done successful transactions
1771 
    """
1772 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1773 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1774 
 
1775 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1776 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1777 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1778 
    args.write(self._oprot)
1779 
    self._oprot.writeMessageEnd()
1780 
    self._oprot.trans.flush()
1781 
 
1782 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1783 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1784 
    if mtype == TMessageType.EXCEPTION:
1785 
      x = TApplicationException()
1786 
      x.read(self._iprot)
1787 
      self._iprot.readMessageEnd()
1788 
      raise x
1789 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1790 
    result.read(self._iprot)
1791 
    self._iprot.readMessageEnd()
3431 rajveer 1792 
    if result.success is not None:
3064 chandransh 1793 
      return result.success
1794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1795 
 
1796 
  def getValidOrdersAmountRange(self, ):
1797 
    """
1798 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1799 
    List contains two values, first minimum amount and second maximum amount.
1800 
    """
1801 
    self.send_getValidOrdersAmountRange()
1802 
    return self.recv_getValidOrdersAmountRange()
1803 
 
1804 
  def send_getValidOrdersAmountRange(self, ):
1805 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1806 
    args = getValidOrdersAmountRange_args()
1807 
    args.write(self._oprot)
1808 
    self._oprot.writeMessageEnd()
1809 
    self._oprot.trans.flush()
1810 
 
1811 
  def recv_getValidOrdersAmountRange(self, ):
1812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1813 
    if mtype == TMessageType.EXCEPTION:
1814 
      x = TApplicationException()
1815 
      x.read(self._iprot)
1816 
      self._iprot.readMessageEnd()
1817 
      raise x
1818 
    result = getValidOrdersAmountRange_result()
1819 
    result.read(self._iprot)
1820 
    self._iprot.readMessageEnd()
3431 rajveer 1821 
    if result.success is not None:
3064 chandransh 1822 
      return result.success
1823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1824 
 
1825 
  def getValidOrders(self, limit):
1826 
    """
1827 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1828 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1829 
 
3064 chandransh 1830 
    Parameters:
1831 
     - limit
1832 
    """
1833 
    self.send_getValidOrders(limit)
1834 
    return self.recv_getValidOrders()
1835 
 
1836 
  def send_getValidOrders(self, limit):
1837 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1838 
    args = getValidOrders_args()
1839 
    args.limit = limit
1840 
    args.write(self._oprot)
1841 
    self._oprot.writeMessageEnd()
1842 
    self._oprot.trans.flush()
1843 
 
1844 
  def recv_getValidOrders(self, ):
1845 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1846 
    if mtype == TMessageType.EXCEPTION:
1847 
      x = TApplicationException()
1848 
      x.read(self._iprot)
1849 
      self._iprot.readMessageEnd()
1850 
      raise x
1851 
    result = getValidOrders_result()
1852 
    result.read(self._iprot)
1853 
    self._iprot.readMessageEnd()
3431 rajveer 1854 
    if result.success is not None:
3064 chandransh 1855 
      return result.success
1856 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1857 
 
1220 chandransh 1858 
  def batchOrders(self, warehouseId):
1859 
    """
1860 
    Create a batch of all the pending orders for the given warehouse.
1861 
    The returned list is orderd by created_timestamp.
1862 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1863 
 
1220 chandransh 1864 
    Parameters:
1865 
     - warehouseId
1866 
    """
1867 
    self.send_batchOrders(warehouseId)
1868 
    return self.recv_batchOrders()
1869 
 
1870 
  def send_batchOrders(self, warehouseId):
1871 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1872 
    args = batchOrders_args()
1873 
    args.warehouseId = warehouseId
1874 
    args.write(self._oprot)
1875 
    self._oprot.writeMessageEnd()
1876 
    self._oprot.trans.flush()
1877 
 
1878 
  def recv_batchOrders(self, ):
1879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1880 
    if mtype == TMessageType.EXCEPTION:
1881 
      x = TApplicationException()
1882 
      x.read(self._iprot)
1883 
      self._iprot.readMessageEnd()
1884 
      raise x
1885 
    result = batchOrders_result()
1886 
    result.read(self._iprot)
1887 
    self._iprot.readMessageEnd()
3431 rajveer 1888 
    if result.success is not None:
1220 chandransh 1889 
      return result.success
3431 rajveer 1890 
    if result.ex is not None:
1220 chandransh 1891 
      raise result.ex
1892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1893 
 
1208 chandransh 1894 
  def markOrderAsOutOfStock(self, orderId):
1895 
    """
1896 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1897 
 
1208 chandransh 1898 
    Parameters:
1899 
     - orderId
1900 
    """
1901 
    self.send_markOrderAsOutOfStock(orderId)
1902 
    return self.recv_markOrderAsOutOfStock()
1903 
 
1904 
  def send_markOrderAsOutOfStock(self, orderId):
1905 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1906 
    args = markOrderAsOutOfStock_args()
1907 
    args.orderId = orderId
1908 
    args.write(self._oprot)
1909 
    self._oprot.writeMessageEnd()
1910 
    self._oprot.trans.flush()
1911 
 
1912 
  def recv_markOrderAsOutOfStock(self, ):
1913 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1914 
    if mtype == TMessageType.EXCEPTION:
1915 
      x = TApplicationException()
1916 
      x.read(self._iprot)
1917 
      self._iprot.readMessageEnd()
1918 
      raise x
1919 
    result = markOrderAsOutOfStock_result()
1920 
    result.read(self._iprot)
1921 
    self._iprot.readMessageEnd()
3431 rajveer 1922 
    if result.success is not None:
1208 chandransh 1923 
      return result.success
3431 rajveer 1924 
    if result.ex is not None:
1208 chandransh 1925 
      raise result.ex
1926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1927 
 
3064 chandransh 1928 
  def verifyOrder(self, orderId):
759 chandransh 1929 
    """
3064 chandransh 1930 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1931 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1932 
    used for all other orders as well.
1933 
    Throws an exception if no such order exists.
3431 rajveer 1934 
 
759 chandransh 1935 
    Parameters:
3064 chandransh 1936 
     - orderId
759 chandransh 1937 
    """
3064 chandransh 1938 
    self.send_verifyOrder(orderId)
1939 
    return self.recv_verifyOrder()
759 chandransh 1940 
 
3064 chandransh 1941 
  def send_verifyOrder(self, orderId):
1942 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1943 
    args = verifyOrder_args()
1944 
    args.orderId = orderId
759 chandransh 1945 
    args.write(self._oprot)
1946 
    self._oprot.writeMessageEnd()
1947 
    self._oprot.trans.flush()
1948 
 
3064 chandransh 1949 
  def recv_verifyOrder(self, ):
759 chandransh 1950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1951 
    if mtype == TMessageType.EXCEPTION:
1952 
      x = TApplicationException()
1953 
      x.read(self._iprot)
1954 
      self._iprot.readMessageEnd()
1955 
      raise x
3064 chandransh 1956 
    result = verifyOrder_result()
759 chandransh 1957 
    result.read(self._iprot)
1958 
    self._iprot.readMessageEnd()
3431 rajveer 1959 
    if result.success is not None:
759 chandransh 1960 
      return result.success
3431 rajveer 1961 
    if result.ex is not None:
759 chandransh 1962 
      raise result.ex
3064 chandransh 1963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1964 
 
3064 chandransh 1965 
  def acceptOrder(self, orderId):
1113 chandransh 1966 
    """
3064 chandransh 1967 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1968 
    given order is not a COD order, it also captures the payment if the same has
1969 
    not been captured.
1970 
    Throws an exception if no such order exists.
3431 rajveer 1971 
 
1113 chandransh 1972 
    Parameters:
3064 chandransh 1973 
     - orderId
1113 chandransh 1974 
    """
3064 chandransh 1975 
    self.send_acceptOrder(orderId)
1976 
    return self.recv_acceptOrder()
1113 chandransh 1977 
 
3064 chandransh 1978 
  def send_acceptOrder(self, orderId):
1979 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1980 
    args = acceptOrder_args()
1981 
    args.orderId = orderId
1113 chandransh 1982 
    args.write(self._oprot)
1983 
    self._oprot.writeMessageEnd()
1984 
    self._oprot.trans.flush()
1985 
 
3064 chandransh 1986 
  def recv_acceptOrder(self, ):
1113 chandransh 1987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1988 
    if mtype == TMessageType.EXCEPTION:
1989 
      x = TApplicationException()
1990 
      x.read(self._iprot)
1991 
      self._iprot.readMessageEnd()
1992 
      raise x
3064 chandransh 1993 
    result = acceptOrder_result()
1113 chandransh 1994 
    result.read(self._iprot)
1995 
    self._iprot.readMessageEnd()
3431 rajveer 1996 
    if result.success is not None:
1113 chandransh 1997 
      return result.success
3431 rajveer 1998 
    if result.ex is not None:
1113 chandransh 1999 
      raise result.ex
3064 chandransh 2000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2001 
 
4283 anupam.sin 2002 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 2003 
    """
3064 chandransh 2004 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 2005 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
2006 
    the IMEI no. if a -1 is supplied.
2007 
    Also, it generates an invoice number for the order, marks the order as
2008 
    BILLED and sets the billing timestamp.
2009 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2010 
 
1135 chandransh 2011 
    Parameters:
3064 chandransh 2012 
     - orderId
2013 
     - invoice_number
4283 anupam.sin 2014 
     - imeiNumber
2015 
     - itemNumber
3064 chandransh 2016 
     - billed_by
4264 rajveer 2017 
     - jacketNumber
4283 anupam.sin 2018 
     - billingType
2019 
     - vendorId
1135 chandransh 2020 
    """
4283 anupam.sin 2021 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 2022 
    return self.recv_addBillingDetails()
1135 chandransh 2023 
 
4283 anupam.sin 2024 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 2025 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2026 
    args = addBillingDetails_args()
2027 
    args.orderId = orderId
2028 
    args.invoice_number = invoice_number
4283 anupam.sin 2029 
    args.imeiNumber = imeiNumber
2030 
    args.itemNumber = itemNumber
3064 chandransh 2031 
    args.billed_by = billed_by
4264 rajveer 2032 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2033 
    args.billingType = billingType
2034 
    args.vendorId = vendorId
1135 chandransh 2035 
    args.write(self._oprot)
2036 
    self._oprot.writeMessageEnd()
2037 
    self._oprot.trans.flush()
2038 
 
3064 chandransh 2039 
  def recv_addBillingDetails(self, ):
1135 chandransh 2040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2041 
    if mtype == TMessageType.EXCEPTION:
2042 
      x = TApplicationException()
2043 
      x.read(self._iprot)
2044 
      self._iprot.readMessageEnd()
2045 
      raise x
3064 chandransh 2046 
    result = addBillingDetails_result()
1135 chandransh 2047 
    result.read(self._iprot)
2048 
    self._iprot.readMessageEnd()
3431 rajveer 2049 
    if result.success is not None:
3064 chandransh 2050 
      return result.success
3431 rajveer 2051 
    if result.ex is not None:
1135 chandransh 2052 
      raise result.ex
3064 chandransh 2053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2054 
 
4579 rajveer 2055 
  def addInvoiceNumber(self, orderId, invoiceNumber):
2056 
    """
2057 
    Add the invoice number to the order.
2058 
 
2059 
    Parameters:
2060 
     - orderId
2061 
     - invoiceNumber
2062 
    """
2063 
    self.send_addInvoiceNumber(orderId, invoiceNumber)
2064 
    self.recv_addInvoiceNumber()
2065 
 
2066 
  def send_addInvoiceNumber(self, orderId, invoiceNumber):
2067 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2068 
    args = addInvoiceNumber_args()
2069 
    args.orderId = orderId
2070 
    args.invoiceNumber = invoiceNumber
2071 
    args.write(self._oprot)
2072 
    self._oprot.writeMessageEnd()
2073 
    self._oprot.trans.flush()
2074 
 
2075 
  def recv_addInvoiceNumber(self, ):
2076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2077 
    if mtype == TMessageType.EXCEPTION:
2078 
      x = TApplicationException()
2079 
      x.read(self._iprot)
2080 
      self._iprot.readMessageEnd()
2081 
      raise x
2082 
    result = addInvoiceNumber_result()
2083 
    result.read(self._iprot)
2084 
    self._iprot.readMessageEnd()
2085 
    if result.ex is not None:
2086 
      raise result.ex
2087 
    return
2088 
 
3064 chandransh 2089 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2090 
    """
3064 chandransh 2091 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2092 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2093 
 
1408 ankur.sing 2094 
    Parameters:
3064 chandransh 2095 
     - warehouseId
1408 ankur.sing 2096 
     - providerId
3064 chandransh 2097 
     - cod
1408 ankur.sing 2098 
    """
3064 chandransh 2099 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2100 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2101 
 
3064 chandransh 2102 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2103 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2104 
    args = markOrdersAsManifested_args()
2105 
    args.warehouseId = warehouseId
1408 ankur.sing 2106 
    args.providerId = providerId
3064 chandransh 2107 
    args.cod = cod
1408 ankur.sing 2108 
    args.write(self._oprot)
2109 
    self._oprot.writeMessageEnd()
2110 
    self._oprot.trans.flush()
2111 
 
3064 chandransh 2112 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2114 
    if mtype == TMessageType.EXCEPTION:
2115 
      x = TApplicationException()
2116 
      x.read(self._iprot)
2117 
      self._iprot.readMessageEnd()
2118 
      raise x
3064 chandransh 2119 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2120 
    result.read(self._iprot)
2121 
    self._iprot.readMessageEnd()
3431 rajveer 2122 
    if result.success is not None:
1408 ankur.sing 2123 
      return result.success
3431 rajveer 2124 
    if result.ex is not None:
3064 chandransh 2125 
      raise result.ex
2126 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2127 
 
4410 rajveer 2128 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2129 
    """
2130 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2131 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2132 
 
2133 
    Parameters:
2134 
     - warehouseId
2135 
     - providerId
2136 
     - cod
2137 
    """
2138 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2139 
    return self.recv_markOrdersAsShippedFromWarehouse()
2140 
 
2141 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2142 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2143 
    args = markOrdersAsShippedFromWarehouse_args()
2144 
    args.warehouseId = warehouseId
2145 
    args.providerId = providerId
2146 
    args.cod = cod
2147 
    args.write(self._oprot)
2148 
    self._oprot.writeMessageEnd()
2149 
    self._oprot.trans.flush()
2150 
 
2151 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2153 
    if mtype == TMessageType.EXCEPTION:
2154 
      x = TApplicationException()
2155 
      x.read(self._iprot)
2156 
      self._iprot.readMessageEnd()
2157 
      raise x
2158 
    result = markOrdersAsShippedFromWarehouse_result()
2159 
    result.read(self._iprot)
2160 
    self._iprot.readMessageEnd()
2161 
    if result.success is not None:
2162 
      return result.success
2163 
    if result.ex is not None:
2164 
      raise result.ex
2165 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2166 
 
3064 chandransh 2167 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2168 
    """
3064 chandransh 2169 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2170 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2171 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2172 
 
94 ashish 2173 
    Parameters:
3064 chandransh 2174 
     - providerId
2175 
     - pickupDetails
304 ashish 2176 
    """
3064 chandransh 2177 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2178 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2179 
 
3064 chandransh 2180 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2181 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2182 
    args = markOrdersAsPickedUp_args()
2183 
    args.providerId = providerId
2184 
    args.pickupDetails = pickupDetails
304 ashish 2185 
    args.write(self._oprot)
2186 
    self._oprot.writeMessageEnd()
2187 
    self._oprot.trans.flush()
2188 
 
3064 chandransh 2189 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2191 
    if mtype == TMessageType.EXCEPTION:
2192 
      x = TApplicationException()
2193 
      x.read(self._iprot)
2194 
      self._iprot.readMessageEnd()
2195 
      raise x
3064 chandransh 2196 
    result = markOrdersAsPickedUp_result()
304 ashish 2197 
    result.read(self._iprot)
2198 
    self._iprot.readMessageEnd()
3431 rajveer 2199 
    if result.success is not None:
304 ashish 2200 
      return result.success
3431 rajveer 2201 
    if result.ex is not None:
3064 chandransh 2202 
      raise result.ex
2203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2204 
 
3064 chandransh 2205 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2206 
    """
3064 chandransh 2207 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2208 
    the name of the receiver.
2209 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2210 
 
304 ashish 2211 
    Parameters:
3064 chandransh 2212 
     - providerId
2213 
     - deliveredOrders
304 ashish 2214 
    """
3064 chandransh 2215 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2216 
    self.recv_markOrdersAsDelivered()
304 ashish 2217 
 
3064 chandransh 2218 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2219 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2220 
    args = markOrdersAsDelivered_args()
2221 
    args.providerId = providerId
2222 
    args.deliveredOrders = deliveredOrders
304 ashish 2223 
    args.write(self._oprot)
2224 
    self._oprot.writeMessageEnd()
2225 
    self._oprot.trans.flush()
2226 
 
3064 chandransh 2227 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2229 
    if mtype == TMessageType.EXCEPTION:
2230 
      x = TApplicationException()
2231 
      x.read(self._iprot)
2232 
      self._iprot.readMessageEnd()
2233 
      raise x
3064 chandransh 2234 
    result = markOrdersAsDelivered_result()
304 ashish 2235 
    result.read(self._iprot)
2236 
    self._iprot.readMessageEnd()
3431 rajveer 2237 
    if result.ex is not None:
3064 chandransh 2238 
      raise result.ex
304 ashish 2239 
    return
2240 
 
3064 chandransh 2241 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2242 
    """
3064 chandransh 2243 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2244 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2245 
 
3064 chandransh 2246 
    Parameters:
2247 
     - providerId
2248 
     - returnedOrders
1596 ankur.sing 2249 
    """
3064 chandransh 2250 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2251 
    self.recv_markOrdersAsFailed()
304 ashish 2252 
 
3064 chandransh 2253 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2254 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2255 
    args = markOrdersAsFailed_args()
2256 
    args.providerId = providerId
2257 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2258 
    args.write(self._oprot)
2259 
    self._oprot.writeMessageEnd()
2260 
    self._oprot.trans.flush()
2261 
 
3064 chandransh 2262 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2264 
    if mtype == TMessageType.EXCEPTION:
2265 
      x = TApplicationException()
2266 
      x.read(self._iprot)
2267 
      self._iprot.readMessageEnd()
2268 
      raise x
3064 chandransh 2269 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2270 
    result.read(self._iprot)
2271 
    self._iprot.readMessageEnd()
3431 rajveer 2272 
    if result.ex is not None:
3064 chandransh 2273 
      raise result.ex
2274 
    return
1596 ankur.sing 2275 
 
3064 chandransh 2276 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2277 
    """
3064 chandransh 2278 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2279 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2280 
 
3064 chandransh 2281 
    Parameters:
2282 
     - providerId
2283 
     - undeliveredOrders
1627 ankur.sing 2284 
    """
3064 chandransh 2285 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2286 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2287 
 
3064 chandransh 2288 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2289 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2290 
    args = updateNonDeliveryReason_args()
2291 
    args.providerId = providerId
2292 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2293 
    args.write(self._oprot)
2294 
    self._oprot.writeMessageEnd()
2295 
    self._oprot.trans.flush()
2296 
 
3064 chandransh 2297 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2298 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2299 
    if mtype == TMessageType.EXCEPTION:
2300 
      x = TApplicationException()
2301 
      x.read(self._iprot)
2302 
      self._iprot.readMessageEnd()
2303 
      raise x
3064 chandransh 2304 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2305 
    result.read(self._iprot)
2306 
    self._iprot.readMessageEnd()
4581 phani.kuma 2307 
    if result.success is not None:
2308 
      return result.success
3431 rajveer 2309 
    if result.ex is not None:
3064 chandransh 2310 
      raise result.ex
4581 phani.kuma 2311 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2312 
 
3064 chandransh 2313 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2314 
    """
3064 chandransh 2315 
    Returns the list of orders whose delivery time has passed but have not been
2316 
    delivered yet for the given provider and warehouse. To get a complete list of
2317 
    undelivered orders, pass them as -1.
2318 
    Returns an empty list if no such orders exist.
3431 rajveer 2319 
 
1886 ankur.sing 2320 
    Parameters:
3064 chandransh 2321 
     - providerId
2322 
     - warehouseId
1886 ankur.sing 2323 
    """
3064 chandransh 2324 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2325 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2326 
 
3064 chandransh 2327 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2328 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2329 
    args = getUndeliveredOrders_args()
2330 
    args.providerId = providerId
2331 
    args.warehouseId = warehouseId
1886 ankur.sing 2332 
    args.write(self._oprot)
2333 
    self._oprot.writeMessageEnd()
2334 
    self._oprot.trans.flush()
2335 
 
3064 chandransh 2336 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2338 
    if mtype == TMessageType.EXCEPTION:
2339 
      x = TApplicationException()
2340 
      x.read(self._iprot)
2341 
      self._iprot.readMessageEnd()
2342 
      raise x
3064 chandransh 2343 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2344 
    result.read(self._iprot)
2345 
    self._iprot.readMessageEnd()
3431 rajveer 2346 
    if result.success is not None:
1886 ankur.sing 2347 
      return result.success
3064 chandransh 2348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2349 
 
2536 chandransh 2350 
  def toggleDOAFlag(self, orderId):
2351 
    """
2352 
    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.
2353 
    Returns the final flag status.
2354 
    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 2355 
 
2536 chandransh 2356 
    Parameters:
2357 
     - orderId
2358 
    """
2359 
    self.send_toggleDOAFlag(orderId)
2360 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2361 
 
2536 chandransh 2362 
  def send_toggleDOAFlag(self, orderId):
2363 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2364 
    args = toggleDOAFlag_args()
2365 
    args.orderId = orderId
2366 
    args.write(self._oprot)
2367 
    self._oprot.writeMessageEnd()
2368 
    self._oprot.trans.flush()
2369 
 
2370 
  def recv_toggleDOAFlag(self, ):
2371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2372 
    if mtype == TMessageType.EXCEPTION:
2373 
      x = TApplicationException()
2374 
      x.read(self._iprot)
2375 
      self._iprot.readMessageEnd()
2376 
      raise x
2377 
    result = toggleDOAFlag_result()
2378 
    result.read(self._iprot)
2379 
    self._iprot.readMessageEnd()
3431 rajveer 2380 
    if result.success is not None:
2536 chandransh 2381 
      return result.success
3431 rajveer 2382 
    if result.ex is not None:
2536 chandransh 2383 
      raise result.ex
2384 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2385 
 
4454 rajveer 2386 
  def markOrderDoaRequestReceived(self, orderId):
2387 
    """
2388 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2389 
 
2390 
    Parameters:
2391 
     - orderId
2392 
    """
2393 
    self.send_markOrderDoaRequestReceived(orderId)
2394 
    return self.recv_markOrderDoaRequestReceived()
2395 
 
2396 
  def send_markOrderDoaRequestReceived(self, orderId):
2397 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2398 
    args = markOrderDoaRequestReceived_args()
2399 
    args.orderId = orderId
2400 
    args.write(self._oprot)
2401 
    self._oprot.writeMessageEnd()
2402 
    self._oprot.trans.flush()
2403 
 
2404 
  def recv_markOrderDoaRequestReceived(self, ):
2405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2406 
    if mtype == TMessageType.EXCEPTION:
2407 
      x = TApplicationException()
2408 
      x.read(self._iprot)
2409 
      self._iprot.readMessageEnd()
2410 
      raise x
2411 
    result = markOrderDoaRequestReceived_result()
2412 
    result.read(self._iprot)
2413 
    self._iprot.readMessageEnd()
2414 
    if result.success is not None:
2415 
      return result.success
2416 
    if result.ex is not None:
2417 
      raise result.ex
2418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2419 
 
2420 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2421 
    """
2422 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2423 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2424 
 
2425 
    Parameters:
2426 
     - orderId
2427 
     - isAuthorized
2428 
    """
2429 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2430 
    return self.recv_markOrderDoaRequestAuthorized()
2431 
 
2432 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2433 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2434 
    args = markOrderDoaRequestAuthorized_args()
2435 
    args.orderId = orderId
2436 
    args.isAuthorized = isAuthorized
2437 
    args.write(self._oprot)
2438 
    self._oprot.writeMessageEnd()
2439 
    self._oprot.trans.flush()
2440 
 
2441 
  def recv_markOrderDoaRequestAuthorized(self, ):
2442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2443 
    if mtype == TMessageType.EXCEPTION:
2444 
      x = TApplicationException()
2445 
      x.read(self._iprot)
2446 
      self._iprot.readMessageEnd()
2447 
      raise x
2448 
    result = markOrderDoaRequestAuthorized_result()
2449 
    result.read(self._iprot)
2450 
    self._iprot.readMessageEnd()
2451 
    if result.success is not None:
2452 
      return result.success
2453 
    if result.ex is not None:
2454 
      raise result.ex
2455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2456 
 
4488 rajveer 2457 
  def markOrderReturnRequestReceived(self, orderId):
2458 
    """
2459 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2460 
 
2461 
    Parameters:
2462 
     - orderId
2463 
    """
2464 
    self.send_markOrderReturnRequestReceived(orderId)
2465 
    return self.recv_markOrderReturnRequestReceived()
2466 
 
2467 
  def send_markOrderReturnRequestReceived(self, orderId):
2468 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2469 
    args = markOrderReturnRequestReceived_args()
2470 
    args.orderId = orderId
2471 
    args.write(self._oprot)
2472 
    self._oprot.writeMessageEnd()
2473 
    self._oprot.trans.flush()
2474 
 
2475 
  def recv_markOrderReturnRequestReceived(self, ):
2476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2477 
    if mtype == TMessageType.EXCEPTION:
2478 
      x = TApplicationException()
2479 
      x.read(self._iprot)
2480 
      self._iprot.readMessageEnd()
2481 
      raise x
2482 
    result = markOrderReturnRequestReceived_result()
2483 
    result.read(self._iprot)
2484 
    self._iprot.readMessageEnd()
2485 
    if result.success is not None:
2486 
      return result.success
2487 
    if result.ex is not None:
2488 
      raise result.ex
2489 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2490 
 
2491 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2492 
    """
2493 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2494 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2495 
 
2496 
    Parameters:
2497 
     - orderId
2498 
     - isAuthorized
2499 
    """
2500 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2501 
    return self.recv_markOrderReturnRequestAuthorized()
2502 
 
2503 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2504 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2505 
    args = markOrderReturnRequestAuthorized_args()
2506 
    args.orderId = orderId
2507 
    args.isAuthorized = isAuthorized
2508 
    args.write(self._oprot)
2509 
    self._oprot.writeMessageEnd()
2510 
    self._oprot.trans.flush()
2511 
 
2512 
  def recv_markOrderReturnRequestAuthorized(self, ):
2513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2514 
    if mtype == TMessageType.EXCEPTION:
2515 
      x = TApplicationException()
2516 
      x.read(self._iprot)
2517 
      self._iprot.readMessageEnd()
2518 
      raise x
2519 
    result = markOrderReturnRequestAuthorized_result()
2520 
    result.read(self._iprot)
2521 
    self._iprot.readMessageEnd()
2522 
    if result.success is not None:
2523 
      return result.success
2524 
    if result.ex is not None:
2525 
      raise result.ex
2526 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2527 
 
4579 rajveer 2528 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2529 
    """
2530 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2531 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2532 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2533 
    For any other status, it returns false.
2534 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2535 
 
2536 chandransh 2536 
    Parameters:
2537 
     - orderId
4579 rajveer 2538 
     - providerId
2536 chandransh 2539 
    """
4579 rajveer 2540 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2541 
    return self.recv_requestPickupNumber()
2542 
 
4579 rajveer 2543 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2544 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2545 
    args = requestPickupNumber_args()
2546 
    args.orderId = orderId
4579 rajveer 2547 
    args.providerId = providerId
2536 chandransh 2548 
    args.write(self._oprot)
2549 
    self._oprot.writeMessageEnd()
2550 
    self._oprot.trans.flush()
2551 
 
2552 
  def recv_requestPickupNumber(self, ):
2553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2554 
    if mtype == TMessageType.EXCEPTION:
2555 
      x = TApplicationException()
2556 
      x.read(self._iprot)
2557 
      self._iprot.readMessageEnd()
2558 
      raise x
2559 
    result = requestPickupNumber_result()
2560 
    result.read(self._iprot)
2561 
    self._iprot.readMessageEnd()
3431 rajveer 2562 
    if result.success is not None:
2536 chandransh 2563 
      return result.success
3431 rajveer 2564 
    if result.ex is not None:
2536 chandransh 2565 
      raise result.ex
2566 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2567 
 
2568 
  def authorizePickup(self, orderId, pickupNumber):
2569 
    """
4452 rajveer 2570 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2571 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2572 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2573 
    	3. Returns true
2591 chandransh 2574 
    If the order is in any other status, it returns false.
2536 chandransh 2575 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2576 
 
2536 chandransh 2577 
    Parameters:
2578 
     - orderId
2579 
     - pickupNumber
2580 
    """
2581 
    self.send_authorizePickup(orderId, pickupNumber)
2582 
    return self.recv_authorizePickup()
2583 
 
2584 
  def send_authorizePickup(self, orderId, pickupNumber):
2585 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2586 
    args = authorizePickup_args()
2587 
    args.orderId = orderId
2588 
    args.pickupNumber = pickupNumber
2589 
    args.write(self._oprot)
2590 
    self._oprot.writeMessageEnd()
2591 
    self._oprot.trans.flush()
2592 
 
2593 
  def recv_authorizePickup(self, ):
2594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2595 
    if mtype == TMessageType.EXCEPTION:
2596 
      x = TApplicationException()
2597 
      x.read(self._iprot)
2598 
      self._iprot.readMessageEnd()
2599 
      raise x
2600 
    result = authorizePickup_result()
2601 
    result.read(self._iprot)
2602 
    self._iprot.readMessageEnd()
3431 rajveer 2603 
    if result.success is not None:
2536 chandransh 2604 
      return result.success
3431 rajveer 2605 
    if result.ex is not None:
2536 chandransh 2606 
      raise result.ex
2607 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2608 
 
2764 chandransh 2609 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2610 
    """
2611 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2612 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2613 
 
2764 chandransh 2614 
    Parameters:
2615 
     - providerId
2616 
     - pickupDetails
2617 
    """
2618 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2619 
    return self.recv_markDoasAsPickedUp()
2620 
 
2621 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2622 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2623 
    args = markDoasAsPickedUp_args()
2624 
    args.providerId = providerId
2625 
    args.pickupDetails = pickupDetails
2626 
    args.write(self._oprot)
2627 
    self._oprot.writeMessageEnd()
2628 
    self._oprot.trans.flush()
2629 
 
2630 
  def recv_markDoasAsPickedUp(self, ):
2631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2632 
    if mtype == TMessageType.EXCEPTION:
2633 
      x = TApplicationException()
2634 
      x.read(self._iprot)
2635 
      self._iprot.readMessageEnd()
2636 
      raise x
2637 
    result = markDoasAsPickedUp_result()
2638 
    result.read(self._iprot)
2639 
    self._iprot.readMessageEnd()
3431 rajveer 2640 
    if result.success is not None:
2764 chandransh 2641 
      return result.success
2642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2643 
 
4479 rajveer 2644 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2645 
    """
4452 rajveer 2646 
    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 2647 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2648 
    If the order is in any other state, it returns false.
2649 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2650 
 
2591 chandransh 2651 
    Parameters:
2652 
     - orderId
4479 rajveer 2653 
     - receiveCondition
2591 chandransh 2654 
    """
4479 rajveer 2655 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2656 
    return self.recv_receiveReturn()
2536 chandransh 2657 
 
4479 rajveer 2658 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2659 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2660 
    args = receiveReturn_args()
2591 chandransh 2661 
    args.orderId = orderId
4479 rajveer 2662 
    args.receiveCondition = receiveCondition
2591 chandransh 2663 
    args.write(self._oprot)
2664 
    self._oprot.writeMessageEnd()
2665 
    self._oprot.trans.flush()
2666 
 
2616 chandransh 2667 
  def recv_receiveReturn(self, ):
2591 chandransh 2668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2669 
    if mtype == TMessageType.EXCEPTION:
2670 
      x = TApplicationException()
2671 
      x.read(self._iprot)
2672 
      self._iprot.readMessageEnd()
2673 
      raise x
2616 chandransh 2674 
    result = receiveReturn_result()
2591 chandransh 2675 
    result.read(self._iprot)
2676 
    self._iprot.readMessageEnd()
3431 rajveer 2677 
    if result.success is not None:
2591 chandransh 2678 
      return result.success
3431 rajveer 2679 
    if result.ex is not None:
2591 chandransh 2680 
      raise result.ex
2616 chandransh 2681 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2682 
 
2683 
  def validateDoa(self, orderId, isValid):
2684 
    """
4452 rajveer 2685 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2686 
    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 2687 
    If the order is in any other state, it returns false.
2688 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2689 
 
2591 chandransh 2690 
    Parameters:
2691 
     - orderId
2692 
     - isValid
2693 
    """
2694 
    self.send_validateDoa(orderId, isValid)
2695 
    return self.recv_validateDoa()
2696 
 
2697 
  def send_validateDoa(self, orderId, isValid):
2698 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2699 
    args = validateDoa_args()
2700 
    args.orderId = orderId
2701 
    args.isValid = isValid
2702 
    args.write(self._oprot)
2703 
    self._oprot.writeMessageEnd()
2704 
    self._oprot.trans.flush()
2705 
 
2706 
  def recv_validateDoa(self, ):
2707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2708 
    if mtype == TMessageType.EXCEPTION:
2709 
      x = TApplicationException()
2710 
      x.read(self._iprot)
2711 
      self._iprot.readMessageEnd()
2712 
      raise x
2713 
    result = validateDoa_result()
2714 
    result.read(self._iprot)
2715 
    self._iprot.readMessageEnd()
3431 rajveer 2716 
    if result.success is not None:
2591 chandransh 2717 
      return result.success
3431 rajveer 2718 
    if result.ex is not None:
2591 chandransh 2719 
      raise result.ex
2720 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2721 
 
4495 rajveer 2722 
  def validateReturnProduct(self, orderId, isUsable):
2723 
    """
2724 
    Parameters:
2725 
     - orderId
2726 
     - isUsable
2727 
    """
2728 
    self.send_validateReturnProduct(orderId, isUsable)
2729 
    return self.recv_validateReturnProduct()
2730 
 
2731 
  def send_validateReturnProduct(self, orderId, isUsable):
2732 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2733 
    args = validateReturnProduct_args()
2734 
    args.orderId = orderId
2735 
    args.isUsable = isUsable
2736 
    args.write(self._oprot)
2737 
    self._oprot.writeMessageEnd()
2738 
    self._oprot.trans.flush()
2739 
 
2740 
  def recv_validateReturnProduct(self, ):
2741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2742 
    if mtype == TMessageType.EXCEPTION:
2743 
      x = TApplicationException()
2744 
      x.read(self._iprot)
2745 
      self._iprot.readMessageEnd()
2746 
      raise x
2747 
    result = validateReturnProduct_result()
2748 
    result.read(self._iprot)
2749 
    self._iprot.readMessageEnd()
2750 
    if result.success is not None:
2751 
      return result.success
2752 
    if result.ex is not None:
2753 
      raise result.ex
2754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2755 
 
2616 chandransh 2756 
  def reshipOrder(self, orderId):
2757 
    """
4484 rajveer 2758 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2759 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2760 
    	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 2761 
 
2762 
    If the order is in DOA_CERT_VALID state, it does the following:
2763 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2764 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2765 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2766 
 
2616 chandransh 2767 
    Returns the id of the newly created order.
3431 rajveer 2768 
 
2616 chandransh 2769 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2770 
 
2616 chandransh 2771 
    Parameters:
2772 
     - orderId
2773 
    """
2774 
    self.send_reshipOrder(orderId)
2775 
    return self.recv_reshipOrder()
2591 chandransh 2776 
 
2616 chandransh 2777 
  def send_reshipOrder(self, orderId):
2778 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2779 
    args = reshipOrder_args()
2780 
    args.orderId = orderId
2781 
    args.write(self._oprot)
2782 
    self._oprot.writeMessageEnd()
2783 
    self._oprot.trans.flush()
2784 
 
2785 
  def recv_reshipOrder(self, ):
2786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2787 
    if mtype == TMessageType.EXCEPTION:
2788 
      x = TApplicationException()
2789 
      x.read(self._iprot)
2790 
      self._iprot.readMessageEnd()
2791 
      raise x
2792 
    result = reshipOrder_result()
2793 
    result.read(self._iprot)
2794 
    self._iprot.readMessageEnd()
3431 rajveer 2795 
    if result.success is not None:
2616 chandransh 2796 
      return result.success
3431 rajveer 2797 
    if result.ex is not None:
2616 chandransh 2798 
      raise result.ex
2799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2800 
 
3226 chandransh 2801 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2802 
    """
4484 rajveer 2803 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2804 
    	1. Creates a refund request for batch processing.
2805 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 2806 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2807 
 
2616 chandransh 2808 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2809 
    	1. Creates a refund request for batch processing.
3226 chandransh 2810 
    	2. Cancels the reservation of the item in the warehouse.
2811 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2812 
 
3226 chandransh 2813 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2814 
    	1. Cancels the reservation of the item in the warehouse.
2815 
    	2. Marks the current order as CANCELED.
2816 
 
2817 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2818 
 
2616 chandransh 2819 
    Returns True if it is successful, False otherwise.
3431 rajveer 2820 
 
2616 chandransh 2821 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2822 
 
2616 chandransh 2823 
    Parameters:
2824 
     - orderId
3226 chandransh 2825 
     - refundedBy
2826 
     - reason
2616 chandransh 2827 
    """
3226 chandransh 2828 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2829 
    return self.recv_refundOrder()
2830 
 
3226 chandransh 2831 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2832 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2833 
    args = refundOrder_args()
2834 
    args.orderId = orderId
3226 chandransh 2835 
    args.refundedBy = refundedBy
2836 
    args.reason = reason
2616 chandransh 2837 
    args.write(self._oprot)
2838 
    self._oprot.writeMessageEnd()
2839 
    self._oprot.trans.flush()
2840 
 
2841 
  def recv_refundOrder(self, ):
2842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2843 
    if mtype == TMessageType.EXCEPTION:
2844 
      x = TApplicationException()
2845 
      x.read(self._iprot)
2846 
      self._iprot.readMessageEnd()
2847 
      raise x
2848 
    result = refundOrder_result()
2849 
    result.read(self._iprot)
2850 
    self._iprot.readMessageEnd()
3431 rajveer 2851 
    if result.success is not None:
2616 chandransh 2852 
      return result.success
3431 rajveer 2853 
    if result.ex is not None:
2616 chandransh 2854 
      raise result.ex
2855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2856 
 
2690 chandransh 2857 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2858 
    """
2859 
    Get all return orders created between the from and to dates for the given warehouse.
2860 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2861 
 
2690 chandransh 2862 
    Parameters:
2863 
     - warehouseId
2864 
     - fromDate
2865 
     - toDate
2866 
    """
2867 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2868 
    return self.recv_getReturnOrders()
2616 chandransh 2869 
 
2690 chandransh 2870 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2871 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2872 
    args = getReturnOrders_args()
2873 
    args.warehouseId = warehouseId
2874 
    args.fromDate = fromDate
2875 
    args.toDate = toDate
2876 
    args.write(self._oprot)
2877 
    self._oprot.writeMessageEnd()
2878 
    self._oprot.trans.flush()
2879 
 
2880 
  def recv_getReturnOrders(self, ):
2881 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2882 
    if mtype == TMessageType.EXCEPTION:
2883 
      x = TApplicationException()
2884 
      x.read(self._iprot)
2885 
      self._iprot.readMessageEnd()
2886 
      raise x
2887 
    result = getReturnOrders_result()
2888 
    result.read(self._iprot)
2889 
    self._iprot.readMessageEnd()
3431 rajveer 2890 
    if result.success is not None:
2690 chandransh 2891 
      return result.success
2892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2893 
 
2700 chandransh 2894 
  def getReturnOrder(self, id):
2895 
    """
2896 
    Returns the ReturnOrder corresponding to the given id.
2897 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2898 
 
2700 chandransh 2899 
    Parameters:
2900 
     - id
2901 
    """
2902 
    self.send_getReturnOrder(id)
2903 
    return self.recv_getReturnOrder()
2904 
 
2905 
  def send_getReturnOrder(self, id):
2906 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2907 
    args = getReturnOrder_args()
2908 
    args.id = id
2909 
    args.write(self._oprot)
2910 
    self._oprot.writeMessageEnd()
2911 
    self._oprot.trans.flush()
2912 
 
2913 
  def recv_getReturnOrder(self, ):
2914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2915 
    if mtype == TMessageType.EXCEPTION:
2916 
      x = TApplicationException()
2917 
      x.read(self._iprot)
2918 
      self._iprot.readMessageEnd()
2919 
      raise x
2920 
    result = getReturnOrder_result()
2921 
    result.read(self._iprot)
2922 
    self._iprot.readMessageEnd()
3431 rajveer 2923 
    if result.success is not None:
2700 chandransh 2924 
      return result.success
3431 rajveer 2925 
    if result.ex is not None:
2700 chandransh 2926 
      raise result.ex
2927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2928 
 
2690 chandransh 2929 
  def processReturn(self, returnOrderId):
2930 
    """
2931 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2932 
 
2690 chandransh 2933 
    Parameters:
2934 
     - returnOrderId
2935 
    """
2936 
    self.send_processReturn(returnOrderId)
2937 
    self.recv_processReturn()
2938 
 
2939 
  def send_processReturn(self, returnOrderId):
2940 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2941 
    args = processReturn_args()
2942 
    args.returnOrderId = returnOrderId
2943 
    args.write(self._oprot)
2944 
    self._oprot.writeMessageEnd()
2945 
    self._oprot.trans.flush()
2946 
 
2947 
  def recv_processReturn(self, ):
2948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2949 
    if mtype == TMessageType.EXCEPTION:
2950 
      x = TApplicationException()
2951 
      x.read(self._iprot)
2952 
      self._iprot.readMessageEnd()
2953 
      raise x
2954 
    result = processReturn_result()
2955 
    result.read(self._iprot)
2956 
    self._iprot.readMessageEnd()
3431 rajveer 2957 
    if result.ex is not None:
2690 chandransh 2958 
      raise result.ex
2959 
    return
2960 
 
2819 chandransh 2961 
  def createPurchaseOrder(self, warehouseId):
2962 
    """
2963 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2964 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2965 
 
2819 chandransh 2966 
    Parameters:
2967 
     - warehouseId
2968 
    """
2969 
    self.send_createPurchaseOrder(warehouseId)
2970 
    return self.recv_createPurchaseOrder()
2690 chandransh 2971 
 
2819 chandransh 2972 
  def send_createPurchaseOrder(self, warehouseId):
2973 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2974 
    args = createPurchaseOrder_args()
2975 
    args.warehouseId = warehouseId
2976 
    args.write(self._oprot)
2977 
    self._oprot.writeMessageEnd()
2978 
    self._oprot.trans.flush()
2979 
 
2980 
  def recv_createPurchaseOrder(self, ):
2981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2982 
    if mtype == TMessageType.EXCEPTION:
2983 
      x = TApplicationException()
2984 
      x.read(self._iprot)
2985 
      self._iprot.readMessageEnd()
2986 
      raise x
2987 
    result = createPurchaseOrder_result()
2988 
    result.read(self._iprot)
2989 
    self._iprot.readMessageEnd()
3431 rajveer 2990 
    if result.success is not None:
2819 chandransh 2991 
      return result.success
3431 rajveer 2992 
    if result.ex is not None:
2819 chandransh 2993 
      raise result.ex
2994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2995 
 
3451 chandransh 2996 
  def updateWeight(self, orderId, weight):
2997 
    """
2998 
    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 2999 
 
3451 chandransh 3000 
    Parameters:
3001 
     - orderId
3002 
     - weight
3003 
    """
3004 
    self.send_updateWeight(orderId, weight)
3005 
    return self.recv_updateWeight()
3006 
 
3007 
  def send_updateWeight(self, orderId, weight):
3008 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3009 
    args = updateWeight_args()
3010 
    args.orderId = orderId
3011 
    args.weight = weight
3012 
    args.write(self._oprot)
3013 
    self._oprot.writeMessageEnd()
3014 
    self._oprot.trans.flush()
3015 
 
3016 
  def recv_updateWeight(self, ):
3017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3018 
    if mtype == TMessageType.EXCEPTION:
3019 
      x = TApplicationException()
3020 
      x.read(self._iprot)
3021 
      self._iprot.readMessageEnd()
3022 
      raise x
3023 
    result = updateWeight_result()
3024 
    result.read(self._iprot)
3025 
    self._iprot.readMessageEnd()
3026 
    if result.success is not None:
3027 
      return result.success
3028 
    if result.ex is not None:
3029 
      raise result.ex
3030 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3031 
 
3469 chandransh 3032 
  def changeItem(self, orderId, itemId):
3033 
    """
3034 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3035 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3036 
 
3469 chandransh 3037 
    Parameters:
3038 
     - orderId
3039 
     - itemId
3040 
    """
3041 
    self.send_changeItem(orderId, itemId)
3042 
    return self.recv_changeItem()
3043 
 
3044 
  def send_changeItem(self, orderId, itemId):
3045 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3046 
    args = changeItem_args()
3047 
    args.orderId = orderId
3048 
    args.itemId = itemId
3049 
    args.write(self._oprot)
3050 
    self._oprot.writeMessageEnd()
3051 
    self._oprot.trans.flush()
3052 
 
3053 
  def recv_changeItem(self, ):
3054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3055 
    if mtype == TMessageType.EXCEPTION:
3056 
      x = TApplicationException()
3057 
      x.read(self._iprot)
3058 
      self._iprot.readMessageEnd()
3059 
      raise x
3060 
    result = changeItem_result()
3061 
    result.read(self._iprot)
3062 
    self._iprot.readMessageEnd()
3063 
    if result.success is not None:
3064 
      return result.success
3065 
    if result.ex is not None:
3066 
      raise result.ex
3067 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3068 
 
3069 
  def shiftToWarehouse(self, orderId, warehouseId):
3070 
    """
3071 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3072 
 
3073 
    Parameters:
3074 
     - orderId
3075 
     - warehouseId
3076 
    """
3077 
    self.send_shiftToWarehouse(orderId, warehouseId)
3078 
    return self.recv_shiftToWarehouse()
3079 
 
3080 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3081 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3082 
    args = shiftToWarehouse_args()
3083 
    args.orderId = orderId
3084 
    args.warehouseId = warehouseId
3085 
    args.write(self._oprot)
3086 
    self._oprot.writeMessageEnd()
3087 
    self._oprot.trans.flush()
3088 
 
3089 
  def recv_shiftToWarehouse(self, ):
3090 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3091 
    if mtype == TMessageType.EXCEPTION:
3092 
      x = TApplicationException()
3093 
      x.read(self._iprot)
3094 
      self._iprot.readMessageEnd()
3095 
      raise x
3096 
    result = shiftToWarehouse_result()
3097 
    result.read(self._iprot)
3098 
    self._iprot.readMessageEnd()
3099 
    if result.success is not None:
3100 
      return result.success
3101 
    if result.ex is not None:
3102 
      raise result.ex
3103 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3104 
 
3986 chandransh 3105 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3106 
    """
3107 
    Adds the given delay reason to the given order.
3986 chandransh 3108 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3109 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3110 
 
3553 chandransh 3111 
    Parameters:
3112 
     - orderId
3113 
     - delayReason
3986 chandransh 3114 
     - furtherDelay
3553 chandransh 3115 
    """
3986 chandransh 3116 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 3117 
    return self.recv_addDelayReason()
3118 
 
3986 chandransh 3119 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3120 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3121 
    args = addDelayReason_args()
3122 
    args.orderId = orderId
3123 
    args.delayReason = delayReason
3986 chandransh 3124 
    args.furtherDelay = furtherDelay
3553 chandransh 3125 
    args.write(self._oprot)
3126 
    self._oprot.writeMessageEnd()
3127 
    self._oprot.trans.flush()
3128 
 
3129 
  def recv_addDelayReason(self, ):
3130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3131 
    if mtype == TMessageType.EXCEPTION:
3132 
      x = TApplicationException()
3133 
      x.read(self._iprot)
3134 
      self._iprot.readMessageEnd()
3135 
      raise x
3136 
    result = addDelayReason_result()
3137 
    result.read(self._iprot)
3138 
    self._iprot.readMessageEnd()
3139 
    if result.success is not None:
3140 
      return result.success
3141 
    if result.ex is not None:
3142 
      raise result.ex
3143 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3144 
 
3956 chandransh 3145 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3146 
    """
3147 
    Marks the COD orders with given AWB nos. as having been processed.
3148 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3149 
 
3956 chandransh 3150 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3151 
    1. There is no order corresponding to an AWB number.
3152 
    2. The captured amount for a payment exceeds the total payment.
3153 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3154 
 
3155 
    Parameters:
3156 
     - collectedAmountMap
3157 
     - xferBy
3158 
     - xferTxnId
3159 
     - xferDate
3160 
    """
3161 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3162 
    return self.recv_reconcileCodCollection()
3163 
 
3164 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3165 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3166 
    args = reconcileCodCollection_args()
3167 
    args.collectedAmountMap = collectedAmountMap
3168 
    args.xferBy = xferBy
3169 
    args.xferTxnId = xferTxnId
3170 
    args.xferDate = xferDate
3171 
    args.write(self._oprot)
3172 
    self._oprot.writeMessageEnd()
3173 
    self._oprot.trans.flush()
3174 
 
3175 
  def recv_reconcileCodCollection(self, ):
3176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3177 
    if mtype == TMessageType.EXCEPTION:
3178 
      x = TApplicationException()
3179 
      x.read(self._iprot)
3180 
      self._iprot.readMessageEnd()
3181 
      raise x
3182 
    result = reconcileCodCollection_result()
3183 
    result.read(self._iprot)
3184 
    self._iprot.readMessageEnd()
3185 
    if result.success is not None:
3186 
      return result.success
3187 
    if result.ex is not None:
3188 
      raise result.ex
3189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3190 
 
4008 mandeep.dh 3191 
  def getTransactionsRequiringExtraProcessing(self, category):
3192 
    """
4065 mandeep.dh 3193 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3194 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3195 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3196 
 
4008 mandeep.dh 3197 
    Parameters:
3198 
     - category
3199 
    """
3200 
    self.send_getTransactionsRequiringExtraProcessing(category)
3201 
    return self.recv_getTransactionsRequiringExtraProcessing()
3202 
 
3203 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3204 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3205 
    args = getTransactionsRequiringExtraProcessing_args()
3206 
    args.category = category
3207 
    args.write(self._oprot)
3208 
    self._oprot.writeMessageEnd()
3209 
    self._oprot.trans.flush()
3210 
 
3211 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3213 
    if mtype == TMessageType.EXCEPTION:
3214 
      x = TApplicationException()
3215 
      x.read(self._iprot)
3216 
      self._iprot.readMessageEnd()
3217 
      raise x
3218 
    result = getTransactionsRequiringExtraProcessing_result()
3219 
    result.read(self._iprot)
3220 
    self._iprot.readMessageEnd()
3221 
    if result.success is not None:
3222 
      return result.success
3223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3224 
 
3225 
  def markTransactionAsProcessed(self, transactionId, category):
3226 
    """
3227 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3228 
    It essentially deletes the transaction id record for a particular
3229 
    processing type category (if present) from DB.
3230 
    This is currently used by CRM application.
4008 mandeep.dh 3231 
 
3232 
    Parameters:
3233 
     - transactionId
3234 
     - category
3235 
    """
3236 
    self.send_markTransactionAsProcessed(transactionId, category)
3237 
    self.recv_markTransactionAsProcessed()
3238 
 
3239 
  def send_markTransactionAsProcessed(self, transactionId, category):
3240 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3241 
    args = markTransactionAsProcessed_args()
3242 
    args.transactionId = transactionId
3243 
    args.category = category
3244 
    args.write(self._oprot)
3245 
    self._oprot.writeMessageEnd()
3246 
    self._oprot.trans.flush()
3247 
 
3248 
  def recv_markTransactionAsProcessed(self, ):
3249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3250 
    if mtype == TMessageType.EXCEPTION:
3251 
      x = TApplicationException()
3252 
      x.read(self._iprot)
3253 
      self._iprot.readMessageEnd()
3254 
      raise x
3255 
    result = markTransactionAsProcessed_result()
3256 
    result.read(self._iprot)
3257 
    self._iprot.readMessageEnd()
3258 
    return
3259 
 
4018 chandransh 3260 
  def getItemWiseRiskyOrdersCount(self, ):
3261 
    """
3262 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3263 
    is defined as one whose shipping date is about to expire.
3264 
    """
3265 
    self.send_getItemWiseRiskyOrdersCount()
3266 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3267 
 
4018 chandransh 3268 
  def send_getItemWiseRiskyOrdersCount(self, ):
3269 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3270 
    args = getItemWiseRiskyOrdersCount_args()
3271 
    args.write(self._oprot)
3272 
    self._oprot.writeMessageEnd()
3273 
    self._oprot.trans.flush()
3274 
 
3275 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3277 
    if mtype == TMessageType.EXCEPTION:
3278 
      x = TApplicationException()
3279 
      x.read(self._iprot)
3280 
      self._iprot.readMessageEnd()
3281 
      raise x
3282 
    result = getItemWiseRiskyOrdersCount_result()
3283 
    result.read(self._iprot)
3284 
    self._iprot.readMessageEnd()
3285 
    if result.success is not None:
3286 
      return result.success
3287 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3288 
 
4295 varun.gupt 3289 
  def getOrdersForItemIds(self, itemIds):
3290 
    """
3291 
    Returns a list of all orders which have items with given id
3292 
 
3293 
    Parameters:
3294 
     - itemIds
3295 
    """
3296 
    self.send_getOrdersForItemIds(itemIds)
3297 
    return self.recv_getOrdersForItemIds()
3298 
 
3299 
  def send_getOrdersForItemIds(self, itemIds):
3300 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3301 
    args = getOrdersForItemIds_args()
3302 
    args.itemIds = itemIds
3303 
    args.write(self._oprot)
3304 
    self._oprot.writeMessageEnd()
3305 
    self._oprot.trans.flush()
3306 
 
3307 
  def recv_getOrdersForItemIds(self, ):
3308 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3309 
    if mtype == TMessageType.EXCEPTION:
3310 
      x = TApplicationException()
3311 
      x.read(self._iprot)
3312 
      self._iprot.readMessageEnd()
3313 
      raise x
3314 
    result = getOrdersForItemIds_result()
3315 
    result.read(self._iprot)
3316 
    self._iprot.readMessageEnd()
3317 
    if result.success is not None:
3318 
      return result.success
3319 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3320 
 
4247 rajveer 3321 
  def markOrderCancellationRequestReceived(self, orderId):
3322 
    """
3323 
    Mark order as cancellation request received. If customer sends request of cancellation of
3324 
    a particular order, this method will be called. It will just change status of the order
3325 
    depending on its current status. It also records the previous status, so that we can move
3326 
    back to that status if cancellation request is denied.
4018 chandransh 3327 
 
4247 rajveer 3328 
    Parameters:
3329 
     - orderId
3330 
    """
3331 
    self.send_markOrderCancellationRequestReceived(orderId)
3332 
    self.recv_markOrderCancellationRequestReceived()
3333 
 
3334 
  def send_markOrderCancellationRequestReceived(self, orderId):
3335 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3336 
    args = markOrderCancellationRequestReceived_args()
3337 
    args.orderId = orderId
3338 
    args.write(self._oprot)
3339 
    self._oprot.writeMessageEnd()
3340 
    self._oprot.trans.flush()
3341 
 
3342 
  def recv_markOrderCancellationRequestReceived(self, ):
3343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3344 
    if mtype == TMessageType.EXCEPTION:
3345 
      x = TApplicationException()
3346 
      x.read(self._iprot)
3347 
      self._iprot.readMessageEnd()
3348 
      raise x
3349 
    result = markOrderCancellationRequestReceived_result()
3350 
    result.read(self._iprot)
3351 
    self._iprot.readMessageEnd()
3352 
    if result.ex is not None:
3353 
      raise result.ex
3354 
    return
3355 
 
3356 
  def markOrderCancellationRequestConfirmed(self, orderId):
3357 
    """
3358 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3359 
    cancellation request confirmed. After this OM will be able to cancel the order.
3360 
 
3361 
    Parameters:
3362 
     - orderId
3363 
    """
3364 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3365 
    self.recv_markOrderCancellationRequestConfirmed()
3366 
 
3367 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3368 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3369 
    args = markOrderCancellationRequestConfirmed_args()
3370 
    args.orderId = orderId
3371 
    args.write(self._oprot)
3372 
    self._oprot.writeMessageEnd()
3373 
    self._oprot.trans.flush()
3374 
 
3375 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3377 
    if mtype == TMessageType.EXCEPTION:
3378 
      x = TApplicationException()
3379 
      x.read(self._iprot)
3380 
      self._iprot.readMessageEnd()
3381 
      raise x
3382 
    result = markOrderCancellationRequestConfirmed_result()
3383 
    result.read(self._iprot)
3384 
    self._iprot.readMessageEnd()
3385 
    if result.ex is not None:
3386 
      raise result.ex
3387 
    return
3388 
 
3389 
  def markOrderCancellationRequestDenied(self, orderId):
3390 
    """
3391 
    If we decide to not to cancel order, we will move the order ro previous status.
3392 
 
3393 
    Parameters:
3394 
     - orderId
3395 
    """
3396 
    self.send_markOrderCancellationRequestDenied(orderId)
3397 
    self.recv_markOrderCancellationRequestDenied()
3398 
 
3399 
  def send_markOrderCancellationRequestDenied(self, orderId):
3400 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3401 
    args = markOrderCancellationRequestDenied_args()
3402 
    args.orderId = orderId
3403 
    args.write(self._oprot)
3404 
    self._oprot.writeMessageEnd()
3405 
    self._oprot.trans.flush()
3406 
 
3407 
  def recv_markOrderCancellationRequestDenied(self, ):
3408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3409 
    if mtype == TMessageType.EXCEPTION:
3410 
      x = TApplicationException()
3411 
      x.read(self._iprot)
3412 
      self._iprot.readMessageEnd()
3413 
      raise x
3414 
    result = markOrderCancellationRequestDenied_result()
3415 
    result.read(self._iprot)
3416 
    self._iprot.readMessageEnd()
3417 
    if result.ex is not None:
3418 
      raise result.ex
3419 
    return
3420 
 
4258 rajveer 3421 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3422 
    """
4258 rajveer 3423 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3424 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3425 
 
3426 
    Parameters:
4258 rajveer 3427 
     - transactionId
4247 rajveer 3428 
    """
4258 rajveer 3429 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3430 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3431 
 
4258 rajveer 3432 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3433 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3434 
    args = markTransactionAsPaymentFlagRemoved_args()
3435 
    args.transactionId = transactionId
4247 rajveer 3436 
    args.write(self._oprot)
3437 
    self._oprot.writeMessageEnd()
3438 
    self._oprot.trans.flush()
3439 
 
4258 rajveer 3440 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3442 
    if mtype == TMessageType.EXCEPTION:
3443 
      x = TApplicationException()
3444 
      x.read(self._iprot)
3445 
      self._iprot.readMessageEnd()
3446 
      raise x
4258 rajveer 3447 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3448 
    result.read(self._iprot)
3449 
    self._iprot.readMessageEnd()
3450 
    if result.ex is not None:
3451 
      raise result.ex
3452 
    return
3453 
 
4259 anupam.sin 3454 
  def refundTransaction(self, transactionId, refundedBy, reason):
3455 
    """
3456 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3457 
    need to be cancelled
4247 rajveer 3458 
 
4259 anupam.sin 3459 
    Parameters:
3460 
     - transactionId
3461 
     - refundedBy
3462 
     - reason
3463 
    """
3464 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3465 
    self.recv_refundTransaction()
3466 
 
3467 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3468 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3469 
    args = refundTransaction_args()
3470 
    args.transactionId = transactionId
3471 
    args.refundedBy = refundedBy
3472 
    args.reason = reason
3473 
    args.write(self._oprot)
3474 
    self._oprot.writeMessageEnd()
3475 
    self._oprot.trans.flush()
3476 
 
3477 
  def recv_refundTransaction(self, ):
3478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3479 
    if mtype == TMessageType.EXCEPTION:
3480 
      x = TApplicationException()
3481 
      x.read(self._iprot)
3482 
      self._iprot.readMessageEnd()
3483 
      raise x
3484 
    result = refundTransaction_result()
3485 
    result.read(self._iprot)
3486 
    self._iprot.readMessageEnd()
3487 
    if result.ex is not None:
3488 
      raise result.ex
3489 
    return
3490 
 
4324 mandeep.dh 3491 
  def updateShipmentAddress(self, orderId, addressId):
3492 
    """
3493 
    Updates shipment address of an order. Delivery and shipping date estimates
3494 
    etc. are also updated here.
3495 
 
3496 
    Throws TransactionServiceException in case address change is not
3497 
    possible due to certain reasons such as new pincode in address is
3498 
    not serviceable etc.
3499 
 
3500 
    Parameters:
3501 
     - orderId
3502 
     - addressId
3503 
    """
3504 
    self.send_updateShipmentAddress(orderId, addressId)
3505 
    self.recv_updateShipmentAddress()
3506 
 
3507 
  def send_updateShipmentAddress(self, orderId, addressId):
3508 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3509 
    args = updateShipmentAddress_args()
3510 
    args.orderId = orderId
3511 
    args.addressId = addressId
3512 
    args.write(self._oprot)
3513 
    self._oprot.writeMessageEnd()
3514 
    self._oprot.trans.flush()
3515 
 
3516 
  def recv_updateShipmentAddress(self, ):
3517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3518 
    if mtype == TMessageType.EXCEPTION:
3519 
      x = TApplicationException()
3520 
      x.read(self._iprot)
3521 
      self._iprot.readMessageEnd()
3522 
      raise x
3523 
    result = updateShipmentAddress_result()
3524 
    result.read(self._iprot)
3525 
    self._iprot.readMessageEnd()
3526 
    if result.ex is not None:
3527 
      raise result.ex
3528 
    return
3529 
 
4285 rajveer 3530 
  def acceptOrdersForItemId(self, itemId, inventory):
3531 
    """
3532 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3533 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3534 
 
4285 rajveer 3535 
    Parameters:
3536 
     - itemId
3537 
     - inventory
3538 
    """
3539 
    self.send_acceptOrdersForItemId(itemId, inventory)
3540 
    return self.recv_acceptOrdersForItemId()
3541 
 
3542 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3543 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3544 
    args = acceptOrdersForItemId_args()
3545 
    args.itemId = itemId
3546 
    args.inventory = inventory
3547 
    args.write(self._oprot)
3548 
    self._oprot.writeMessageEnd()
3549 
    self._oprot.trans.flush()
3550 
 
3551 
  def recv_acceptOrdersForItemId(self, ):
3552 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3553 
    if mtype == TMessageType.EXCEPTION:
3554 
      x = TApplicationException()
3555 
      x.read(self._iprot)
3556 
      self._iprot.readMessageEnd()
3557 
      raise x
3558 
    result = acceptOrdersForItemId_result()
3559 
    result.read(self._iprot)
3560 
    self._iprot.readMessageEnd()
3561 
    if result.success is not None:
3562 
      return result.success
3563 
    if result.ex is not None:
3564 
      raise result.ex
3565 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3566 
 
4369 rajveer 3567 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3568 
    """
3569 
    Parameters:
3570 
     - vendorId
3571 
     - itemId
3572 
     - quantity
3573 
     - estimate
4369 rajveer 3574 
     - isReminder
4303 rajveer 3575 
    """
4369 rajveer 3576 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3577 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3578 
 
4369 rajveer 3579 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3580 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3581 
    args = markOrdersAsPORaised_args()
3582 
    args.vendorId = vendorId
3583 
    args.itemId = itemId
3584 
    args.quantity = quantity
3585 
    args.estimate = estimate
4369 rajveer 3586 
    args.isReminder = isReminder
4303 rajveer 3587 
    args.write(self._oprot)
3588 
    self._oprot.writeMessageEnd()
3589 
    self._oprot.trans.flush()
3590 
 
3591 
  def recv_markOrdersAsPORaised(self, ):
3592 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3593 
    if mtype == TMessageType.EXCEPTION:
3594 
      x = TApplicationException()
3595 
      x.read(self._iprot)
3596 
      self._iprot.readMessageEnd()
3597 
      raise x
3598 
    result = markOrdersAsPORaised_result()
3599 
    result.read(self._iprot)
3600 
    self._iprot.readMessageEnd()
3601 
    if result.ex is not None:
3602 
      raise result.ex
3603 
    return
3604 
 
4369 rajveer 3605 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3606 
    """
3607 
    Parameters:
3608 
     - vendorId
3609 
     - itemId
3610 
     - quantity
3611 
     - estimate
4369 rajveer 3612 
     - isReminder
4303 rajveer 3613 
    """
4369 rajveer 3614 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3615 
    self.recv_markOrdersAsReversalInitiated()
3616 
 
4369 rajveer 3617 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3618 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3619 
    args = markOrdersAsReversalInitiated_args()
3620 
    args.vendorId = vendorId
3621 
    args.itemId = itemId
3622 
    args.quantity = quantity
3623 
    args.estimate = estimate
4369 rajveer 3624 
    args.isReminder = isReminder
4303 rajveer 3625 
    args.write(self._oprot)
3626 
    self._oprot.writeMessageEnd()
3627 
    self._oprot.trans.flush()
3628 
 
3629 
  def recv_markOrdersAsReversalInitiated(self, ):
3630 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3631 
    if mtype == TMessageType.EXCEPTION:
3632 
      x = TApplicationException()
3633 
      x.read(self._iprot)
3634 
      self._iprot.readMessageEnd()
3635 
      raise x
3636 
    result = markOrdersAsReversalInitiated_result()
3637 
    result.read(self._iprot)
3638 
    self._iprot.readMessageEnd()
3639 
    if result.ex is not None:
3640 
      raise result.ex
3641 
    return
3642 
 
4369 rajveer 3643 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3644 
    """
3645 
    Parameters:
3646 
     - vendorId
3647 
     - itemId
3648 
     - quantity
3649 
     - estimate
4369 rajveer 3650 
     - isReminder
4303 rajveer 3651 
    """
4369 rajveer 3652 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3653 
    self.recv_markOrdersAsNotAvailabke()
3654 
 
4369 rajveer 3655 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3656 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3657 
    args = markOrdersAsNotAvailabke_args()
3658 
    args.vendorId = vendorId
3659 
    args.itemId = itemId
3660 
    args.quantity = quantity
3661 
    args.estimate = estimate
4369 rajveer 3662 
    args.isReminder = isReminder
4303 rajveer 3663 
    args.write(self._oprot)
3664 
    self._oprot.writeMessageEnd()
3665 
    self._oprot.trans.flush()
3666 
 
3667 
  def recv_markOrdersAsNotAvailabke(self, ):
3668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3669 
    if mtype == TMessageType.EXCEPTION:
3670 
      x = TApplicationException()
3671 
      x.read(self._iprot)
3672 
      self._iprot.readMessageEnd()
3673 
      raise x
3674 
    result = markOrdersAsNotAvailabke_result()
3675 
    result.read(self._iprot)
3676 
    self._iprot.readMessageEnd()
3677 
    if result.ex is not None:
3678 
      raise result.ex
3679 
    return
3680 
 
4369 rajveer 3681 
  def markOrdersAsTimeout(self, vendorId):
3682 
    """
3683 
    Parameters:
3684 
     - vendorId
3685 
    """
3686 
    self.send_markOrdersAsTimeout(vendorId)
3687 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3688 
 
4369 rajveer 3689 
  def send_markOrdersAsTimeout(self, vendorId):
3690 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3691 
    args = markOrdersAsTimeout_args()
3692 
    args.vendorId = vendorId
3693 
    args.write(self._oprot)
3694 
    self._oprot.writeMessageEnd()
3695 
    self._oprot.trans.flush()
3696 
 
3697 
  def recv_markOrdersAsTimeout(self, ):
3698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3699 
    if mtype == TMessageType.EXCEPTION:
3700 
      x = TApplicationException()
3701 
      x.read(self._iprot)
3702 
      self._iprot.readMessageEnd()
3703 
      raise x
3704 
    result = markOrdersAsTimeout_result()
3705 
    result.read(self._iprot)
3706 
    self._iprot.readMessageEnd()
3707 
    if result.success is not None:
3708 
      return result.success
3709 
    if result.ex is not None:
3710 
      raise result.ex
3711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3712 
 
4386 anupam.sin 3713 
  def getOrderForAwb(self, awb):
3714 
    """
3715 
    Returns the order corresponding to an AWB number
4369 rajveer 3716 
 
4386 anupam.sin 3717 
    Parameters:
3718 
     - awb
3719 
    """
3720 
    self.send_getOrderForAwb(awb)
3721 
    return self.recv_getOrderForAwb()
3722 
 
3723 
  def send_getOrderForAwb(self, awb):
3724 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3725 
    args = getOrderForAwb_args()
3726 
    args.awb = awb
3727 
    args.write(self._oprot)
3728 
    self._oprot.writeMessageEnd()
3729 
    self._oprot.trans.flush()
3730 
 
3731 
  def recv_getOrderForAwb(self, ):
3732 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3733 
    if mtype == TMessageType.EXCEPTION:
3734 
      x = TApplicationException()
3735 
      x.read(self._iprot)
3736 
      self._iprot.readMessageEnd()
3737 
      raise x
3738 
    result = getOrderForAwb_result()
3739 
    result.read(self._iprot)
3740 
    self._iprot.readMessageEnd()
3741 
    if result.success is not None:
3742 
      return result.success
3743 
    if result.ex is not None:
3744 
      raise result.ex
3745 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3746 
 
4506 phani.kuma 3747 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3748 
    """
3749 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3750 
 
4506 phani.kuma 3751 
    Parameters:
3752 
     - logistics_provider_id
3753 
     - order_status
3754 
    """
3755 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
3756 
    return self.recv_getOrdersForProviderForStatus()
3757 
 
3758 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3759 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
3760 
    args = getOrdersForProviderForStatus_args()
3761 
    args.logistics_provider_id = logistics_provider_id
3762 
    args.order_status = order_status
3763 
    args.write(self._oprot)
3764 
    self._oprot.writeMessageEnd()
3765 
    self._oprot.trans.flush()
3766 
 
3767 
  def recv_getOrdersForProviderForStatus(self, ):
3768 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3769 
    if mtype == TMessageType.EXCEPTION:
3770 
      x = TApplicationException()
3771 
      x.read(self._iprot)
3772 
      self._iprot.readMessageEnd()
3773 
      raise x
3774 
    result = getOrdersForProviderForStatus_result()
3775 
    result.read(self._iprot)
3776 
    self._iprot.readMessageEnd()
3777 
    if result.success is not None:
3778 
      return result.success
3779 
    if result.ex is not None:
3780 
      raise result.ex
3781 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
3782 
 
3783 
 
3376 rajveer 3784 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3785 
  def __init__(self, handler):
3376 rajveer 3786 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3787 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3788 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3789 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3790 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3791 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3792 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3793 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3794 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3795 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3796 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3797 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3798 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3799 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3800 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3801 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3802 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3803 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3804 
    self._processMap["createOrder"] = Processor.process_createOrder
3805 
    self._processMap["getOrder"] = Processor.process_getOrder
3806 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3807 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3808 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 3809 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 3810 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 3811 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3812 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3813 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3814 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3815 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3816 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3817 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3818 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3819 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 3820 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 3821 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 3822 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 3823 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3824 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3825 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3826 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3827 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3828 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4454 rajveer 3829 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
3830 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 3831 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
3832 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 3833 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3834 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3835 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3836 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3837 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 3838 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 3839 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3840 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3841 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3842 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3843 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3844 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3845 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3846 
    self._processMap["changeItem"] = Processor.process_changeItem
3847 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3848 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3849 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3850 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3851 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3852 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 3853 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 3854 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3855 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3856 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3857 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3858 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 3859 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 3860 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 3861 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
3862 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
3863 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 3864 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4386 anupam.sin 3865 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 3866 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
94 ashish 3867 
 
3868 
  def process(self, iprot, oprot):
3869 
    (name, type, seqid) = iprot.readMessageBegin()
3870 
    if name not in self._processMap:
3871 
      iprot.skip(TType.STRUCT)
3872 
      iprot.readMessageEnd()
3873 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3874 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3875 
      x.write(oprot)
3876 
      oprot.writeMessageEnd()
3877 
      oprot.trans.flush()
3878 
      return
3879 
    else:
3880 
      self._processMap[name](self, seqid, iprot, oprot)
3881 
    return True
3882 
 
3883 
  def process_createTransaction(self, seqid, iprot, oprot):
3884 
    args = createTransaction_args()
3885 
    args.read(iprot)
3886 
    iprot.readMessageEnd()
3887 
    result = createTransaction_result()
3888 
    try:
132 ashish 3889 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3890 
    except TransactionServiceException, ex:
3891 
      result.ex = ex
3892 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3893 
    result.write(oprot)
3894 
    oprot.writeMessageEnd()
3895 
    oprot.trans.flush()
3896 
 
3897 
  def process_getTransaction(self, seqid, iprot, oprot):
3898 
    args = getTransaction_args()
3899 
    args.read(iprot)
3900 
    iprot.readMessageEnd()
3901 
    result = getTransaction_result()
3902 
    try:
3903 
      result.success = self._handler.getTransaction(args.id)
3904 
    except TransactionServiceException, ex:
3905 
      result.ex = ex
3906 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3907 
    result.write(oprot)
3908 
    oprot.writeMessageEnd()
3909 
    oprot.trans.flush()
3910 
 
3911 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3912 
    args = getTransactionsForCustomer_args()
3913 
    args.read(iprot)
3914 
    iprot.readMessageEnd()
3915 
    result = getTransactionsForCustomer_result()
3916 
    try:
3917 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3918 
    except TransactionServiceException, ex:
3919 
      result.ex = ex
3920 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3921 
    result.write(oprot)
3922 
    oprot.writeMessageEnd()
3923 
    oprot.trans.flush()
3924 
 
132 ashish 3925 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3926 
    args = getTransactionsForShoppingCartId_args()
3927 
    args.read(iprot)
3928 
    iprot.readMessageEnd()
3929 
    result = getTransactionsForShoppingCartId_result()
3930 
    try:
3931 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3932 
    except TransactionServiceException, ex:
3933 
      result.ex = ex
3934 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3935 
    result.write(oprot)
3936 
    oprot.writeMessageEnd()
3937 
    oprot.trans.flush()
3938 
 
94 ashish 3939 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3940 
    args = getTransactionStatus_args()
3941 
    args.read(iprot)
3942 
    iprot.readMessageEnd()
3943 
    result = getTransactionStatus_result()
3944 
    try:
3945 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3946 
    except TransactionServiceException, ex:
3947 
      result.ex = ex
3948 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3949 
    result.write(oprot)
3950 
    oprot.writeMessageEnd()
3951 
    oprot.trans.flush()
3952 
 
3953 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3954 
    args = changeTransactionStatus_args()
3955 
    args.read(iprot)
3956 
    iprot.readMessageEnd()
3957 
    result = changeTransactionStatus_result()
3958 
    try:
3959 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3960 
    except TransactionServiceException, ex:
3961 
      result.ex = ex
3962 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3963 
    result.write(oprot)
3964 
    oprot.writeMessageEnd()
3965 
    oprot.trans.flush()
3966 
 
1398 varun.gupt 3967 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3968 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3969 
    args.read(iprot)
3970 
    iprot.readMessageEnd()
1398 varun.gupt 3971 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3972 
    try:
1398 varun.gupt 3973 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3974 
    except TransactionServiceException, ex:
3975 
      result.ex = ex
1398 varun.gupt 3976 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3977 
    result.write(oprot)
3978 
    oprot.writeMessageEnd()
3979 
    oprot.trans.flush()
3980 
 
483 rajveer 3981 
  def process_getAllOrders(self, seqid, iprot, oprot):
3982 
    args = getAllOrders_args()
94 ashish 3983 
    args.read(iprot)
3984 
    iprot.readMessageEnd()
483 rajveer 3985 
    result = getAllOrders_result()
94 ashish 3986 
    try:
483 rajveer 3987 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3988 
    except TransactionServiceException, ex:
3989 
      result.ex = ex
483 rajveer 3990 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3991 
    result.write(oprot)
3992 
    oprot.writeMessageEnd()
3993 
    oprot.trans.flush()
3994 
 
4133 chandransh 3995 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3996 
    args = getOrdersInBatch_args()
3997 
    args.read(iprot)
3998 
    iprot.readMessageEnd()
3999 
    result = getOrdersInBatch_result()
4000 
    try:
4001 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4002 
    except TransactionServiceException, ex:
4003 
      result.ex = ex
4004 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4005 
    result.write(oprot)
4006 
    oprot.writeMessageEnd()
4007 
    oprot.trans.flush()
4008 
 
4009 
  def process_getOrderCount(self, seqid, iprot, oprot):
4010 
    args = getOrderCount_args()
4011 
    args.read(iprot)
4012 
    iprot.readMessageEnd()
4013 
    result = getOrderCount_result()
4014 
    try:
4015 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4016 
    except TransactionServiceException, ex:
4017 
      result.ex = ex
4018 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4019 
    result.write(oprot)
4020 
    oprot.writeMessageEnd()
4021 
    oprot.trans.flush()
4022 
 
999 varun.gupt 4023 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4024 
    args = getOrdersByBillingDate_args()
4025 
    args.read(iprot)
4026 
    iprot.readMessageEnd()
4027 
    result = getOrdersByBillingDate_result()
4028 
    try:
4029 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4030 
    except TransactionServiceException, ex:
4031 
      result.ex = ex
4032 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4033 
    result.write(oprot)
4034 
    oprot.writeMessageEnd()
4035 
    oprot.trans.flush()
4036 
 
3427 chandransh 4037 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4038 
    args = getOrdersByShippingDate_args()
4039 
    args.read(iprot)
4040 
    iprot.readMessageEnd()
4041 
    result = getOrdersByShippingDate_result()
4042 
    try:
3451 chandransh 4043 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4044 
    except TransactionServiceException, ex:
4045 
      result.ex = ex
4046 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4047 
    result.write(oprot)
4048 
    oprot.writeMessageEnd()
4049 
    oprot.trans.flush()
4050 
 
1382 varun.gupt 4051 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4052 
    args = getReturnableOrdersForCustomer_args()
4053 
    args.read(iprot)
4054 
    iprot.readMessageEnd()
4055 
    result = getReturnableOrdersForCustomer_result()
4056 
    try:
4057 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4058 
    except TransactionServiceException, ex:
4059 
      result.ex = ex
4060 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4061 
    result.write(oprot)
4062 
    oprot.writeMessageEnd()
4063 
    oprot.trans.flush()
4064 
 
4065 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4066 
    args = getCancellableOrdersForCustomer_args()
4067 
    args.read(iprot)
4068 
    iprot.readMessageEnd()
4069 
    result = getCancellableOrdersForCustomer_result()
4070 
    try:
4071 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4072 
    except TransactionServiceException, ex:
4073 
      result.ex = ex
4074 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4075 
    result.write(oprot)
4076 
    oprot.writeMessageEnd()
4077 
    oprot.trans.flush()
4078 
 
483 rajveer 4079 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4080 
    args = changeOrderStatus_args()
94 ashish 4081 
    args.read(iprot)
4082 
    iprot.readMessageEnd()
483 rajveer 4083 
    result = changeOrderStatus_result()
94 ashish 4084 
    try:
483 rajveer 4085 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4086 
    except TransactionServiceException, ex:
4087 
      result.ex = ex
483 rajveer 4088 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4089 
    result.write(oprot)
4090 
    oprot.writeMessageEnd()
4091 
    oprot.trans.flush()
4092 
 
483 rajveer 4093 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4094 
    args = getOrdersForTransaction_args()
94 ashish 4095 
    args.read(iprot)
4096 
    iprot.readMessageEnd()
483 rajveer 4097 
    result = getOrdersForTransaction_result()
94 ashish 4098 
    try:
1528 ankur.sing 4099 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4100 
    except TransactionServiceException, ex:
4101 
      result.ex = ex
483 rajveer 4102 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4103 
    result.write(oprot)
4104 
    oprot.writeMessageEnd()
4105 
    oprot.trans.flush()
4106 
 
483 rajveer 4107 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4108 
    args = getOrdersForCustomer_args()
94 ashish 4109 
    args.read(iprot)
4110 
    iprot.readMessageEnd()
483 rajveer 4111 
    result = getOrdersForCustomer_result()
94 ashish 4112 
    try:
3014 chandransh 4113 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4114 
    except TransactionServiceException, ex:
4115 
      result.ex = ex
483 rajveer 4116 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4117 
    result.write(oprot)
4118 
    oprot.writeMessageEnd()
4119 
    oprot.trans.flush()
4120 
 
483 rajveer 4121 
  def process_createOrder(self, seqid, iprot, oprot):
4122 
    args = createOrder_args()
94 ashish 4123 
    args.read(iprot)
4124 
    iprot.readMessageEnd()
483 rajveer 4125 
    result = createOrder_result()
94 ashish 4126 
    try:
483 rajveer 4127 
      result.success = self._handler.createOrder(args.order)
94 ashish 4128 
    except TransactionServiceException, ex:
4129 
      result.ex = ex
483 rajveer 4130 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4131 
    result.write(oprot)
4132 
    oprot.writeMessageEnd()
4133 
    oprot.trans.flush()
4134 
 
483 rajveer 4135 
  def process_getOrder(self, seqid, iprot, oprot):
4136 
    args = getOrder_args()
94 ashish 4137 
    args.read(iprot)
4138 
    iprot.readMessageEnd()
483 rajveer 4139 
    result = getOrder_result()
94 ashish 4140 
    try:
483 rajveer 4141 
      result.success = self._handler.getOrder(args.id)
94 ashish 4142 
    except TransactionServiceException, ex:
4143 
      result.ex = ex
483 rajveer 4144 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4145 
    result.write(oprot)
4146 
    oprot.writeMessageEnd()
4147 
    oprot.trans.flush()
4148 
 
483 rajveer 4149 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4150 
    args = getLineItemsForOrder_args()
94 ashish 4151 
    args.read(iprot)
4152 
    iprot.readMessageEnd()
483 rajveer 4153 
    result = getLineItemsForOrder_result()
94 ashish 4154 
    try:
483 rajveer 4155 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4156 
    except TransactionServiceException, ex:
4157 
      result.ex = ex
483 rajveer 4158 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4159 
    result.write(oprot)
4160 
    oprot.writeMessageEnd()
4161 
    oprot.trans.flush()
4162 
 
1528 ankur.sing 4163 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4164 
    args = getOrderForCustomer_args()
4165 
    args.read(iprot)
4166 
    iprot.readMessageEnd()
4167 
    result = getOrderForCustomer_result()
4168 
    try:
4169 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4170 
    except TransactionServiceException, ex:
4171 
      result.ex = ex
4172 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4173 
    result.write(oprot)
4174 
    oprot.writeMessageEnd()
4175 
    oprot.trans.flush()
4176 
 
3064 chandransh 4177 
  def process_getAlerts(self, seqid, iprot, oprot):
4178 
    args = getAlerts_args()
4179 
    args.read(iprot)
4180 
    iprot.readMessageEnd()
4181 
    result = getAlerts_result()
4444 rajveer 4182 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4183 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4184 
    result.write(oprot)
4185 
    oprot.writeMessageEnd()
4186 
    oprot.trans.flush()
4187 
 
4394 rajveer 4188 
  def process_addAlert(self, seqid, iprot, oprot):
4189 
    args = addAlert_args()
3064 chandransh 4190 
    args.read(iprot)
4191 
    iprot.readMessageEnd()
4394 rajveer 4192 
    result = addAlert_result()
4444 rajveer 4193 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4194 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4195 
    result.write(oprot)
4196 
    oprot.writeMessageEnd()
4197 
    oprot.trans.flush()
4198 
 
4444 rajveer 4199 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4200 
    args = markAlertsAsSeen_args()
4201 
    args.read(iprot)
4202 
    iprot.readMessageEnd()
4203 
    result = markAlertsAsSeen_result()
4204 
    self._handler.markAlertsAsSeen(args.warehouseId)
4205 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4206 
    result.write(oprot)
4207 
    oprot.writeMessageEnd()
4208 
    oprot.trans.flush()
4209 
 
3064 chandransh 4210 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4211 
    args = getValidOrderCount_args()
4212 
    args.read(iprot)
4213 
    iprot.readMessageEnd()
4214 
    result = getValidOrderCount_result()
4215 
    result.success = self._handler.getValidOrderCount()
4216 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4217 
    result.write(oprot)
4218 
    oprot.writeMessageEnd()
4219 
    oprot.trans.flush()
4220 
 
4221 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4222 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4223 
    args.read(iprot)
4224 
    iprot.readMessageEnd()
4225 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4226 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4227 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4228 
    result.write(oprot)
4229 
    oprot.writeMessageEnd()
4230 
    oprot.trans.flush()
4231 
 
4232 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4233 
    args = getValidOrdersAmountRange_args()
4234 
    args.read(iprot)
4235 
    iprot.readMessageEnd()
4236 
    result = getValidOrdersAmountRange_result()
4237 
    result.success = self._handler.getValidOrdersAmountRange()
4238 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4239 
    result.write(oprot)
4240 
    oprot.writeMessageEnd()
4241 
    oprot.trans.flush()
4242 
 
4243 
  def process_getValidOrders(self, seqid, iprot, oprot):
4244 
    args = getValidOrders_args()
4245 
    args.read(iprot)
4246 
    iprot.readMessageEnd()
4247 
    result = getValidOrders_result()
4248 
    result.success = self._handler.getValidOrders(args.limit)
4249 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4250 
    result.write(oprot)
4251 
    oprot.writeMessageEnd()
4252 
    oprot.trans.flush()
4253 
 
1220 chandransh 4254 
  def process_batchOrders(self, seqid, iprot, oprot):
4255 
    args = batchOrders_args()
4256 
    args.read(iprot)
4257 
    iprot.readMessageEnd()
4258 
    result = batchOrders_result()
4259 
    try:
4260 
      result.success = self._handler.batchOrders(args.warehouseId)
4261 
    except TransactionServiceException, ex:
4262 
      result.ex = ex
4263 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4264 
    result.write(oprot)
4265 
    oprot.writeMessageEnd()
4266 
    oprot.trans.flush()
4267 
 
1208 chandransh 4268 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4269 
    args = markOrderAsOutOfStock_args()
4270 
    args.read(iprot)
4271 
    iprot.readMessageEnd()
4272 
    result = markOrderAsOutOfStock_result()
4273 
    try:
4274 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4275 
    except TransactionServiceException, ex:
4276 
      result.ex = ex
4277 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4278 
    result.write(oprot)
4279 
    oprot.writeMessageEnd()
4280 
    oprot.trans.flush()
4281 
 
3064 chandransh 4282 
  def process_verifyOrder(self, seqid, iprot, oprot):
4283 
    args = verifyOrder_args()
759 chandransh 4284 
    args.read(iprot)
4285 
    iprot.readMessageEnd()
3064 chandransh 4286 
    result = verifyOrder_result()
759 chandransh 4287 
    try:
3064 chandransh 4288 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4289 
    except TransactionServiceException, ex:
4290 
      result.ex = ex
3064 chandransh 4291 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4292 
    result.write(oprot)
4293 
    oprot.writeMessageEnd()
4294 
    oprot.trans.flush()
4295 
 
3064 chandransh 4296 
  def process_acceptOrder(self, seqid, iprot, oprot):
4297 
    args = acceptOrder_args()
1113 chandransh 4298 
    args.read(iprot)
4299 
    iprot.readMessageEnd()
3064 chandransh 4300 
    result = acceptOrder_result()
1113 chandransh 4301 
    try:
3064 chandransh 4302 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4303 
    except TransactionServiceException, ex:
4304 
      result.ex = ex
3064 chandransh 4305 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4306 
    result.write(oprot)
4307 
    oprot.writeMessageEnd()
4308 
    oprot.trans.flush()
4309 
 
3064 chandransh 4310 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4311 
    args = addBillingDetails_args()
1135 chandransh 4312 
    args.read(iprot)
4313 
    iprot.readMessageEnd()
3064 chandransh 4314 
    result = addBillingDetails_result()
1135 chandransh 4315 
    try:
4283 anupam.sin 4316 
      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 4317 
    except TransactionServiceException, ex:
4318 
      result.ex = ex
3064 chandransh 4319 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4320 
    result.write(oprot)
4321 
    oprot.writeMessageEnd()
4322 
    oprot.trans.flush()
4323 
 
4579 rajveer 4324 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
4325 
    args = addInvoiceNumber_args()
4326 
    args.read(iprot)
4327 
    iprot.readMessageEnd()
4328 
    result = addInvoiceNumber_result()
4329 
    try:
4330 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber)
4331 
    except TransactionServiceException, ex:
4332 
      result.ex = ex
4333 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
4334 
    result.write(oprot)
4335 
    oprot.writeMessageEnd()
4336 
    oprot.trans.flush()
4337 
 
3064 chandransh 4338 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4339 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4340 
    args.read(iprot)
4341 
    iprot.readMessageEnd()
3064 chandransh 4342 
    result = markOrdersAsManifested_result()
4343 
    try:
4344 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4345 
    except TransactionServiceException, ex:
4346 
      result.ex = ex
4347 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4348 
    result.write(oprot)
4349 
    oprot.writeMessageEnd()
4350 
    oprot.trans.flush()
4351 
 
4410 rajveer 4352 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4353 
    args = markOrdersAsShippedFromWarehouse_args()
4354 
    args.read(iprot)
4355 
    iprot.readMessageEnd()
4356 
    result = markOrdersAsShippedFromWarehouse_result()
4357 
    try:
4358 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4359 
    except TransactionServiceException, ex:
4360 
      result.ex = ex
4361 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4362 
    result.write(oprot)
4363 
    oprot.writeMessageEnd()
4364 
    oprot.trans.flush()
4365 
 
3064 chandransh 4366 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4367 
    args = markOrdersAsPickedUp_args()
304 ashish 4368 
    args.read(iprot)
4369 
    iprot.readMessageEnd()
3064 chandransh 4370 
    result = markOrdersAsPickedUp_result()
4371 
    try:
4372 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4373 
    except TransactionServiceException, ex:
4374 
      result.ex = ex
4375 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4376 
    result.write(oprot)
4377 
    oprot.writeMessageEnd()
4378 
    oprot.trans.flush()
94 ashish 4379 
 
3064 chandransh 4380 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4381 
    args = markOrdersAsDelivered_args()
304 ashish 4382 
    args.read(iprot)
4383 
    iprot.readMessageEnd()
3064 chandransh 4384 
    result = markOrdersAsDelivered_result()
4385 
    try:
4386 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4387 
    except TransactionServiceException, ex:
4388 
      result.ex = ex
4389 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4390 
    result.write(oprot)
4391 
    oprot.writeMessageEnd()
4392 
    oprot.trans.flush()
4393 
 
3064 chandransh 4394 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4395 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4396 
    args.read(iprot)
4397 
    iprot.readMessageEnd()
3064 chandransh 4398 
    result = markOrdersAsFailed_result()
4399 
    try:
4400 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4401 
    except TransactionServiceException, ex:
4402 
      result.ex = ex
4403 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4404 
    result.write(oprot)
4405 
    oprot.writeMessageEnd()
4406 
    oprot.trans.flush()
304 ashish 4407 
 
3064 chandransh 4408 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4409 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4410 
    args.read(iprot)
4411 
    iprot.readMessageEnd()
3064 chandransh 4412 
    result = updateNonDeliveryReason_result()
4413 
    try:
4581 phani.kuma 4414 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 4415 
    except TransactionServiceException, ex:
4416 
      result.ex = ex
4417 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4418 
    result.write(oprot)
4419 
    oprot.writeMessageEnd()
4420 
    oprot.trans.flush()
1596 ankur.sing 4421 
 
3064 chandransh 4422 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4423 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4424 
    args.read(iprot)
4425 
    iprot.readMessageEnd()
3064 chandransh 4426 
    result = getUndeliveredOrders_result()
4427 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4428 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4429 
    result.write(oprot)
4430 
    oprot.writeMessageEnd()
4431 
    oprot.trans.flush()
4432 
 
2536 chandransh 4433 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4434 
    args = toggleDOAFlag_args()
4435 
    args.read(iprot)
4436 
    iprot.readMessageEnd()
4437 
    result = toggleDOAFlag_result()
4438 
    try:
4439 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4440 
    except TransactionServiceException, ex:
4441 
      result.ex = ex
4442 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4443 
    result.write(oprot)
4444 
    oprot.writeMessageEnd()
4445 
    oprot.trans.flush()
1886 ankur.sing 4446 
 
4454 rajveer 4447 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
4448 
    args = markOrderDoaRequestReceived_args()
4449 
    args.read(iprot)
4450 
    iprot.readMessageEnd()
4451 
    result = markOrderDoaRequestReceived_result()
4452 
    try:
4453 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
4454 
    except TransactionServiceException, ex:
4455 
      result.ex = ex
4456 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
4457 
    result.write(oprot)
4458 
    oprot.writeMessageEnd()
4459 
    oprot.trans.flush()
4460 
 
4461 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
4462 
    args = markOrderDoaRequestAuthorized_args()
4463 
    args.read(iprot)
4464 
    iprot.readMessageEnd()
4465 
    result = markOrderDoaRequestAuthorized_result()
4466 
    try:
4467 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
4468 
    except TransactionServiceException, ex:
4469 
      result.ex = ex
4470 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
4471 
    result.write(oprot)
4472 
    oprot.writeMessageEnd()
4473 
    oprot.trans.flush()
4474 
 
4488 rajveer 4475 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
4476 
    args = markOrderReturnRequestReceived_args()
4477 
    args.read(iprot)
4478 
    iprot.readMessageEnd()
4479 
    result = markOrderReturnRequestReceived_result()
4480 
    try:
4481 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
4482 
    except TransactionServiceException, ex:
4483 
      result.ex = ex
4484 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
4485 
    result.write(oprot)
4486 
    oprot.writeMessageEnd()
4487 
    oprot.trans.flush()
4488 
 
4489 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
4490 
    args = markOrderReturnRequestAuthorized_args()
4491 
    args.read(iprot)
4492 
    iprot.readMessageEnd()
4493 
    result = markOrderReturnRequestAuthorized_result()
4494 
    try:
4495 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
4496 
    except TransactionServiceException, ex:
4497 
      result.ex = ex
4498 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
4499 
    result.write(oprot)
4500 
    oprot.writeMessageEnd()
4501 
    oprot.trans.flush()
4502 
 
2536 chandransh 4503 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
4504 
    args = requestPickupNumber_args()
4505 
    args.read(iprot)
4506 
    iprot.readMessageEnd()
4507 
    result = requestPickupNumber_result()
4508 
    try:
4579 rajveer 4509 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 4510 
    except TransactionServiceException, ex:
4511 
      result.ex = ex
4512 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
4513 
    result.write(oprot)
4514 
    oprot.writeMessageEnd()
4515 
    oprot.trans.flush()
4516 
 
4517 
  def process_authorizePickup(self, seqid, iprot, oprot):
4518 
    args = authorizePickup_args()
4519 
    args.read(iprot)
4520 
    iprot.readMessageEnd()
4521 
    result = authorizePickup_result()
4522 
    try:
4523 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
4524 
    except TransactionServiceException, ex:
4525 
      result.ex = ex
4526 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4527 
    result.write(oprot)
4528 
    oprot.writeMessageEnd()
4529 
    oprot.trans.flush()
4530 
 
2764 chandransh 4531 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4532 
    args = markDoasAsPickedUp_args()
4533 
    args.read(iprot)
4534 
    iprot.readMessageEnd()
4535 
    result = markDoasAsPickedUp_result()
4536 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4537 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4538 
    result.write(oprot)
4539 
    oprot.writeMessageEnd()
4540 
    oprot.trans.flush()
4541 
 
2616 chandransh 4542 
  def process_receiveReturn(self, seqid, iprot, oprot):
4543 
    args = receiveReturn_args()
2591 chandransh 4544 
    args.read(iprot)
4545 
    iprot.readMessageEnd()
2616 chandransh 4546 
    result = receiveReturn_result()
2591 chandransh 4547 
    try:
4479 rajveer 4548 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 4549 
    except TransactionServiceException, ex:
4550 
      result.ex = ex
2616 chandransh 4551 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4552 
    result.write(oprot)
4553 
    oprot.writeMessageEnd()
4554 
    oprot.trans.flush()
2536 chandransh 4555 
 
2591 chandransh 4556 
  def process_validateDoa(self, seqid, iprot, oprot):
4557 
    args = validateDoa_args()
4558 
    args.read(iprot)
4559 
    iprot.readMessageEnd()
4560 
    result = validateDoa_result()
4561 
    try:
4562 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4563 
    except TransactionServiceException, ex:
4564 
      result.ex = ex
4565 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4566 
    result.write(oprot)
4567 
    oprot.writeMessageEnd()
4568 
    oprot.trans.flush()
4569 
 
4495 rajveer 4570 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
4571 
    args = validateReturnProduct_args()
4572 
    args.read(iprot)
4573 
    iprot.readMessageEnd()
4574 
    result = validateReturnProduct_result()
4575 
    try:
4576 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
4577 
    except TransactionServiceException, ex:
4578 
      result.ex = ex
4579 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
4580 
    result.write(oprot)
4581 
    oprot.writeMessageEnd()
4582 
    oprot.trans.flush()
4583 
 
2616 chandransh 4584 
  def process_reshipOrder(self, seqid, iprot, oprot):
4585 
    args = reshipOrder_args()
4586 
    args.read(iprot)
4587 
    iprot.readMessageEnd()
4588 
    result = reshipOrder_result()
4589 
    try:
4590 
      result.success = self._handler.reshipOrder(args.orderId)
4591 
    except TransactionServiceException, ex:
4592 
      result.ex = ex
4593 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4594 
    result.write(oprot)
4595 
    oprot.writeMessageEnd()
4596 
    oprot.trans.flush()
2591 chandransh 4597 
 
2616 chandransh 4598 
  def process_refundOrder(self, seqid, iprot, oprot):
4599 
    args = refundOrder_args()
4600 
    args.read(iprot)
4601 
    iprot.readMessageEnd()
4602 
    result = refundOrder_result()
4603 
    try:
3226 chandransh 4604 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4605 
    except TransactionServiceException, ex:
4606 
      result.ex = ex
4607 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4608 
    result.write(oprot)
4609 
    oprot.writeMessageEnd()
4610 
    oprot.trans.flush()
4611 
 
2690 chandransh 4612 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4613 
    args = getReturnOrders_args()
4614 
    args.read(iprot)
4615 
    iprot.readMessageEnd()
4616 
    result = getReturnOrders_result()
4617 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4618 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4619 
    result.write(oprot)
4620 
    oprot.writeMessageEnd()
4621 
    oprot.trans.flush()
2616 chandransh 4622 
 
2700 chandransh 4623 
  def process_getReturnOrder(self, seqid, iprot, oprot):
4624 
    args = getReturnOrder_args()
4625 
    args.read(iprot)
4626 
    iprot.readMessageEnd()
4627 
    result = getReturnOrder_result()
4628 
    try:
4629 
      result.success = self._handler.getReturnOrder(args.id)
4630 
    except TransactionServiceException, ex:
4631 
      result.ex = ex
4632 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
4633 
    result.write(oprot)
4634 
    oprot.writeMessageEnd()
4635 
    oprot.trans.flush()
4636 
 
2690 chandransh 4637 
  def process_processReturn(self, seqid, iprot, oprot):
4638 
    args = processReturn_args()
4639 
    args.read(iprot)
4640 
    iprot.readMessageEnd()
4641 
    result = processReturn_result()
4642 
    try:
4643 
      self._handler.processReturn(args.returnOrderId)
4644 
    except TransactionServiceException, ex:
4645 
      result.ex = ex
4646 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
4647 
    result.write(oprot)
4648 
    oprot.writeMessageEnd()
4649 
    oprot.trans.flush()
4650 
 
2819 chandransh 4651 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
4652 
    args = createPurchaseOrder_args()
4653 
    args.read(iprot)
4654 
    iprot.readMessageEnd()
4655 
    result = createPurchaseOrder_result()
4656 
    try:
4657 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
4658 
    except TransactionServiceException, ex:
4659 
      result.ex = ex
4660 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
4661 
    result.write(oprot)
4662 
    oprot.writeMessageEnd()
4663 
    oprot.trans.flush()
2690 chandransh 4664 
 
3451 chandransh 4665 
  def process_updateWeight(self, seqid, iprot, oprot):
4666 
    args = updateWeight_args()
4667 
    args.read(iprot)
4668 
    iprot.readMessageEnd()
4669 
    result = updateWeight_result()
4670 
    try:
4671 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
4672 
    except TransactionServiceException, ex:
4673 
      result.ex = ex
4674 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
4675 
    result.write(oprot)
4676 
    oprot.writeMessageEnd()
4677 
    oprot.trans.flush()
2819 chandransh 4678 
 
3469 chandransh 4679 
  def process_changeItem(self, seqid, iprot, oprot):
4680 
    args = changeItem_args()
4681 
    args.read(iprot)
4682 
    iprot.readMessageEnd()
4683 
    result = changeItem_result()
4684 
    try:
4685 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
4686 
    except TransactionServiceException, ex:
4687 
      result.ex = ex
4688 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
4689 
    result.write(oprot)
4690 
    oprot.writeMessageEnd()
4691 
    oprot.trans.flush()
3451 chandransh 4692 
 
3469 chandransh 4693 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
4694 
    args = shiftToWarehouse_args()
4695 
    args.read(iprot)
4696 
    iprot.readMessageEnd()
4697 
    result = shiftToWarehouse_result()
4698 
    try:
4699 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
4700 
    except TransactionServiceException, ex:
4701 
      result.ex = ex
4702 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
4703 
    result.write(oprot)
4704 
    oprot.writeMessageEnd()
4705 
    oprot.trans.flush()
4706 
 
3553 chandransh 4707 
  def process_addDelayReason(self, seqid, iprot, oprot):
4708 
    args = addDelayReason_args()
4709 
    args.read(iprot)
4710 
    iprot.readMessageEnd()
4711 
    result = addDelayReason_result()
4712 
    try:
3986 chandransh 4713 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 4714 
    except TransactionServiceException, ex:
4715 
      result.ex = ex
4716 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
4717 
    result.write(oprot)
4718 
    oprot.writeMessageEnd()
4719 
    oprot.trans.flush()
3469 chandransh 4720 
 
3956 chandransh 4721 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
4722 
    args = reconcileCodCollection_args()
4723 
    args.read(iprot)
4724 
    iprot.readMessageEnd()
4725 
    result = reconcileCodCollection_result()
4726 
    try:
4727 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
4728 
    except TransactionServiceException, ex:
4729 
      result.ex = ex
4730 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
4731 
    result.write(oprot)
4732 
    oprot.writeMessageEnd()
4733 
    oprot.trans.flush()
3553 chandransh 4734 
 
4008 mandeep.dh 4735 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
4736 
    args = getTransactionsRequiringExtraProcessing_args()
4737 
    args.read(iprot)
4738 
    iprot.readMessageEnd()
4739 
    result = getTransactionsRequiringExtraProcessing_result()
4740 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
4741 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
4742 
    result.write(oprot)
4743 
    oprot.writeMessageEnd()
4744 
    oprot.trans.flush()
3956 chandransh 4745 
 
4008 mandeep.dh 4746 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
4747 
    args = markTransactionAsProcessed_args()
4748 
    args.read(iprot)
4749 
    iprot.readMessageEnd()
4750 
    result = markTransactionAsProcessed_result()
4751 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
4752 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
4753 
    result.write(oprot)
4754 
    oprot.writeMessageEnd()
4755 
    oprot.trans.flush()
4756 
 
4018 chandransh 4757 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
4758 
    args = getItemWiseRiskyOrdersCount_args()
4759 
    args.read(iprot)
4760 
    iprot.readMessageEnd()
4761 
    result = getItemWiseRiskyOrdersCount_result()
4762 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
4763 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
4764 
    result.write(oprot)
4765 
    oprot.writeMessageEnd()
4766 
    oprot.trans.flush()
4008 mandeep.dh 4767 
 
4295 varun.gupt 4768 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
4769 
    args = getOrdersForItemIds_args()
4770 
    args.read(iprot)
4771 
    iprot.readMessageEnd()
4772 
    result = getOrdersForItemIds_result()
4773 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
4774 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
4775 
    result.write(oprot)
4776 
    oprot.writeMessageEnd()
4777 
    oprot.trans.flush()
4778 
 
4247 rajveer 4779 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
4780 
    args = markOrderCancellationRequestReceived_args()
4781 
    args.read(iprot)
4782 
    iprot.readMessageEnd()
4783 
    result = markOrderCancellationRequestReceived_result()
4784 
    try:
4785 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
4786 
    except TransactionServiceException, ex:
4787 
      result.ex = ex
4788 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
4789 
    result.write(oprot)
4790 
    oprot.writeMessageEnd()
4791 
    oprot.trans.flush()
4018 chandransh 4792 
 
4247 rajveer 4793 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
4794 
    args = markOrderCancellationRequestConfirmed_args()
4795 
    args.read(iprot)
4796 
    iprot.readMessageEnd()
4797 
    result = markOrderCancellationRequestConfirmed_result()
4798 
    try:
4799 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
4800 
    except TransactionServiceException, ex:
4801 
      result.ex = ex
4802 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
4803 
    result.write(oprot)
4804 
    oprot.writeMessageEnd()
4805 
    oprot.trans.flush()
4806 
 
4807 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4808 
    args = markOrderCancellationRequestDenied_args()
4809 
    args.read(iprot)
4810 
    iprot.readMessageEnd()
4811 
    result = markOrderCancellationRequestDenied_result()
4812 
    try:
4813 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4814 
    except TransactionServiceException, ex:
4815 
      result.ex = ex
4816 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4817 
    result.write(oprot)
4818 
    oprot.writeMessageEnd()
4819 
    oprot.trans.flush()
4820 
 
4258 rajveer 4821 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4822 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4823 
    args.read(iprot)
4824 
    iprot.readMessageEnd()
4258 rajveer 4825 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4826 
    try:
4258 rajveer 4827 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4828 
    except TransactionServiceException, ex:
4829 
      result.ex = ex
4258 rajveer 4830 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4831 
    result.write(oprot)
4832 
    oprot.writeMessageEnd()
4833 
    oprot.trans.flush()
4834 
 
4259 anupam.sin 4835 
  def process_refundTransaction(self, seqid, iprot, oprot):
4836 
    args = refundTransaction_args()
4837 
    args.read(iprot)
4838 
    iprot.readMessageEnd()
4839 
    result = refundTransaction_result()
4840 
    try:
4841 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4842 
    except TransactionServiceException, ex:
4843 
      result.ex = ex
4844 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4845 
    result.write(oprot)
4846 
    oprot.writeMessageEnd()
4847 
    oprot.trans.flush()
4247 rajveer 4848 
 
4324 mandeep.dh 4849 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
4850 
    args = updateShipmentAddress_args()
4851 
    args.read(iprot)
4852 
    iprot.readMessageEnd()
4853 
    result = updateShipmentAddress_result()
4854 
    try:
4855 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
4856 
    except TransactionServiceException, ex:
4857 
      result.ex = ex
4858 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
4859 
    result.write(oprot)
4860 
    oprot.writeMessageEnd()
4861 
    oprot.trans.flush()
4862 
 
4285 rajveer 4863 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
4864 
    args = acceptOrdersForItemId_args()
4865 
    args.read(iprot)
4866 
    iprot.readMessageEnd()
4867 
    result = acceptOrdersForItemId_result()
4868 
    try:
4869 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
4870 
    except TransactionServiceException, ex:
4871 
      result.ex = ex
4872 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
4873 
    result.write(oprot)
4874 
    oprot.writeMessageEnd()
4875 
    oprot.trans.flush()
4259 anupam.sin 4876 
 
4303 rajveer 4877 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
4878 
    args = markOrdersAsPORaised_args()
4879 
    args.read(iprot)
4880 
    iprot.readMessageEnd()
4881 
    result = markOrdersAsPORaised_result()
4882 
    try:
4369 rajveer 4883 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4884 
    except TransactionServiceException, ex:
4885 
      result.ex = ex
4886 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
4887 
    result.write(oprot)
4888 
    oprot.writeMessageEnd()
4889 
    oprot.trans.flush()
4285 rajveer 4890 
 
4303 rajveer 4891 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
4892 
    args = markOrdersAsReversalInitiated_args()
4893 
    args.read(iprot)
4894 
    iprot.readMessageEnd()
4895 
    result = markOrdersAsReversalInitiated_result()
4896 
    try:
4369 rajveer 4897 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4898 
    except TransactionServiceException, ex:
4899 
      result.ex = ex
4900 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
4901 
    result.write(oprot)
4902 
    oprot.writeMessageEnd()
4903 
    oprot.trans.flush()
4904 
 
4905 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
4906 
    args = markOrdersAsNotAvailabke_args()
4907 
    args.read(iprot)
4908 
    iprot.readMessageEnd()
4909 
    result = markOrdersAsNotAvailabke_result()
4910 
    try:
4369 rajveer 4911 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4912 
    except TransactionServiceException, ex:
4913 
      result.ex = ex
4914 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
4915 
    result.write(oprot)
4916 
    oprot.writeMessageEnd()
4917 
    oprot.trans.flush()
4918 
 
4369 rajveer 4919 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
4920 
    args = markOrdersAsTimeout_args()
4921 
    args.read(iprot)
4922 
    iprot.readMessageEnd()
4923 
    result = markOrdersAsTimeout_result()
4924 
    try:
4925 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
4926 
    except TransactionServiceException, ex:
4927 
      result.ex = ex
4928 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
4929 
    result.write(oprot)
4930 
    oprot.writeMessageEnd()
4931 
    oprot.trans.flush()
4303 rajveer 4932 
 
4386 anupam.sin 4933 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
4934 
    args = getOrderForAwb_args()
4935 
    args.read(iprot)
4936 
    iprot.readMessageEnd()
4937 
    result = getOrderForAwb_result()
4938 
    try:
4939 
      result.success = self._handler.getOrderForAwb(args.awb)
4940 
    except TransactionServiceException, ex:
4941 
      result.ex = ex
4942 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
4943 
    result.write(oprot)
4944 
    oprot.writeMessageEnd()
4945 
    oprot.trans.flush()
4369 rajveer 4946 
 
4506 phani.kuma 4947 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
4948 
    args = getOrdersForProviderForStatus_args()
4949 
    args.read(iprot)
4950 
    iprot.readMessageEnd()
4951 
    result = getOrdersForProviderForStatus_result()
4952 
    try:
4953 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
4954 
    except TransactionServiceException, ex:
4955 
      result.ex = ex
4956 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
4957 
    result.write(oprot)
4958 
    oprot.writeMessageEnd()
4959 
    oprot.trans.flush()
4386 anupam.sin 4960 
 
4506 phani.kuma 4961 
 
94 ashish 4962 
# HELPER FUNCTIONS AND STRUCTURES
4963 
 
4964 
class createTransaction_args:
4965 
  """
4966 
  Attributes:
4967 
   - transaction
4968 
  """
4969 
 
4970 
  thrift_spec = (
4971 
    None, # 0
4972 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4973 
  )
4974 
 
4975 
  def __init__(self, transaction=None,):
4976 
    self.transaction = transaction
4977 
 
4978 
  def read(self, iprot):
4979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4981 
      return
4982 
    iprot.readStructBegin()
4983 
    while True:
4984 
      (fname, ftype, fid) = iprot.readFieldBegin()
4985 
      if ftype == TType.STOP:
4986 
        break
4987 
      if fid == 1:
4988 
        if ftype == TType.STRUCT:
4989 
          self.transaction = Transaction()
4990 
          self.transaction.read(iprot)
4991 
        else:
4992 
          iprot.skip(ftype)
4993 
      else:
4994 
        iprot.skip(ftype)
4995 
      iprot.readFieldEnd()
4996 
    iprot.readStructEnd()
4997 
 
4998 
  def write(self, oprot):
4999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5001 
      return
5002 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 5003 
    if self.transaction is not None:
94 ashish 5004 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5005 
      self.transaction.write(oprot)
5006 
      oprot.writeFieldEnd()
5007 
    oprot.writeFieldStop()
5008 
    oprot.writeStructEnd()
5009 
 
3431 rajveer 5010 
  def validate(self):
5011 
    return
5012 
 
5013 
 
94 ashish 5014 
  def __repr__(self):
5015 
    L = ['%s=%r' % (key, value)
5016 
      for key, value in self.__dict__.iteritems()]
5017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5018 
 
5019 
  def __eq__(self, other):
5020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5021 
 
5022 
  def __ne__(self, other):
5023 
    return not (self == other)
5024 
 
5025 
class createTransaction_result:
5026 
  """
5027 
  Attributes:
132 ashish 5028 
   - success
94 ashish 5029 
   - ex
5030 
  """
5031 
 
5032 
  thrift_spec = (
132 ashish 5033 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5034 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5035 
  )
5036 
 
132 ashish 5037 
  def __init__(self, success=None, ex=None,):
5038 
    self.success = success
94 ashish 5039 
    self.ex = ex
5040 
 
5041 
  def read(self, iprot):
5042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5044 
      return
5045 
    iprot.readStructBegin()
5046 
    while True:
5047 
      (fname, ftype, fid) = iprot.readFieldBegin()
5048 
      if ftype == TType.STOP:
5049 
        break
132 ashish 5050 
      if fid == 0:
5051 
        if ftype == TType.I64:
5052 
          self.success = iprot.readI64();
5053 
        else:
5054 
          iprot.skip(ftype)
5055 
      elif fid == 1:
94 ashish 5056 
        if ftype == TType.STRUCT:
5057 
          self.ex = TransactionServiceException()
5058 
          self.ex.read(iprot)
5059 
        else:
5060 
          iprot.skip(ftype)
5061 
      else:
5062 
        iprot.skip(ftype)
5063 
      iprot.readFieldEnd()
5064 
    iprot.readStructEnd()
5065 
 
5066 
  def write(self, oprot):
5067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5069 
      return
5070 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5071 
    if self.success is not None:
132 ashish 5072 
      oprot.writeFieldBegin('success', TType.I64, 0)
5073 
      oprot.writeI64(self.success)
5074 
      oprot.writeFieldEnd()
3431 rajveer 5075 
    if self.ex is not None:
94 ashish 5076 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5077 
      self.ex.write(oprot)
5078 
      oprot.writeFieldEnd()
5079 
    oprot.writeFieldStop()
5080 
    oprot.writeStructEnd()
5081 
 
3431 rajveer 5082 
  def validate(self):
5083 
    return
5084 
 
5085 
 
94 ashish 5086 
  def __repr__(self):
5087 
    L = ['%s=%r' % (key, value)
5088 
      for key, value in self.__dict__.iteritems()]
5089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5090 
 
5091 
  def __eq__(self, other):
5092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5093 
 
5094 
  def __ne__(self, other):
5095 
    return not (self == other)
5096 
 
5097 
class getTransaction_args:
5098 
  """
5099 
  Attributes:
5100 
   - id
5101 
  """
5102 
 
5103 
  thrift_spec = (
5104 
    None, # 0
5105 
    (1, TType.I64, 'id', None, None, ), # 1
5106 
  )
5107 
 
5108 
  def __init__(self, id=None,):
5109 
    self.id = id
5110 
 
5111 
  def read(self, iprot):
5112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5114 
      return
5115 
    iprot.readStructBegin()
5116 
    while True:
5117 
      (fname, ftype, fid) = iprot.readFieldBegin()
5118 
      if ftype == TType.STOP:
5119 
        break
5120 
      if fid == 1:
5121 
        if ftype == TType.I64:
5122 
          self.id = iprot.readI64();
5123 
        else:
5124 
          iprot.skip(ftype)
5125 
      else:
5126 
        iprot.skip(ftype)
5127 
      iprot.readFieldEnd()
5128 
    iprot.readStructEnd()
5129 
 
5130 
  def write(self, oprot):
5131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5133 
      return
5134 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 5135 
    if self.id is not None:
94 ashish 5136 
      oprot.writeFieldBegin('id', TType.I64, 1)
5137 
      oprot.writeI64(self.id)
5138 
      oprot.writeFieldEnd()
5139 
    oprot.writeFieldStop()
5140 
    oprot.writeStructEnd()
5141 
 
3431 rajveer 5142 
  def validate(self):
5143 
    return
5144 
 
5145 
 
94 ashish 5146 
  def __repr__(self):
5147 
    L = ['%s=%r' % (key, value)
5148 
      for key, value in self.__dict__.iteritems()]
5149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5150 
 
5151 
  def __eq__(self, other):
5152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5153 
 
5154 
  def __ne__(self, other):
5155 
    return not (self == other)
5156 
 
5157 
class getTransaction_result:
5158 
  """
5159 
  Attributes:
5160 
   - success
5161 
   - ex
5162 
  """
5163 
 
5164 
  thrift_spec = (
5165 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
5166 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5167 
  )
5168 
 
5169 
  def __init__(self, success=None, ex=None,):
5170 
    self.success = success
5171 
    self.ex = ex
5172 
 
5173 
  def read(self, iprot):
5174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5176 
      return
5177 
    iprot.readStructBegin()
5178 
    while True:
5179 
      (fname, ftype, fid) = iprot.readFieldBegin()
5180 
      if ftype == TType.STOP:
5181 
        break
5182 
      if fid == 0:
5183 
        if ftype == TType.STRUCT:
5184 
          self.success = Transaction()
5185 
          self.success.read(iprot)
5186 
        else:
5187 
          iprot.skip(ftype)
5188 
      elif fid == 1:
5189 
        if ftype == TType.STRUCT:
5190 
          self.ex = TransactionServiceException()
5191 
          self.ex.read(iprot)
5192 
        else:
5193 
          iprot.skip(ftype)
5194 
      else:
5195 
        iprot.skip(ftype)
5196 
      iprot.readFieldEnd()
5197 
    iprot.readStructEnd()
5198 
 
5199 
  def write(self, oprot):
5200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5202 
      return
5203 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 5204 
    if self.success is not None:
94 ashish 5205 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5206 
      self.success.write(oprot)
5207 
      oprot.writeFieldEnd()
3431 rajveer 5208 
    if self.ex is not None:
94 ashish 5209 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5210 
      self.ex.write(oprot)
5211 
      oprot.writeFieldEnd()
5212 
    oprot.writeFieldStop()
5213 
    oprot.writeStructEnd()
5214 
 
3431 rajveer 5215 
  def validate(self):
5216 
    return
5217 
 
5218 
 
94 ashish 5219 
  def __repr__(self):
5220 
    L = ['%s=%r' % (key, value)
5221 
      for key, value in self.__dict__.iteritems()]
5222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5223 
 
5224 
  def __eq__(self, other):
5225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5226 
 
5227 
  def __ne__(self, other):
5228 
    return not (self == other)
5229 
 
5230 
class getTransactionsForCustomer_args:
5231 
  """
5232 
  Attributes:
5233 
   - customerId
5234 
   - from_date
5235 
   - to_date
5236 
   - status
5237 
  """
5238 
 
5239 
  thrift_spec = (
5240 
    None, # 0
5241 
    (1, TType.I64, 'customerId', None, None, ), # 1
5242 
    (2, TType.I64, 'from_date', None, None, ), # 2
5243 
    (3, TType.I64, 'to_date', None, None, ), # 3
5244 
    (4, TType.I32, 'status', None, None, ), # 4
5245 
  )
5246 
 
5247 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
5248 
    self.customerId = customerId
5249 
    self.from_date = from_date
5250 
    self.to_date = to_date
5251 
    self.status = status
5252 
 
5253 
  def read(self, iprot):
5254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5256 
      return
5257 
    iprot.readStructBegin()
5258 
    while True:
5259 
      (fname, ftype, fid) = iprot.readFieldBegin()
5260 
      if ftype == TType.STOP:
5261 
        break
5262 
      if fid == 1:
5263 
        if ftype == TType.I64:
5264 
          self.customerId = iprot.readI64();
5265 
        else:
5266 
          iprot.skip(ftype)
5267 
      elif fid == 2:
5268 
        if ftype == TType.I64:
5269 
          self.from_date = iprot.readI64();
5270 
        else:
5271 
          iprot.skip(ftype)
5272 
      elif fid == 3:
5273 
        if ftype == TType.I64:
5274 
          self.to_date = iprot.readI64();
5275 
        else:
5276 
          iprot.skip(ftype)
5277 
      elif fid == 4:
5278 
        if ftype == TType.I32:
5279 
          self.status = iprot.readI32();
5280 
        else:
5281 
          iprot.skip(ftype)
5282 
      else:
5283 
        iprot.skip(ftype)
5284 
      iprot.readFieldEnd()
5285 
    iprot.readStructEnd()
5286 
 
5287 
  def write(self, oprot):
5288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5290 
      return
5291 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 5292 
    if self.customerId is not None:
94 ashish 5293 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5294 
      oprot.writeI64(self.customerId)
5295 
      oprot.writeFieldEnd()
3431 rajveer 5296 
    if self.from_date is not None:
94 ashish 5297 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5298 
      oprot.writeI64(self.from_date)
5299 
      oprot.writeFieldEnd()
3431 rajveer 5300 
    if self.to_date is not None:
94 ashish 5301 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5302 
      oprot.writeI64(self.to_date)
5303 
      oprot.writeFieldEnd()
3431 rajveer 5304 
    if self.status is not None:
94 ashish 5305 
      oprot.writeFieldBegin('status', TType.I32, 4)
5306 
      oprot.writeI32(self.status)
5307 
      oprot.writeFieldEnd()
5308 
    oprot.writeFieldStop()
5309 
    oprot.writeStructEnd()
5310 
 
3431 rajveer 5311 
  def validate(self):
5312 
    return
5313 
 
5314 
 
94 ashish 5315 
  def __repr__(self):
5316 
    L = ['%s=%r' % (key, value)
5317 
      for key, value in self.__dict__.iteritems()]
5318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5319 
 
5320 
  def __eq__(self, other):
5321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5322 
 
5323 
  def __ne__(self, other):
5324 
    return not (self == other)
5325 
 
5326 
class getTransactionsForCustomer_result:
5327 
  """
5328 
  Attributes:
5329 
   - success
5330 
   - ex
5331 
  """
5332 
 
5333 
  thrift_spec = (
5334 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5335 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5336 
  )
5337 
 
5338 
  def __init__(self, success=None, ex=None,):
5339 
    self.success = success
5340 
    self.ex = ex
5341 
 
5342 
  def read(self, iprot):
5343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5345 
      return
5346 
    iprot.readStructBegin()
5347 
    while True:
5348 
      (fname, ftype, fid) = iprot.readFieldBegin()
5349 
      if ftype == TType.STOP:
5350 
        break
5351 
      if fid == 0:
5352 
        if ftype == TType.LIST:
5353 
          self.success = []
685 chandransh 5354 
          (_etype17, _size14) = iprot.readListBegin()
5355 
          for _i18 in xrange(_size14):
5356 
            _elem19 = Transaction()
5357 
            _elem19.read(iprot)
5358 
            self.success.append(_elem19)
94 ashish 5359 
          iprot.readListEnd()
5360 
        else:
5361 
          iprot.skip(ftype)
5362 
      elif fid == 1:
5363 
        if ftype == TType.STRUCT:
5364 
          self.ex = TransactionServiceException()
5365 
          self.ex.read(iprot)
5366 
        else:
5367 
          iprot.skip(ftype)
5368 
      else:
5369 
        iprot.skip(ftype)
5370 
      iprot.readFieldEnd()
5371 
    iprot.readStructEnd()
5372 
 
5373 
  def write(self, oprot):
5374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5376 
      return
5377 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 5378 
    if self.success is not None:
94 ashish 5379 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5380 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5381 
      for iter20 in self.success:
5382 
        iter20.write(oprot)
94 ashish 5383 
      oprot.writeListEnd()
5384 
      oprot.writeFieldEnd()
3431 rajveer 5385 
    if self.ex is not None:
94 ashish 5386 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5387 
      self.ex.write(oprot)
5388 
      oprot.writeFieldEnd()
5389 
    oprot.writeFieldStop()
5390 
    oprot.writeStructEnd()
5391 
 
3431 rajveer 5392 
  def validate(self):
5393 
    return
5394 
 
5395 
 
94 ashish 5396 
  def __repr__(self):
5397 
    L = ['%s=%r' % (key, value)
5398 
      for key, value in self.__dict__.iteritems()]
5399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5400 
 
5401 
  def __eq__(self, other):
5402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5403 
 
5404 
  def __ne__(self, other):
5405 
    return not (self == other)
5406 
 
132 ashish 5407 
class getTransactionsForShoppingCartId_args:
5408 
  """
5409 
  Attributes:
5410 
   - shoppingCartId
5411 
  """
5412 
 
5413 
  thrift_spec = (
5414 
    None, # 0
5415 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
5416 
  )
5417 
 
5418 
  def __init__(self, shoppingCartId=None,):
5419 
    self.shoppingCartId = shoppingCartId
5420 
 
5421 
  def read(self, iprot):
5422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5424 
      return
5425 
    iprot.readStructBegin()
5426 
    while True:
5427 
      (fname, ftype, fid) = iprot.readFieldBegin()
5428 
      if ftype == TType.STOP:
5429 
        break
5430 
      if fid == 1:
5431 
        if ftype == TType.I64:
5432 
          self.shoppingCartId = iprot.readI64();
5433 
        else:
5434 
          iprot.skip(ftype)
5435 
      else:
5436 
        iprot.skip(ftype)
5437 
      iprot.readFieldEnd()
5438 
    iprot.readStructEnd()
5439 
 
5440 
  def write(self, oprot):
5441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5443 
      return
5444 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 5445 
    if self.shoppingCartId is not None:
132 ashish 5446 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
5447 
      oprot.writeI64(self.shoppingCartId)
5448 
      oprot.writeFieldEnd()
5449 
    oprot.writeFieldStop()
5450 
    oprot.writeStructEnd()
5451 
 
3431 rajveer 5452 
  def validate(self):
5453 
    return
5454 
 
5455 
 
132 ashish 5456 
  def __repr__(self):
5457 
    L = ['%s=%r' % (key, value)
5458 
      for key, value in self.__dict__.iteritems()]
5459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5460 
 
5461 
  def __eq__(self, other):
5462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5463 
 
5464 
  def __ne__(self, other):
5465 
    return not (self == other)
5466 
 
5467 
class getTransactionsForShoppingCartId_result:
5468 
  """
5469 
  Attributes:
5470 
   - success
5471 
   - ex
5472 
  """
5473 
 
5474 
  thrift_spec = (
5475 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5476 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5477 
  )
5478 
 
5479 
  def __init__(self, success=None, ex=None,):
5480 
    self.success = success
5481 
    self.ex = ex
5482 
 
5483 
  def read(self, iprot):
5484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5486 
      return
5487 
    iprot.readStructBegin()
5488 
    while True:
5489 
      (fname, ftype, fid) = iprot.readFieldBegin()
5490 
      if ftype == TType.STOP:
5491 
        break
5492 
      if fid == 0:
5493 
        if ftype == TType.LIST:
5494 
          self.success = []
685 chandransh 5495 
          (_etype24, _size21) = iprot.readListBegin()
5496 
          for _i25 in xrange(_size21):
5497 
            _elem26 = Transaction()
5498 
            _elem26.read(iprot)
5499 
            self.success.append(_elem26)
132 ashish 5500 
          iprot.readListEnd()
5501 
        else:
5502 
          iprot.skip(ftype)
5503 
      elif fid == 1:
5504 
        if ftype == TType.STRUCT:
5505 
          self.ex = TransactionServiceException()
5506 
          self.ex.read(iprot)
5507 
        else:
5508 
          iprot.skip(ftype)
5509 
      else:
5510 
        iprot.skip(ftype)
5511 
      iprot.readFieldEnd()
5512 
    iprot.readStructEnd()
5513 
 
5514 
  def write(self, oprot):
5515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5517 
      return
5518 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 5519 
    if self.success is not None:
132 ashish 5520 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5521 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5522 
      for iter27 in self.success:
5523 
        iter27.write(oprot)
132 ashish 5524 
      oprot.writeListEnd()
5525 
      oprot.writeFieldEnd()
3431 rajveer 5526 
    if self.ex is not None:
132 ashish 5527 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5528 
      self.ex.write(oprot)
5529 
      oprot.writeFieldEnd()
5530 
    oprot.writeFieldStop()
5531 
    oprot.writeStructEnd()
5532 
 
3431 rajveer 5533 
  def validate(self):
5534 
    return
5535 
 
5536 
 
132 ashish 5537 
  def __repr__(self):
5538 
    L = ['%s=%r' % (key, value)
5539 
      for key, value in self.__dict__.iteritems()]
5540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5541 
 
5542 
  def __eq__(self, other):
5543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5544 
 
5545 
  def __ne__(self, other):
5546 
    return not (self == other)
5547 
 
94 ashish 5548 
class getTransactionStatus_args:
5549 
  """
5550 
  Attributes:
5551 
   - transactionId
5552 
  """
5553 
 
5554 
  thrift_spec = (
5555 
    None, # 0
5556 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5557 
  )
5558 
 
5559 
  def __init__(self, transactionId=None,):
5560 
    self.transactionId = transactionId
5561 
 
5562 
  def read(self, iprot):
5563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5565 
      return
5566 
    iprot.readStructBegin()
5567 
    while True:
5568 
      (fname, ftype, fid) = iprot.readFieldBegin()
5569 
      if ftype == TType.STOP:
5570 
        break
5571 
      if fid == 1:
5572 
        if ftype == TType.I64:
5573 
          self.transactionId = iprot.readI64();
5574 
        else:
5575 
          iprot.skip(ftype)
5576 
      else:
5577 
        iprot.skip(ftype)
5578 
      iprot.readFieldEnd()
5579 
    iprot.readStructEnd()
5580 
 
5581 
  def write(self, oprot):
5582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5584 
      return
5585 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 5586 
    if self.transactionId is not None:
94 ashish 5587 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5588 
      oprot.writeI64(self.transactionId)
5589 
      oprot.writeFieldEnd()
5590 
    oprot.writeFieldStop()
5591 
    oprot.writeStructEnd()
5592 
 
3431 rajveer 5593 
  def validate(self):
5594 
    return
5595 
 
5596 
 
94 ashish 5597 
  def __repr__(self):
5598 
    L = ['%s=%r' % (key, value)
5599 
      for key, value in self.__dict__.iteritems()]
5600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5601 
 
5602 
  def __eq__(self, other):
5603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5604 
 
5605 
  def __ne__(self, other):
5606 
    return not (self == other)
5607 
 
5608 
class getTransactionStatus_result:
5609 
  """
5610 
  Attributes:
5611 
   - success
5612 
   - ex
5613 
  """
5614 
 
5615 
  thrift_spec = (
5616 
    (0, TType.I32, 'success', None, None, ), # 0
5617 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5618 
  )
5619 
 
5620 
  def __init__(self, success=None, ex=None,):
5621 
    self.success = success
5622 
    self.ex = ex
5623 
 
5624 
  def read(self, iprot):
5625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5627 
      return
5628 
    iprot.readStructBegin()
5629 
    while True:
5630 
      (fname, ftype, fid) = iprot.readFieldBegin()
5631 
      if ftype == TType.STOP:
5632 
        break
5633 
      if fid == 0:
5634 
        if ftype == TType.I32:
5635 
          self.success = iprot.readI32();
5636 
        else:
5637 
          iprot.skip(ftype)
5638 
      elif fid == 1:
5639 
        if ftype == TType.STRUCT:
5640 
          self.ex = TransactionServiceException()
5641 
          self.ex.read(iprot)
5642 
        else:
5643 
          iprot.skip(ftype)
5644 
      else:
5645 
        iprot.skip(ftype)
5646 
      iprot.readFieldEnd()
5647 
    iprot.readStructEnd()
5648 
 
5649 
  def write(self, oprot):
5650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5652 
      return
5653 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 5654 
    if self.success is not None:
94 ashish 5655 
      oprot.writeFieldBegin('success', TType.I32, 0)
5656 
      oprot.writeI32(self.success)
5657 
      oprot.writeFieldEnd()
3431 rajveer 5658 
    if self.ex is not None:
94 ashish 5659 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5660 
      self.ex.write(oprot)
5661 
      oprot.writeFieldEnd()
5662 
    oprot.writeFieldStop()
5663 
    oprot.writeStructEnd()
5664 
 
3431 rajveer 5665 
  def validate(self):
5666 
    return
5667 
 
5668 
 
94 ashish 5669 
  def __repr__(self):
5670 
    L = ['%s=%r' % (key, value)
5671 
      for key, value in self.__dict__.iteritems()]
5672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5673 
 
5674 
  def __eq__(self, other):
5675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5676 
 
5677 
  def __ne__(self, other):
5678 
    return not (self == other)
5679 
 
5680 
class changeTransactionStatus_args:
5681 
  """
5682 
  Attributes:
5683 
   - transactionId
5684 
   - status
5685 
   - description
5686 
  """
5687 
 
5688 
  thrift_spec = (
5689 
    None, # 0
5690 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5691 
    (2, TType.I32, 'status', None, None, ), # 2
5692 
    (3, TType.STRING, 'description', None, None, ), # 3
5693 
  )
5694 
 
5695 
  def __init__(self, transactionId=None, status=None, description=None,):
5696 
    self.transactionId = transactionId
5697 
    self.status = status
5698 
    self.description = description
5699 
 
5700 
  def read(self, iprot):
5701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5703 
      return
5704 
    iprot.readStructBegin()
5705 
    while True:
5706 
      (fname, ftype, fid) = iprot.readFieldBegin()
5707 
      if ftype == TType.STOP:
5708 
        break
5709 
      if fid == 1:
5710 
        if ftype == TType.I64:
5711 
          self.transactionId = iprot.readI64();
5712 
        else:
5713 
          iprot.skip(ftype)
5714 
      elif fid == 2:
5715 
        if ftype == TType.I32:
5716 
          self.status = iprot.readI32();
5717 
        else:
5718 
          iprot.skip(ftype)
5719 
      elif fid == 3:
5720 
        if ftype == TType.STRING:
5721 
          self.description = iprot.readString();
5722 
        else:
5723 
          iprot.skip(ftype)
5724 
      else:
5725 
        iprot.skip(ftype)
5726 
      iprot.readFieldEnd()
5727 
    iprot.readStructEnd()
5728 
 
5729 
  def write(self, oprot):
5730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5732 
      return
5733 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 5734 
    if self.transactionId is not None:
94 ashish 5735 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5736 
      oprot.writeI64(self.transactionId)
5737 
      oprot.writeFieldEnd()
3431 rajveer 5738 
    if self.status is not None:
94 ashish 5739 
      oprot.writeFieldBegin('status', TType.I32, 2)
5740 
      oprot.writeI32(self.status)
5741 
      oprot.writeFieldEnd()
3431 rajveer 5742 
    if self.description is not None:
94 ashish 5743 
      oprot.writeFieldBegin('description', TType.STRING, 3)
5744 
      oprot.writeString(self.description)
5745 
      oprot.writeFieldEnd()
5746 
    oprot.writeFieldStop()
5747 
    oprot.writeStructEnd()
5748 
 
3431 rajveer 5749 
  def validate(self):
5750 
    return
5751 
 
5752 
 
94 ashish 5753 
  def __repr__(self):
5754 
    L = ['%s=%r' % (key, value)
5755 
      for key, value in self.__dict__.iteritems()]
5756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5757 
 
5758 
  def __eq__(self, other):
5759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5760 
 
5761 
  def __ne__(self, other):
5762 
    return not (self == other)
5763 
 
5764 
class changeTransactionStatus_result:
5765 
  """
5766 
  Attributes:
5767 
   - success
5768 
   - ex
5769 
  """
5770 
 
5771 
  thrift_spec = (
5772 
    (0, TType.BOOL, 'success', None, None, ), # 0
5773 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5774 
  )
5775 
 
5776 
  def __init__(self, success=None, ex=None,):
5777 
    self.success = success
5778 
    self.ex = ex
5779 
 
5780 
  def read(self, iprot):
5781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5783 
      return
5784 
    iprot.readStructBegin()
5785 
    while True:
5786 
      (fname, ftype, fid) = iprot.readFieldBegin()
5787 
      if ftype == TType.STOP:
5788 
        break
5789 
      if fid == 0:
5790 
        if ftype == TType.BOOL:
5791 
          self.success = iprot.readBool();
5792 
        else:
5793 
          iprot.skip(ftype)
5794 
      elif fid == 1:
5795 
        if ftype == TType.STRUCT:
5796 
          self.ex = TransactionServiceException()
5797 
          self.ex.read(iprot)
5798 
        else:
5799 
          iprot.skip(ftype)
5800 
      else:
5801 
        iprot.skip(ftype)
5802 
      iprot.readFieldEnd()
5803 
    iprot.readStructEnd()
5804 
 
5805 
  def write(self, oprot):
5806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5808 
      return
5809 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 5810 
    if self.success is not None:
94 ashish 5811 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5812 
      oprot.writeBool(self.success)
5813 
      oprot.writeFieldEnd()
3431 rajveer 5814 
    if self.ex is not None:
94 ashish 5815 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5816 
      self.ex.write(oprot)
5817 
      oprot.writeFieldEnd()
5818 
    oprot.writeFieldStop()
5819 
    oprot.writeStructEnd()
5820 
 
3431 rajveer 5821 
  def validate(self):
5822 
    return
5823 
 
5824 
 
94 ashish 5825 
  def __repr__(self):
5826 
    L = ['%s=%r' % (key, value)
5827 
      for key, value in self.__dict__.iteritems()]
5828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5829 
 
5830 
  def __eq__(self, other):
5831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5832 
 
5833 
  def __ne__(self, other):
5834 
    return not (self == other)
5835 
 
1398 varun.gupt 5836 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 5837 
  """
5838 
  Attributes:
5839 
   - transactionId
5840 
  """
5841 
 
5842 
  thrift_spec = (
5843 
    None, # 0
5844 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5845 
  )
5846 
 
5847 
  def __init__(self, transactionId=None,):
5848 
    self.transactionId = transactionId
5849 
 
5850 
  def read(self, iprot):
5851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5853 
      return
5854 
    iprot.readStructBegin()
5855 
    while True:
5856 
      (fname, ftype, fid) = iprot.readFieldBegin()
5857 
      if ftype == TType.STOP:
5858 
        break
5859 
      if fid == 1:
5860 
        if ftype == TType.I64:
5861 
          self.transactionId = iprot.readI64();
5862 
        else:
5863 
          iprot.skip(ftype)
5864 
      else:
5865 
        iprot.skip(ftype)
5866 
      iprot.readFieldEnd()
5867 
    iprot.readStructEnd()
5868 
 
5869 
  def write(self, oprot):
5870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5872 
      return
1398 varun.gupt 5873 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 5874 
    if self.transactionId is not None:
1382 varun.gupt 5875 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5876 
      oprot.writeI64(self.transactionId)
5877 
      oprot.writeFieldEnd()
5878 
    oprot.writeFieldStop()
5879 
    oprot.writeStructEnd()
5880 
 
3431 rajveer 5881 
  def validate(self):
5882 
    return
5883 
 
5884 
 
1382 varun.gupt 5885 
  def __repr__(self):
5886 
    L = ['%s=%r' % (key, value)
5887 
      for key, value in self.__dict__.iteritems()]
5888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5889 
 
5890 
  def __eq__(self, other):
5891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5892 
 
5893 
  def __ne__(self, other):
5894 
    return not (self == other)
5895 
 
1398 varun.gupt 5896 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 5897 
  """
5898 
  Attributes:
5899 
   - success
5900 
   - ex
5901 
  """
5902 
 
5903 
  thrift_spec = (
5904 
    (0, TType.BOOL, 'success', None, None, ), # 0
5905 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5906 
  )
5907 
 
5908 
  def __init__(self, success=None, ex=None,):
5909 
    self.success = success
5910 
    self.ex = ex
5911 
 
5912 
  def read(self, iprot):
5913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5915 
      return
5916 
    iprot.readStructBegin()
5917 
    while True:
5918 
      (fname, ftype, fid) = iprot.readFieldBegin()
5919 
      if ftype == TType.STOP:
5920 
        break
5921 
      if fid == 0:
5922 
        if ftype == TType.BOOL:
5923 
          self.success = iprot.readBool();
5924 
        else:
5925 
          iprot.skip(ftype)
5926 
      elif fid == 1:
5927 
        if ftype == TType.STRUCT:
5928 
          self.ex = TransactionServiceException()
5929 
          self.ex.read(iprot)
5930 
        else:
5931 
          iprot.skip(ftype)
5932 
      else:
5933 
        iprot.skip(ftype)
5934 
      iprot.readFieldEnd()
5935 
    iprot.readStructEnd()
5936 
 
5937 
  def write(self, oprot):
5938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5940 
      return
1398 varun.gupt 5941 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5942 
    if self.success is not None:
1382 varun.gupt 5943 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5944 
      oprot.writeBool(self.success)
5945 
      oprot.writeFieldEnd()
3431 rajveer 5946 
    if self.ex is not None:
1382 varun.gupt 5947 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5948 
      self.ex.write(oprot)
5949 
      oprot.writeFieldEnd()
5950 
    oprot.writeFieldStop()
5951 
    oprot.writeStructEnd()
5952 
 
3431 rajveer 5953 
  def validate(self):
5954 
    return
5955 
 
5956 
 
1382 varun.gupt 5957 
  def __repr__(self):
5958 
    L = ['%s=%r' % (key, value)
5959 
      for key, value in self.__dict__.iteritems()]
5960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5961 
 
5962 
  def __eq__(self, other):
5963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5964 
 
5965 
  def __ne__(self, other):
5966 
    return not (self == other)
5967 
 
483 rajveer 5968 
class getAllOrders_args:
94 ashish 5969 
  """
5970 
  Attributes:
483 rajveer 5971 
   - status
5972 
   - from_date
5973 
   - to_date
5974 
   - warehouse_id
94 ashish 5975 
  """
5976 
 
5977 
  thrift_spec = (
5978 
    None, # 0
483 rajveer 5979 
    (1, TType.I32, 'status', None, None, ), # 1
5980 
    (2, TType.I64, 'from_date', None, None, ), # 2
5981 
    (3, TType.I64, 'to_date', None, None, ), # 3
5982 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5983 
  )
5984 
 
483 rajveer 5985 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5986 
    self.status = status
5987 
    self.from_date = from_date
5988 
    self.to_date = to_date
5989 
    self.warehouse_id = warehouse_id
94 ashish 5990 
 
5991 
  def read(self, iprot):
5992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5994 
      return
5995 
    iprot.readStructBegin()
5996 
    while True:
5997 
      (fname, ftype, fid) = iprot.readFieldBegin()
5998 
      if ftype == TType.STOP:
5999 
        break
6000 
      if fid == 1:
483 rajveer 6001 
        if ftype == TType.I32:
6002 
          self.status = iprot.readI32();
94 ashish 6003 
        else:
6004 
          iprot.skip(ftype)
483 rajveer 6005 
      elif fid == 2:
6006 
        if ftype == TType.I64:
6007 
          self.from_date = iprot.readI64();
94 ashish 6008 
        else:
6009 
          iprot.skip(ftype)
483 rajveer 6010 
      elif fid == 3:
6011 
        if ftype == TType.I64:
6012 
          self.to_date = iprot.readI64();
94 ashish 6013 
        else:
6014 
          iprot.skip(ftype)
483 rajveer 6015 
      elif fid == 4:
94 ashish 6016 
        if ftype == TType.I64:
483 rajveer 6017 
          self.warehouse_id = iprot.readI64();
94 ashish 6018 
        else:
6019 
          iprot.skip(ftype)
6020 
      else:
6021 
        iprot.skip(ftype)
6022 
      iprot.readFieldEnd()
6023 
    iprot.readStructEnd()
6024 
 
6025 
  def write(self, oprot):
6026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6028 
      return
483 rajveer 6029 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 6030 
    if self.status is not None:
483 rajveer 6031 
      oprot.writeFieldBegin('status', TType.I32, 1)
6032 
      oprot.writeI32(self.status)
94 ashish 6033 
      oprot.writeFieldEnd()
3431 rajveer 6034 
    if self.from_date is not None:
483 rajveer 6035 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6036 
      oprot.writeI64(self.from_date)
94 ashish 6037 
      oprot.writeFieldEnd()
3431 rajveer 6038 
    if self.to_date is not None:
483 rajveer 6039 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6040 
      oprot.writeI64(self.to_date)
94 ashish 6041 
      oprot.writeFieldEnd()
3431 rajveer 6042 
    if self.warehouse_id is not None:
483 rajveer 6043 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6044 
      oprot.writeI64(self.warehouse_id)
94 ashish 6045 
      oprot.writeFieldEnd()
6046 
    oprot.writeFieldStop()
6047 
    oprot.writeStructEnd()
6048 
 
3431 rajveer 6049 
  def validate(self):
6050 
    return
6051 
 
6052 
 
94 ashish 6053 
  def __repr__(self):
6054 
    L = ['%s=%r' % (key, value)
6055 
      for key, value in self.__dict__.iteritems()]
6056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6057 
 
6058 
  def __eq__(self, other):
6059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6060 
 
6061 
  def __ne__(self, other):
6062 
    return not (self == other)
6063 
 
483 rajveer 6064 
class getAllOrders_result:
94 ashish 6065 
  """
6066 
  Attributes:
6067 
   - success
6068 
   - ex
6069 
  """
6070 
 
6071 
  thrift_spec = (
483 rajveer 6072 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6073 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6074 
  )
6075 
 
6076 
  def __init__(self, success=None, ex=None,):
6077 
    self.success = success
6078 
    self.ex = ex
6079 
 
6080 
  def read(self, iprot):
6081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6083 
      return
6084 
    iprot.readStructBegin()
6085 
    while True:
6086 
      (fname, ftype, fid) = iprot.readFieldBegin()
6087 
      if ftype == TType.STOP:
6088 
        break
6089 
      if fid == 0:
483 rajveer 6090 
        if ftype == TType.LIST:
6091 
          self.success = []
685 chandransh 6092 
          (_etype31, _size28) = iprot.readListBegin()
6093 
          for _i32 in xrange(_size28):
6094 
            _elem33 = Order()
6095 
            _elem33.read(iprot)
6096 
            self.success.append(_elem33)
483 rajveer 6097 
          iprot.readListEnd()
94 ashish 6098 
        else:
6099 
          iprot.skip(ftype)
6100 
      elif fid == 1:
6101 
        if ftype == TType.STRUCT:
6102 
          self.ex = TransactionServiceException()
6103 
          self.ex.read(iprot)
6104 
        else:
6105 
          iprot.skip(ftype)
6106 
      else:
6107 
        iprot.skip(ftype)
6108 
      iprot.readFieldEnd()
6109 
    iprot.readStructEnd()
6110 
 
6111 
  def write(self, oprot):
6112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6114 
      return
483 rajveer 6115 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 6116 
    if self.success is not None:
483 rajveer 6117 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6118 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6119 
      for iter34 in self.success:
6120 
        iter34.write(oprot)
483 rajveer 6121 
      oprot.writeListEnd()
94 ashish 6122 
      oprot.writeFieldEnd()
3431 rajveer 6123 
    if self.ex is not None:
94 ashish 6124 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6125 
      self.ex.write(oprot)
6126 
      oprot.writeFieldEnd()
6127 
    oprot.writeFieldStop()
6128 
    oprot.writeStructEnd()
6129 
 
3431 rajveer 6130 
  def validate(self):
6131 
    return
6132 
 
6133 
 
94 ashish 6134 
  def __repr__(self):
6135 
    L = ['%s=%r' % (key, value)
6136 
      for key, value in self.__dict__.iteritems()]
6137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6138 
 
6139 
  def __eq__(self, other):
6140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6141 
 
6142 
  def __ne__(self, other):
6143 
    return not (self == other)
6144 
 
4133 chandransh 6145 
class getOrdersInBatch_args:
6146 
  """
6147 
  Attributes:
6148 
   - statuses
6149 
   - offset
6150 
   - limit
6151 
   - warehouse_id
6152 
  """
6153 
 
6154 
  thrift_spec = (
6155 
    None, # 0
6156 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6157 
    (2, TType.I64, 'offset', None, None, ), # 2
6158 
    (3, TType.I64, 'limit', None, None, ), # 3
6159 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6160 
  )
6161 
 
6162 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
6163 
    self.statuses = statuses
6164 
    self.offset = offset
6165 
    self.limit = limit
6166 
    self.warehouse_id = warehouse_id
6167 
 
6168 
  def read(self, iprot):
6169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6171 
      return
6172 
    iprot.readStructBegin()
6173 
    while True:
6174 
      (fname, ftype, fid) = iprot.readFieldBegin()
6175 
      if ftype == TType.STOP:
6176 
        break
6177 
      if fid == 1:
6178 
        if ftype == TType.LIST:
6179 
          self.statuses = []
6180 
          (_etype38, _size35) = iprot.readListBegin()
6181 
          for _i39 in xrange(_size35):
6182 
            _elem40 = iprot.readI32();
6183 
            self.statuses.append(_elem40)
6184 
          iprot.readListEnd()
6185 
        else:
6186 
          iprot.skip(ftype)
6187 
      elif fid == 2:
6188 
        if ftype == TType.I64:
6189 
          self.offset = iprot.readI64();
6190 
        else:
6191 
          iprot.skip(ftype)
6192 
      elif fid == 3:
6193 
        if ftype == TType.I64:
6194 
          self.limit = iprot.readI64();
6195 
        else:
6196 
          iprot.skip(ftype)
6197 
      elif fid == 4:
6198 
        if ftype == TType.I64:
6199 
          self.warehouse_id = iprot.readI64();
6200 
        else:
6201 
          iprot.skip(ftype)
6202 
      else:
6203 
        iprot.skip(ftype)
6204 
      iprot.readFieldEnd()
6205 
    iprot.readStructEnd()
6206 
 
6207 
  def write(self, oprot):
6208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6210 
      return
6211 
    oprot.writeStructBegin('getOrdersInBatch_args')
6212 
    if self.statuses is not None:
6213 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6214 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6215 
      for iter41 in self.statuses:
6216 
        oprot.writeI32(iter41)
6217 
      oprot.writeListEnd()
6218 
      oprot.writeFieldEnd()
6219 
    if self.offset is not None:
6220 
      oprot.writeFieldBegin('offset', TType.I64, 2)
6221 
      oprot.writeI64(self.offset)
6222 
      oprot.writeFieldEnd()
6223 
    if self.limit is not None:
6224 
      oprot.writeFieldBegin('limit', TType.I64, 3)
6225 
      oprot.writeI64(self.limit)
6226 
      oprot.writeFieldEnd()
6227 
    if self.warehouse_id is not None:
6228 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6229 
      oprot.writeI64(self.warehouse_id)
6230 
      oprot.writeFieldEnd()
6231 
    oprot.writeFieldStop()
6232 
    oprot.writeStructEnd()
6233 
 
6234 
  def validate(self):
6235 
    return
6236 
 
6237 
 
6238 
  def __repr__(self):
6239 
    L = ['%s=%r' % (key, value)
6240 
      for key, value in self.__dict__.iteritems()]
6241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6242 
 
6243 
  def __eq__(self, other):
6244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6245 
 
6246 
  def __ne__(self, other):
6247 
    return not (self == other)
6248 
 
6249 
class getOrdersInBatch_result:
6250 
  """
6251 
  Attributes:
6252 
   - success
6253 
   - ex
6254 
  """
6255 
 
6256 
  thrift_spec = (
6257 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6258 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6259 
  )
6260 
 
6261 
  def __init__(self, success=None, ex=None,):
6262 
    self.success = success
6263 
    self.ex = ex
6264 
 
6265 
  def read(self, iprot):
6266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6268 
      return
6269 
    iprot.readStructBegin()
6270 
    while True:
6271 
      (fname, ftype, fid) = iprot.readFieldBegin()
6272 
      if ftype == TType.STOP:
6273 
        break
6274 
      if fid == 0:
6275 
        if ftype == TType.LIST:
6276 
          self.success = []
6277 
          (_etype45, _size42) = iprot.readListBegin()
6278 
          for _i46 in xrange(_size42):
6279 
            _elem47 = Order()
6280 
            _elem47.read(iprot)
6281 
            self.success.append(_elem47)
6282 
          iprot.readListEnd()
6283 
        else:
6284 
          iprot.skip(ftype)
6285 
      elif fid == 1:
6286 
        if ftype == TType.STRUCT:
6287 
          self.ex = TransactionServiceException()
6288 
          self.ex.read(iprot)
6289 
        else:
6290 
          iprot.skip(ftype)
6291 
      else:
6292 
        iprot.skip(ftype)
6293 
      iprot.readFieldEnd()
6294 
    iprot.readStructEnd()
6295 
 
6296 
  def write(self, oprot):
6297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6299 
      return
6300 
    oprot.writeStructBegin('getOrdersInBatch_result')
6301 
    if self.success is not None:
6302 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6303 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6304 
      for iter48 in self.success:
6305 
        iter48.write(oprot)
6306 
      oprot.writeListEnd()
6307 
      oprot.writeFieldEnd()
6308 
    if self.ex is not None:
6309 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6310 
      self.ex.write(oprot)
6311 
      oprot.writeFieldEnd()
6312 
    oprot.writeFieldStop()
6313 
    oprot.writeStructEnd()
6314 
 
6315 
  def validate(self):
6316 
    return
6317 
 
6318 
 
6319 
  def __repr__(self):
6320 
    L = ['%s=%r' % (key, value)
6321 
      for key, value in self.__dict__.iteritems()]
6322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6323 
 
6324 
  def __eq__(self, other):
6325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6326 
 
6327 
  def __ne__(self, other):
6328 
    return not (self == other)
6329 
 
6330 
class getOrderCount_args:
6331 
  """
6332 
  Attributes:
6333 
   - statuses
6334 
   - warehouseId
6335 
  """
6336 
 
6337 
  thrift_spec = (
6338 
    None, # 0
6339 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6340 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6341 
  )
6342 
 
6343 
  def __init__(self, statuses=None, warehouseId=None,):
6344 
    self.statuses = statuses
6345 
    self.warehouseId = warehouseId
6346 
 
6347 
  def read(self, iprot):
6348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6350 
      return
6351 
    iprot.readStructBegin()
6352 
    while True:
6353 
      (fname, ftype, fid) = iprot.readFieldBegin()
6354 
      if ftype == TType.STOP:
6355 
        break
6356 
      if fid == 1:
6357 
        if ftype == TType.LIST:
6358 
          self.statuses = []
6359 
          (_etype52, _size49) = iprot.readListBegin()
6360 
          for _i53 in xrange(_size49):
6361 
            _elem54 = iprot.readI32();
6362 
            self.statuses.append(_elem54)
6363 
          iprot.readListEnd()
6364 
        else:
6365 
          iprot.skip(ftype)
6366 
      elif fid == 2:
6367 
        if ftype == TType.I64:
6368 
          self.warehouseId = iprot.readI64();
6369 
        else:
6370 
          iprot.skip(ftype)
6371 
      else:
6372 
        iprot.skip(ftype)
6373 
      iprot.readFieldEnd()
6374 
    iprot.readStructEnd()
6375 
 
6376 
  def write(self, oprot):
6377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6379 
      return
6380 
    oprot.writeStructBegin('getOrderCount_args')
6381 
    if self.statuses is not None:
6382 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6383 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6384 
      for iter55 in self.statuses:
6385 
        oprot.writeI32(iter55)
6386 
      oprot.writeListEnd()
6387 
      oprot.writeFieldEnd()
6388 
    if self.warehouseId is not None:
6389 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6390 
      oprot.writeI64(self.warehouseId)
6391 
      oprot.writeFieldEnd()
6392 
    oprot.writeFieldStop()
6393 
    oprot.writeStructEnd()
6394 
 
6395 
  def validate(self):
6396 
    return
6397 
 
6398 
 
6399 
  def __repr__(self):
6400 
    L = ['%s=%r' % (key, value)
6401 
      for key, value in self.__dict__.iteritems()]
6402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6403 
 
6404 
  def __eq__(self, other):
6405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6406 
 
6407 
  def __ne__(self, other):
6408 
    return not (self == other)
6409 
 
6410 
class getOrderCount_result:
6411 
  """
6412 
  Attributes:
6413 
   - success
6414 
   - ex
6415 
  """
6416 
 
6417 
  thrift_spec = (
6418 
    (0, TType.I32, 'success', None, None, ), # 0
6419 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6420 
  )
6421 
 
6422 
  def __init__(self, success=None, ex=None,):
6423 
    self.success = success
6424 
    self.ex = ex
6425 
 
6426 
  def read(self, iprot):
6427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6429 
      return
6430 
    iprot.readStructBegin()
6431 
    while True:
6432 
      (fname, ftype, fid) = iprot.readFieldBegin()
6433 
      if ftype == TType.STOP:
6434 
        break
6435 
      if fid == 0:
6436 
        if ftype == TType.I32:
6437 
          self.success = iprot.readI32();
6438 
        else:
6439 
          iprot.skip(ftype)
6440 
      elif fid == 1:
6441 
        if ftype == TType.STRUCT:
6442 
          self.ex = TransactionServiceException()
6443 
          self.ex.read(iprot)
6444 
        else:
6445 
          iprot.skip(ftype)
6446 
      else:
6447 
        iprot.skip(ftype)
6448 
      iprot.readFieldEnd()
6449 
    iprot.readStructEnd()
6450 
 
6451 
  def write(self, oprot):
6452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6454 
      return
6455 
    oprot.writeStructBegin('getOrderCount_result')
6456 
    if self.success is not None:
6457 
      oprot.writeFieldBegin('success', TType.I32, 0)
6458 
      oprot.writeI32(self.success)
6459 
      oprot.writeFieldEnd()
6460 
    if self.ex is not None:
6461 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6462 
      self.ex.write(oprot)
6463 
      oprot.writeFieldEnd()
6464 
    oprot.writeFieldStop()
6465 
    oprot.writeStructEnd()
6466 
 
6467 
  def validate(self):
6468 
    return
6469 
 
6470 
 
6471 
  def __repr__(self):
6472 
    L = ['%s=%r' % (key, value)
6473 
      for key, value in self.__dict__.iteritems()]
6474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6475 
 
6476 
  def __eq__(self, other):
6477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6478 
 
6479 
  def __ne__(self, other):
6480 
    return not (self == other)
6481 
 
999 varun.gupt 6482 
class getOrdersByBillingDate_args:
6483 
  """
6484 
  Attributes:
6485 
   - status
6486 
   - start_billing_date
6487 
   - end_billing_date
6488 
   - warehouse_id
6489 
  """
6490 
 
6491 
  thrift_spec = (
6492 
    None, # 0
6493 
    (1, TType.I32, 'status', None, None, ), # 1
6494 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
6495 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
6496 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6497 
  )
6498 
 
6499 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
6500 
    self.status = status
6501 
    self.start_billing_date = start_billing_date
6502 
    self.end_billing_date = end_billing_date
6503 
    self.warehouse_id = warehouse_id
6504 
 
6505 
  def read(self, iprot):
6506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6508 
      return
6509 
    iprot.readStructBegin()
6510 
    while True:
6511 
      (fname, ftype, fid) = iprot.readFieldBegin()
6512 
      if ftype == TType.STOP:
6513 
        break
6514 
      if fid == 1:
6515 
        if ftype == TType.I32:
6516 
          self.status = iprot.readI32();
6517 
        else:
6518 
          iprot.skip(ftype)
6519 
      elif fid == 2:
6520 
        if ftype == TType.I64:
6521 
          self.start_billing_date = iprot.readI64();
6522 
        else:
6523 
          iprot.skip(ftype)
6524 
      elif fid == 3:
6525 
        if ftype == TType.I64:
6526 
          self.end_billing_date = iprot.readI64();
6527 
        else:
6528 
          iprot.skip(ftype)
6529 
      elif fid == 4:
6530 
        if ftype == TType.I64:
6531 
          self.warehouse_id = iprot.readI64();
6532 
        else:
6533 
          iprot.skip(ftype)
6534 
      else:
6535 
        iprot.skip(ftype)
6536 
      iprot.readFieldEnd()
6537 
    iprot.readStructEnd()
6538 
 
6539 
  def write(self, oprot):
6540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6542 
      return
6543 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 6544 
    if self.status is not None:
999 varun.gupt 6545 
      oprot.writeFieldBegin('status', TType.I32, 1)
6546 
      oprot.writeI32(self.status)
6547 
      oprot.writeFieldEnd()
3431 rajveer 6548 
    if self.start_billing_date is not None:
999 varun.gupt 6549 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
6550 
      oprot.writeI64(self.start_billing_date)
6551 
      oprot.writeFieldEnd()
3431 rajveer 6552 
    if self.end_billing_date is not None:
999 varun.gupt 6553 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
6554 
      oprot.writeI64(self.end_billing_date)
6555 
      oprot.writeFieldEnd()
3431 rajveer 6556 
    if self.warehouse_id is not None:
999 varun.gupt 6557 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6558 
      oprot.writeI64(self.warehouse_id)
6559 
      oprot.writeFieldEnd()
6560 
    oprot.writeFieldStop()
6561 
    oprot.writeStructEnd()
6562 
 
3431 rajveer 6563 
  def validate(self):
6564 
    return
6565 
 
6566 
 
999 varun.gupt 6567 
  def __repr__(self):
6568 
    L = ['%s=%r' % (key, value)
6569 
      for key, value in self.__dict__.iteritems()]
6570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6571 
 
6572 
  def __eq__(self, other):
6573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6574 
 
6575 
  def __ne__(self, other):
6576 
    return not (self == other)
6577 
 
6578 
class getOrdersByBillingDate_result:
6579 
  """
6580 
  Attributes:
6581 
   - success
6582 
   - ex
6583 
  """
6584 
 
6585 
  thrift_spec = (
6586 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6587 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6588 
  )
6589 
 
6590 
  def __init__(self, success=None, ex=None,):
6591 
    self.success = success
6592 
    self.ex = ex
6593 
 
6594 
  def read(self, iprot):
6595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6597 
      return
6598 
    iprot.readStructBegin()
6599 
    while True:
6600 
      (fname, ftype, fid) = iprot.readFieldBegin()
6601 
      if ftype == TType.STOP:
6602 
        break
6603 
      if fid == 0:
6604 
        if ftype == TType.LIST:
6605 
          self.success = []
4133 chandransh 6606 
          (_etype59, _size56) = iprot.readListBegin()
6607 
          for _i60 in xrange(_size56):
6608 
            _elem61 = Order()
6609 
            _elem61.read(iprot)
6610 
            self.success.append(_elem61)
999 varun.gupt 6611 
          iprot.readListEnd()
6612 
        else:
6613 
          iprot.skip(ftype)
6614 
      elif fid == 1:
6615 
        if ftype == TType.STRUCT:
6616 
          self.ex = TransactionServiceException()
6617 
          self.ex.read(iprot)
6618 
        else:
6619 
          iprot.skip(ftype)
6620 
      else:
6621 
        iprot.skip(ftype)
6622 
      iprot.readFieldEnd()
6623 
    iprot.readStructEnd()
6624 
 
6625 
  def write(self, oprot):
6626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6628 
      return
6629 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 6630 
    if self.success is not None:
999 varun.gupt 6631 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6632 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6633 
      for iter62 in self.success:
6634 
        iter62.write(oprot)
999 varun.gupt 6635 
      oprot.writeListEnd()
6636 
      oprot.writeFieldEnd()
3431 rajveer 6637 
    if self.ex is not None:
999 varun.gupt 6638 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6639 
      self.ex.write(oprot)
6640 
      oprot.writeFieldEnd()
6641 
    oprot.writeFieldStop()
6642 
    oprot.writeStructEnd()
6643 
 
3431 rajveer 6644 
  def validate(self):
6645 
    return
6646 
 
6647 
 
999 varun.gupt 6648 
  def __repr__(self):
6649 
    L = ['%s=%r' % (key, value)
6650 
      for key, value in self.__dict__.iteritems()]
6651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6652 
 
6653 
  def __eq__(self, other):
6654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6655 
 
6656 
  def __ne__(self, other):
6657 
    return not (self == other)
6658 
 
3427 chandransh 6659 
class getOrdersByShippingDate_args:
6660 
  """
6661 
  Attributes:
6662 
   - fromShippingDate
6663 
   - toShippingDate
6664 
   - providerId
6665 
   - warehouseId
3451 chandransh 6666 
   - cod
3427 chandransh 6667 
  """
6668 
 
6669 
  thrift_spec = (
6670 
    None, # 0
6671 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
6672 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
6673 
    (3, TType.I64, 'providerId', None, None, ), # 3
6674 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 6675 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 6676 
  )
6677 
 
3451 chandransh 6678 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 6679 
    self.fromShippingDate = fromShippingDate
6680 
    self.toShippingDate = toShippingDate
6681 
    self.providerId = providerId
6682 
    self.warehouseId = warehouseId
3451 chandransh 6683 
    self.cod = cod
3427 chandransh 6684 
 
6685 
  def read(self, iprot):
6686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6688 
      return
6689 
    iprot.readStructBegin()
6690 
    while True:
6691 
      (fname, ftype, fid) = iprot.readFieldBegin()
6692 
      if ftype == TType.STOP:
6693 
        break
6694 
      if fid == 1:
6695 
        if ftype == TType.I64:
6696 
          self.fromShippingDate = iprot.readI64();
6697 
        else:
6698 
          iprot.skip(ftype)
6699 
      elif fid == 2:
6700 
        if ftype == TType.I64:
6701 
          self.toShippingDate = iprot.readI64();
6702 
        else:
6703 
          iprot.skip(ftype)
6704 
      elif fid == 3:
6705 
        if ftype == TType.I64:
6706 
          self.providerId = iprot.readI64();
6707 
        else:
6708 
          iprot.skip(ftype)
6709 
      elif fid == 4:
6710 
        if ftype == TType.I64:
6711 
          self.warehouseId = iprot.readI64();
6712 
        else:
6713 
          iprot.skip(ftype)
3451 chandransh 6714 
      elif fid == 5:
6715 
        if ftype == TType.BOOL:
6716 
          self.cod = iprot.readBool();
6717 
        else:
6718 
          iprot.skip(ftype)
3427 chandransh 6719 
      else:
6720 
        iprot.skip(ftype)
6721 
      iprot.readFieldEnd()
6722 
    iprot.readStructEnd()
6723 
 
6724 
  def write(self, oprot):
6725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6727 
      return
6728 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 6729 
    if self.fromShippingDate is not None:
3427 chandransh 6730 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
6731 
      oprot.writeI64(self.fromShippingDate)
6732 
      oprot.writeFieldEnd()
3431 rajveer 6733 
    if self.toShippingDate is not None:
3427 chandransh 6734 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
6735 
      oprot.writeI64(self.toShippingDate)
6736 
      oprot.writeFieldEnd()
3431 rajveer 6737 
    if self.providerId is not None:
3427 chandransh 6738 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
6739 
      oprot.writeI64(self.providerId)
6740 
      oprot.writeFieldEnd()
3431 rajveer 6741 
    if self.warehouseId is not None:
3427 chandransh 6742 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
6743 
      oprot.writeI64(self.warehouseId)
6744 
      oprot.writeFieldEnd()
3451 chandransh 6745 
    if self.cod is not None:
6746 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
6747 
      oprot.writeBool(self.cod)
6748 
      oprot.writeFieldEnd()
3427 chandransh 6749 
    oprot.writeFieldStop()
6750 
    oprot.writeStructEnd()
6751 
 
3431 rajveer 6752 
  def validate(self):
6753 
    return
6754 
 
6755 
 
3427 chandransh 6756 
  def __repr__(self):
6757 
    L = ['%s=%r' % (key, value)
6758 
      for key, value in self.__dict__.iteritems()]
6759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6760 
 
6761 
  def __eq__(self, other):
6762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6763 
 
6764 
  def __ne__(self, other):
6765 
    return not (self == other)
6766 
 
6767 
class getOrdersByShippingDate_result:
6768 
  """
6769 
  Attributes:
6770 
   - success
6771 
   - ex
6772 
  """
6773 
 
6774 
  thrift_spec = (
6775 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6776 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6777 
  )
6778 
 
6779 
  def __init__(self, success=None, ex=None,):
6780 
    self.success = success
6781 
    self.ex = ex
6782 
 
6783 
  def read(self, iprot):
6784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6786 
      return
6787 
    iprot.readStructBegin()
6788 
    while True:
6789 
      (fname, ftype, fid) = iprot.readFieldBegin()
6790 
      if ftype == TType.STOP:
6791 
        break
6792 
      if fid == 0:
6793 
        if ftype == TType.LIST:
6794 
          self.success = []
4133 chandransh 6795 
          (_etype66, _size63) = iprot.readListBegin()
6796 
          for _i67 in xrange(_size63):
6797 
            _elem68 = Order()
6798 
            _elem68.read(iprot)
6799 
            self.success.append(_elem68)
3427 chandransh 6800 
          iprot.readListEnd()
6801 
        else:
6802 
          iprot.skip(ftype)
6803 
      elif fid == 1:
6804 
        if ftype == TType.STRUCT:
6805 
          self.ex = TransactionServiceException()
6806 
          self.ex.read(iprot)
6807 
        else:
6808 
          iprot.skip(ftype)
6809 
      else:
6810 
        iprot.skip(ftype)
6811 
      iprot.readFieldEnd()
6812 
    iprot.readStructEnd()
6813 
 
6814 
  def write(self, oprot):
6815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6817 
      return
6818 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 6819 
    if self.success is not None:
3427 chandransh 6820 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6821 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6822 
      for iter69 in self.success:
6823 
        iter69.write(oprot)
3427 chandransh 6824 
      oprot.writeListEnd()
6825 
      oprot.writeFieldEnd()
3431 rajveer 6826 
    if self.ex is not None:
3427 chandransh 6827 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6828 
      self.ex.write(oprot)
6829 
      oprot.writeFieldEnd()
6830 
    oprot.writeFieldStop()
6831 
    oprot.writeStructEnd()
6832 
 
3431 rajveer 6833 
  def validate(self):
6834 
    return
6835 
 
6836 
 
3427 chandransh 6837 
  def __repr__(self):
6838 
    L = ['%s=%r' % (key, value)
6839 
      for key, value in self.__dict__.iteritems()]
6840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6841 
 
6842 
  def __eq__(self, other):
6843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6844 
 
6845 
  def __ne__(self, other):
6846 
    return not (self == other)
6847 
 
1382 varun.gupt 6848 
class getReturnableOrdersForCustomer_args:
6849 
  """
6850 
  Attributes:
6851 
   - customer_id
6852 
   - limit
6853 
  """
6854 
 
6855 
  thrift_spec = (
6856 
    None, # 0
6857 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6858 
    (2, TType.I64, 'limit', None, None, ), # 2
6859 
  )
6860 
 
6861 
  def __init__(self, customer_id=None, limit=None,):
6862 
    self.customer_id = customer_id
6863 
    self.limit = limit
6864 
 
6865 
  def read(self, iprot):
6866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6868 
      return
6869 
    iprot.readStructBegin()
6870 
    while True:
6871 
      (fname, ftype, fid) = iprot.readFieldBegin()
6872 
      if ftype == TType.STOP:
6873 
        break
6874 
      if fid == 1:
6875 
        if ftype == TType.I64:
6876 
          self.customer_id = iprot.readI64();
6877 
        else:
6878 
          iprot.skip(ftype)
6879 
      elif fid == 2:
6880 
        if ftype == TType.I64:
6881 
          self.limit = iprot.readI64();
6882 
        else:
6883 
          iprot.skip(ftype)
6884 
      else:
6885 
        iprot.skip(ftype)
6886 
      iprot.readFieldEnd()
6887 
    iprot.readStructEnd()
6888 
 
6889 
  def write(self, oprot):
6890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6892 
      return
6893 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 6894 
    if self.customer_id is not None:
1382 varun.gupt 6895 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6896 
      oprot.writeI64(self.customer_id)
6897 
      oprot.writeFieldEnd()
3431 rajveer 6898 
    if self.limit is not None:
1382 varun.gupt 6899 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6900 
      oprot.writeI64(self.limit)
6901 
      oprot.writeFieldEnd()
6902 
    oprot.writeFieldStop()
6903 
    oprot.writeStructEnd()
6904 
 
3431 rajveer 6905 
  def validate(self):
6906 
    return
6907 
 
6908 
 
1382 varun.gupt 6909 
  def __repr__(self):
6910 
    L = ['%s=%r' % (key, value)
6911 
      for key, value in self.__dict__.iteritems()]
6912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6913 
 
6914 
  def __eq__(self, other):
6915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6916 
 
6917 
  def __ne__(self, other):
6918 
    return not (self == other)
6919 
 
6920 
class getReturnableOrdersForCustomer_result:
6921 
  """
6922 
  Attributes:
6923 
   - success
6924 
   - ex
6925 
  """
6926 
 
6927 
  thrift_spec = (
6928 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6929 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6930 
  )
6931 
 
6932 
  def __init__(self, success=None, ex=None,):
6933 
    self.success = success
6934 
    self.ex = ex
6935 
 
6936 
  def read(self, iprot):
6937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6939 
      return
6940 
    iprot.readStructBegin()
6941 
    while True:
6942 
      (fname, ftype, fid) = iprot.readFieldBegin()
6943 
      if ftype == TType.STOP:
6944 
        break
6945 
      if fid == 0:
6946 
        if ftype == TType.LIST:
6947 
          self.success = []
4133 chandransh 6948 
          (_etype73, _size70) = iprot.readListBegin()
6949 
          for _i74 in xrange(_size70):
6950 
            _elem75 = iprot.readI64();
6951 
            self.success.append(_elem75)
1382 varun.gupt 6952 
          iprot.readListEnd()
6953 
        else:
6954 
          iprot.skip(ftype)
6955 
      elif fid == 1:
6956 
        if ftype == TType.STRUCT:
6957 
          self.ex = TransactionServiceException()
6958 
          self.ex.read(iprot)
6959 
        else:
6960 
          iprot.skip(ftype)
6961 
      else:
6962 
        iprot.skip(ftype)
6963 
      iprot.readFieldEnd()
6964 
    iprot.readStructEnd()
6965 
 
6966 
  def write(self, oprot):
6967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6969 
      return
6970 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6971 
    if self.success is not None:
1382 varun.gupt 6972 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6973 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6974 
      for iter76 in self.success:
6975 
        oprot.writeI64(iter76)
1382 varun.gupt 6976 
      oprot.writeListEnd()
6977 
      oprot.writeFieldEnd()
3431 rajveer 6978 
    if self.ex is not None:
1382 varun.gupt 6979 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6980 
      self.ex.write(oprot)
6981 
      oprot.writeFieldEnd()
6982 
    oprot.writeFieldStop()
6983 
    oprot.writeStructEnd()
6984 
 
3431 rajveer 6985 
  def validate(self):
6986 
    return
6987 
 
6988 
 
1382 varun.gupt 6989 
  def __repr__(self):
6990 
    L = ['%s=%r' % (key, value)
6991 
      for key, value in self.__dict__.iteritems()]
6992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6993 
 
6994 
  def __eq__(self, other):
6995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6996 
 
6997 
  def __ne__(self, other):
6998 
    return not (self == other)
6999 
 
7000 
class getCancellableOrdersForCustomer_args:
7001 
  """
7002 
  Attributes:
7003 
   - customer_id
7004 
   - limit
7005 
  """
7006 
 
7007 
  thrift_spec = (
7008 
    None, # 0
7009 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7010 
    (2, TType.I64, 'limit', None, None, ), # 2
7011 
  )
7012 
 
7013 
  def __init__(self, customer_id=None, limit=None,):
7014 
    self.customer_id = customer_id
7015 
    self.limit = limit
7016 
 
7017 
  def read(self, iprot):
7018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7020 
      return
7021 
    iprot.readStructBegin()
7022 
    while True:
7023 
      (fname, ftype, fid) = iprot.readFieldBegin()
7024 
      if ftype == TType.STOP:
7025 
        break
7026 
      if fid == 1:
7027 
        if ftype == TType.I64:
7028 
          self.customer_id = iprot.readI64();
7029 
        else:
7030 
          iprot.skip(ftype)
7031 
      elif fid == 2:
7032 
        if ftype == TType.I64:
7033 
          self.limit = iprot.readI64();
7034 
        else:
7035 
          iprot.skip(ftype)
7036 
      else:
7037 
        iprot.skip(ftype)
7038 
      iprot.readFieldEnd()
7039 
    iprot.readStructEnd()
7040 
 
7041 
  def write(self, oprot):
7042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7044 
      return
7045 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7046 
    if self.customer_id is not None:
1382 varun.gupt 7047 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7048 
      oprot.writeI64(self.customer_id)
7049 
      oprot.writeFieldEnd()
3431 rajveer 7050 
    if self.limit is not None:
1382 varun.gupt 7051 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7052 
      oprot.writeI64(self.limit)
7053 
      oprot.writeFieldEnd()
7054 
    oprot.writeFieldStop()
7055 
    oprot.writeStructEnd()
7056 
 
3431 rajveer 7057 
  def validate(self):
7058 
    return
7059 
 
7060 
 
1382 varun.gupt 7061 
  def __repr__(self):
7062 
    L = ['%s=%r' % (key, value)
7063 
      for key, value in self.__dict__.iteritems()]
7064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7065 
 
7066 
  def __eq__(self, other):
7067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7068 
 
7069 
  def __ne__(self, other):
7070 
    return not (self == other)
7071 
 
7072 
class getCancellableOrdersForCustomer_result:
7073 
  """
7074 
  Attributes:
7075 
   - success
7076 
   - ex
7077 
  """
7078 
 
7079 
  thrift_spec = (
7080 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7081 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7082 
  )
7083 
 
7084 
  def __init__(self, success=None, ex=None,):
7085 
    self.success = success
7086 
    self.ex = ex
7087 
 
7088 
  def read(self, iprot):
7089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7091 
      return
7092 
    iprot.readStructBegin()
7093 
    while True:
7094 
      (fname, ftype, fid) = iprot.readFieldBegin()
7095 
      if ftype == TType.STOP:
7096 
        break
7097 
      if fid == 0:
7098 
        if ftype == TType.LIST:
7099 
          self.success = []
4133 chandransh 7100 
          (_etype80, _size77) = iprot.readListBegin()
7101 
          for _i81 in xrange(_size77):
7102 
            _elem82 = iprot.readI64();
7103 
            self.success.append(_elem82)
1382 varun.gupt 7104 
          iprot.readListEnd()
7105 
        else:
7106 
          iprot.skip(ftype)
7107 
      elif fid == 1:
7108 
        if ftype == TType.STRUCT:
7109 
          self.ex = TransactionServiceException()
7110 
          self.ex.read(iprot)
7111 
        else:
7112 
          iprot.skip(ftype)
7113 
      else:
7114 
        iprot.skip(ftype)
7115 
      iprot.readFieldEnd()
7116 
    iprot.readStructEnd()
7117 
 
7118 
  def write(self, oprot):
7119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7121 
      return
7122 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 7123 
    if self.success is not None:
1382 varun.gupt 7124 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7125 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7126 
      for iter83 in self.success:
7127 
        oprot.writeI64(iter83)
1382 varun.gupt 7128 
      oprot.writeListEnd()
7129 
      oprot.writeFieldEnd()
3431 rajveer 7130 
    if self.ex is not None:
1382 varun.gupt 7131 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7132 
      self.ex.write(oprot)
7133 
      oprot.writeFieldEnd()
7134 
    oprot.writeFieldStop()
7135 
    oprot.writeStructEnd()
7136 
 
3431 rajveer 7137 
  def validate(self):
7138 
    return
7139 
 
7140 
 
1382 varun.gupt 7141 
  def __repr__(self):
7142 
    L = ['%s=%r' % (key, value)
7143 
      for key, value in self.__dict__.iteritems()]
7144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7145 
 
7146 
  def __eq__(self, other):
7147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7148 
 
7149 
  def __ne__(self, other):
7150 
    return not (self == other)
7151 
 
483 rajveer 7152 
class changeOrderStatus_args:
94 ashish 7153 
  """
7154 
  Attributes:
483 rajveer 7155 
   - orderId
7156 
   - status
7157 
   - description
94 ashish 7158 
  """
7159 
 
7160 
  thrift_spec = (
7161 
    None, # 0
483 rajveer 7162 
    (1, TType.I64, 'orderId', None, None, ), # 1
7163 
    (2, TType.I32, 'status', None, None, ), # 2
7164 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 7165 
  )
7166 
 
483 rajveer 7167 
  def __init__(self, orderId=None, status=None, description=None,):
7168 
    self.orderId = orderId
7169 
    self.status = status
7170 
    self.description = description
94 ashish 7171 
 
7172 
  def read(self, iprot):
7173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7175 
      return
7176 
    iprot.readStructBegin()
7177 
    while True:
7178 
      (fname, ftype, fid) = iprot.readFieldBegin()
7179 
      if ftype == TType.STOP:
7180 
        break
7181 
      if fid == 1:
7182 
        if ftype == TType.I64:
483 rajveer 7183 
          self.orderId = iprot.readI64();
94 ashish 7184 
        else:
7185 
          iprot.skip(ftype)
7186 
      elif fid == 2:
483 rajveer 7187 
        if ftype == TType.I32:
7188 
          self.status = iprot.readI32();
94 ashish 7189 
        else:
7190 
          iprot.skip(ftype)
483 rajveer 7191 
      elif fid == 3:
7192 
        if ftype == TType.STRING:
7193 
          self.description = iprot.readString();
7194 
        else:
7195 
          iprot.skip(ftype)
94 ashish 7196 
      else:
7197 
        iprot.skip(ftype)
7198 
      iprot.readFieldEnd()
7199 
    iprot.readStructEnd()
7200 
 
7201 
  def write(self, oprot):
7202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7204 
      return
483 rajveer 7205 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 7206 
    if self.orderId is not None:
483 rajveer 7207 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7208 
      oprot.writeI64(self.orderId)
94 ashish 7209 
      oprot.writeFieldEnd()
3431 rajveer 7210 
    if self.status is not None:
483 rajveer 7211 
      oprot.writeFieldBegin('status', TType.I32, 2)
7212 
      oprot.writeI32(self.status)
94 ashish 7213 
      oprot.writeFieldEnd()
3431 rajveer 7214 
    if self.description is not None:
483 rajveer 7215 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7216 
      oprot.writeString(self.description)
7217 
      oprot.writeFieldEnd()
94 ashish 7218 
    oprot.writeFieldStop()
7219 
    oprot.writeStructEnd()
7220 
 
3431 rajveer 7221 
  def validate(self):
7222 
    return
7223 
 
7224 
 
94 ashish 7225 
  def __repr__(self):
7226 
    L = ['%s=%r' % (key, value)
7227 
      for key, value in self.__dict__.iteritems()]
7228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7229 
 
7230 
  def __eq__(self, other):
7231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7232 
 
7233 
  def __ne__(self, other):
7234 
    return not (self == other)
7235 
 
483 rajveer 7236 
class changeOrderStatus_result:
94 ashish 7237 
  """
7238 
  Attributes:
7239 
   - success
7240 
   - ex
7241 
  """
7242 
 
7243 
  thrift_spec = (
7244 
    (0, TType.BOOL, 'success', None, None, ), # 0
7245 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7246 
  )
7247 
 
7248 
  def __init__(self, success=None, ex=None,):
7249 
    self.success = success
7250 
    self.ex = ex
7251 
 
7252 
  def read(self, iprot):
7253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7255 
      return
7256 
    iprot.readStructBegin()
7257 
    while True:
7258 
      (fname, ftype, fid) = iprot.readFieldBegin()
7259 
      if ftype == TType.STOP:
7260 
        break
7261 
      if fid == 0:
7262 
        if ftype == TType.BOOL:
7263 
          self.success = iprot.readBool();
7264 
        else:
7265 
          iprot.skip(ftype)
7266 
      elif fid == 1:
7267 
        if ftype == TType.STRUCT:
7268 
          self.ex = TransactionServiceException()
7269 
          self.ex.read(iprot)
7270 
        else:
7271 
          iprot.skip(ftype)
7272 
      else:
7273 
        iprot.skip(ftype)
7274 
      iprot.readFieldEnd()
7275 
    iprot.readStructEnd()
7276 
 
7277 
  def write(self, oprot):
7278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7280 
      return
483 rajveer 7281 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 7282 
    if self.success is not None:
94 ashish 7283 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7284 
      oprot.writeBool(self.success)
7285 
      oprot.writeFieldEnd()
3431 rajveer 7286 
    if self.ex is not None:
94 ashish 7287 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7288 
      self.ex.write(oprot)
7289 
      oprot.writeFieldEnd()
7290 
    oprot.writeFieldStop()
7291 
    oprot.writeStructEnd()
7292 
 
3431 rajveer 7293 
  def validate(self):
7294 
    return
7295 
 
7296 
 
94 ashish 7297 
  def __repr__(self):
7298 
    L = ['%s=%r' % (key, value)
7299 
      for key, value in self.__dict__.iteritems()]
7300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7301 
 
7302 
  def __eq__(self, other):
7303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7304 
 
7305 
  def __ne__(self, other):
7306 
    return not (self == other)
7307 
 
3064 chandransh 7308 
class getOrdersForTransaction_args:
494 rajveer 7309 
  """
7310 
  Attributes:
3064 chandransh 7311 
   - transactionId
7312 
   - customerId
494 rajveer 7313 
  """
7314 
 
7315 
  thrift_spec = (
7316 
    None, # 0
3064 chandransh 7317 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7318 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 7319 
  )
7320 
 
3064 chandransh 7321 
  def __init__(self, transactionId=None, customerId=None,):
7322 
    self.transactionId = transactionId
7323 
    self.customerId = customerId
494 rajveer 7324 
 
7325 
  def read(self, iprot):
7326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7328 
      return
7329 
    iprot.readStructBegin()
7330 
    while True:
7331 
      (fname, ftype, fid) = iprot.readFieldBegin()
7332 
      if ftype == TType.STOP:
7333 
        break
7334 
      if fid == 1:
7335 
        if ftype == TType.I64:
3064 chandransh 7336 
          self.transactionId = iprot.readI64();
494 rajveer 7337 
        else:
7338 
          iprot.skip(ftype)
7339 
      elif fid == 2:
3064 chandransh 7340 
        if ftype == TType.I64:
7341 
          self.customerId = iprot.readI64();
494 rajveer 7342 
        else:
7343 
          iprot.skip(ftype)
7344 
      else:
7345 
        iprot.skip(ftype)
7346 
      iprot.readFieldEnd()
7347 
    iprot.readStructEnd()
7348 
 
7349 
  def write(self, oprot):
7350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7352 
      return
3064 chandransh 7353 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 7354 
    if self.transactionId is not None:
3064 chandransh 7355 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7356 
      oprot.writeI64(self.transactionId)
494 rajveer 7357 
      oprot.writeFieldEnd()
3431 rajveer 7358 
    if self.customerId is not None:
3064 chandransh 7359 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
7360 
      oprot.writeI64(self.customerId)
494 rajveer 7361 
      oprot.writeFieldEnd()
7362 
    oprot.writeFieldStop()
7363 
    oprot.writeStructEnd()
7364 
 
3431 rajveer 7365 
  def validate(self):
7366 
    return
7367 
 
7368 
 
494 rajveer 7369 
  def __repr__(self):
7370 
    L = ['%s=%r' % (key, value)
7371 
      for key, value in self.__dict__.iteritems()]
7372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7373 
 
7374 
  def __eq__(self, other):
7375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7376 
 
7377 
  def __ne__(self, other):
7378 
    return not (self == other)
7379 
 
3064 chandransh 7380 
class getOrdersForTransaction_result:
494 rajveer 7381 
  """
7382 
  Attributes:
7383 
   - success
7384 
   - ex
7385 
  """
7386 
 
7387 
  thrift_spec = (
3064 chandransh 7388 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 7389 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7390 
  )
7391 
 
7392 
  def __init__(self, success=None, ex=None,):
7393 
    self.success = success
7394 
    self.ex = ex
7395 
 
7396 
  def read(self, iprot):
7397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7399 
      return
7400 
    iprot.readStructBegin()
7401 
    while True:
7402 
      (fname, ftype, fid) = iprot.readFieldBegin()
7403 
      if ftype == TType.STOP:
7404 
        break
7405 
      if fid == 0:
3064 chandransh 7406 
        if ftype == TType.LIST:
7407 
          self.success = []
4133 chandransh 7408 
          (_etype87, _size84) = iprot.readListBegin()
7409 
          for _i88 in xrange(_size84):
7410 
            _elem89 = Order()
7411 
            _elem89.read(iprot)
7412 
            self.success.append(_elem89)
3064 chandransh 7413 
          iprot.readListEnd()
494 rajveer 7414 
        else:
7415 
          iprot.skip(ftype)
7416 
      elif fid == 1:
7417 
        if ftype == TType.STRUCT:
7418 
          self.ex = TransactionServiceException()
7419 
          self.ex.read(iprot)
7420 
        else:
7421 
          iprot.skip(ftype)
7422 
      else:
7423 
        iprot.skip(ftype)
7424 
      iprot.readFieldEnd()
7425 
    iprot.readStructEnd()
7426 
 
7427 
  def write(self, oprot):
7428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7430 
      return
3064 chandransh 7431 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 7432 
    if self.success is not None:
3064 chandransh 7433 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7434 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7435 
      for iter90 in self.success:
7436 
        iter90.write(oprot)
3064 chandransh 7437 
      oprot.writeListEnd()
494 rajveer 7438 
      oprot.writeFieldEnd()
3431 rajveer 7439 
    if self.ex is not None:
494 rajveer 7440 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7441 
      self.ex.write(oprot)
7442 
      oprot.writeFieldEnd()
7443 
    oprot.writeFieldStop()
7444 
    oprot.writeStructEnd()
7445 
 
3431 rajveer 7446 
  def validate(self):
7447 
    return
7448 
 
7449 
 
494 rajveer 7450 
  def __repr__(self):
7451 
    L = ['%s=%r' % (key, value)
7452 
      for key, value in self.__dict__.iteritems()]
7453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7454 
 
7455 
  def __eq__(self, other):
7456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7457 
 
7458 
  def __ne__(self, other):
7459 
    return not (self == other)
7460 
 
3064 chandransh 7461 
class getOrdersForCustomer_args:
1149 chandransh 7462 
  """
7463 
  Attributes:
3064 chandransh 7464 
   - customerId
7465 
   - from_date
7466 
   - to_date
7467 
   - statuses
1149 chandransh 7468 
  """
7469 
 
7470 
  thrift_spec = (
7471 
    None, # 0
3064 chandransh 7472 
    (1, TType.I64, 'customerId', None, None, ), # 1
7473 
    (2, TType.I64, 'from_date', None, None, ), # 2
7474 
    (3, TType.I64, 'to_date', None, None, ), # 3
7475 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 7476 
  )
7477 
 
3064 chandransh 7478 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
7479 
    self.customerId = customerId
7480 
    self.from_date = from_date
7481 
    self.to_date = to_date
7482 
    self.statuses = statuses
1149 chandransh 7483 
 
7484 
  def read(self, iprot):
7485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7487 
      return
7488 
    iprot.readStructBegin()
7489 
    while True:
7490 
      (fname, ftype, fid) = iprot.readFieldBegin()
7491 
      if ftype == TType.STOP:
7492 
        break
7493 
      if fid == 1:
7494 
        if ftype == TType.I64:
3064 chandransh 7495 
          self.customerId = iprot.readI64();
1149 chandransh 7496 
        else:
7497 
          iprot.skip(ftype)
7498 
      elif fid == 2:
7499 
        if ftype == TType.I64:
3064 chandransh 7500 
          self.from_date = iprot.readI64();
1149 chandransh 7501 
        else:
7502 
          iprot.skip(ftype)
2783 chandransh 7503 
      elif fid == 3:
7504 
        if ftype == TType.I64:
3064 chandransh 7505 
          self.to_date = iprot.readI64();
2783 chandransh 7506 
        else:
7507 
          iprot.skip(ftype)
7508 
      elif fid == 4:
3064 chandransh 7509 
        if ftype == TType.LIST:
7510 
          self.statuses = []
4133 chandransh 7511 
          (_etype94, _size91) = iprot.readListBegin()
7512 
          for _i95 in xrange(_size91):
7513 
            _elem96 = iprot.readI32();
7514 
            self.statuses.append(_elem96)
3064 chandransh 7515 
          iprot.readListEnd()
2783 chandransh 7516 
        else:
7517 
          iprot.skip(ftype)
1149 chandransh 7518 
      else:
7519 
        iprot.skip(ftype)
7520 
      iprot.readFieldEnd()
7521 
    iprot.readStructEnd()
7522 
 
7523 
  def write(self, oprot):
7524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7526 
      return
3064 chandransh 7527 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 7528 
    if self.customerId is not None:
3064 chandransh 7529 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7530 
      oprot.writeI64(self.customerId)
1149 chandransh 7531 
      oprot.writeFieldEnd()
3431 rajveer 7532 
    if self.from_date is not None:
3064 chandransh 7533 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7534 
      oprot.writeI64(self.from_date)
1149 chandransh 7535 
      oprot.writeFieldEnd()
3431 rajveer 7536 
    if self.to_date is not None:
3064 chandransh 7537 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7538 
      oprot.writeI64(self.to_date)
2783 chandransh 7539 
      oprot.writeFieldEnd()
3431 rajveer 7540 
    if self.statuses is not None:
3064 chandransh 7541 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
7542 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 7543 
      for iter97 in self.statuses:
7544 
        oprot.writeI32(iter97)
3064 chandransh 7545 
      oprot.writeListEnd()
2783 chandransh 7546 
      oprot.writeFieldEnd()
1149 chandransh 7547 
    oprot.writeFieldStop()
7548 
    oprot.writeStructEnd()
7549 
 
3431 rajveer 7550 
  def validate(self):
7551 
    return
7552 
 
7553 
 
1149 chandransh 7554 
  def __repr__(self):
7555 
    L = ['%s=%r' % (key, value)
7556 
      for key, value in self.__dict__.iteritems()]
7557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7558 
 
7559 
  def __eq__(self, other):
7560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7561 
 
7562 
  def __ne__(self, other):
7563 
    return not (self == other)
7564 
 
3064 chandransh 7565 
class getOrdersForCustomer_result:
1149 chandransh 7566 
  """
7567 
  Attributes:
7568 
   - success
7569 
   - ex
7570 
  """
7571 
 
7572 
  thrift_spec = (
3064 chandransh 7573 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 7574 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7575 
  )
7576 
 
7577 
  def __init__(self, success=None, ex=None,):
7578 
    self.success = success
7579 
    self.ex = ex
7580 
 
7581 
  def read(self, iprot):
7582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7584 
      return
7585 
    iprot.readStructBegin()
7586 
    while True:
7587 
      (fname, ftype, fid) = iprot.readFieldBegin()
7588 
      if ftype == TType.STOP:
7589 
        break
7590 
      if fid == 0:
3064 chandransh 7591 
        if ftype == TType.LIST:
7592 
          self.success = []
4133 chandransh 7593 
          (_etype101, _size98) = iprot.readListBegin()
7594 
          for _i102 in xrange(_size98):
7595 
            _elem103 = Order()
7596 
            _elem103.read(iprot)
7597 
            self.success.append(_elem103)
3064 chandransh 7598 
          iprot.readListEnd()
1149 chandransh 7599 
        else:
7600 
          iprot.skip(ftype)
7601 
      elif fid == 1:
7602 
        if ftype == TType.STRUCT:
7603 
          self.ex = TransactionServiceException()
7604 
          self.ex.read(iprot)
7605 
        else:
7606 
          iprot.skip(ftype)
7607 
      else:
7608 
        iprot.skip(ftype)
7609 
      iprot.readFieldEnd()
7610 
    iprot.readStructEnd()
7611 
 
7612 
  def write(self, oprot):
7613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7615 
      return
3064 chandransh 7616 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 7617 
    if self.success is not None:
3064 chandransh 7618 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7619 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7620 
      for iter104 in self.success:
7621 
        iter104.write(oprot)
3064 chandransh 7622 
      oprot.writeListEnd()
1149 chandransh 7623 
      oprot.writeFieldEnd()
3431 rajveer 7624 
    if self.ex is not None:
1149 chandransh 7625 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7626 
      self.ex.write(oprot)
7627 
      oprot.writeFieldEnd()
7628 
    oprot.writeFieldStop()
7629 
    oprot.writeStructEnd()
7630 
 
3431 rajveer 7631 
  def validate(self):
7632 
    return
7633 
 
7634 
 
1149 chandransh 7635 
  def __repr__(self):
7636 
    L = ['%s=%r' % (key, value)
7637 
      for key, value in self.__dict__.iteritems()]
7638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7639 
 
7640 
  def __eq__(self, other):
7641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7642 
 
7643 
  def __ne__(self, other):
7644 
    return not (self == other)
7645 
 
3064 chandransh 7646 
class createOrder_args:
921 rajveer 7647 
  """
7648 
  Attributes:
3064 chandransh 7649 
   - order
921 rajveer 7650 
  """
7651 
 
7652 
  thrift_spec = (
7653 
    None, # 0
3064 chandransh 7654 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 7655 
  )
7656 
 
3064 chandransh 7657 
  def __init__(self, order=None,):
7658 
    self.order = order
921 rajveer 7659 
 
7660 
  def read(self, iprot):
7661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7663 
      return
7664 
    iprot.readStructBegin()
7665 
    while True:
7666 
      (fname, ftype, fid) = iprot.readFieldBegin()
7667 
      if ftype == TType.STOP:
7668 
        break
7669 
      if fid == 1:
3064 chandransh 7670 
        if ftype == TType.STRUCT:
7671 
          self.order = Order()
7672 
          self.order.read(iprot)
921 rajveer 7673 
        else:
7674 
          iprot.skip(ftype)
7675 
      else:
7676 
        iprot.skip(ftype)
7677 
      iprot.readFieldEnd()
7678 
    iprot.readStructEnd()
7679 
 
7680 
  def write(self, oprot):
7681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7683 
      return
3064 chandransh 7684 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 7685 
    if self.order is not None:
3064 chandransh 7686 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
7687 
      self.order.write(oprot)
921 rajveer 7688 
      oprot.writeFieldEnd()
7689 
    oprot.writeFieldStop()
7690 
    oprot.writeStructEnd()
7691 
 
3431 rajveer 7692 
  def validate(self):
7693 
    return
7694 
 
7695 
 
921 rajveer 7696 
  def __repr__(self):
7697 
    L = ['%s=%r' % (key, value)
7698 
      for key, value in self.__dict__.iteritems()]
7699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7700 
 
7701 
  def __eq__(self, other):
7702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7703 
 
7704 
  def __ne__(self, other):
7705 
    return not (self == other)
7706 
 
3064 chandransh 7707 
class createOrder_result:
921 rajveer 7708 
  """
7709 
  Attributes:
7710 
   - success
7711 
   - ex
7712 
  """
7713 
 
7714 
  thrift_spec = (
3064 chandransh 7715 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 7716 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7717 
  )
7718 
 
7719 
  def __init__(self, success=None, ex=None,):
7720 
    self.success = success
7721 
    self.ex = ex
7722 
 
7723 
  def read(self, iprot):
7724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7726 
      return
7727 
    iprot.readStructBegin()
7728 
    while True:
7729 
      (fname, ftype, fid) = iprot.readFieldBegin()
7730 
      if ftype == TType.STOP:
7731 
        break
7732 
      if fid == 0:
3064 chandransh 7733 
        if ftype == TType.I64:
7734 
          self.success = iprot.readI64();
921 rajveer 7735 
        else:
7736 
          iprot.skip(ftype)
7737 
      elif fid == 1:
7738 
        if ftype == TType.STRUCT:
7739 
          self.ex = TransactionServiceException()
7740 
          self.ex.read(iprot)
7741 
        else:
7742 
          iprot.skip(ftype)
7743 
      else:
7744 
        iprot.skip(ftype)
7745 
      iprot.readFieldEnd()
7746 
    iprot.readStructEnd()
7747 
 
7748 
  def write(self, oprot):
7749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7751 
      return
3064 chandransh 7752 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 7753 
    if self.success is not None:
3064 chandransh 7754 
      oprot.writeFieldBegin('success', TType.I64, 0)
7755 
      oprot.writeI64(self.success)
921 rajveer 7756 
      oprot.writeFieldEnd()
3431 rajveer 7757 
    if self.ex is not None:
921 rajveer 7758 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7759 
      self.ex.write(oprot)
7760 
      oprot.writeFieldEnd()
7761 
    oprot.writeFieldStop()
7762 
    oprot.writeStructEnd()
7763 
 
3431 rajveer 7764 
  def validate(self):
7765 
    return
7766 
 
7767 
 
921 rajveer 7768 
  def __repr__(self):
7769 
    L = ['%s=%r' % (key, value)
7770 
      for key, value in self.__dict__.iteritems()]
7771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7772 
 
7773 
  def __eq__(self, other):
7774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7775 
 
7776 
  def __ne__(self, other):
7777 
    return not (self == other)
7778 
 
3064 chandransh 7779 
class getOrder_args:
921 rajveer 7780 
  """
7781 
  Attributes:
3064 chandransh 7782 
   - id
921 rajveer 7783 
  """
7784 
 
7785 
  thrift_spec = (
7786 
    None, # 0
3064 chandransh 7787 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 7788 
  )
7789 
 
3064 chandransh 7790 
  def __init__(self, id=None,):
7791 
    self.id = id
921 rajveer 7792 
 
7793 
  def read(self, iprot):
7794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7796 
      return
7797 
    iprot.readStructBegin()
7798 
    while True:
7799 
      (fname, ftype, fid) = iprot.readFieldBegin()
7800 
      if ftype == TType.STOP:
7801 
        break
7802 
      if fid == 1:
7803 
        if ftype == TType.I64:
3064 chandransh 7804 
          self.id = iprot.readI64();
921 rajveer 7805 
        else:
7806 
          iprot.skip(ftype)
7807 
      else:
7808 
        iprot.skip(ftype)
7809 
      iprot.readFieldEnd()
7810 
    iprot.readStructEnd()
7811 
 
7812 
  def write(self, oprot):
7813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7815 
      return
3064 chandransh 7816 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 7817 
    if self.id is not None:
3064 chandransh 7818 
      oprot.writeFieldBegin('id', TType.I64, 1)
7819 
      oprot.writeI64(self.id)
921 rajveer 7820 
      oprot.writeFieldEnd()
7821 
    oprot.writeFieldStop()
7822 
    oprot.writeStructEnd()
7823 
 
3431 rajveer 7824 
  def validate(self):
7825 
    return
7826 
 
7827 
 
921 rajveer 7828 
  def __repr__(self):
7829 
    L = ['%s=%r' % (key, value)
7830 
      for key, value in self.__dict__.iteritems()]
7831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7832 
 
7833 
  def __eq__(self, other):
7834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7835 
 
7836 
  def __ne__(self, other):
7837 
    return not (self == other)
7838 
 
3064 chandransh 7839 
class getOrder_result:
921 rajveer 7840 
  """
7841 
  Attributes:
7842 
   - success
7843 
   - ex
7844 
  """
7845 
 
7846 
  thrift_spec = (
3064 chandransh 7847 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 7848 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7849 
  )
7850 
 
7851 
  def __init__(self, success=None, ex=None,):
7852 
    self.success = success
7853 
    self.ex = ex
7854 
 
7855 
  def read(self, iprot):
7856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7858 
      return
7859 
    iprot.readStructBegin()
7860 
    while True:
7861 
      (fname, ftype, fid) = iprot.readFieldBegin()
7862 
      if ftype == TType.STOP:
7863 
        break
7864 
      if fid == 0:
3064 chandransh 7865 
        if ftype == TType.STRUCT:
7866 
          self.success = Order()
7867 
          self.success.read(iprot)
921 rajveer 7868 
        else:
7869 
          iprot.skip(ftype)
7870 
      elif fid == 1:
7871 
        if ftype == TType.STRUCT:
7872 
          self.ex = TransactionServiceException()
7873 
          self.ex.read(iprot)
7874 
        else:
7875 
          iprot.skip(ftype)
7876 
      else:
7877 
        iprot.skip(ftype)
7878 
      iprot.readFieldEnd()
7879 
    iprot.readStructEnd()
7880 
 
7881 
  def write(self, oprot):
7882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7884 
      return
3064 chandransh 7885 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 7886 
    if self.success is not None:
3064 chandransh 7887 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7888 
      self.success.write(oprot)
921 rajveer 7889 
      oprot.writeFieldEnd()
3431 rajveer 7890 
    if self.ex is not None:
921 rajveer 7891 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7892 
      self.ex.write(oprot)
7893 
      oprot.writeFieldEnd()
7894 
    oprot.writeFieldStop()
7895 
    oprot.writeStructEnd()
7896 
 
3431 rajveer 7897 
  def validate(self):
7898 
    return
7899 
 
7900 
 
921 rajveer 7901 
  def __repr__(self):
7902 
    L = ['%s=%r' % (key, value)
7903 
      for key, value in self.__dict__.iteritems()]
7904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7905 
 
7906 
  def __eq__(self, other):
7907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7908 
 
7909 
  def __ne__(self, other):
7910 
    return not (self == other)
7911 
 
3064 chandransh 7912 
class getLineItemsForOrder_args:
94 ashish 7913 
  """
7914 
  Attributes:
3064 chandransh 7915 
   - orderId
94 ashish 7916 
  """
7917 
 
7918 
  thrift_spec = (
7919 
    None, # 0
3064 chandransh 7920 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7921 
  )
7922 
 
3064 chandransh 7923 
  def __init__(self, orderId=None,):
7924 
    self.orderId = orderId
94 ashish 7925 
 
7926 
  def read(self, iprot):
7927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7929 
      return
7930 
    iprot.readStructBegin()
7931 
    while True:
7932 
      (fname, ftype, fid) = iprot.readFieldBegin()
7933 
      if ftype == TType.STOP:
7934 
        break
7935 
      if fid == 1:
7936 
        if ftype == TType.I64:
3064 chandransh 7937 
          self.orderId = iprot.readI64();
94 ashish 7938 
        else:
7939 
          iprot.skip(ftype)
7940 
      else:
7941 
        iprot.skip(ftype)
7942 
      iprot.readFieldEnd()
7943 
    iprot.readStructEnd()
7944 
 
7945 
  def write(self, oprot):
7946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7948 
      return
3064 chandransh 7949 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7950 
    if self.orderId is not None:
3064 chandransh 7951 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7952 
      oprot.writeI64(self.orderId)
94 ashish 7953 
      oprot.writeFieldEnd()
7954 
    oprot.writeFieldStop()
7955 
    oprot.writeStructEnd()
7956 
 
3431 rajveer 7957 
  def validate(self):
7958 
    return
7959 
 
7960 
 
94 ashish 7961 
  def __repr__(self):
7962 
    L = ['%s=%r' % (key, value)
7963 
      for key, value in self.__dict__.iteritems()]
7964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7965 
 
7966 
  def __eq__(self, other):
7967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7968 
 
7969 
  def __ne__(self, other):
7970 
    return not (self == other)
7971 
 
3064 chandransh 7972 
class getLineItemsForOrder_result:
94 ashish 7973 
  """
7974 
  Attributes:
7975 
   - success
7976 
   - ex
7977 
  """
7978 
 
7979 
  thrift_spec = (
3064 chandransh 7980 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7981 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7982 
  )
7983 
 
7984 
  def __init__(self, success=None, ex=None,):
7985 
    self.success = success
7986 
    self.ex = ex
7987 
 
7988 
  def read(self, iprot):
7989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7991 
      return
7992 
    iprot.readStructBegin()
7993 
    while True:
7994 
      (fname, ftype, fid) = iprot.readFieldBegin()
7995 
      if ftype == TType.STOP:
7996 
        break
7997 
      if fid == 0:
483 rajveer 7998 
        if ftype == TType.LIST:
7999 
          self.success = []
4133 chandransh 8000 
          (_etype108, _size105) = iprot.readListBegin()
8001 
          for _i109 in xrange(_size105):
8002 
            _elem110 = LineItem()
8003 
            _elem110.read(iprot)
8004 
            self.success.append(_elem110)
483 rajveer 8005 
          iprot.readListEnd()
94 ashish 8006 
        else:
8007 
          iprot.skip(ftype)
8008 
      elif fid == 1:
8009 
        if ftype == TType.STRUCT:
8010 
          self.ex = TransactionServiceException()
8011 
          self.ex.read(iprot)
8012 
        else:
8013 
          iprot.skip(ftype)
8014 
      else:
8015 
        iprot.skip(ftype)
8016 
      iprot.readFieldEnd()
8017 
    iprot.readStructEnd()
8018 
 
8019 
  def write(self, oprot):
8020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8022 
      return
3064 chandransh 8023 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8024 
    if self.success is not None:
483 rajveer 8025 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8026 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8027 
      for iter111 in self.success:
8028 
        iter111.write(oprot)
483 rajveer 8029 
      oprot.writeListEnd()
94 ashish 8030 
      oprot.writeFieldEnd()
3431 rajveer 8031 
    if self.ex is not None:
94 ashish 8032 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8033 
      self.ex.write(oprot)
8034 
      oprot.writeFieldEnd()
8035 
    oprot.writeFieldStop()
8036 
    oprot.writeStructEnd()
8037 
 
3431 rajveer 8038 
  def validate(self):
8039 
    return
8040 
 
8041 
 
94 ashish 8042 
  def __repr__(self):
8043 
    L = ['%s=%r' % (key, value)
8044 
      for key, value in self.__dict__.iteritems()]
8045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8046 
 
8047 
  def __eq__(self, other):
8048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8049 
 
8050 
  def __ne__(self, other):
8051 
    return not (self == other)
8052 
 
3064 chandransh 8053 
class getOrderForCustomer_args:
94 ashish 8054 
  """
8055 
  Attributes:
3064 chandransh 8056 
   - orderId
483 rajveer 8057 
   - customerId
94 ashish 8058 
  """
8059 
 
8060 
  thrift_spec = (
8061 
    None, # 0
3064 chandransh 8062 
    (1, TType.I64, 'orderId', None, None, ), # 1
8063 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8064 
  )
8065 
 
3064 chandransh 8066 
  def __init__(self, orderId=None, customerId=None,):
8067 
    self.orderId = orderId
483 rajveer 8068 
    self.customerId = customerId
94 ashish 8069 
 
8070 
  def read(self, iprot):
8071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8073 
      return
8074 
    iprot.readStructBegin()
8075 
    while True:
8076 
      (fname, ftype, fid) = iprot.readFieldBegin()
8077 
      if ftype == TType.STOP:
8078 
        break
8079 
      if fid == 1:
8080 
        if ftype == TType.I64:
3064 chandransh 8081 
          self.orderId = iprot.readI64();
94 ashish 8082 
        else:
8083 
          iprot.skip(ftype)
8084 
      elif fid == 2:
8085 
        if ftype == TType.I64:
3064 chandransh 8086 
          self.customerId = iprot.readI64();
94 ashish 8087 
        else:
8088 
          iprot.skip(ftype)
8089 
      else:
8090 
        iprot.skip(ftype)
8091 
      iprot.readFieldEnd()
8092 
    iprot.readStructEnd()
8093 
 
8094 
  def write(self, oprot):
8095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8097 
      return
3064 chandransh 8098 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 8099 
    if self.orderId is not None:
3064 chandransh 8100 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8101 
      oprot.writeI64(self.orderId)
8102 
      oprot.writeFieldEnd()
3431 rajveer 8103 
    if self.customerId is not None:
3064 chandransh 8104 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 8105 
      oprot.writeI64(self.customerId)
94 ashish 8106 
      oprot.writeFieldEnd()
8107 
    oprot.writeFieldStop()
8108 
    oprot.writeStructEnd()
8109 
 
3431 rajveer 8110 
  def validate(self):
8111 
    return
8112 
 
8113 
 
94 ashish 8114 
  def __repr__(self):
8115 
    L = ['%s=%r' % (key, value)
8116 
      for key, value in self.__dict__.iteritems()]
8117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8118 
 
8119 
  def __eq__(self, other):
8120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8121 
 
8122 
  def __ne__(self, other):
8123 
    return not (self == other)
8124 
 
3064 chandransh 8125 
class getOrderForCustomer_result:
94 ashish 8126 
  """
8127 
  Attributes:
8128 
   - success
8129 
   - ex
8130 
  """
8131 
 
8132 
  thrift_spec = (
3064 chandransh 8133 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 8134 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8135 
  )
8136 
 
8137 
  def __init__(self, success=None, ex=None,):
8138 
    self.success = success
8139 
    self.ex = ex
8140 
 
8141 
  def read(self, iprot):
8142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8144 
      return
8145 
    iprot.readStructBegin()
8146 
    while True:
8147 
      (fname, ftype, fid) = iprot.readFieldBegin()
8148 
      if ftype == TType.STOP:
8149 
        break
8150 
      if fid == 0:
3064 chandransh 8151 
        if ftype == TType.STRUCT:
8152 
          self.success = Order()
8153 
          self.success.read(iprot)
94 ashish 8154 
        else:
8155 
          iprot.skip(ftype)
8156 
      elif fid == 1:
8157 
        if ftype == TType.STRUCT:
8158 
          self.ex = TransactionServiceException()
8159 
          self.ex.read(iprot)
8160 
        else:
8161 
          iprot.skip(ftype)
8162 
      else:
8163 
        iprot.skip(ftype)
8164 
      iprot.readFieldEnd()
8165 
    iprot.readStructEnd()
8166 
 
8167 
  def write(self, oprot):
8168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8170 
      return
3064 chandransh 8171 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 8172 
    if self.success is not None:
3064 chandransh 8173 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8174 
      self.success.write(oprot)
94 ashish 8175 
      oprot.writeFieldEnd()
3431 rajveer 8176 
    if self.ex is not None:
94 ashish 8177 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8178 
      self.ex.write(oprot)
8179 
      oprot.writeFieldEnd()
8180 
    oprot.writeFieldStop()
8181 
    oprot.writeStructEnd()
8182 
 
3431 rajveer 8183 
  def validate(self):
8184 
    return
8185 
 
8186 
 
94 ashish 8187 
  def __repr__(self):
8188 
    L = ['%s=%r' % (key, value)
8189 
      for key, value in self.__dict__.iteritems()]
8190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8191 
 
8192 
  def __eq__(self, other):
8193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8194 
 
8195 
  def __ne__(self, other):
8196 
    return not (self == other)
8197 
 
3064 chandransh 8198 
class getAlerts_args:
94 ashish 8199 
  """
8200 
  Attributes:
4394 rajveer 8201 
   - type
4444 rajveer 8202 
   - warehouseId
4394 rajveer 8203 
   - status
8204 
   - timestamp
94 ashish 8205 
  """
8206 
 
8207 
  thrift_spec = (
8208 
    None, # 0
4394 rajveer 8209 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8210 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8211 
    (3, TType.I64, 'status', None, None, ), # 3
8212 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 8213 
  )
8214 
 
4444 rajveer 8215 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 8216 
    self.type = type
4444 rajveer 8217 
    self.warehouseId = warehouseId
4394 rajveer 8218 
    self.status = status
8219 
    self.timestamp = timestamp
94 ashish 8220 
 
8221 
  def read(self, iprot):
8222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8224 
      return
8225 
    iprot.readStructBegin()
8226 
    while True:
8227 
      (fname, ftype, fid) = iprot.readFieldBegin()
8228 
      if ftype == TType.STOP:
8229 
        break
8230 
      if fid == 1:
3064 chandransh 8231 
        if ftype == TType.I64:
4394 rajveer 8232 
          self.type = iprot.readI64();
94 ashish 8233 
        else:
8234 
          iprot.skip(ftype)
3064 chandransh 8235 
      elif fid == 2:
4394 rajveer 8236 
        if ftype == TType.I64:
4444 rajveer 8237 
          self.warehouseId = iprot.readI64();
3064 chandransh 8238 
        else:
8239 
          iprot.skip(ftype)
4394 rajveer 8240 
      elif fid == 3:
8241 
        if ftype == TType.I64:
4444 rajveer 8242 
          self.status = iprot.readI64();
8243 
        else:
8244 
          iprot.skip(ftype)
8245 
      elif fid == 4:
8246 
        if ftype == TType.I64:
4394 rajveer 8247 
          self.timestamp = iprot.readI64();
8248 
        else:
8249 
          iprot.skip(ftype)
94 ashish 8250 
      else:
8251 
        iprot.skip(ftype)
8252 
      iprot.readFieldEnd()
8253 
    iprot.readStructEnd()
8254 
 
8255 
  def write(self, oprot):
8256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8258 
      return
3064 chandransh 8259 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 8260 
    if self.type is not None:
8261 
      oprot.writeFieldBegin('type', TType.I64, 1)
8262 
      oprot.writeI64(self.type)
94 ashish 8263 
      oprot.writeFieldEnd()
4444 rajveer 8264 
    if self.warehouseId is not None:
8265 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8266 
      oprot.writeI64(self.warehouseId)
8267 
      oprot.writeFieldEnd()
4394 rajveer 8268 
    if self.status is not None:
4444 rajveer 8269 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 8270 
      oprot.writeI64(self.status)
3064 chandransh 8271 
      oprot.writeFieldEnd()
4394 rajveer 8272 
    if self.timestamp is not None:
4444 rajveer 8273 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 8274 
      oprot.writeI64(self.timestamp)
8275 
      oprot.writeFieldEnd()
94 ashish 8276 
    oprot.writeFieldStop()
8277 
    oprot.writeStructEnd()
8278 
 
3431 rajveer 8279 
  def validate(self):
8280 
    return
8281 
 
8282 
 
94 ashish 8283 
  def __repr__(self):
8284 
    L = ['%s=%r' % (key, value)
8285 
      for key, value in self.__dict__.iteritems()]
8286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8287 
 
8288 
  def __eq__(self, other):
8289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8290 
 
8291 
  def __ne__(self, other):
8292 
    return not (self == other)
8293 
 
3064 chandransh 8294 
class getAlerts_result:
94 ashish 8295 
  """
8296 
  Attributes:
8297 
   - success
8298 
  """
8299 
 
8300 
  thrift_spec = (
3064 chandransh 8301 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 8302 
  )
8303 
 
3064 chandransh 8304 
  def __init__(self, success=None,):
94 ashish 8305 
    self.success = success
8306 
 
8307 
  def read(self, iprot):
8308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8310 
      return
8311 
    iprot.readStructBegin()
8312 
    while True:
8313 
      (fname, ftype, fid) = iprot.readFieldBegin()
8314 
      if ftype == TType.STOP:
8315 
        break
8316 
      if fid == 0:
3064 chandransh 8317 
        if ftype == TType.LIST:
8318 
          self.success = []
4133 chandransh 8319 
          (_etype115, _size112) = iprot.readListBegin()
8320 
          for _i116 in xrange(_size112):
8321 
            _elem117 = Alert()
8322 
            _elem117.read(iprot)
8323 
            self.success.append(_elem117)
3064 chandransh 8324 
          iprot.readListEnd()
94 ashish 8325 
        else:
8326 
          iprot.skip(ftype)
8327 
      else:
8328 
        iprot.skip(ftype)
8329 
      iprot.readFieldEnd()
8330 
    iprot.readStructEnd()
8331 
 
8332 
  def write(self, oprot):
8333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8335 
      return
3064 chandransh 8336 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 8337 
    if self.success is not None:
3064 chandransh 8338 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8339 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8340 
      for iter118 in self.success:
8341 
        iter118.write(oprot)
3064 chandransh 8342 
      oprot.writeListEnd()
94 ashish 8343 
      oprot.writeFieldEnd()
8344 
    oprot.writeFieldStop()
8345 
    oprot.writeStructEnd()
8346 
 
3431 rajveer 8347 
  def validate(self):
8348 
    return
8349 
 
8350 
 
94 ashish 8351 
  def __repr__(self):
8352 
    L = ['%s=%r' % (key, value)
8353 
      for key, value in self.__dict__.iteritems()]
8354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8355 
 
8356 
  def __eq__(self, other):
8357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8358 
 
8359 
  def __ne__(self, other):
8360 
    return not (self == other)
8361 
 
4394 rajveer 8362 
class addAlert_args:
94 ashish 8363 
  """
8364 
  Attributes:
3064 chandransh 8365 
   - type
4444 rajveer 8366 
   - warehouseId
4394 rajveer 8367 
   - description
94 ashish 8368 
  """
8369 
 
8370 
  thrift_spec = (
8371 
    None, # 0
4394 rajveer 8372 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8373 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8374 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8375 
  )
8376 
 
4444 rajveer 8377 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 8378 
    self.type = type
4444 rajveer 8379 
    self.warehouseId = warehouseId
4394 rajveer 8380 
    self.description = description
94 ashish 8381 
 
8382 
  def read(self, iprot):
8383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8385 
      return
8386 
    iprot.readStructBegin()
8387 
    while True:
8388 
      (fname, ftype, fid) = iprot.readFieldBegin()
8389 
      if ftype == TType.STOP:
8390 
        break
8391 
      if fid == 1:
8392 
        if ftype == TType.I64:
4394 rajveer 8393 
          self.type = iprot.readI64();
94 ashish 8394 
        else:
8395 
          iprot.skip(ftype)
3064 chandransh 8396 
      elif fid == 2:
4444 rajveer 8397 
        if ftype == TType.I64:
8398 
          self.warehouseId = iprot.readI64();
8399 
        else:
8400 
          iprot.skip(ftype)
8401 
      elif fid == 3:
3064 chandransh 8402 
        if ftype == TType.STRING:
4394 rajveer 8403 
          self.description = iprot.readString();
3064 chandransh 8404 
        else:
8405 
          iprot.skip(ftype)
94 ashish 8406 
      else:
8407 
        iprot.skip(ftype)
8408 
      iprot.readFieldEnd()
8409 
    iprot.readStructEnd()
8410 
 
8411 
  def write(self, oprot):
8412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8414 
      return
4394 rajveer 8415 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 8416 
    if self.type is not None:
4394 rajveer 8417 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 8418 
      oprot.writeI64(self.type)
8419 
      oprot.writeFieldEnd()
4444 rajveer 8420 
    if self.warehouseId is not None:
8421 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8422 
      oprot.writeI64(self.warehouseId)
8423 
      oprot.writeFieldEnd()
4394 rajveer 8424 
    if self.description is not None:
4444 rajveer 8425 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 8426 
      oprot.writeString(self.description)
3064 chandransh 8427 
      oprot.writeFieldEnd()
94 ashish 8428 
    oprot.writeFieldStop()
8429 
    oprot.writeStructEnd()
8430 
 
3431 rajveer 8431 
  def validate(self):
8432 
    return
8433 
 
8434 
 
94 ashish 8435 
  def __repr__(self):
8436 
    L = ['%s=%r' % (key, value)
8437 
      for key, value in self.__dict__.iteritems()]
8438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8439 
 
8440 
  def __eq__(self, other):
8441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8442 
 
8443 
  def __ne__(self, other):
8444 
    return not (self == other)
8445 
 
4394 rajveer 8446 
class addAlert_result:
3064 chandransh 8447 
 
8448 
  thrift_spec = (
8449 
  )
8450 
 
8451 
  def read(self, iprot):
8452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8454 
      return
8455 
    iprot.readStructBegin()
8456 
    while True:
8457 
      (fname, ftype, fid) = iprot.readFieldBegin()
8458 
      if ftype == TType.STOP:
8459 
        break
8460 
      else:
8461 
        iprot.skip(ftype)
8462 
      iprot.readFieldEnd()
8463 
    iprot.readStructEnd()
8464 
 
8465 
  def write(self, oprot):
8466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8468 
      return
4394 rajveer 8469 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 8470 
    oprot.writeFieldStop()
8471 
    oprot.writeStructEnd()
8472 
 
3431 rajveer 8473 
  def validate(self):
8474 
    return
8475 
 
8476 
 
3064 chandransh 8477 
  def __repr__(self):
8478 
    L = ['%s=%r' % (key, value)
8479 
      for key, value in self.__dict__.iteritems()]
8480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8481 
 
8482 
  def __eq__(self, other):
8483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8484 
 
8485 
  def __ne__(self, other):
8486 
    return not (self == other)
8487 
 
4444 rajveer 8488 
class markAlertsAsSeen_args:
8489 
  """
8490 
  Attributes:
8491 
   - warehouseId
8492 
  """
8493 
 
8494 
  thrift_spec = (
8495 
    None, # 0
8496 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8497 
  )
8498 
 
8499 
  def __init__(self, warehouseId=None,):
8500 
    self.warehouseId = warehouseId
8501 
 
8502 
  def read(self, iprot):
8503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8505 
      return
8506 
    iprot.readStructBegin()
8507 
    while True:
8508 
      (fname, ftype, fid) = iprot.readFieldBegin()
8509 
      if ftype == TType.STOP:
8510 
        break
8511 
      if fid == 1:
8512 
        if ftype == TType.I64:
8513 
          self.warehouseId = iprot.readI64();
8514 
        else:
8515 
          iprot.skip(ftype)
8516 
      else:
8517 
        iprot.skip(ftype)
8518 
      iprot.readFieldEnd()
8519 
    iprot.readStructEnd()
8520 
 
8521 
  def write(self, oprot):
8522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8524 
      return
8525 
    oprot.writeStructBegin('markAlertsAsSeen_args')
8526 
    if self.warehouseId is not None:
8527 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8528 
      oprot.writeI64(self.warehouseId)
8529 
      oprot.writeFieldEnd()
8530 
    oprot.writeFieldStop()
8531 
    oprot.writeStructEnd()
8532 
 
8533 
  def validate(self):
8534 
    return
8535 
 
8536 
 
8537 
  def __repr__(self):
8538 
    L = ['%s=%r' % (key, value)
8539 
      for key, value in self.__dict__.iteritems()]
8540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8541 
 
8542 
  def __eq__(self, other):
8543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8544 
 
8545 
  def __ne__(self, other):
8546 
    return not (self == other)
8547 
 
8548 
class markAlertsAsSeen_result:
8549 
 
8550 
  thrift_spec = (
8551 
  )
8552 
 
8553 
  def read(self, iprot):
8554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8556 
      return
8557 
    iprot.readStructBegin()
8558 
    while True:
8559 
      (fname, ftype, fid) = iprot.readFieldBegin()
8560 
      if ftype == TType.STOP:
8561 
        break
8562 
      else:
8563 
        iprot.skip(ftype)
8564 
      iprot.readFieldEnd()
8565 
    iprot.readStructEnd()
8566 
 
8567 
  def write(self, oprot):
8568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8570 
      return
8571 
    oprot.writeStructBegin('markAlertsAsSeen_result')
8572 
    oprot.writeFieldStop()
8573 
    oprot.writeStructEnd()
8574 
 
8575 
  def validate(self):
8576 
    return
8577 
 
8578 
 
8579 
  def __repr__(self):
8580 
    L = ['%s=%r' % (key, value)
8581 
      for key, value in self.__dict__.iteritems()]
8582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8583 
 
8584 
  def __eq__(self, other):
8585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8586 
 
8587 
  def __ne__(self, other):
8588 
    return not (self == other)
8589 
 
3064 chandransh 8590 
class getValidOrderCount_args:
8591 
 
8592 
  thrift_spec = (
8593 
  )
8594 
 
8595 
  def read(self, iprot):
8596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8598 
      return
8599 
    iprot.readStructBegin()
8600 
    while True:
8601 
      (fname, ftype, fid) = iprot.readFieldBegin()
8602 
      if ftype == TType.STOP:
8603 
        break
8604 
      else:
8605 
        iprot.skip(ftype)
8606 
      iprot.readFieldEnd()
8607 
    iprot.readStructEnd()
8608 
 
8609 
  def write(self, oprot):
8610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8612 
      return
8613 
    oprot.writeStructBegin('getValidOrderCount_args')
8614 
    oprot.writeFieldStop()
8615 
    oprot.writeStructEnd()
8616 
 
3431 rajveer 8617 
  def validate(self):
8618 
    return
8619 
 
8620 
 
3064 chandransh 8621 
  def __repr__(self):
8622 
    L = ['%s=%r' % (key, value)
8623 
      for key, value in self.__dict__.iteritems()]
8624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8625 
 
8626 
  def __eq__(self, other):
8627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8628 
 
8629 
  def __ne__(self, other):
8630 
    return not (self == other)
8631 
 
8632 
class getValidOrderCount_result:
94 ashish 8633 
  """
8634 
  Attributes:
8635 
   - success
8636 
  """
8637 
 
8638 
  thrift_spec = (
3064 chandransh 8639 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8640 
  )
8641 
 
3064 chandransh 8642 
  def __init__(self, success=None,):
94 ashish 8643 
    self.success = success
8644 
 
8645 
  def read(self, iprot):
8646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8648 
      return
8649 
    iprot.readStructBegin()
8650 
    while True:
8651 
      (fname, ftype, fid) = iprot.readFieldBegin()
8652 
      if ftype == TType.STOP:
8653 
        break
8654 
      if fid == 0:
3064 chandransh 8655 
        if ftype == TType.I64:
8656 
          self.success = iprot.readI64();
94 ashish 8657 
        else:
8658 
          iprot.skip(ftype)
8659 
      else:
8660 
        iprot.skip(ftype)
8661 
      iprot.readFieldEnd()
8662 
    iprot.readStructEnd()
8663 
 
8664 
  def write(self, oprot):
8665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8667 
      return
3064 chandransh 8668 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 8669 
    if self.success is not None:
3064 chandransh 8670 
      oprot.writeFieldBegin('success', TType.I64, 0)
8671 
      oprot.writeI64(self.success)
94 ashish 8672 
      oprot.writeFieldEnd()
8673 
    oprot.writeFieldStop()
8674 
    oprot.writeStructEnd()
8675 
 
3431 rajveer 8676 
  def validate(self):
8677 
    return
8678 
 
8679 
 
94 ashish 8680 
  def __repr__(self):
8681 
    L = ['%s=%r' % (key, value)
8682 
      for key, value in self.__dict__.iteritems()]
8683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8684 
 
8685 
  def __eq__(self, other):
8686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8687 
 
8688 
  def __ne__(self, other):
8689 
    return not (self == other)
8690 
 
3064 chandransh 8691 
class getNoOfCustomersWithSuccessfulTransaction_args:
8692 
 
8693 
  thrift_spec = (
8694 
  )
8695 
 
8696 
  def read(self, iprot):
8697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8699 
      return
8700 
    iprot.readStructBegin()
8701 
    while True:
8702 
      (fname, ftype, fid) = iprot.readFieldBegin()
8703 
      if ftype == TType.STOP:
8704 
        break
8705 
      else:
8706 
        iprot.skip(ftype)
8707 
      iprot.readFieldEnd()
8708 
    iprot.readStructEnd()
8709 
 
8710 
  def write(self, oprot):
8711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8713 
      return
8714 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
8715 
    oprot.writeFieldStop()
8716 
    oprot.writeStructEnd()
8717 
 
3431 rajveer 8718 
  def validate(self):
8719 
    return
8720 
 
8721 
 
3064 chandransh 8722 
  def __repr__(self):
8723 
    L = ['%s=%r' % (key, value)
8724 
      for key, value in self.__dict__.iteritems()]
8725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8726 
 
8727 
  def __eq__(self, other):
8728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8729 
 
8730 
  def __ne__(self, other):
8731 
    return not (self == other)
8732 
 
8733 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 8734 
  """
8735 
  Attributes:
3064 chandransh 8736 
   - success
94 ashish 8737 
  """
8738 
 
8739 
  thrift_spec = (
3064 chandransh 8740 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8741 
  )
8742 
 
3064 chandransh 8743 
  def __init__(self, success=None,):
8744 
    self.success = success
94 ashish 8745 
 
8746 
  def read(self, iprot):
8747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8749 
      return
8750 
    iprot.readStructBegin()
8751 
    while True:
8752 
      (fname, ftype, fid) = iprot.readFieldBegin()
8753 
      if ftype == TType.STOP:
8754 
        break
3064 chandransh 8755 
      if fid == 0:
94 ashish 8756 
        if ftype == TType.I64:
3064 chandransh 8757 
          self.success = iprot.readI64();
94 ashish 8758 
        else:
8759 
          iprot.skip(ftype)
8760 
      else:
8761 
        iprot.skip(ftype)
8762 
      iprot.readFieldEnd()
8763 
    iprot.readStructEnd()
8764 
 
8765 
  def write(self, oprot):
8766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8768 
      return
3064 chandransh 8769 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 8770 
    if self.success is not None:
3064 chandransh 8771 
      oprot.writeFieldBegin('success', TType.I64, 0)
8772 
      oprot.writeI64(self.success)
94 ashish 8773 
      oprot.writeFieldEnd()
8774 
    oprot.writeFieldStop()
8775 
    oprot.writeStructEnd()
8776 
 
3431 rajveer 8777 
  def validate(self):
8778 
    return
8779 
 
8780 
 
94 ashish 8781 
  def __repr__(self):
8782 
    L = ['%s=%r' % (key, value)
8783 
      for key, value in self.__dict__.iteritems()]
8784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8785 
 
8786 
  def __eq__(self, other):
8787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8788 
 
8789 
  def __ne__(self, other):
8790 
    return not (self == other)
8791 
 
3064 chandransh 8792 
class getValidOrdersAmountRange_args:
8793 
 
8794 
  thrift_spec = (
8795 
  )
8796 
 
8797 
  def read(self, iprot):
8798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8800 
      return
8801 
    iprot.readStructBegin()
8802 
    while True:
8803 
      (fname, ftype, fid) = iprot.readFieldBegin()
8804 
      if ftype == TType.STOP:
8805 
        break
8806 
      else:
8807 
        iprot.skip(ftype)
8808 
      iprot.readFieldEnd()
8809 
    iprot.readStructEnd()
8810 
 
8811 
  def write(self, oprot):
8812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8814 
      return
8815 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
8816 
    oprot.writeFieldStop()
8817 
    oprot.writeStructEnd()
8818 
 
3431 rajveer 8819 
  def validate(self):
8820 
    return
8821 
 
8822 
 
3064 chandransh 8823 
  def __repr__(self):
8824 
    L = ['%s=%r' % (key, value)
8825 
      for key, value in self.__dict__.iteritems()]
8826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8827 
 
8828 
  def __eq__(self, other):
8829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8830 
 
8831 
  def __ne__(self, other):
8832 
    return not (self == other)
8833 
 
8834 
class getValidOrdersAmountRange_result:
94 ashish 8835 
  """
8836 
  Attributes:
8837 
   - success
8838 
  """
8839 
 
8840 
  thrift_spec = (
3064 chandransh 8841 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 8842 
  )
8843 
 
3064 chandransh 8844 
  def __init__(self, success=None,):
94 ashish 8845 
    self.success = success
8846 
 
8847 
  def read(self, iprot):
8848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8850 
      return
8851 
    iprot.readStructBegin()
8852 
    while True:
8853 
      (fname, ftype, fid) = iprot.readFieldBegin()
8854 
      if ftype == TType.STOP:
8855 
        break
8856 
      if fid == 0:
483 rajveer 8857 
        if ftype == TType.LIST:
8858 
          self.success = []
4133 chandransh 8859 
          (_etype122, _size119) = iprot.readListBegin()
8860 
          for _i123 in xrange(_size119):
8861 
            _elem124 = iprot.readDouble();
8862 
            self.success.append(_elem124)
483 rajveer 8863 
          iprot.readListEnd()
94 ashish 8864 
        else:
8865 
          iprot.skip(ftype)
8866 
      else:
8867 
        iprot.skip(ftype)
8868 
      iprot.readFieldEnd()
8869 
    iprot.readStructEnd()
8870 
 
8871 
  def write(self, oprot):
8872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8874 
      return
3064 chandransh 8875 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 8876 
    if self.success is not None:
483 rajveer 8877 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 8878 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 8879 
      for iter125 in self.success:
8880 
        oprot.writeDouble(iter125)
483 rajveer 8881 
      oprot.writeListEnd()
94 ashish 8882 
      oprot.writeFieldEnd()
8883 
    oprot.writeFieldStop()
8884 
    oprot.writeStructEnd()
8885 
 
3431 rajveer 8886 
  def validate(self):
8887 
    return
8888 
 
8889 
 
94 ashish 8890 
  def __repr__(self):
8891 
    L = ['%s=%r' % (key, value)
8892 
      for key, value in self.__dict__.iteritems()]
8893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8894 
 
8895 
  def __eq__(self, other):
8896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8897 
 
8898 
  def __ne__(self, other):
8899 
    return not (self == other)
8900 
 
3064 chandransh 8901 
class getValidOrders_args:
1528 ankur.sing 8902 
  """
8903 
  Attributes:
3064 chandransh 8904 
   - limit
1528 ankur.sing 8905 
  """
8906 
 
8907 
  thrift_spec = (
8908 
    None, # 0
3064 chandransh 8909 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 8910 
  )
8911 
 
3064 chandransh 8912 
  def __init__(self, limit=None,):
8913 
    self.limit = limit
1528 ankur.sing 8914 
 
8915 
  def read(self, iprot):
8916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8918 
      return
8919 
    iprot.readStructBegin()
8920 
    while True:
8921 
      (fname, ftype, fid) = iprot.readFieldBegin()
8922 
      if ftype == TType.STOP:
8923 
        break
8924 
      if fid == 1:
8925 
        if ftype == TType.I64:
3064 chandransh 8926 
          self.limit = iprot.readI64();
1528 ankur.sing 8927 
        else:
8928 
          iprot.skip(ftype)
8929 
      else:
8930 
        iprot.skip(ftype)
8931 
      iprot.readFieldEnd()
8932 
    iprot.readStructEnd()
8933 
 
8934 
  def write(self, oprot):
8935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8937 
      return
3064 chandransh 8938 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 8939 
    if self.limit is not None:
3064 chandransh 8940 
      oprot.writeFieldBegin('limit', TType.I64, 1)
8941 
      oprot.writeI64(self.limit)
1528 ankur.sing 8942 
      oprot.writeFieldEnd()
8943 
    oprot.writeFieldStop()
8944 
    oprot.writeStructEnd()
8945 
 
3431 rajveer 8946 
  def validate(self):
8947 
    return
8948 
 
8949 
 
1528 ankur.sing 8950 
  def __repr__(self):
8951 
    L = ['%s=%r' % (key, value)
8952 
      for key, value in self.__dict__.iteritems()]
8953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8954 
 
8955 
  def __eq__(self, other):
8956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8957 
 
8958 
  def __ne__(self, other):
8959 
    return not (self == other)
8960 
 
3064 chandransh 8961 
class getValidOrders_result:
1528 ankur.sing 8962 
  """
8963 
  Attributes:
8964 
   - success
8965 
  """
8966 
 
8967 
  thrift_spec = (
3064 chandransh 8968 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 8969 
  )
8970 
 
3064 chandransh 8971 
  def __init__(self, success=None,):
1528 ankur.sing 8972 
    self.success = success
8973 
 
8974 
  def read(self, iprot):
8975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8977 
      return
8978 
    iprot.readStructBegin()
8979 
    while True:
8980 
      (fname, ftype, fid) = iprot.readFieldBegin()
8981 
      if ftype == TType.STOP:
8982 
        break
8983 
      if fid == 0:
3064 chandransh 8984 
        if ftype == TType.LIST:
8985 
          self.success = []
4133 chandransh 8986 
          (_etype129, _size126) = iprot.readListBegin()
8987 
          for _i130 in xrange(_size126):
8988 
            _elem131 = Order()
8989 
            _elem131.read(iprot)
8990 
            self.success.append(_elem131)
3064 chandransh 8991 
          iprot.readListEnd()
1528 ankur.sing 8992 
        else:
8993 
          iprot.skip(ftype)
8994 
      else:
8995 
        iprot.skip(ftype)
8996 
      iprot.readFieldEnd()
8997 
    iprot.readStructEnd()
8998 
 
8999 
  def write(self, oprot):
9000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9002 
      return
3064 chandransh 9003 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9004 
    if self.success is not None:
3064 chandransh 9005 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9006 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9007 
      for iter132 in self.success:
9008 
        iter132.write(oprot)
3064 chandransh 9009 
      oprot.writeListEnd()
1528 ankur.sing 9010 
      oprot.writeFieldEnd()
9011 
    oprot.writeFieldStop()
9012 
    oprot.writeStructEnd()
9013 
 
3431 rajveer 9014 
  def validate(self):
9015 
    return
9016 
 
9017 
 
1528 ankur.sing 9018 
  def __repr__(self):
9019 
    L = ['%s=%r' % (key, value)
9020 
      for key, value in self.__dict__.iteritems()]
9021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9022 
 
9023 
  def __eq__(self, other):
9024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9025 
 
9026 
  def __ne__(self, other):
9027 
    return not (self == other)
9028 
 
1220 chandransh 9029 
class batchOrders_args:
9030 
  """
9031 
  Attributes:
9032 
   - warehouseId
9033 
  """
9034 
 
9035 
  thrift_spec = (
9036 
    None, # 0
9037 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9038 
  )
9039 
 
9040 
  def __init__(self, warehouseId=None,):
9041 
    self.warehouseId = warehouseId
9042 
 
9043 
  def read(self, iprot):
9044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9046 
      return
9047 
    iprot.readStructBegin()
9048 
    while True:
9049 
      (fname, ftype, fid) = iprot.readFieldBegin()
9050 
      if ftype == TType.STOP:
9051 
        break
9052 
      if fid == 1:
9053 
        if ftype == TType.I64:
9054 
          self.warehouseId = iprot.readI64();
9055 
        else:
9056 
          iprot.skip(ftype)
9057 
      else:
9058 
        iprot.skip(ftype)
9059 
      iprot.readFieldEnd()
9060 
    iprot.readStructEnd()
9061 
 
9062 
  def write(self, oprot):
9063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9065 
      return
9066 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9067 
    if self.warehouseId is not None:
1220 chandransh 9068 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9069 
      oprot.writeI64(self.warehouseId)
9070 
      oprot.writeFieldEnd()
9071 
    oprot.writeFieldStop()
9072 
    oprot.writeStructEnd()
9073 
 
3431 rajveer 9074 
  def validate(self):
9075 
    return
9076 
 
9077 
 
1220 chandransh 9078 
  def __repr__(self):
9079 
    L = ['%s=%r' % (key, value)
9080 
      for key, value in self.__dict__.iteritems()]
9081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9082 
 
9083 
  def __eq__(self, other):
9084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9085 
 
9086 
  def __ne__(self, other):
9087 
    return not (self == other)
9088 
 
9089 
class batchOrders_result:
9090 
  """
9091 
  Attributes:
9092 
   - success
9093 
   - ex
9094 
  """
9095 
 
9096 
  thrift_spec = (
9097 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9098 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9099 
  )
9100 
 
9101 
  def __init__(self, success=None, ex=None,):
9102 
    self.success = success
9103 
    self.ex = ex
9104 
 
9105 
  def read(self, iprot):
9106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9108 
      return
9109 
    iprot.readStructBegin()
9110 
    while True:
9111 
      (fname, ftype, fid) = iprot.readFieldBegin()
9112 
      if ftype == TType.STOP:
9113 
        break
9114 
      if fid == 0:
9115 
        if ftype == TType.LIST:
9116 
          self.success = []
4133 chandransh 9117 
          (_etype136, _size133) = iprot.readListBegin()
9118 
          for _i137 in xrange(_size133):
9119 
            _elem138 = Order()
9120 
            _elem138.read(iprot)
9121 
            self.success.append(_elem138)
1220 chandransh 9122 
          iprot.readListEnd()
9123 
        else:
9124 
          iprot.skip(ftype)
9125 
      elif fid == 1:
9126 
        if ftype == TType.STRUCT:
9127 
          self.ex = TransactionServiceException()
9128 
          self.ex.read(iprot)
9129 
        else:
9130 
          iprot.skip(ftype)
9131 
      else:
9132 
        iprot.skip(ftype)
9133 
      iprot.readFieldEnd()
9134 
    iprot.readStructEnd()
9135 
 
9136 
  def write(self, oprot):
9137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9139 
      return
9140 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 9141 
    if self.success is not None:
1220 chandransh 9142 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9143 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9144 
      for iter139 in self.success:
9145 
        iter139.write(oprot)
1220 chandransh 9146 
      oprot.writeListEnd()
9147 
      oprot.writeFieldEnd()
3431 rajveer 9148 
    if self.ex is not None:
1220 chandransh 9149 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9150 
      self.ex.write(oprot)
9151 
      oprot.writeFieldEnd()
9152 
    oprot.writeFieldStop()
9153 
    oprot.writeStructEnd()
9154 
 
3431 rajveer 9155 
  def validate(self):
9156 
    return
9157 
 
9158 
 
1220 chandransh 9159 
  def __repr__(self):
9160 
    L = ['%s=%r' % (key, value)
9161 
      for key, value in self.__dict__.iteritems()]
9162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9163 
 
9164 
  def __eq__(self, other):
9165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9166 
 
9167 
  def __ne__(self, other):
9168 
    return not (self == other)
9169 
 
1208 chandransh 9170 
class markOrderAsOutOfStock_args:
9171 
  """
9172 
  Attributes:
9173 
   - orderId
9174 
  """
9175 
 
9176 
  thrift_spec = (
9177 
    None, # 0
9178 
    (1, TType.I64, 'orderId', None, None, ), # 1
9179 
  )
9180 
 
9181 
  def __init__(self, orderId=None,):
9182 
    self.orderId = orderId
9183 
 
9184 
  def read(self, iprot):
9185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9187 
      return
9188 
    iprot.readStructBegin()
9189 
    while True:
9190 
      (fname, ftype, fid) = iprot.readFieldBegin()
9191 
      if ftype == TType.STOP:
9192 
        break
9193 
      if fid == 1:
9194 
        if ftype == TType.I64:
9195 
          self.orderId = iprot.readI64();
9196 
        else:
9197 
          iprot.skip(ftype)
9198 
      else:
9199 
        iprot.skip(ftype)
9200 
      iprot.readFieldEnd()
9201 
    iprot.readStructEnd()
9202 
 
9203 
  def write(self, oprot):
9204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9206 
      return
9207 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 9208 
    if self.orderId is not None:
1208 chandransh 9209 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9210 
      oprot.writeI64(self.orderId)
9211 
      oprot.writeFieldEnd()
9212 
    oprot.writeFieldStop()
9213 
    oprot.writeStructEnd()
9214 
 
3431 rajveer 9215 
  def validate(self):
9216 
    return
9217 
 
9218 
 
1208 chandransh 9219 
  def __repr__(self):
9220 
    L = ['%s=%r' % (key, value)
9221 
      for key, value in self.__dict__.iteritems()]
9222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9223 
 
9224 
  def __eq__(self, other):
9225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9226 
 
9227 
  def __ne__(self, other):
9228 
    return not (self == other)
9229 
 
9230 
class markOrderAsOutOfStock_result:
9231 
  """
9232 
  Attributes:
9233 
   - success
9234 
   - ex
9235 
  """
9236 
 
9237 
  thrift_spec = (
9238 
    (0, TType.BOOL, 'success', None, None, ), # 0
9239 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9240 
  )
9241 
 
9242 
  def __init__(self, success=None, ex=None,):
9243 
    self.success = success
9244 
    self.ex = ex
9245 
 
9246 
  def read(self, iprot):
9247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9249 
      return
9250 
    iprot.readStructBegin()
9251 
    while True:
9252 
      (fname, ftype, fid) = iprot.readFieldBegin()
9253 
      if ftype == TType.STOP:
9254 
        break
9255 
      if fid == 0:
9256 
        if ftype == TType.BOOL:
9257 
          self.success = iprot.readBool();
9258 
        else:
9259 
          iprot.skip(ftype)
9260 
      elif fid == 1:
9261 
        if ftype == TType.STRUCT:
9262 
          self.ex = TransactionServiceException()
9263 
          self.ex.read(iprot)
9264 
        else:
9265 
          iprot.skip(ftype)
9266 
      else:
9267 
        iprot.skip(ftype)
9268 
      iprot.readFieldEnd()
9269 
    iprot.readStructEnd()
9270 
 
9271 
  def write(self, oprot):
9272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9274 
      return
9275 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 9276 
    if self.success is not None:
1208 chandransh 9277 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9278 
      oprot.writeBool(self.success)
9279 
      oprot.writeFieldEnd()
3431 rajveer 9280 
    if self.ex is not None:
1208 chandransh 9281 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9282 
      self.ex.write(oprot)
9283 
      oprot.writeFieldEnd()
9284 
    oprot.writeFieldStop()
9285 
    oprot.writeStructEnd()
9286 
 
3431 rajveer 9287 
  def validate(self):
9288 
    return
9289 
 
9290 
 
1208 chandransh 9291 
  def __repr__(self):
9292 
    L = ['%s=%r' % (key, value)
9293 
      for key, value in self.__dict__.iteritems()]
9294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9295 
 
9296 
  def __eq__(self, other):
9297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9298 
 
9299 
  def __ne__(self, other):
9300 
    return not (self == other)
9301 
 
3064 chandransh 9302 
class verifyOrder_args:
759 chandransh 9303 
  """
9304 
  Attributes:
3064 chandransh 9305 
   - orderId
759 chandransh 9306 
  """
9307 
 
9308 
  thrift_spec = (
9309 
    None, # 0
3064 chandransh 9310 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 9311 
  )
9312 
 
3064 chandransh 9313 
  def __init__(self, orderId=None,):
9314 
    self.orderId = orderId
759 chandransh 9315 
 
9316 
  def read(self, iprot):
9317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9319 
      return
9320 
    iprot.readStructBegin()
9321 
    while True:
9322 
      (fname, ftype, fid) = iprot.readFieldBegin()
9323 
      if ftype == TType.STOP:
9324 
        break
9325 
      if fid == 1:
9326 
        if ftype == TType.I64:
3064 chandransh 9327 
          self.orderId = iprot.readI64();
759 chandransh 9328 
        else:
9329 
          iprot.skip(ftype)
9330 
      else:
9331 
        iprot.skip(ftype)
9332 
      iprot.readFieldEnd()
9333 
    iprot.readStructEnd()
9334 
 
9335 
  def write(self, oprot):
9336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9338 
      return
3064 chandransh 9339 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 9340 
    if self.orderId is not None:
3064 chandransh 9341 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9342 
      oprot.writeI64(self.orderId)
759 chandransh 9343 
      oprot.writeFieldEnd()
9344 
    oprot.writeFieldStop()
9345 
    oprot.writeStructEnd()
9346 
 
3431 rajveer 9347 
  def validate(self):
9348 
    return
9349 
 
9350 
 
759 chandransh 9351 
  def __repr__(self):
9352 
    L = ['%s=%r' % (key, value)
9353 
      for key, value in self.__dict__.iteritems()]
9354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9355 
 
9356 
  def __eq__(self, other):
9357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9358 
 
9359 
  def __ne__(self, other):
9360 
    return not (self == other)
9361 
 
3064 chandransh 9362 
class verifyOrder_result:
759 chandransh 9363 
  """
9364 
  Attributes:
9365 
   - success
9366 
   - ex
9367 
  """
9368 
 
9369 
  thrift_spec = (
9370 
    (0, TType.BOOL, 'success', None, None, ), # 0
9371 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9372 
  )
9373 
 
9374 
  def __init__(self, success=None, ex=None,):
9375 
    self.success = success
9376 
    self.ex = ex
9377 
 
9378 
  def read(self, iprot):
9379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9381 
      return
9382 
    iprot.readStructBegin()
9383 
    while True:
9384 
      (fname, ftype, fid) = iprot.readFieldBegin()
9385 
      if ftype == TType.STOP:
9386 
        break
9387 
      if fid == 0:
9388 
        if ftype == TType.BOOL:
9389 
          self.success = iprot.readBool();
9390 
        else:
9391 
          iprot.skip(ftype)
9392 
      elif fid == 1:
9393 
        if ftype == TType.STRUCT:
9394 
          self.ex = TransactionServiceException()
9395 
          self.ex.read(iprot)
9396 
        else:
9397 
          iprot.skip(ftype)
9398 
      else:
9399 
        iprot.skip(ftype)
9400 
      iprot.readFieldEnd()
9401 
    iprot.readStructEnd()
9402 
 
9403 
  def write(self, oprot):
9404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9406 
      return
3064 chandransh 9407 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 9408 
    if self.success is not None:
759 chandransh 9409 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9410 
      oprot.writeBool(self.success)
9411 
      oprot.writeFieldEnd()
3431 rajveer 9412 
    if self.ex is not None:
759 chandransh 9413 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9414 
      self.ex.write(oprot)
9415 
      oprot.writeFieldEnd()
9416 
    oprot.writeFieldStop()
9417 
    oprot.writeStructEnd()
9418 
 
3431 rajveer 9419 
  def validate(self):
9420 
    return
9421 
 
9422 
 
759 chandransh 9423 
  def __repr__(self):
9424 
    L = ['%s=%r' % (key, value)
9425 
      for key, value in self.__dict__.iteritems()]
9426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9427 
 
9428 
  def __eq__(self, other):
9429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9430 
 
9431 
  def __ne__(self, other):
9432 
    return not (self == other)
9433 
 
3064 chandransh 9434 
class acceptOrder_args:
1113 chandransh 9435 
  """
9436 
  Attributes:
3064 chandransh 9437 
   - orderId
1113 chandransh 9438 
  """
9439 
 
9440 
  thrift_spec = (
9441 
    None, # 0
3064 chandransh 9442 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 9443 
  )
9444 
 
3064 chandransh 9445 
  def __init__(self, orderId=None,):
9446 
    self.orderId = orderId
1113 chandransh 9447 
 
9448 
  def read(self, iprot):
9449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9451 
      return
9452 
    iprot.readStructBegin()
9453 
    while True:
9454 
      (fname, ftype, fid) = iprot.readFieldBegin()
9455 
      if ftype == TType.STOP:
9456 
        break
9457 
      if fid == 1:
9458 
        if ftype == TType.I64:
3064 chandransh 9459 
          self.orderId = iprot.readI64();
1113 chandransh 9460 
        else:
9461 
          iprot.skip(ftype)
9462 
      else:
9463 
        iprot.skip(ftype)
9464 
      iprot.readFieldEnd()
9465 
    iprot.readStructEnd()
9466 
 
9467 
  def write(self, oprot):
9468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9470 
      return
3064 chandransh 9471 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 9472 
    if self.orderId is not None:
3064 chandransh 9473 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9474 
      oprot.writeI64(self.orderId)
1113 chandransh 9475 
      oprot.writeFieldEnd()
9476 
    oprot.writeFieldStop()
9477 
    oprot.writeStructEnd()
9478 
 
3431 rajveer 9479 
  def validate(self):
9480 
    return
9481 
 
9482 
 
1113 chandransh 9483 
  def __repr__(self):
9484 
    L = ['%s=%r' % (key, value)
9485 
      for key, value in self.__dict__.iteritems()]
9486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9487 
 
9488 
  def __eq__(self, other):
9489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9490 
 
9491 
  def __ne__(self, other):
9492 
    return not (self == other)
9493 
 
3064 chandransh 9494 
class acceptOrder_result:
1113 chandransh 9495 
  """
9496 
  Attributes:
9497 
   - success
9498 
   - ex
9499 
  """
9500 
 
9501 
  thrift_spec = (
3064 chandransh 9502 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 9503 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9504 
  )
9505 
 
9506 
  def __init__(self, success=None, ex=None,):
9507 
    self.success = success
9508 
    self.ex = ex
9509 
 
9510 
  def read(self, iprot):
9511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9513 
      return
9514 
    iprot.readStructBegin()
9515 
    while True:
9516 
      (fname, ftype, fid) = iprot.readFieldBegin()
9517 
      if ftype == TType.STOP:
9518 
        break
9519 
      if fid == 0:
3064 chandransh 9520 
        if ftype == TType.BOOL:
9521 
          self.success = iprot.readBool();
1113 chandransh 9522 
        else:
9523 
          iprot.skip(ftype)
9524 
      elif fid == 1:
9525 
        if ftype == TType.STRUCT:
9526 
          self.ex = TransactionServiceException()
9527 
          self.ex.read(iprot)
9528 
        else:
9529 
          iprot.skip(ftype)
9530 
      else:
9531 
        iprot.skip(ftype)
9532 
      iprot.readFieldEnd()
9533 
    iprot.readStructEnd()
9534 
 
9535 
  def write(self, oprot):
9536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9538 
      return
3064 chandransh 9539 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 9540 
    if self.success is not None:
3064 chandransh 9541 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9542 
      oprot.writeBool(self.success)
1113 chandransh 9543 
      oprot.writeFieldEnd()
3431 rajveer 9544 
    if self.ex is not None:
1113 chandransh 9545 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9546 
      self.ex.write(oprot)
9547 
      oprot.writeFieldEnd()
9548 
    oprot.writeFieldStop()
9549 
    oprot.writeStructEnd()
9550 
 
3431 rajveer 9551 
  def validate(self):
9552 
    return
9553 
 
9554 
 
1113 chandransh 9555 
  def __repr__(self):
9556 
    L = ['%s=%r' % (key, value)
9557 
      for key, value in self.__dict__.iteritems()]
9558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9559 
 
9560 
  def __eq__(self, other):
9561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9562 
 
9563 
  def __ne__(self, other):
9564 
    return not (self == other)
9565 
 
3064 chandransh 9566 
class addBillingDetails_args:
1135 chandransh 9567 
  """
9568 
  Attributes:
3064 chandransh 9569 
   - orderId
9570 
   - invoice_number
4283 anupam.sin 9571 
   - imeiNumber
9572 
   - itemNumber
3064 chandransh 9573 
   - billed_by
4264 rajveer 9574 
   - jacketNumber
4283 anupam.sin 9575 
   - billingType
9576 
   - vendorId
1135 chandransh 9577 
  """
9578 
 
9579 
  thrift_spec = (
9580 
    None, # 0
3064 chandransh 9581 
    (1, TType.I64, 'orderId', None, None, ), # 1
9582 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 9583 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
9584 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
9585 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
9586 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
9587 
    (7, TType.I64, 'billingType', None, None, ), # 7
9588 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 9589 
  )
9590 
 
4283 anupam.sin 9591 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 9592 
    self.orderId = orderId
9593 
    self.invoice_number = invoice_number
4283 anupam.sin 9594 
    self.imeiNumber = imeiNumber
9595 
    self.itemNumber = itemNumber
3064 chandransh 9596 
    self.billed_by = billed_by
4264 rajveer 9597 
    self.jacketNumber = jacketNumber
4283 anupam.sin 9598 
    self.billingType = billingType
9599 
    self.vendorId = vendorId
1135 chandransh 9600 
 
9601 
  def read(self, iprot):
9602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9604 
      return
9605 
    iprot.readStructBegin()
9606 
    while True:
9607 
      (fname, ftype, fid) = iprot.readFieldBegin()
9608 
      if ftype == TType.STOP:
9609 
        break
9610 
      if fid == 1:
9611 
        if ftype == TType.I64:
3064 chandransh 9612 
          self.orderId = iprot.readI64();
1135 chandransh 9613 
        else:
9614 
          iprot.skip(ftype)
9615 
      elif fid == 2:
3064 chandransh 9616 
        if ftype == TType.STRING:
9617 
          self.invoice_number = iprot.readString();
1135 chandransh 9618 
        else:
9619 
          iprot.skip(ftype)
3064 chandransh 9620 
      elif fid == 3:
4264 rajveer 9621 
        if ftype == TType.I64:
3064 chandransh 9622 
          self.imeiNumber = iprot.readI64();
9623 
        else:
9624 
          iprot.skip(ftype)
9625 
      elif fid == 4:
9626 
        if ftype == TType.STRING:
9627 
          self.itemNumber = iprot.readString();
9628 
        else:
9629 
          iprot.skip(ftype)
9630 
      elif fid == 5:
9631 
        if ftype == TType.STRING:
4283 anupam.sin 9632 
          self.billed_by = iprot.readString();
3064 chandransh 9633 
        else:
9634 
          iprot.skip(ftype)
9635 
      elif fid == 6:
9636 
        if ftype == TType.I64:
4283 anupam.sin 9637 
          self.jacketNumber = iprot.readI64();
9638 
        else:
9639 
          iprot.skip(ftype)
9640 
      elif fid == 7:
9641 
        if ftype == TType.I64:
3064 chandransh 9642 
          self.billingType = iprot.readI64();
9643 
        else:
9644 
          iprot.skip(ftype)
4283 anupam.sin 9645 
      elif fid == 8:
9646 
        if ftype == TType.I64:
9647 
          self.vendorId = iprot.readI64();
9648 
        else:
9649 
          iprot.skip(ftype)
1246 chandransh 9650 
      else:
9651 
        iprot.skip(ftype)
9652 
      iprot.readFieldEnd()
9653 
    iprot.readStructEnd()
9654 
 
9655 
  def write(self, oprot):
9656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9658 
      return
4283 anupam.sin 9659 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 9660 
    if self.orderId is not None:
3064 chandransh 9661 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9662 
      oprot.writeI64(self.orderId)
1246 chandransh 9663 
      oprot.writeFieldEnd()
4283 anupam.sin 9664 
    if self.invoice_number is not None:
9665 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
9666 
      oprot.writeString(self.invoice_number)
1246 chandransh 9667 
      oprot.writeFieldEnd()
3431 rajveer 9668 
    if self.imeiNumber is not None:
3064 chandransh 9669 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
9670 
      oprot.writeI64(self.imeiNumber)
9671 
      oprot.writeFieldEnd()
3431 rajveer 9672 
    if self.itemNumber is not None:
3064 chandransh 9673 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
9674 
      oprot.writeString(self.itemNumber)
9675 
      oprot.writeFieldEnd()
4283 anupam.sin 9676 
    if self.billed_by is not None:
9677 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
9678 
      oprot.writeString(self.billed_by)
3064 chandransh 9679 
      oprot.writeFieldEnd()
4283 anupam.sin 9680 
    if self.jacketNumber is not None:
9681 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
9682 
      oprot.writeI64(self.jacketNumber)
9683 
      oprot.writeFieldEnd()
3431 rajveer 9684 
    if self.billingType is not None:
4283 anupam.sin 9685 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 9686 
      oprot.writeI64(self.billingType)
9687 
      oprot.writeFieldEnd()
4283 anupam.sin 9688 
    if self.vendorId is not None:
9689 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
9690 
      oprot.writeI64(self.vendorId)
9691 
      oprot.writeFieldEnd()
1246 chandransh 9692 
    oprot.writeFieldStop()
9693 
    oprot.writeStructEnd()
9694 
 
3431 rajveer 9695 
  def validate(self):
9696 
    return
9697 
 
9698 
 
1246 chandransh 9699 
  def __repr__(self):
9700 
    L = ['%s=%r' % (key, value)
9701 
      for key, value in self.__dict__.iteritems()]
9702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9703 
 
9704 
  def __eq__(self, other):
9705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9706 
 
9707 
  def __ne__(self, other):
9708 
    return not (self == other)
9709 
 
4283 anupam.sin 9710 
class addBillingDetails_result:
1246 chandransh 9711 
  """
9712 
  Attributes:
3064 chandransh 9713 
   - success
1246 chandransh 9714 
   - ex
9715 
  """
9716 
 
9717 
  thrift_spec = (
3064 chandransh 9718 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 9719 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9720 
  )
9721 
 
3064 chandransh 9722 
  def __init__(self, success=None, ex=None,):
9723 
    self.success = success
1246 chandransh 9724 
    self.ex = ex
9725 
 
9726 
  def read(self, iprot):
9727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9729 
      return
9730 
    iprot.readStructBegin()
9731 
    while True:
9732 
      (fname, ftype, fid) = iprot.readFieldBegin()
9733 
      if ftype == TType.STOP:
9734 
        break
3064 chandransh 9735 
      if fid == 0:
9736 
        if ftype == TType.BOOL:
9737 
          self.success = iprot.readBool();
9738 
        else:
9739 
          iprot.skip(ftype)
9740 
      elif fid == 1:
1246 chandransh 9741 
        if ftype == TType.STRUCT:
9742 
          self.ex = TransactionServiceException()
9743 
          self.ex.read(iprot)
9744 
        else:
9745 
          iprot.skip(ftype)
9746 
      else:
9747 
        iprot.skip(ftype)
9748 
      iprot.readFieldEnd()
9749 
    iprot.readStructEnd()
9750 
 
9751 
  def write(self, oprot):
9752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9754 
      return
4283 anupam.sin 9755 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 9756 
    if self.success is not None:
3064 chandransh 9757 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9758 
      oprot.writeBool(self.success)
9759 
      oprot.writeFieldEnd()
3431 rajveer 9760 
    if self.ex is not None:
1246 chandransh 9761 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9762 
      self.ex.write(oprot)
9763 
      oprot.writeFieldEnd()
9764 
    oprot.writeFieldStop()
9765 
    oprot.writeStructEnd()
9766 
 
3431 rajveer 9767 
  def validate(self):
9768 
    return
9769 
 
9770 
 
1246 chandransh 9771 
  def __repr__(self):
9772 
    L = ['%s=%r' % (key, value)
9773 
      for key, value in self.__dict__.iteritems()]
9774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9775 
 
9776 
  def __eq__(self, other):
9777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9778 
 
9779 
  def __ne__(self, other):
9780 
    return not (self == other)
9781 
 
4579 rajveer 9782 
class addInvoiceNumber_args:
9783 
  """
9784 
  Attributes:
9785 
   - orderId
9786 
   - invoiceNumber
9787 
  """
9788 
 
9789 
  thrift_spec = (
9790 
    None, # 0
9791 
    (1, TType.I64, 'orderId', None, None, ), # 1
9792 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
9793 
  )
9794 
 
9795 
  def __init__(self, orderId=None, invoiceNumber=None,):
9796 
    self.orderId = orderId
9797 
    self.invoiceNumber = invoiceNumber
9798 
 
9799 
  def read(self, iprot):
9800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9802 
      return
9803 
    iprot.readStructBegin()
9804 
    while True:
9805 
      (fname, ftype, fid) = iprot.readFieldBegin()
9806 
      if ftype == TType.STOP:
9807 
        break
9808 
      if fid == 1:
9809 
        if ftype == TType.I64:
9810 
          self.orderId = iprot.readI64();
9811 
        else:
9812 
          iprot.skip(ftype)
9813 
      elif fid == 2:
9814 
        if ftype == TType.STRING:
9815 
          self.invoiceNumber = iprot.readString();
9816 
        else:
9817 
          iprot.skip(ftype)
9818 
      else:
9819 
        iprot.skip(ftype)
9820 
      iprot.readFieldEnd()
9821 
    iprot.readStructEnd()
9822 
 
9823 
  def write(self, oprot):
9824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9826 
      return
9827 
    oprot.writeStructBegin('addInvoiceNumber_args')
9828 
    if self.orderId is not None:
9829 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9830 
      oprot.writeI64(self.orderId)
9831 
      oprot.writeFieldEnd()
9832 
    if self.invoiceNumber is not None:
9833 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
9834 
      oprot.writeString(self.invoiceNumber)
9835 
      oprot.writeFieldEnd()
9836 
    oprot.writeFieldStop()
9837 
    oprot.writeStructEnd()
9838 
 
9839 
  def validate(self):
9840 
    return
9841 
 
9842 
 
9843 
  def __repr__(self):
9844 
    L = ['%s=%r' % (key, value)
9845 
      for key, value in self.__dict__.iteritems()]
9846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9847 
 
9848 
  def __eq__(self, other):
9849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9850 
 
9851 
  def __ne__(self, other):
9852 
    return not (self == other)
9853 
 
9854 
class addInvoiceNumber_result:
9855 
  """
9856 
  Attributes:
9857 
   - ex
9858 
  """
9859 
 
9860 
  thrift_spec = (
9861 
    None, # 0
9862 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9863 
  )
9864 
 
9865 
  def __init__(self, ex=None,):
9866 
    self.ex = ex
9867 
 
9868 
  def read(self, iprot):
9869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9871 
      return
9872 
    iprot.readStructBegin()
9873 
    while True:
9874 
      (fname, ftype, fid) = iprot.readFieldBegin()
9875 
      if ftype == TType.STOP:
9876 
        break
9877 
      if fid == 1:
9878 
        if ftype == TType.STRUCT:
9879 
          self.ex = TransactionServiceException()
9880 
          self.ex.read(iprot)
9881 
        else:
9882 
          iprot.skip(ftype)
9883 
      else:
9884 
        iprot.skip(ftype)
9885 
      iprot.readFieldEnd()
9886 
    iprot.readStructEnd()
9887 
 
9888 
  def write(self, oprot):
9889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9891 
      return
9892 
    oprot.writeStructBegin('addInvoiceNumber_result')
9893 
    if self.ex is not None:
9894 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9895 
      self.ex.write(oprot)
9896 
      oprot.writeFieldEnd()
9897 
    oprot.writeFieldStop()
9898 
    oprot.writeStructEnd()
9899 
 
9900 
  def validate(self):
9901 
    return
9902 
 
9903 
 
9904 
  def __repr__(self):
9905 
    L = ['%s=%r' % (key, value)
9906 
      for key, value in self.__dict__.iteritems()]
9907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9908 
 
9909 
  def __eq__(self, other):
9910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9911 
 
9912 
  def __ne__(self, other):
9913 
    return not (self == other)
9914 
 
3064 chandransh 9915 
class markOrdersAsManifested_args:
1408 ankur.sing 9916 
  """
9917 
  Attributes:
3064 chandransh 9918 
   - warehouseId
1408 ankur.sing 9919 
   - providerId
3064 chandransh 9920 
   - cod
1408 ankur.sing 9921 
  """
9922 
 
9923 
  thrift_spec = (
9924 
    None, # 0
3064 chandransh 9925 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9926 
    (2, TType.I64, 'providerId', None, None, ), # 2
9927 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 9928 
  )
9929 
 
3064 chandransh 9930 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9931 
    self.warehouseId = warehouseId
1408 ankur.sing 9932 
    self.providerId = providerId
3064 chandransh 9933 
    self.cod = cod
1408 ankur.sing 9934 
 
9935 
  def read(self, iprot):
9936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9938 
      return
9939 
    iprot.readStructBegin()
9940 
    while True:
9941 
      (fname, ftype, fid) = iprot.readFieldBegin()
9942 
      if ftype == TType.STOP:
9943 
        break
9944 
      if fid == 1:
9945 
        if ftype == TType.I64:
3064 chandransh 9946 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 9947 
        else:
9948 
          iprot.skip(ftype)
9949 
      elif fid == 2:
9950 
        if ftype == TType.I64:
3064 chandransh 9951 
          self.providerId = iprot.readI64();
1408 ankur.sing 9952 
        else:
9953 
          iprot.skip(ftype)
3064 chandransh 9954 
      elif fid == 3:
9955 
        if ftype == TType.BOOL:
9956 
          self.cod = iprot.readBool();
9957 
        else:
9958 
          iprot.skip(ftype)
1408 ankur.sing 9959 
      else:
9960 
        iprot.skip(ftype)
9961 
      iprot.readFieldEnd()
9962 
    iprot.readStructEnd()
9963 
 
9964 
  def write(self, oprot):
9965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9967 
      return
3064 chandransh 9968 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 9969 
    if self.warehouseId is not None:
3064 chandransh 9970 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9971 
      oprot.writeI64(self.warehouseId)
9972 
      oprot.writeFieldEnd()
3431 rajveer 9973 
    if self.providerId is not None:
3064 chandransh 9974 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9975 
      oprot.writeI64(self.providerId)
9976 
      oprot.writeFieldEnd()
3431 rajveer 9977 
    if self.cod is not None:
3064 chandransh 9978 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9979 
      oprot.writeBool(self.cod)
1408 ankur.sing 9980 
      oprot.writeFieldEnd()
9981 
    oprot.writeFieldStop()
9982 
    oprot.writeStructEnd()
9983 
 
3431 rajveer 9984 
  def validate(self):
9985 
    return
9986 
 
9987 
 
1408 ankur.sing 9988 
  def __repr__(self):
9989 
    L = ['%s=%r' % (key, value)
9990 
      for key, value in self.__dict__.iteritems()]
9991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9992 
 
9993 
  def __eq__(self, other):
9994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9995 
 
9996 
  def __ne__(self, other):
9997 
    return not (self == other)
9998 
 
3064 chandransh 9999 
class markOrdersAsManifested_result:
1408 ankur.sing 10000 
  """
10001 
  Attributes:
10002 
   - success
3064 chandransh 10003 
   - ex
1408 ankur.sing 10004 
  """
10005 
 
10006 
  thrift_spec = (
3064 chandransh 10007 
    (0, TType.BOOL, 'success', None, None, ), # 0
10008 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10009 
  )
10010 
 
3064 chandransh 10011 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10012 
    self.success = success
3064 chandransh 10013 
    self.ex = ex
1408 ankur.sing 10014 
 
10015 
  def read(self, iprot):
10016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10018 
      return
10019 
    iprot.readStructBegin()
10020 
    while True:
10021 
      (fname, ftype, fid) = iprot.readFieldBegin()
10022 
      if ftype == TType.STOP:
10023 
        break
10024 
      if fid == 0:
3064 chandransh 10025 
        if ftype == TType.BOOL:
10026 
          self.success = iprot.readBool();
1408 ankur.sing 10027 
        else:
10028 
          iprot.skip(ftype)
3064 chandransh 10029 
      elif fid == 1:
10030 
        if ftype == TType.STRUCT:
10031 
          self.ex = TransactionServiceException()
10032 
          self.ex.read(iprot)
10033 
        else:
10034 
          iprot.skip(ftype)
1408 ankur.sing 10035 
      else:
10036 
        iprot.skip(ftype)
10037 
      iprot.readFieldEnd()
10038 
    iprot.readStructEnd()
10039 
 
10040 
  def write(self, oprot):
10041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10043 
      return
3064 chandransh 10044 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10045 
    if self.success is not None:
3064 chandransh 10046 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10047 
      oprot.writeBool(self.success)
1408 ankur.sing 10048 
      oprot.writeFieldEnd()
3431 rajveer 10049 
    if self.ex is not None:
3064 chandransh 10050 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10051 
      self.ex.write(oprot)
10052 
      oprot.writeFieldEnd()
1408 ankur.sing 10053 
    oprot.writeFieldStop()
10054 
    oprot.writeStructEnd()
10055 
 
3431 rajveer 10056 
  def validate(self):
10057 
    return
10058 
 
10059 
 
1408 ankur.sing 10060 
  def __repr__(self):
10061 
    L = ['%s=%r' % (key, value)
10062 
      for key, value in self.__dict__.iteritems()]
10063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10064 
 
10065 
  def __eq__(self, other):
10066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10067 
 
10068 
  def __ne__(self, other):
10069 
    return not (self == other)
10070 
 
4410 rajveer 10071 
class markOrdersAsShippedFromWarehouse_args:
10072 
  """
10073 
  Attributes:
10074 
   - warehouseId
10075 
   - providerId
10076 
   - cod
10077 
  """
10078 
 
10079 
  thrift_spec = (
10080 
    None, # 0
10081 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10082 
    (2, TType.I64, 'providerId', None, None, ), # 2
10083 
    (3, TType.BOOL, 'cod', None, None, ), # 3
10084 
  )
10085 
 
10086 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10087 
    self.warehouseId = warehouseId
10088 
    self.providerId = providerId
10089 
    self.cod = cod
10090 
 
10091 
  def read(self, iprot):
10092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10094 
      return
10095 
    iprot.readStructBegin()
10096 
    while True:
10097 
      (fname, ftype, fid) = iprot.readFieldBegin()
10098 
      if ftype == TType.STOP:
10099 
        break
10100 
      if fid == 1:
10101 
        if ftype == TType.I64:
10102 
          self.warehouseId = iprot.readI64();
10103 
        else:
10104 
          iprot.skip(ftype)
10105 
      elif fid == 2:
10106 
        if ftype == TType.I64:
10107 
          self.providerId = iprot.readI64();
10108 
        else:
10109 
          iprot.skip(ftype)
10110 
      elif fid == 3:
10111 
        if ftype == TType.BOOL:
10112 
          self.cod = iprot.readBool();
10113 
        else:
10114 
          iprot.skip(ftype)
10115 
      else:
10116 
        iprot.skip(ftype)
10117 
      iprot.readFieldEnd()
10118 
    iprot.readStructEnd()
10119 
 
10120 
  def write(self, oprot):
10121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10123 
      return
10124 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
10125 
    if self.warehouseId is not None:
10126 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10127 
      oprot.writeI64(self.warehouseId)
10128 
      oprot.writeFieldEnd()
10129 
    if self.providerId is not None:
10130 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
10131 
      oprot.writeI64(self.providerId)
10132 
      oprot.writeFieldEnd()
10133 
    if self.cod is not None:
10134 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10135 
      oprot.writeBool(self.cod)
10136 
      oprot.writeFieldEnd()
10137 
    oprot.writeFieldStop()
10138 
    oprot.writeStructEnd()
10139 
 
10140 
  def validate(self):
10141 
    return
10142 
 
10143 
 
10144 
  def __repr__(self):
10145 
    L = ['%s=%r' % (key, value)
10146 
      for key, value in self.__dict__.iteritems()]
10147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10148 
 
10149 
  def __eq__(self, other):
10150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10151 
 
10152 
  def __ne__(self, other):
10153 
    return not (self == other)
10154 
 
10155 
class markOrdersAsShippedFromWarehouse_result:
10156 
  """
10157 
  Attributes:
10158 
   - success
10159 
   - ex
10160 
  """
10161 
 
10162 
  thrift_spec = (
10163 
    (0, TType.BOOL, 'success', None, None, ), # 0
10164 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10165 
  )
10166 
 
10167 
  def __init__(self, success=None, ex=None,):
10168 
    self.success = success
10169 
    self.ex = ex
10170 
 
10171 
  def read(self, iprot):
10172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10174 
      return
10175 
    iprot.readStructBegin()
10176 
    while True:
10177 
      (fname, ftype, fid) = iprot.readFieldBegin()
10178 
      if ftype == TType.STOP:
10179 
        break
10180 
      if fid == 0:
10181 
        if ftype == TType.BOOL:
10182 
          self.success = iprot.readBool();
10183 
        else:
10184 
          iprot.skip(ftype)
10185 
      elif fid == 1:
10186 
        if ftype == TType.STRUCT:
10187 
          self.ex = TransactionServiceException()
10188 
          self.ex.read(iprot)
10189 
        else:
10190 
          iprot.skip(ftype)
10191 
      else:
10192 
        iprot.skip(ftype)
10193 
      iprot.readFieldEnd()
10194 
    iprot.readStructEnd()
10195 
 
10196 
  def write(self, oprot):
10197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10199 
      return
10200 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
10201 
    if self.success is not None:
10202 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10203 
      oprot.writeBool(self.success)
10204 
      oprot.writeFieldEnd()
10205 
    if self.ex is not None:
10206 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10207 
      self.ex.write(oprot)
10208 
      oprot.writeFieldEnd()
10209 
    oprot.writeFieldStop()
10210 
    oprot.writeStructEnd()
10211 
 
10212 
  def validate(self):
10213 
    return
10214 
 
10215 
 
10216 
  def __repr__(self):
10217 
    L = ['%s=%r' % (key, value)
10218 
      for key, value in self.__dict__.iteritems()]
10219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10220 
 
10221 
  def __eq__(self, other):
10222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10223 
 
10224 
  def __ne__(self, other):
10225 
    return not (self == other)
10226 
 
3064 chandransh 10227 
class markOrdersAsPickedUp_args:
304 ashish 10228 
  """
10229 
  Attributes:
3064 chandransh 10230 
   - providerId
10231 
   - pickupDetails
304 ashish 10232 
  """
94 ashish 10233 
 
304 ashish 10234 
  thrift_spec = (
10235 
    None, # 0
3064 chandransh 10236 
    (1, TType.I64, 'providerId', None, None, ), # 1
10237 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10238 
  )
10239 
 
3064 chandransh 10240 
  def __init__(self, providerId=None, pickupDetails=None,):
10241 
    self.providerId = providerId
10242 
    self.pickupDetails = pickupDetails
304 ashish 10243 
 
10244 
  def read(self, iprot):
10245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10247 
      return
10248 
    iprot.readStructBegin()
10249 
    while True:
10250 
      (fname, ftype, fid) = iprot.readFieldBegin()
10251 
      if ftype == TType.STOP:
10252 
        break
10253 
      if fid == 1:
10254 
        if ftype == TType.I64:
3064 chandransh 10255 
          self.providerId = iprot.readI64();
304 ashish 10256 
        else:
10257 
          iprot.skip(ftype)
10258 
      elif fid == 2:
3064 chandransh 10259 
        if ftype == TType.MAP:
10260 
          self.pickupDetails = {}
4133 chandransh 10261 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
10262 
          for _i144 in xrange(_size140):
10263 
            _key145 = iprot.readString();
10264 
            _val146 = iprot.readString();
10265 
            self.pickupDetails[_key145] = _val146
3064 chandransh 10266 
          iprot.readMapEnd()
304 ashish 10267 
        else:
10268 
          iprot.skip(ftype)
10269 
      else:
10270 
        iprot.skip(ftype)
10271 
      iprot.readFieldEnd()
10272 
    iprot.readStructEnd()
10273 
 
10274 
  def write(self, oprot):
10275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10277 
      return
3064 chandransh 10278 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 10279 
    if self.providerId is not None:
3064 chandransh 10280 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10281 
      oprot.writeI64(self.providerId)
304 ashish 10282 
      oprot.writeFieldEnd()
3431 rajveer 10283 
    if self.pickupDetails is not None:
3064 chandransh 10284 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10285 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10286 
      for kiter147,viter148 in self.pickupDetails.items():
10287 
        oprot.writeString(kiter147)
10288 
        oprot.writeString(viter148)
3064 chandransh 10289 
      oprot.writeMapEnd()
304 ashish 10290 
      oprot.writeFieldEnd()
10291 
    oprot.writeFieldStop()
10292 
    oprot.writeStructEnd()
10293 
 
3431 rajveer 10294 
  def validate(self):
10295 
    return
10296 
 
10297 
 
304 ashish 10298 
  def __repr__(self):
10299 
    L = ['%s=%r' % (key, value)
10300 
      for key, value in self.__dict__.iteritems()]
10301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10302 
 
10303 
  def __eq__(self, other):
10304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10305 
 
10306 
  def __ne__(self, other):
10307 
    return not (self == other)
10308 
 
3064 chandransh 10309 
class markOrdersAsPickedUp_result:
304 ashish 10310 
  """
10311 
  Attributes:
10312 
   - success
3064 chandransh 10313 
   - ex
304 ashish 10314 
  """
10315 
 
10316 
  thrift_spec = (
3064 chandransh 10317 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10318 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10319 
  )
10320 
 
3064 chandransh 10321 
  def __init__(self, success=None, ex=None,):
304 ashish 10322 
    self.success = success
3064 chandransh 10323 
    self.ex = ex
304 ashish 10324 
 
10325 
  def read(self, iprot):
10326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10328 
      return
10329 
    iprot.readStructBegin()
10330 
    while True:
10331 
      (fname, ftype, fid) = iprot.readFieldBegin()
10332 
      if ftype == TType.STOP:
10333 
        break
10334 
      if fid == 0:
10335 
        if ftype == TType.LIST:
10336 
          self.success = []
4133 chandransh 10337 
          (_etype152, _size149) = iprot.readListBegin()
10338 
          for _i153 in xrange(_size149):
10339 
            _elem154 = Order()
10340 
            _elem154.read(iprot)
10341 
            self.success.append(_elem154)
304 ashish 10342 
          iprot.readListEnd()
10343 
        else:
10344 
          iprot.skip(ftype)
3064 chandransh 10345 
      elif fid == 1:
10346 
        if ftype == TType.STRUCT:
10347 
          self.ex = TransactionServiceException()
10348 
          self.ex.read(iprot)
10349 
        else:
10350 
          iprot.skip(ftype)
304 ashish 10351 
      else:
10352 
        iprot.skip(ftype)
10353 
      iprot.readFieldEnd()
10354 
    iprot.readStructEnd()
10355 
 
10356 
  def write(self, oprot):
10357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10359 
      return
3064 chandransh 10360 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 10361 
    if self.success is not None:
304 ashish 10362 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10363 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10364 
      for iter155 in self.success:
10365 
        iter155.write(oprot)
304 ashish 10366 
      oprot.writeListEnd()
10367 
      oprot.writeFieldEnd()
3431 rajveer 10368 
    if self.ex is not None:
3064 chandransh 10369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10370 
      self.ex.write(oprot)
10371 
      oprot.writeFieldEnd()
304 ashish 10372 
    oprot.writeFieldStop()
10373 
    oprot.writeStructEnd()
10374 
 
3431 rajveer 10375 
  def validate(self):
10376 
    return
10377 
 
10378 
 
304 ashish 10379 
  def __repr__(self):
10380 
    L = ['%s=%r' % (key, value)
10381 
      for key, value in self.__dict__.iteritems()]
10382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10383 
 
10384 
  def __eq__(self, other):
10385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10386 
 
10387 
  def __ne__(self, other):
10388 
    return not (self == other)
10389 
 
3064 chandransh 10390 
class markOrdersAsDelivered_args:
304 ashish 10391 
  """
10392 
  Attributes:
3064 chandransh 10393 
   - providerId
10394 
   - deliveredOrders
304 ashish 10395 
  """
10396 
 
10397 
  thrift_spec = (
10398 
    None, # 0
3064 chandransh 10399 
    (1, TType.I64, 'providerId', None, None, ), # 1
10400 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10401 
  )
10402 
 
3064 chandransh 10403 
  def __init__(self, providerId=None, deliveredOrders=None,):
10404 
    self.providerId = providerId
10405 
    self.deliveredOrders = deliveredOrders
304 ashish 10406 
 
10407 
  def read(self, iprot):
10408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10410 
      return
10411 
    iprot.readStructBegin()
10412 
    while True:
10413 
      (fname, ftype, fid) = iprot.readFieldBegin()
10414 
      if ftype == TType.STOP:
10415 
        break
10416 
      if fid == 1:
10417 
        if ftype == TType.I64:
3064 chandransh 10418 
          self.providerId = iprot.readI64();
304 ashish 10419 
        else:
10420 
          iprot.skip(ftype)
10421 
      elif fid == 2:
3064 chandransh 10422 
        if ftype == TType.MAP:
10423 
          self.deliveredOrders = {}
4133 chandransh 10424 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
10425 
          for _i160 in xrange(_size156):
10426 
            _key161 = iprot.readString();
10427 
            _val162 = iprot.readString();
10428 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 10429 
          iprot.readMapEnd()
304 ashish 10430 
        else:
10431 
          iprot.skip(ftype)
10432 
      else:
10433 
        iprot.skip(ftype)
10434 
      iprot.readFieldEnd()
10435 
    iprot.readStructEnd()
10436 
 
10437 
  def write(self, oprot):
10438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10440 
      return
3064 chandransh 10441 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 10442 
    if self.providerId is not None:
3064 chandransh 10443 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10444 
      oprot.writeI64(self.providerId)
304 ashish 10445 
      oprot.writeFieldEnd()
3431 rajveer 10446 
    if self.deliveredOrders is not None:
3064 chandransh 10447 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
10448 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 10449 
      for kiter163,viter164 in self.deliveredOrders.items():
10450 
        oprot.writeString(kiter163)
10451 
        oprot.writeString(viter164)
3064 chandransh 10452 
      oprot.writeMapEnd()
304 ashish 10453 
      oprot.writeFieldEnd()
10454 
    oprot.writeFieldStop()
10455 
    oprot.writeStructEnd()
10456 
 
3431 rajveer 10457 
  def validate(self):
10458 
    return
10459 
 
10460 
 
304 ashish 10461 
  def __repr__(self):
10462 
    L = ['%s=%r' % (key, value)
10463 
      for key, value in self.__dict__.iteritems()]
10464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10465 
 
10466 
  def __eq__(self, other):
10467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10468 
 
10469 
  def __ne__(self, other):
10470 
    return not (self == other)
10471 
 
3064 chandransh 10472 
class markOrdersAsDelivered_result:
10473 
  """
10474 
  Attributes:
10475 
   - ex
10476 
  """
304 ashish 10477 
 
10478 
  thrift_spec = (
3064 chandransh 10479 
    None, # 0
10480 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10481 
  )
10482 
 
3064 chandransh 10483 
  def __init__(self, ex=None,):
10484 
    self.ex = ex
304 ashish 10485 
 
1596 ankur.sing 10486 
  def read(self, iprot):
10487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10489 
      return
10490 
    iprot.readStructBegin()
10491 
    while True:
10492 
      (fname, ftype, fid) = iprot.readFieldBegin()
10493 
      if ftype == TType.STOP:
10494 
        break
3064 chandransh 10495 
      if fid == 1:
10496 
        if ftype == TType.STRUCT:
10497 
          self.ex = TransactionServiceException()
10498 
          self.ex.read(iprot)
10499 
        else:
10500 
          iprot.skip(ftype)
1596 ankur.sing 10501 
      else:
10502 
        iprot.skip(ftype)
10503 
      iprot.readFieldEnd()
10504 
    iprot.readStructEnd()
10505 
 
10506 
  def write(self, oprot):
10507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10509 
      return
3064 chandransh 10510 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 10511 
    if self.ex is not None:
3064 chandransh 10512 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10513 
      self.ex.write(oprot)
10514 
      oprot.writeFieldEnd()
1596 ankur.sing 10515 
    oprot.writeFieldStop()
10516 
    oprot.writeStructEnd()
10517 
 
3431 rajveer 10518 
  def validate(self):
10519 
    return
10520 
 
10521 
 
1596 ankur.sing 10522 
  def __repr__(self):
10523 
    L = ['%s=%r' % (key, value)
10524 
      for key, value in self.__dict__.iteritems()]
10525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10526 
 
10527 
  def __eq__(self, other):
10528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10529 
 
10530 
  def __ne__(self, other):
10531 
    return not (self == other)
10532 
 
3064 chandransh 10533 
class markOrdersAsFailed_args:
1596 ankur.sing 10534 
  """
10535 
  Attributes:
3064 chandransh 10536 
   - providerId
10537 
   - returnedOrders
1596 ankur.sing 10538 
  """
10539 
 
10540 
  thrift_spec = (
3064 chandransh 10541 
    None, # 0
10542 
    (1, TType.I64, 'providerId', None, None, ), # 1
10543 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 10544 
  )
10545 
 
3064 chandransh 10546 
  def __init__(self, providerId=None, returnedOrders=None,):
10547 
    self.providerId = providerId
10548 
    self.returnedOrders = returnedOrders
1596 ankur.sing 10549 
 
10550 
  def read(self, iprot):
10551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10553 
      return
10554 
    iprot.readStructBegin()
10555 
    while True:
10556 
      (fname, ftype, fid) = iprot.readFieldBegin()
10557 
      if ftype == TType.STOP:
10558 
        break
3064 chandransh 10559 
      if fid == 1:
1596 ankur.sing 10560 
        if ftype == TType.I64:
3064 chandransh 10561 
          self.providerId = iprot.readI64();
1596 ankur.sing 10562 
        else:
10563 
          iprot.skip(ftype)
3064 chandransh 10564 
      elif fid == 2:
10565 
        if ftype == TType.MAP:
10566 
          self.returnedOrders = {}
4133 chandransh 10567 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
10568 
          for _i169 in xrange(_size165):
10569 
            _key170 = iprot.readString();
10570 
            _val171 = iprot.readString();
10571 
            self.returnedOrders[_key170] = _val171
3064 chandransh 10572 
          iprot.readMapEnd()
10573 
        else:
10574 
          iprot.skip(ftype)
1596 ankur.sing 10575 
      else:
10576 
        iprot.skip(ftype)
10577 
      iprot.readFieldEnd()
10578 
    iprot.readStructEnd()
10579 
 
10580 
  def write(self, oprot):
10581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10583 
      return
3064 chandransh 10584 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 10585 
    if self.providerId is not None:
3064 chandransh 10586 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10587 
      oprot.writeI64(self.providerId)
1596 ankur.sing 10588 
      oprot.writeFieldEnd()
3431 rajveer 10589 
    if self.returnedOrders is not None:
3064 chandransh 10590 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
10591 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 10592 
      for kiter172,viter173 in self.returnedOrders.items():
10593 
        oprot.writeString(kiter172)
10594 
        oprot.writeString(viter173)
3064 chandransh 10595 
      oprot.writeMapEnd()
10596 
      oprot.writeFieldEnd()
1596 ankur.sing 10597 
    oprot.writeFieldStop()
10598 
    oprot.writeStructEnd()
10599 
 
3431 rajveer 10600 
  def validate(self):
10601 
    return
10602 
 
10603 
 
1596 ankur.sing 10604 
  def __repr__(self):
10605 
    L = ['%s=%r' % (key, value)
10606 
      for key, value in self.__dict__.iteritems()]
10607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10608 
 
10609 
  def __eq__(self, other):
10610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10611 
 
10612 
  def __ne__(self, other):
10613 
    return not (self == other)
10614 
 
3064 chandransh 10615 
class markOrdersAsFailed_result:
10616 
  """
10617 
  Attributes:
10618 
   - ex
10619 
  """
1596 ankur.sing 10620 
 
1627 ankur.sing 10621 
  thrift_spec = (
3064 chandransh 10622 
    None, # 0
10623 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10624 
  )
10625 
 
3064 chandransh 10626 
  def __init__(self, ex=None,):
10627 
    self.ex = ex
10628 
 
1627 ankur.sing 10629 
  def read(self, iprot):
10630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10632 
      return
10633 
    iprot.readStructBegin()
10634 
    while True:
10635 
      (fname, ftype, fid) = iprot.readFieldBegin()
10636 
      if ftype == TType.STOP:
10637 
        break
3064 chandransh 10638 
      if fid == 1:
10639 
        if ftype == TType.STRUCT:
10640 
          self.ex = TransactionServiceException()
10641 
          self.ex.read(iprot)
10642 
        else:
10643 
          iprot.skip(ftype)
1627 ankur.sing 10644 
      else:
10645 
        iprot.skip(ftype)
10646 
      iprot.readFieldEnd()
10647 
    iprot.readStructEnd()
10648 
 
10649 
  def write(self, oprot):
10650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10652 
      return
3064 chandransh 10653 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 10654 
    if self.ex is not None:
3064 chandransh 10655 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10656 
      self.ex.write(oprot)
10657 
      oprot.writeFieldEnd()
1627 ankur.sing 10658 
    oprot.writeFieldStop()
10659 
    oprot.writeStructEnd()
10660 
 
3431 rajveer 10661 
  def validate(self):
10662 
    return
10663 
 
10664 
 
1627 ankur.sing 10665 
  def __repr__(self):
10666 
    L = ['%s=%r' % (key, value)
10667 
      for key, value in self.__dict__.iteritems()]
10668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10669 
 
10670 
  def __eq__(self, other):
10671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10672 
 
10673 
  def __ne__(self, other):
10674 
    return not (self == other)
10675 
 
3064 chandransh 10676 
class updateNonDeliveryReason_args:
1627 ankur.sing 10677 
  """
10678 
  Attributes:
3064 chandransh 10679 
   - providerId
10680 
   - undeliveredOrders
1627 ankur.sing 10681 
  """
10682 
 
10683 
  thrift_spec = (
3064 chandransh 10684 
    None, # 0
10685 
    (1, TType.I64, 'providerId', None, None, ), # 1
10686 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 10687 
  )
10688 
 
3064 chandransh 10689 
  def __init__(self, providerId=None, undeliveredOrders=None,):
10690 
    self.providerId = providerId
10691 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 10692 
 
10693 
  def read(self, iprot):
10694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10696 
      return
10697 
    iprot.readStructBegin()
10698 
    while True:
10699 
      (fname, ftype, fid) = iprot.readFieldBegin()
10700 
      if ftype == TType.STOP:
10701 
        break
3064 chandransh 10702 
      if fid == 1:
1627 ankur.sing 10703 
        if ftype == TType.I64:
3064 chandransh 10704 
          self.providerId = iprot.readI64();
1627 ankur.sing 10705 
        else:
10706 
          iprot.skip(ftype)
3064 chandransh 10707 
      elif fid == 2:
10708 
        if ftype == TType.MAP:
10709 
          self.undeliveredOrders = {}
4133 chandransh 10710 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
10711 
          for _i178 in xrange(_size174):
10712 
            _key179 = iprot.readString();
10713 
            _val180 = iprot.readString();
10714 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 10715 
          iprot.readMapEnd()
10716 
        else:
10717 
          iprot.skip(ftype)
1627 ankur.sing 10718 
      else:
10719 
        iprot.skip(ftype)
10720 
      iprot.readFieldEnd()
10721 
    iprot.readStructEnd()
10722 
 
10723 
  def write(self, oprot):
10724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10726 
      return
3064 chandransh 10727 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 10728 
    if self.providerId is not None:
3064 chandransh 10729 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10730 
      oprot.writeI64(self.providerId)
1627 ankur.sing 10731 
      oprot.writeFieldEnd()
3431 rajveer 10732 
    if self.undeliveredOrders is not None:
3064 chandransh 10733 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
10734 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 10735 
      for kiter181,viter182 in self.undeliveredOrders.items():
10736 
        oprot.writeString(kiter181)
10737 
        oprot.writeString(viter182)
3064 chandransh 10738 
      oprot.writeMapEnd()
10739 
      oprot.writeFieldEnd()
1627 ankur.sing 10740 
    oprot.writeFieldStop()
10741 
    oprot.writeStructEnd()
10742 
 
3431 rajveer 10743 
  def validate(self):
10744 
    return
10745 
 
10746 
 
1627 ankur.sing 10747 
  def __repr__(self):
10748 
    L = ['%s=%r' % (key, value)
10749 
      for key, value in self.__dict__.iteritems()]
10750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10751 
 
10752 
  def __eq__(self, other):
10753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10754 
 
10755 
  def __ne__(self, other):
10756 
    return not (self == other)
10757 
 
3064 chandransh 10758 
class updateNonDeliveryReason_result:
1627 ankur.sing 10759 
  """
10760 
  Attributes:
4581 phani.kuma 10761 
   - success
3064 chandransh 10762 
   - ex
1627 ankur.sing 10763 
  """
10764 
 
10765 
  thrift_spec = (
4581 phani.kuma 10766 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 10767 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10768 
  )
10769 
 
4581 phani.kuma 10770 
  def __init__(self, success=None, ex=None,):
10771 
    self.success = success
3064 chandransh 10772 
    self.ex = ex
1627 ankur.sing 10773 
 
10774 
  def read(self, iprot):
10775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10777 
      return
10778 
    iprot.readStructBegin()
10779 
    while True:
10780 
      (fname, ftype, fid) = iprot.readFieldBegin()
10781 
      if ftype == TType.STOP:
10782 
        break
4581 phani.kuma 10783 
      if fid == 0:
10784 
        if ftype == TType.LIST:
10785 
          self.success = []
10786 
          (_etype186, _size183) = iprot.readListBegin()
10787 
          for _i187 in xrange(_size183):
10788 
            _elem188 = Order()
10789 
            _elem188.read(iprot)
10790 
            self.success.append(_elem188)
10791 
          iprot.readListEnd()
10792 
        else:
10793 
          iprot.skip(ftype)
10794 
      elif fid == 1:
3064 chandransh 10795 
        if ftype == TType.STRUCT:
10796 
          self.ex = TransactionServiceException()
10797 
          self.ex.read(iprot)
1627 ankur.sing 10798 
        else:
10799 
          iprot.skip(ftype)
10800 
      else:
10801 
        iprot.skip(ftype)
10802 
      iprot.readFieldEnd()
10803 
    iprot.readStructEnd()
10804 
 
10805 
  def write(self, oprot):
10806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10808 
      return
3064 chandransh 10809 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 10810 
    if self.success is not None:
10811 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10812 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10813 
      for iter189 in self.success:
10814 
        iter189.write(oprot)
10815 
      oprot.writeListEnd()
10816 
      oprot.writeFieldEnd()
3431 rajveer 10817 
    if self.ex is not None:
3064 chandransh 10818 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10819 
      self.ex.write(oprot)
1627 ankur.sing 10820 
      oprot.writeFieldEnd()
10821 
    oprot.writeFieldStop()
10822 
    oprot.writeStructEnd()
10823 
 
3431 rajveer 10824 
  def validate(self):
10825 
    return
10826 
 
10827 
 
1627 ankur.sing 10828 
  def __repr__(self):
10829 
    L = ['%s=%r' % (key, value)
10830 
      for key, value in self.__dict__.iteritems()]
10831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10832 
 
10833 
  def __eq__(self, other):
10834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10835 
 
10836 
  def __ne__(self, other):
10837 
    return not (self == other)
10838 
 
3064 chandransh 10839 
class getUndeliveredOrders_args:
1886 ankur.sing 10840 
  """
10841 
  Attributes:
3064 chandransh 10842 
   - providerId
10843 
   - warehouseId
1886 ankur.sing 10844 
  """
1627 ankur.sing 10845 
 
1886 ankur.sing 10846 
  thrift_spec = (
10847 
    None, # 0
3064 chandransh 10848 
    (1, TType.I64, 'providerId', None, None, ), # 1
10849 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 10850 
  )
10851 
 
3064 chandransh 10852 
  def __init__(self, providerId=None, warehouseId=None,):
10853 
    self.providerId = providerId
10854 
    self.warehouseId = warehouseId
1886 ankur.sing 10855 
 
10856 
  def read(self, iprot):
10857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10859 
      return
10860 
    iprot.readStructBegin()
10861 
    while True:
10862 
      (fname, ftype, fid) = iprot.readFieldBegin()
10863 
      if ftype == TType.STOP:
10864 
        break
10865 
      if fid == 1:
10866 
        if ftype == TType.I64:
3064 chandransh 10867 
          self.providerId = iprot.readI64();
1886 ankur.sing 10868 
        else:
10869 
          iprot.skip(ftype)
3064 chandransh 10870 
      elif fid == 2:
10871 
        if ftype == TType.I64:
10872 
          self.warehouseId = iprot.readI64();
10873 
        else:
10874 
          iprot.skip(ftype)
1886 ankur.sing 10875 
      else:
10876 
        iprot.skip(ftype)
10877 
      iprot.readFieldEnd()
10878 
    iprot.readStructEnd()
10879 
 
10880 
  def write(self, oprot):
10881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10883 
      return
3064 chandransh 10884 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 10885 
    if self.providerId is not None:
3064 chandransh 10886 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10887 
      oprot.writeI64(self.providerId)
1886 ankur.sing 10888 
      oprot.writeFieldEnd()
3431 rajveer 10889 
    if self.warehouseId is not None:
3064 chandransh 10890 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10891 
      oprot.writeI64(self.warehouseId)
10892 
      oprot.writeFieldEnd()
1886 ankur.sing 10893 
    oprot.writeFieldStop()
10894 
    oprot.writeStructEnd()
10895 
 
3431 rajveer 10896 
  def validate(self):
10897 
    return
10898 
 
10899 
 
1886 ankur.sing 10900 
  def __repr__(self):
10901 
    L = ['%s=%r' % (key, value)
10902 
      for key, value in self.__dict__.iteritems()]
10903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10904 
 
10905 
  def __eq__(self, other):
10906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10907 
 
10908 
  def __ne__(self, other):
10909 
    return not (self == other)
10910 
 
3064 chandransh 10911 
class getUndeliveredOrders_result:
1886 ankur.sing 10912 
  """
10913 
  Attributes:
10914 
   - success
10915 
  """
10916 
 
10917 
  thrift_spec = (
10918 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10919 
  )
10920 
 
10921 
  def __init__(self, success=None,):
10922 
    self.success = success
10923 
 
10924 
  def read(self, iprot):
10925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10927 
      return
10928 
    iprot.readStructBegin()
10929 
    while True:
10930 
      (fname, ftype, fid) = iprot.readFieldBegin()
10931 
      if ftype == TType.STOP:
10932 
        break
10933 
      if fid == 0:
10934 
        if ftype == TType.LIST:
10935 
          self.success = []
4581 phani.kuma 10936 
          (_etype193, _size190) = iprot.readListBegin()
10937 
          for _i194 in xrange(_size190):
10938 
            _elem195 = Order()
10939 
            _elem195.read(iprot)
10940 
            self.success.append(_elem195)
1886 ankur.sing 10941 
          iprot.readListEnd()
10942 
        else:
10943 
          iprot.skip(ftype)
10944 
      else:
10945 
        iprot.skip(ftype)
10946 
      iprot.readFieldEnd()
10947 
    iprot.readStructEnd()
10948 
 
10949 
  def write(self, oprot):
10950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10952 
      return
3064 chandransh 10953 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 10954 
    if self.success is not None:
1886 ankur.sing 10955 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10956 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 10957 
      for iter196 in self.success:
10958 
        iter196.write(oprot)
1886 ankur.sing 10959 
      oprot.writeListEnd()
10960 
      oprot.writeFieldEnd()
10961 
    oprot.writeFieldStop()
10962 
    oprot.writeStructEnd()
10963 
 
3431 rajveer 10964 
  def validate(self):
10965 
    return
10966 
 
10967 
 
1886 ankur.sing 10968 
  def __repr__(self):
10969 
    L = ['%s=%r' % (key, value)
10970 
      for key, value in self.__dict__.iteritems()]
10971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10972 
 
10973 
  def __eq__(self, other):
10974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10975 
 
10976 
  def __ne__(self, other):
10977 
    return not (self == other)
10978 
 
2536 chandransh 10979 
class toggleDOAFlag_args:
10980 
  """
10981 
  Attributes:
10982 
   - orderId
10983 
  """
1886 ankur.sing 10984 
 
2536 chandransh 10985 
  thrift_spec = (
10986 
    None, # 0
10987 
    (1, TType.I64, 'orderId', None, None, ), # 1
10988 
  )
10989 
 
10990 
  def __init__(self, orderId=None,):
10991 
    self.orderId = orderId
10992 
 
10993 
  def read(self, iprot):
10994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10996 
      return
10997 
    iprot.readStructBegin()
10998 
    while True:
10999 
      (fname, ftype, fid) = iprot.readFieldBegin()
11000 
      if ftype == TType.STOP:
11001 
        break
11002 
      if fid == 1:
11003 
        if ftype == TType.I64:
11004 
          self.orderId = iprot.readI64();
11005 
        else:
11006 
          iprot.skip(ftype)
11007 
      else:
11008 
        iprot.skip(ftype)
11009 
      iprot.readFieldEnd()
11010 
    iprot.readStructEnd()
11011 
 
11012 
  def write(self, oprot):
11013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11015 
      return
11016 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 11017 
    if self.orderId is not None:
2536 chandransh 11018 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11019 
      oprot.writeI64(self.orderId)
11020 
      oprot.writeFieldEnd()
11021 
    oprot.writeFieldStop()
11022 
    oprot.writeStructEnd()
11023 
 
3431 rajveer 11024 
  def validate(self):
11025 
    return
11026 
 
11027 
 
2536 chandransh 11028 
  def __repr__(self):
11029 
    L = ['%s=%r' % (key, value)
11030 
      for key, value in self.__dict__.iteritems()]
11031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11032 
 
11033 
  def __eq__(self, other):
11034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11035 
 
11036 
  def __ne__(self, other):
11037 
    return not (self == other)
11038 
 
11039 
class toggleDOAFlag_result:
11040 
  """
11041 
  Attributes:
11042 
   - success
11043 
   - ex
11044 
  """
11045 
 
11046 
  thrift_spec = (
11047 
    (0, TType.BOOL, 'success', None, None, ), # 0
11048 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11049 
  )
11050 
 
11051 
  def __init__(self, success=None, ex=None,):
11052 
    self.success = success
11053 
    self.ex = ex
11054 
 
11055 
  def read(self, iprot):
11056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11058 
      return
11059 
    iprot.readStructBegin()
11060 
    while True:
11061 
      (fname, ftype, fid) = iprot.readFieldBegin()
11062 
      if ftype == TType.STOP:
11063 
        break
11064 
      if fid == 0:
11065 
        if ftype == TType.BOOL:
11066 
          self.success = iprot.readBool();
11067 
        else:
11068 
          iprot.skip(ftype)
11069 
      elif fid == 1:
11070 
        if ftype == TType.STRUCT:
11071 
          self.ex = TransactionServiceException()
11072 
          self.ex.read(iprot)
11073 
        else:
11074 
          iprot.skip(ftype)
11075 
      else:
11076 
        iprot.skip(ftype)
11077 
      iprot.readFieldEnd()
11078 
    iprot.readStructEnd()
11079 
 
11080 
  def write(self, oprot):
11081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11083 
      return
11084 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 11085 
    if self.success is not None:
2536 chandransh 11086 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11087 
      oprot.writeBool(self.success)
11088 
      oprot.writeFieldEnd()
3431 rajveer 11089 
    if self.ex is not None:
2536 chandransh 11090 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11091 
      self.ex.write(oprot)
11092 
      oprot.writeFieldEnd()
11093 
    oprot.writeFieldStop()
11094 
    oprot.writeStructEnd()
11095 
 
3431 rajveer 11096 
  def validate(self):
11097 
    return
11098 
 
11099 
 
2536 chandransh 11100 
  def __repr__(self):
11101 
    L = ['%s=%r' % (key, value)
11102 
      for key, value in self.__dict__.iteritems()]
11103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11104 
 
11105 
  def __eq__(self, other):
11106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11107 
 
11108 
  def __ne__(self, other):
11109 
    return not (self == other)
11110 
 
4454 rajveer 11111 
class markOrderDoaRequestReceived_args:
11112 
  """
11113 
  Attributes:
11114 
   - orderId
11115 
  """
11116 
 
11117 
  thrift_spec = (
11118 
    None, # 0
11119 
    (1, TType.I64, 'orderId', None, None, ), # 1
11120 
  )
11121 
 
11122 
  def __init__(self, orderId=None,):
11123 
    self.orderId = orderId
11124 
 
11125 
  def read(self, iprot):
11126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11128 
      return
11129 
    iprot.readStructBegin()
11130 
    while True:
11131 
      (fname, ftype, fid) = iprot.readFieldBegin()
11132 
      if ftype == TType.STOP:
11133 
        break
11134 
      if fid == 1:
11135 
        if ftype == TType.I64:
11136 
          self.orderId = iprot.readI64();
11137 
        else:
11138 
          iprot.skip(ftype)
11139 
      else:
11140 
        iprot.skip(ftype)
11141 
      iprot.readFieldEnd()
11142 
    iprot.readStructEnd()
11143 
 
11144 
  def write(self, oprot):
11145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11147 
      return
11148 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
11149 
    if self.orderId is not None:
11150 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11151 
      oprot.writeI64(self.orderId)
11152 
      oprot.writeFieldEnd()
11153 
    oprot.writeFieldStop()
11154 
    oprot.writeStructEnd()
11155 
 
11156 
  def validate(self):
11157 
    return
11158 
 
11159 
 
11160 
  def __repr__(self):
11161 
    L = ['%s=%r' % (key, value)
11162 
      for key, value in self.__dict__.iteritems()]
11163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11164 
 
11165 
  def __eq__(self, other):
11166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11167 
 
11168 
  def __ne__(self, other):
11169 
    return not (self == other)
11170 
 
11171 
class markOrderDoaRequestReceived_result:
11172 
  """
11173 
  Attributes:
11174 
   - success
11175 
   - ex
11176 
  """
11177 
 
11178 
  thrift_spec = (
11179 
    (0, TType.BOOL, 'success', None, None, ), # 0
11180 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11181 
  )
11182 
 
11183 
  def __init__(self, success=None, ex=None,):
11184 
    self.success = success
11185 
    self.ex = ex
11186 
 
11187 
  def read(self, iprot):
11188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11190 
      return
11191 
    iprot.readStructBegin()
11192 
    while True:
11193 
      (fname, ftype, fid) = iprot.readFieldBegin()
11194 
      if ftype == TType.STOP:
11195 
        break
11196 
      if fid == 0:
11197 
        if ftype == TType.BOOL:
11198 
          self.success = iprot.readBool();
11199 
        else:
11200 
          iprot.skip(ftype)
11201 
      elif fid == 1:
11202 
        if ftype == TType.STRUCT:
11203 
          self.ex = TransactionServiceException()
11204 
          self.ex.read(iprot)
11205 
        else:
11206 
          iprot.skip(ftype)
11207 
      else:
11208 
        iprot.skip(ftype)
11209 
      iprot.readFieldEnd()
11210 
    iprot.readStructEnd()
11211 
 
11212 
  def write(self, oprot):
11213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11215 
      return
11216 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
11217 
    if self.success is not None:
11218 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11219 
      oprot.writeBool(self.success)
11220 
      oprot.writeFieldEnd()
11221 
    if self.ex is not None:
11222 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11223 
      self.ex.write(oprot)
11224 
      oprot.writeFieldEnd()
11225 
    oprot.writeFieldStop()
11226 
    oprot.writeStructEnd()
11227 
 
11228 
  def validate(self):
11229 
    return
11230 
 
11231 
 
11232 
  def __repr__(self):
11233 
    L = ['%s=%r' % (key, value)
11234 
      for key, value in self.__dict__.iteritems()]
11235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11236 
 
11237 
  def __eq__(self, other):
11238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11239 
 
11240 
  def __ne__(self, other):
11241 
    return not (self == other)
11242 
 
11243 
class markOrderDoaRequestAuthorized_args:
11244 
  """
11245 
  Attributes:
11246 
   - orderId
11247 
   - isAuthorized
11248 
  """
11249 
 
11250 
  thrift_spec = (
11251 
    None, # 0
11252 
    (1, TType.I64, 'orderId', None, None, ), # 1
11253 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11254 
  )
11255 
 
11256 
  def __init__(self, orderId=None, isAuthorized=None,):
11257 
    self.orderId = orderId
11258 
    self.isAuthorized = isAuthorized
11259 
 
11260 
  def read(self, iprot):
11261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11263 
      return
11264 
    iprot.readStructBegin()
11265 
    while True:
11266 
      (fname, ftype, fid) = iprot.readFieldBegin()
11267 
      if ftype == TType.STOP:
11268 
        break
11269 
      if fid == 1:
11270 
        if ftype == TType.I64:
11271 
          self.orderId = iprot.readI64();
11272 
        else:
11273 
          iprot.skip(ftype)
11274 
      elif fid == 2:
11275 
        if ftype == TType.BOOL:
11276 
          self.isAuthorized = iprot.readBool();
11277 
        else:
11278 
          iprot.skip(ftype)
11279 
      else:
11280 
        iprot.skip(ftype)
11281 
      iprot.readFieldEnd()
11282 
    iprot.readStructEnd()
11283 
 
11284 
  def write(self, oprot):
11285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11287 
      return
11288 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
11289 
    if self.orderId is not None:
11290 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11291 
      oprot.writeI64(self.orderId)
11292 
      oprot.writeFieldEnd()
11293 
    if self.isAuthorized is not None:
11294 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11295 
      oprot.writeBool(self.isAuthorized)
11296 
      oprot.writeFieldEnd()
11297 
    oprot.writeFieldStop()
11298 
    oprot.writeStructEnd()
11299 
 
11300 
  def validate(self):
11301 
    return
11302 
 
11303 
 
11304 
  def __repr__(self):
11305 
    L = ['%s=%r' % (key, value)
11306 
      for key, value in self.__dict__.iteritems()]
11307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11308 
 
11309 
  def __eq__(self, other):
11310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11311 
 
11312 
  def __ne__(self, other):
11313 
    return not (self == other)
11314 
 
11315 
class markOrderDoaRequestAuthorized_result:
11316 
  """
11317 
  Attributes:
11318 
   - success
11319 
   - ex
11320 
  """
11321 
 
11322 
  thrift_spec = (
11323 
    (0, TType.BOOL, 'success', None, None, ), # 0
11324 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11325 
  )
11326 
 
11327 
  def __init__(self, success=None, ex=None,):
11328 
    self.success = success
11329 
    self.ex = ex
11330 
 
11331 
  def read(self, iprot):
11332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11334 
      return
11335 
    iprot.readStructBegin()
11336 
    while True:
11337 
      (fname, ftype, fid) = iprot.readFieldBegin()
11338 
      if ftype == TType.STOP:
11339 
        break
11340 
      if fid == 0:
11341 
        if ftype == TType.BOOL:
11342 
          self.success = iprot.readBool();
11343 
        else:
11344 
          iprot.skip(ftype)
11345 
      elif fid == 1:
11346 
        if ftype == TType.STRUCT:
11347 
          self.ex = TransactionServiceException()
11348 
          self.ex.read(iprot)
11349 
        else:
11350 
          iprot.skip(ftype)
11351 
      else:
11352 
        iprot.skip(ftype)
11353 
      iprot.readFieldEnd()
11354 
    iprot.readStructEnd()
11355 
 
11356 
  def write(self, oprot):
11357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11359 
      return
11360 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
11361 
    if self.success is not None:
11362 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11363 
      oprot.writeBool(self.success)
11364 
      oprot.writeFieldEnd()
11365 
    if self.ex is not None:
11366 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11367 
      self.ex.write(oprot)
11368 
      oprot.writeFieldEnd()
11369 
    oprot.writeFieldStop()
11370 
    oprot.writeStructEnd()
11371 
 
11372 
  def validate(self):
11373 
    return
11374 
 
11375 
 
11376 
  def __repr__(self):
11377 
    L = ['%s=%r' % (key, value)
11378 
      for key, value in self.__dict__.iteritems()]
11379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11380 
 
11381 
  def __eq__(self, other):
11382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11383 
 
11384 
  def __ne__(self, other):
11385 
    return not (self == other)
11386 
 
4488 rajveer 11387 
class markOrderReturnRequestReceived_args:
11388 
  """
11389 
  Attributes:
11390 
   - orderId
11391 
  """
11392 
 
11393 
  thrift_spec = (
11394 
    None, # 0
11395 
    (1, TType.I64, 'orderId', None, None, ), # 1
11396 
  )
11397 
 
11398 
  def __init__(self, orderId=None,):
11399 
    self.orderId = orderId
11400 
 
11401 
  def read(self, iprot):
11402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11404 
      return
11405 
    iprot.readStructBegin()
11406 
    while True:
11407 
      (fname, ftype, fid) = iprot.readFieldBegin()
11408 
      if ftype == TType.STOP:
11409 
        break
11410 
      if fid == 1:
11411 
        if ftype == TType.I64:
11412 
          self.orderId = iprot.readI64();
11413 
        else:
11414 
          iprot.skip(ftype)
11415 
      else:
11416 
        iprot.skip(ftype)
11417 
      iprot.readFieldEnd()
11418 
    iprot.readStructEnd()
11419 
 
11420 
  def write(self, oprot):
11421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11423 
      return
11424 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
11425 
    if self.orderId is not None:
11426 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11427 
      oprot.writeI64(self.orderId)
11428 
      oprot.writeFieldEnd()
11429 
    oprot.writeFieldStop()
11430 
    oprot.writeStructEnd()
11431 
 
11432 
  def validate(self):
11433 
    return
11434 
 
11435 
 
11436 
  def __repr__(self):
11437 
    L = ['%s=%r' % (key, value)
11438 
      for key, value in self.__dict__.iteritems()]
11439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11440 
 
11441 
  def __eq__(self, other):
11442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11443 
 
11444 
  def __ne__(self, other):
11445 
    return not (self == other)
11446 
 
11447 
class markOrderReturnRequestReceived_result:
11448 
  """
11449 
  Attributes:
11450 
   - success
11451 
   - ex
11452 
  """
11453 
 
11454 
  thrift_spec = (
11455 
    (0, TType.BOOL, 'success', None, None, ), # 0
11456 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11457 
  )
11458 
 
11459 
  def __init__(self, success=None, ex=None,):
11460 
    self.success = success
11461 
    self.ex = ex
11462 
 
11463 
  def read(self, iprot):
11464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11466 
      return
11467 
    iprot.readStructBegin()
11468 
    while True:
11469 
      (fname, ftype, fid) = iprot.readFieldBegin()
11470 
      if ftype == TType.STOP:
11471 
        break
11472 
      if fid == 0:
11473 
        if ftype == TType.BOOL:
11474 
          self.success = iprot.readBool();
11475 
        else:
11476 
          iprot.skip(ftype)
11477 
      elif fid == 1:
11478 
        if ftype == TType.STRUCT:
11479 
          self.ex = TransactionServiceException()
11480 
          self.ex.read(iprot)
11481 
        else:
11482 
          iprot.skip(ftype)
11483 
      else:
11484 
        iprot.skip(ftype)
11485 
      iprot.readFieldEnd()
11486 
    iprot.readStructEnd()
11487 
 
11488 
  def write(self, oprot):
11489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11491 
      return
11492 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
11493 
    if self.success is not None:
11494 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11495 
      oprot.writeBool(self.success)
11496 
      oprot.writeFieldEnd()
11497 
    if self.ex is not None:
11498 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11499 
      self.ex.write(oprot)
11500 
      oprot.writeFieldEnd()
11501 
    oprot.writeFieldStop()
11502 
    oprot.writeStructEnd()
11503 
 
11504 
  def validate(self):
11505 
    return
11506 
 
11507 
 
11508 
  def __repr__(self):
11509 
    L = ['%s=%r' % (key, value)
11510 
      for key, value in self.__dict__.iteritems()]
11511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11512 
 
11513 
  def __eq__(self, other):
11514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11515 
 
11516 
  def __ne__(self, other):
11517 
    return not (self == other)
11518 
 
11519 
class markOrderReturnRequestAuthorized_args:
11520 
  """
11521 
  Attributes:
11522 
   - orderId
11523 
   - isAuthorized
11524 
  """
11525 
 
11526 
  thrift_spec = (
11527 
    None, # 0
11528 
    (1, TType.I64, 'orderId', None, None, ), # 1
11529 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11530 
  )
11531 
 
11532 
  def __init__(self, orderId=None, isAuthorized=None,):
11533 
    self.orderId = orderId
11534 
    self.isAuthorized = isAuthorized
11535 
 
11536 
  def read(self, iprot):
11537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11539 
      return
11540 
    iprot.readStructBegin()
11541 
    while True:
11542 
      (fname, ftype, fid) = iprot.readFieldBegin()
11543 
      if ftype == TType.STOP:
11544 
        break
11545 
      if fid == 1:
11546 
        if ftype == TType.I64:
11547 
          self.orderId = iprot.readI64();
11548 
        else:
11549 
          iprot.skip(ftype)
11550 
      elif fid == 2:
11551 
        if ftype == TType.BOOL:
11552 
          self.isAuthorized = iprot.readBool();
11553 
        else:
11554 
          iprot.skip(ftype)
11555 
      else:
11556 
        iprot.skip(ftype)
11557 
      iprot.readFieldEnd()
11558 
    iprot.readStructEnd()
11559 
 
11560 
  def write(self, oprot):
11561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11563 
      return
11564 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
11565 
    if self.orderId is not None:
11566 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11567 
      oprot.writeI64(self.orderId)
11568 
      oprot.writeFieldEnd()
11569 
    if self.isAuthorized is not None:
11570 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11571 
      oprot.writeBool(self.isAuthorized)
11572 
      oprot.writeFieldEnd()
11573 
    oprot.writeFieldStop()
11574 
    oprot.writeStructEnd()
11575 
 
11576 
  def validate(self):
11577 
    return
11578 
 
11579 
 
11580 
  def __repr__(self):
11581 
    L = ['%s=%r' % (key, value)
11582 
      for key, value in self.__dict__.iteritems()]
11583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11584 
 
11585 
  def __eq__(self, other):
11586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11587 
 
11588 
  def __ne__(self, other):
11589 
    return not (self == other)
11590 
 
11591 
class markOrderReturnRequestAuthorized_result:
11592 
  """
11593 
  Attributes:
11594 
   - success
11595 
   - ex
11596 
  """
11597 
 
11598 
  thrift_spec = (
11599 
    (0, TType.BOOL, 'success', None, None, ), # 0
11600 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11601 
  )
11602 
 
11603 
  def __init__(self, success=None, ex=None,):
11604 
    self.success = success
11605 
    self.ex = ex
11606 
 
11607 
  def read(self, iprot):
11608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11610 
      return
11611 
    iprot.readStructBegin()
11612 
    while True:
11613 
      (fname, ftype, fid) = iprot.readFieldBegin()
11614 
      if ftype == TType.STOP:
11615 
        break
11616 
      if fid == 0:
11617 
        if ftype == TType.BOOL:
11618 
          self.success = iprot.readBool();
11619 
        else:
11620 
          iprot.skip(ftype)
11621 
      elif fid == 1:
11622 
        if ftype == TType.STRUCT:
11623 
          self.ex = TransactionServiceException()
11624 
          self.ex.read(iprot)
11625 
        else:
11626 
          iprot.skip(ftype)
11627 
      else:
11628 
        iprot.skip(ftype)
11629 
      iprot.readFieldEnd()
11630 
    iprot.readStructEnd()
11631 
 
11632 
  def write(self, oprot):
11633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11635 
      return
11636 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
11637 
    if self.success is not None:
11638 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11639 
      oprot.writeBool(self.success)
11640 
      oprot.writeFieldEnd()
11641 
    if self.ex is not None:
11642 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11643 
      self.ex.write(oprot)
11644 
      oprot.writeFieldEnd()
11645 
    oprot.writeFieldStop()
11646 
    oprot.writeStructEnd()
11647 
 
11648 
  def validate(self):
11649 
    return
11650 
 
11651 
 
11652 
  def __repr__(self):
11653 
    L = ['%s=%r' % (key, value)
11654 
      for key, value in self.__dict__.iteritems()]
11655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11656 
 
11657 
  def __eq__(self, other):
11658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11659 
 
11660 
  def __ne__(self, other):
11661 
    return not (self == other)
11662 
 
2536 chandransh 11663 
class requestPickupNumber_args:
11664 
  """
11665 
  Attributes:
11666 
   - orderId
4579 rajveer 11667 
   - providerId
2536 chandransh 11668 
  """
11669 
 
11670 
  thrift_spec = (
11671 
    None, # 0
11672 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 11673 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 11674 
  )
11675 
 
4579 rajveer 11676 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 11677 
    self.orderId = orderId
4579 rajveer 11678 
    self.providerId = providerId
2536 chandransh 11679 
 
11680 
  def read(self, iprot):
11681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11683 
      return
11684 
    iprot.readStructBegin()
11685 
    while True:
11686 
      (fname, ftype, fid) = iprot.readFieldBegin()
11687 
      if ftype == TType.STOP:
11688 
        break
11689 
      if fid == 1:
11690 
        if ftype == TType.I64:
11691 
          self.orderId = iprot.readI64();
11692 
        else:
11693 
          iprot.skip(ftype)
4579 rajveer 11694 
      elif fid == 2:
11695 
        if ftype == TType.I64:
11696 
          self.providerId = iprot.readI64();
11697 
        else:
11698 
          iprot.skip(ftype)
2536 chandransh 11699 
      else:
11700 
        iprot.skip(ftype)
11701 
      iprot.readFieldEnd()
11702 
    iprot.readStructEnd()
11703 
 
11704 
  def write(self, oprot):
11705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11707 
      return
11708 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 11709 
    if self.orderId is not None:
2536 chandransh 11710 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11711 
      oprot.writeI64(self.orderId)
11712 
      oprot.writeFieldEnd()
4579 rajveer 11713 
    if self.providerId is not None:
11714 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
11715 
      oprot.writeI64(self.providerId)
11716 
      oprot.writeFieldEnd()
2536 chandransh 11717 
    oprot.writeFieldStop()
11718 
    oprot.writeStructEnd()
11719 
 
3431 rajveer 11720 
  def validate(self):
11721 
    return
11722 
 
11723 
 
2536 chandransh 11724 
  def __repr__(self):
11725 
    L = ['%s=%r' % (key, value)
11726 
      for key, value in self.__dict__.iteritems()]
11727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11728 
 
11729 
  def __eq__(self, other):
11730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11731 
 
11732 
  def __ne__(self, other):
11733 
    return not (self == other)
11734 
 
11735 
class requestPickupNumber_result:
11736 
  """
11737 
  Attributes:
11738 
   - success
11739 
   - ex
11740 
  """
11741 
 
11742 
  thrift_spec = (
11743 
    (0, TType.BOOL, 'success', None, None, ), # 0
11744 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11745 
  )
11746 
 
11747 
  def __init__(self, success=None, ex=None,):
11748 
    self.success = success
11749 
    self.ex = ex
11750 
 
11751 
  def read(self, iprot):
11752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11754 
      return
11755 
    iprot.readStructBegin()
11756 
    while True:
11757 
      (fname, ftype, fid) = iprot.readFieldBegin()
11758 
      if ftype == TType.STOP:
11759 
        break
11760 
      if fid == 0:
11761 
        if ftype == TType.BOOL:
11762 
          self.success = iprot.readBool();
11763 
        else:
11764 
          iprot.skip(ftype)
11765 
      elif fid == 1:
11766 
        if ftype == TType.STRUCT:
11767 
          self.ex = TransactionServiceException()
11768 
          self.ex.read(iprot)
11769 
        else:
11770 
          iprot.skip(ftype)
11771 
      else:
11772 
        iprot.skip(ftype)
11773 
      iprot.readFieldEnd()
11774 
    iprot.readStructEnd()
11775 
 
11776 
  def write(self, oprot):
11777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11779 
      return
11780 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 11781 
    if self.success is not None:
2536 chandransh 11782 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11783 
      oprot.writeBool(self.success)
11784 
      oprot.writeFieldEnd()
3431 rajveer 11785 
    if self.ex is not None:
2536 chandransh 11786 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11787 
      self.ex.write(oprot)
11788 
      oprot.writeFieldEnd()
11789 
    oprot.writeFieldStop()
11790 
    oprot.writeStructEnd()
11791 
 
3431 rajveer 11792 
  def validate(self):
11793 
    return
11794 
 
11795 
 
2536 chandransh 11796 
  def __repr__(self):
11797 
    L = ['%s=%r' % (key, value)
11798 
      for key, value in self.__dict__.iteritems()]
11799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11800 
 
11801 
  def __eq__(self, other):
11802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11803 
 
11804 
  def __ne__(self, other):
11805 
    return not (self == other)
11806 
 
11807 
class authorizePickup_args:
11808 
  """
11809 
  Attributes:
11810 
   - orderId
11811 
   - pickupNumber
11812 
  """
11813 
 
11814 
  thrift_spec = (
11815 
    None, # 0
11816 
    (1, TType.I64, 'orderId', None, None, ), # 1
11817 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
11818 
  )
11819 
 
11820 
  def __init__(self, orderId=None, pickupNumber=None,):
11821 
    self.orderId = orderId
11822 
    self.pickupNumber = pickupNumber
11823 
 
11824 
  def read(self, iprot):
11825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11827 
      return
11828 
    iprot.readStructBegin()
11829 
    while True:
11830 
      (fname, ftype, fid) = iprot.readFieldBegin()
11831 
      if ftype == TType.STOP:
11832 
        break
11833 
      if fid == 1:
11834 
        if ftype == TType.I64:
11835 
          self.orderId = iprot.readI64();
11836 
        else:
11837 
          iprot.skip(ftype)
11838 
      elif fid == 2:
11839 
        if ftype == TType.STRING:
11840 
          self.pickupNumber = iprot.readString();
11841 
        else:
11842 
          iprot.skip(ftype)
11843 
      else:
11844 
        iprot.skip(ftype)
11845 
      iprot.readFieldEnd()
11846 
    iprot.readStructEnd()
11847 
 
11848 
  def write(self, oprot):
11849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11851 
      return
11852 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 11853 
    if self.orderId is not None:
2536 chandransh 11854 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11855 
      oprot.writeI64(self.orderId)
11856 
      oprot.writeFieldEnd()
3431 rajveer 11857 
    if self.pickupNumber is not None:
2536 chandransh 11858 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
11859 
      oprot.writeString(self.pickupNumber)
11860 
      oprot.writeFieldEnd()
11861 
    oprot.writeFieldStop()
11862 
    oprot.writeStructEnd()
11863 
 
3431 rajveer 11864 
  def validate(self):
11865 
    return
11866 
 
11867 
 
2536 chandransh 11868 
  def __repr__(self):
11869 
    L = ['%s=%r' % (key, value)
11870 
      for key, value in self.__dict__.iteritems()]
11871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11872 
 
11873 
  def __eq__(self, other):
11874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11875 
 
11876 
  def __ne__(self, other):
11877 
    return not (self == other)
11878 
 
11879 
class authorizePickup_result:
11880 
  """
11881 
  Attributes:
11882 
   - success
11883 
   - ex
11884 
  """
11885 
 
11886 
  thrift_spec = (
11887 
    (0, TType.BOOL, 'success', None, None, ), # 0
11888 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11889 
  )
11890 
 
11891 
  def __init__(self, success=None, ex=None,):
11892 
    self.success = success
11893 
    self.ex = ex
11894 
 
11895 
  def read(self, iprot):
11896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11898 
      return
11899 
    iprot.readStructBegin()
11900 
    while True:
11901 
      (fname, ftype, fid) = iprot.readFieldBegin()
11902 
      if ftype == TType.STOP:
11903 
        break
11904 
      if fid == 0:
11905 
        if ftype == TType.BOOL:
11906 
          self.success = iprot.readBool();
11907 
        else:
11908 
          iprot.skip(ftype)
11909 
      elif fid == 1:
11910 
        if ftype == TType.STRUCT:
11911 
          self.ex = TransactionServiceException()
11912 
          self.ex.read(iprot)
11913 
        else:
11914 
          iprot.skip(ftype)
11915 
      else:
11916 
        iprot.skip(ftype)
11917 
      iprot.readFieldEnd()
11918 
    iprot.readStructEnd()
11919 
 
11920 
  def write(self, oprot):
11921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11923 
      return
11924 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 11925 
    if self.success is not None:
2536 chandransh 11926 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11927 
      oprot.writeBool(self.success)
11928 
      oprot.writeFieldEnd()
3431 rajveer 11929 
    if self.ex is not None:
2536 chandransh 11930 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11931 
      self.ex.write(oprot)
11932 
      oprot.writeFieldEnd()
11933 
    oprot.writeFieldStop()
11934 
    oprot.writeStructEnd()
11935 
 
3431 rajveer 11936 
  def validate(self):
11937 
    return
11938 
 
11939 
 
2536 chandransh 11940 
  def __repr__(self):
11941 
    L = ['%s=%r' % (key, value)
11942 
      for key, value in self.__dict__.iteritems()]
11943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11944 
 
11945 
  def __eq__(self, other):
11946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11947 
 
11948 
  def __ne__(self, other):
11949 
    return not (self == other)
11950 
 
2764 chandransh 11951 
class markDoasAsPickedUp_args:
11952 
  """
11953 
  Attributes:
11954 
   - providerId
11955 
   - pickupDetails
11956 
  """
11957 
 
11958 
  thrift_spec = (
11959 
    None, # 0
11960 
    (1, TType.I64, 'providerId', None, None, ), # 1
11961 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
11962 
  )
11963 
 
11964 
  def __init__(self, providerId=None, pickupDetails=None,):
11965 
    self.providerId = providerId
11966 
    self.pickupDetails = pickupDetails
11967 
 
11968 
  def read(self, iprot):
11969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11971 
      return
11972 
    iprot.readStructBegin()
11973 
    while True:
11974 
      (fname, ftype, fid) = iprot.readFieldBegin()
11975 
      if ftype == TType.STOP:
11976 
        break
11977 
      if fid == 1:
11978 
        if ftype == TType.I64:
11979 
          self.providerId = iprot.readI64();
11980 
        else:
11981 
          iprot.skip(ftype)
11982 
      elif fid == 2:
11983 
        if ftype == TType.MAP:
11984 
          self.pickupDetails = {}
4581 phani.kuma 11985 
          (_ktype198, _vtype199, _size197 ) = iprot.readMapBegin()
11986 
          for _i201 in xrange(_size197):
11987 
            _key202 = iprot.readString();
11988 
            _val203 = iprot.readString();
11989 
            self.pickupDetails[_key202] = _val203
2764 chandransh 11990 
          iprot.readMapEnd()
11991 
        else:
11992 
          iprot.skip(ftype)
11993 
      else:
11994 
        iprot.skip(ftype)
11995 
      iprot.readFieldEnd()
11996 
    iprot.readStructEnd()
11997 
 
11998 
  def write(self, oprot):
11999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12001 
      return
12002 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 12003 
    if self.providerId is not None:
2764 chandransh 12004 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12005 
      oprot.writeI64(self.providerId)
12006 
      oprot.writeFieldEnd()
3431 rajveer 12007 
    if self.pickupDetails is not None:
2764 chandransh 12008 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12009 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4581 phani.kuma 12010 
      for kiter204,viter205 in self.pickupDetails.items():
12011 
        oprot.writeString(kiter204)
12012 
        oprot.writeString(viter205)
2764 chandransh 12013 
      oprot.writeMapEnd()
12014 
      oprot.writeFieldEnd()
12015 
    oprot.writeFieldStop()
12016 
    oprot.writeStructEnd()
12017 
 
3431 rajveer 12018 
  def validate(self):
12019 
    return
12020 
 
12021 
 
2764 chandransh 12022 
  def __repr__(self):
12023 
    L = ['%s=%r' % (key, value)
12024 
      for key, value in self.__dict__.iteritems()]
12025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12026 
 
12027 
  def __eq__(self, other):
12028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12029 
 
12030 
  def __ne__(self, other):
12031 
    return not (self == other)
12032 
 
12033 
class markDoasAsPickedUp_result:
12034 
  """
12035 
  Attributes:
12036 
   - success
12037 
  """
12038 
 
12039 
  thrift_spec = (
12040 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12041 
  )
12042 
 
12043 
  def __init__(self, success=None,):
12044 
    self.success = success
12045 
 
12046 
  def read(self, iprot):
12047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12049 
      return
12050 
    iprot.readStructBegin()
12051 
    while True:
12052 
      (fname, ftype, fid) = iprot.readFieldBegin()
12053 
      if ftype == TType.STOP:
12054 
        break
12055 
      if fid == 0:
12056 
        if ftype == TType.LIST:
12057 
          self.success = []
4581 phani.kuma 12058 
          (_etype209, _size206) = iprot.readListBegin()
12059 
          for _i210 in xrange(_size206):
12060 
            _elem211 = Order()
12061 
            _elem211.read(iprot)
12062 
            self.success.append(_elem211)
2764 chandransh 12063 
          iprot.readListEnd()
12064 
        else:
12065 
          iprot.skip(ftype)
12066 
      else:
12067 
        iprot.skip(ftype)
12068 
      iprot.readFieldEnd()
12069 
    iprot.readStructEnd()
12070 
 
12071 
  def write(self, oprot):
12072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12074 
      return
12075 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 12076 
    if self.success is not None:
2764 chandransh 12077 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12078 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 12079 
      for iter212 in self.success:
12080 
        iter212.write(oprot)
2764 chandransh 12081 
      oprot.writeListEnd()
12082 
      oprot.writeFieldEnd()
12083 
    oprot.writeFieldStop()
12084 
    oprot.writeStructEnd()
12085 
 
3431 rajveer 12086 
  def validate(self):
12087 
    return
12088 
 
12089 
 
2764 chandransh 12090 
  def __repr__(self):
12091 
    L = ['%s=%r' % (key, value)
12092 
      for key, value in self.__dict__.iteritems()]
12093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12094 
 
12095 
  def __eq__(self, other):
12096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12097 
 
12098 
  def __ne__(self, other):
12099 
    return not (self == other)
12100 
 
2616 chandransh 12101 
class receiveReturn_args:
2591 chandransh 12102 
  """
12103 
  Attributes:
12104 
   - orderId
4479 rajveer 12105 
   - receiveCondition
2591 chandransh 12106 
  """
2536 chandransh 12107 
 
2591 chandransh 12108 
  thrift_spec = (
12109 
    None, # 0
12110 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 12111 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 12112 
  )
12113 
 
4479 rajveer 12114 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 12115 
    self.orderId = orderId
4479 rajveer 12116 
    self.receiveCondition = receiveCondition
2591 chandransh 12117 
 
12118 
  def read(self, iprot):
12119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12121 
      return
12122 
    iprot.readStructBegin()
12123 
    while True:
12124 
      (fname, ftype, fid) = iprot.readFieldBegin()
12125 
      if ftype == TType.STOP:
12126 
        break
12127 
      if fid == 1:
12128 
        if ftype == TType.I64:
12129 
          self.orderId = iprot.readI64();
12130 
        else:
12131 
          iprot.skip(ftype)
4479 rajveer 12132 
      elif fid == 2:
12133 
        if ftype == TType.I64:
12134 
          self.receiveCondition = iprot.readI64();
12135 
        else:
12136 
          iprot.skip(ftype)
2591 chandransh 12137 
      else:
12138 
        iprot.skip(ftype)
12139 
      iprot.readFieldEnd()
12140 
    iprot.readStructEnd()
12141 
 
12142 
  def write(self, oprot):
12143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12145 
      return
2616 chandransh 12146 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 12147 
    if self.orderId is not None:
2591 chandransh 12148 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12149 
      oprot.writeI64(self.orderId)
12150 
      oprot.writeFieldEnd()
4479 rajveer 12151 
    if self.receiveCondition is not None:
12152 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
12153 
      oprot.writeI64(self.receiveCondition)
12154 
      oprot.writeFieldEnd()
2591 chandransh 12155 
    oprot.writeFieldStop()
12156 
    oprot.writeStructEnd()
12157 
 
3431 rajveer 12158 
  def validate(self):
12159 
    return
12160 
 
12161 
 
2591 chandransh 12162 
  def __repr__(self):
12163 
    L = ['%s=%r' % (key, value)
12164 
      for key, value in self.__dict__.iteritems()]
12165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12166 
 
12167 
  def __eq__(self, other):
12168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12169 
 
12170 
  def __ne__(self, other):
12171 
    return not (self == other)
12172 
 
2616 chandransh 12173 
class receiveReturn_result:
2591 chandransh 12174 
  """
12175 
  Attributes:
12176 
   - success
12177 
   - ex
12178 
  """
12179 
 
12180 
  thrift_spec = (
12181 
    (0, TType.BOOL, 'success', None, None, ), # 0
12182 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12183 
  )
12184 
 
12185 
  def __init__(self, success=None, ex=None,):
12186 
    self.success = success
12187 
    self.ex = ex
12188 
 
12189 
  def read(self, iprot):
12190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12192 
      return
12193 
    iprot.readStructBegin()
12194 
    while True:
12195 
      (fname, ftype, fid) = iprot.readFieldBegin()
12196 
      if ftype == TType.STOP:
12197 
        break
12198 
      if fid == 0:
12199 
        if ftype == TType.BOOL:
12200 
          self.success = iprot.readBool();
12201 
        else:
12202 
          iprot.skip(ftype)
12203 
      elif fid == 1:
12204 
        if ftype == TType.STRUCT:
12205 
          self.ex = TransactionServiceException()
12206 
          self.ex.read(iprot)
12207 
        else:
12208 
          iprot.skip(ftype)
12209 
      else:
12210 
        iprot.skip(ftype)
12211 
      iprot.readFieldEnd()
12212 
    iprot.readStructEnd()
12213 
 
12214 
  def write(self, oprot):
12215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12217 
      return
2616 chandransh 12218 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 12219 
    if self.success is not None:
2591 chandransh 12220 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12221 
      oprot.writeBool(self.success)
12222 
      oprot.writeFieldEnd()
3431 rajveer 12223 
    if self.ex is not None:
2591 chandransh 12224 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12225 
      self.ex.write(oprot)
12226 
      oprot.writeFieldEnd()
12227 
    oprot.writeFieldStop()
12228 
    oprot.writeStructEnd()
12229 
 
3431 rajveer 12230 
  def validate(self):
12231 
    return
12232 
 
12233 
 
2591 chandransh 12234 
  def __repr__(self):
12235 
    L = ['%s=%r' % (key, value)
12236 
      for key, value in self.__dict__.iteritems()]
12237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12238 
 
12239 
  def __eq__(self, other):
12240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12241 
 
12242 
  def __ne__(self, other):
12243 
    return not (self == other)
12244 
 
12245 
class validateDoa_args:
12246 
  """
12247 
  Attributes:
12248 
   - orderId
12249 
   - isValid
12250 
  """
12251 
 
12252 
  thrift_spec = (
12253 
    None, # 0
12254 
    (1, TType.I64, 'orderId', None, None, ), # 1
12255 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
12256 
  )
12257 
 
12258 
  def __init__(self, orderId=None, isValid=None,):
12259 
    self.orderId = orderId
12260 
    self.isValid = isValid
12261 
 
12262 
  def read(self, iprot):
12263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12265 
      return
12266 
    iprot.readStructBegin()
12267 
    while True:
12268 
      (fname, ftype, fid) = iprot.readFieldBegin()
12269 
      if ftype == TType.STOP:
12270 
        break
12271 
      if fid == 1:
12272 
        if ftype == TType.I64:
12273 
          self.orderId = iprot.readI64();
12274 
        else:
12275 
          iprot.skip(ftype)
12276 
      elif fid == 2:
12277 
        if ftype == TType.BOOL:
12278 
          self.isValid = iprot.readBool();
12279 
        else:
12280 
          iprot.skip(ftype)
12281 
      else:
12282 
        iprot.skip(ftype)
12283 
      iprot.readFieldEnd()
12284 
    iprot.readStructEnd()
12285 
 
12286 
  def write(self, oprot):
12287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12289 
      return
12290 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 12291 
    if self.orderId is not None:
2591 chandransh 12292 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12293 
      oprot.writeI64(self.orderId)
12294 
      oprot.writeFieldEnd()
3431 rajveer 12295 
    if self.isValid is not None:
2591 chandransh 12296 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
12297 
      oprot.writeBool(self.isValid)
12298 
      oprot.writeFieldEnd()
12299 
    oprot.writeFieldStop()
12300 
    oprot.writeStructEnd()
12301 
 
3431 rajveer 12302 
  def validate(self):
12303 
    return
12304 
 
12305 
 
2591 chandransh 12306 
  def __repr__(self):
12307 
    L = ['%s=%r' % (key, value)
12308 
      for key, value in self.__dict__.iteritems()]
12309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12310 
 
12311 
  def __eq__(self, other):
12312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12313 
 
12314 
  def __ne__(self, other):
12315 
    return not (self == other)
12316 
 
12317 
class validateDoa_result:
12318 
  """
12319 
  Attributes:
12320 
   - success
12321 
   - ex
12322 
  """
12323 
 
12324 
  thrift_spec = (
12325 
    (0, TType.BOOL, 'success', None, None, ), # 0
12326 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12327 
  )
12328 
 
12329 
  def __init__(self, success=None, ex=None,):
12330 
    self.success = success
12331 
    self.ex = ex
12332 
 
12333 
  def read(self, iprot):
12334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12336 
      return
12337 
    iprot.readStructBegin()
12338 
    while True:
12339 
      (fname, ftype, fid) = iprot.readFieldBegin()
12340 
      if ftype == TType.STOP:
12341 
        break
12342 
      if fid == 0:
12343 
        if ftype == TType.BOOL:
12344 
          self.success = iprot.readBool();
12345 
        else:
12346 
          iprot.skip(ftype)
12347 
      elif fid == 1:
12348 
        if ftype == TType.STRUCT:
12349 
          self.ex = TransactionServiceException()
12350 
          self.ex.read(iprot)
12351 
        else:
12352 
          iprot.skip(ftype)
12353 
      else:
12354 
        iprot.skip(ftype)
12355 
      iprot.readFieldEnd()
12356 
    iprot.readStructEnd()
12357 
 
12358 
  def write(self, oprot):
12359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12361 
      return
12362 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 12363 
    if self.success is not None:
2591 chandransh 12364 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12365 
      oprot.writeBool(self.success)
12366 
      oprot.writeFieldEnd()
3431 rajveer 12367 
    if self.ex is not None:
2591 chandransh 12368 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12369 
      self.ex.write(oprot)
12370 
      oprot.writeFieldEnd()
12371 
    oprot.writeFieldStop()
12372 
    oprot.writeStructEnd()
12373 
 
3431 rajveer 12374 
  def validate(self):
12375 
    return
12376 
 
12377 
 
2591 chandransh 12378 
  def __repr__(self):
12379 
    L = ['%s=%r' % (key, value)
12380 
      for key, value in self.__dict__.iteritems()]
12381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12382 
 
12383 
  def __eq__(self, other):
12384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12385 
 
12386 
  def __ne__(self, other):
12387 
    return not (self == other)
12388 
 
4495 rajveer 12389 
class validateReturnProduct_args:
12390 
  """
12391 
  Attributes:
12392 
   - orderId
12393 
   - isUsable
12394 
  """
12395 
 
12396 
  thrift_spec = (
12397 
    None, # 0
12398 
    (1, TType.I64, 'orderId', None, None, ), # 1
12399 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
12400 
  )
12401 
 
12402 
  def __init__(self, orderId=None, isUsable=None,):
12403 
    self.orderId = orderId
12404 
    self.isUsable = isUsable
12405 
 
12406 
  def read(self, iprot):
12407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12409 
      return
12410 
    iprot.readStructBegin()
12411 
    while True:
12412 
      (fname, ftype, fid) = iprot.readFieldBegin()
12413 
      if ftype == TType.STOP:
12414 
        break
12415 
      if fid == 1:
12416 
        if ftype == TType.I64:
12417 
          self.orderId = iprot.readI64();
12418 
        else:
12419 
          iprot.skip(ftype)
12420 
      elif fid == 2:
12421 
        if ftype == TType.BOOL:
12422 
          self.isUsable = iprot.readBool();
12423 
        else:
12424 
          iprot.skip(ftype)
12425 
      else:
12426 
        iprot.skip(ftype)
12427 
      iprot.readFieldEnd()
12428 
    iprot.readStructEnd()
12429 
 
12430 
  def write(self, oprot):
12431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12433 
      return
12434 
    oprot.writeStructBegin('validateReturnProduct_args')
12435 
    if self.orderId is not None:
12436 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12437 
      oprot.writeI64(self.orderId)
12438 
      oprot.writeFieldEnd()
12439 
    if self.isUsable is not None:
12440 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
12441 
      oprot.writeBool(self.isUsable)
12442 
      oprot.writeFieldEnd()
12443 
    oprot.writeFieldStop()
12444 
    oprot.writeStructEnd()
12445 
 
12446 
  def validate(self):
12447 
    return
12448 
 
12449 
 
12450 
  def __repr__(self):
12451 
    L = ['%s=%r' % (key, value)
12452 
      for key, value in self.__dict__.iteritems()]
12453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12454 
 
12455 
  def __eq__(self, other):
12456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12457 
 
12458 
  def __ne__(self, other):
12459 
    return not (self == other)
12460 
 
12461 
class validateReturnProduct_result:
12462 
  """
12463 
  Attributes:
12464 
   - success
12465 
   - ex
12466 
  """
12467 
 
12468 
  thrift_spec = (
12469 
    (0, TType.BOOL, 'success', None, None, ), # 0
12470 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12471 
  )
12472 
 
12473 
  def __init__(self, success=None, ex=None,):
12474 
    self.success = success
12475 
    self.ex = ex
12476 
 
12477 
  def read(self, iprot):
12478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12480 
      return
12481 
    iprot.readStructBegin()
12482 
    while True:
12483 
      (fname, ftype, fid) = iprot.readFieldBegin()
12484 
      if ftype == TType.STOP:
12485 
        break
12486 
      if fid == 0:
12487 
        if ftype == TType.BOOL:
12488 
          self.success = iprot.readBool();
12489 
        else:
12490 
          iprot.skip(ftype)
12491 
      elif fid == 1:
12492 
        if ftype == TType.STRUCT:
12493 
          self.ex = TransactionServiceException()
12494 
          self.ex.read(iprot)
12495 
        else:
12496 
          iprot.skip(ftype)
12497 
      else:
12498 
        iprot.skip(ftype)
12499 
      iprot.readFieldEnd()
12500 
    iprot.readStructEnd()
12501 
 
12502 
  def write(self, oprot):
12503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12505 
      return
12506 
    oprot.writeStructBegin('validateReturnProduct_result')
12507 
    if self.success is not None:
12508 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12509 
      oprot.writeBool(self.success)
12510 
      oprot.writeFieldEnd()
12511 
    if self.ex is not None:
12512 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12513 
      self.ex.write(oprot)
12514 
      oprot.writeFieldEnd()
12515 
    oprot.writeFieldStop()
12516 
    oprot.writeStructEnd()
12517 
 
12518 
  def validate(self):
12519 
    return
12520 
 
12521 
 
12522 
  def __repr__(self):
12523 
    L = ['%s=%r' % (key, value)
12524 
      for key, value in self.__dict__.iteritems()]
12525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12526 
 
12527 
  def __eq__(self, other):
12528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12529 
 
12530 
  def __ne__(self, other):
12531 
    return not (self == other)
12532 
 
2616 chandransh 12533 
class reshipOrder_args:
12534 
  """
12535 
  Attributes:
12536 
   - orderId
12537 
  """
2591 chandransh 12538 
 
2616 chandransh 12539 
  thrift_spec = (
12540 
    None, # 0
12541 
    (1, TType.I64, 'orderId', None, None, ), # 1
12542 
  )
12543 
 
12544 
  def __init__(self, orderId=None,):
12545 
    self.orderId = orderId
12546 
 
12547 
  def read(self, iprot):
12548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12550 
      return
12551 
    iprot.readStructBegin()
12552 
    while True:
12553 
      (fname, ftype, fid) = iprot.readFieldBegin()
12554 
      if ftype == TType.STOP:
12555 
        break
12556 
      if fid == 1:
12557 
        if ftype == TType.I64:
12558 
          self.orderId = iprot.readI64();
12559 
        else:
12560 
          iprot.skip(ftype)
12561 
      else:
12562 
        iprot.skip(ftype)
12563 
      iprot.readFieldEnd()
12564 
    iprot.readStructEnd()
12565 
 
12566 
  def write(self, oprot):
12567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12569 
      return
12570 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 12571 
    if self.orderId is not None:
2616 chandransh 12572 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12573 
      oprot.writeI64(self.orderId)
12574 
      oprot.writeFieldEnd()
12575 
    oprot.writeFieldStop()
12576 
    oprot.writeStructEnd()
12577 
 
3431 rajveer 12578 
  def validate(self):
12579 
    return
12580 
 
12581 
 
2616 chandransh 12582 
  def __repr__(self):
12583 
    L = ['%s=%r' % (key, value)
12584 
      for key, value in self.__dict__.iteritems()]
12585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12586 
 
12587 
  def __eq__(self, other):
12588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12589 
 
12590 
  def __ne__(self, other):
12591 
    return not (self == other)
12592 
 
12593 
class reshipOrder_result:
12594 
  """
12595 
  Attributes:
12596 
   - success
12597 
   - ex
12598 
  """
12599 
 
12600 
  thrift_spec = (
12601 
    (0, TType.I64, 'success', None, None, ), # 0
12602 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12603 
  )
12604 
 
12605 
  def __init__(self, success=None, ex=None,):
12606 
    self.success = success
12607 
    self.ex = ex
12608 
 
12609 
  def read(self, iprot):
12610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12612 
      return
12613 
    iprot.readStructBegin()
12614 
    while True:
12615 
      (fname, ftype, fid) = iprot.readFieldBegin()
12616 
      if ftype == TType.STOP:
12617 
        break
12618 
      if fid == 0:
12619 
        if ftype == TType.I64:
12620 
          self.success = iprot.readI64();
12621 
        else:
12622 
          iprot.skip(ftype)
12623 
      elif fid == 1:
12624 
        if ftype == TType.STRUCT:
12625 
          self.ex = TransactionServiceException()
12626 
          self.ex.read(iprot)
12627 
        else:
12628 
          iprot.skip(ftype)
12629 
      else:
12630 
        iprot.skip(ftype)
12631 
      iprot.readFieldEnd()
12632 
    iprot.readStructEnd()
12633 
 
12634 
  def write(self, oprot):
12635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12637 
      return
12638 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 12639 
    if self.success is not None:
2616 chandransh 12640 
      oprot.writeFieldBegin('success', TType.I64, 0)
12641 
      oprot.writeI64(self.success)
12642 
      oprot.writeFieldEnd()
3431 rajveer 12643 
    if self.ex is not None:
2616 chandransh 12644 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12645 
      self.ex.write(oprot)
12646 
      oprot.writeFieldEnd()
12647 
    oprot.writeFieldStop()
12648 
    oprot.writeStructEnd()
12649 
 
3431 rajveer 12650 
  def validate(self):
12651 
    return
12652 
 
12653 
 
2616 chandransh 12654 
  def __repr__(self):
12655 
    L = ['%s=%r' % (key, value)
12656 
      for key, value in self.__dict__.iteritems()]
12657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12658 
 
12659 
  def __eq__(self, other):
12660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12661 
 
12662 
  def __ne__(self, other):
12663 
    return not (self == other)
12664 
 
12665 
class refundOrder_args:
12666 
  """
12667 
  Attributes:
12668 
   - orderId
3226 chandransh 12669 
   - refundedBy
12670 
   - reason
2616 chandransh 12671 
  """
12672 
 
12673 
  thrift_spec = (
12674 
    None, # 0
12675 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 12676 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
12677 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 12678 
  )
12679 
 
3226 chandransh 12680 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 12681 
    self.orderId = orderId
3226 chandransh 12682 
    self.refundedBy = refundedBy
12683 
    self.reason = reason
2616 chandransh 12684 
 
12685 
  def read(self, iprot):
12686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12688 
      return
12689 
    iprot.readStructBegin()
12690 
    while True:
12691 
      (fname, ftype, fid) = iprot.readFieldBegin()
12692 
      if ftype == TType.STOP:
12693 
        break
12694 
      if fid == 1:
12695 
        if ftype == TType.I64:
12696 
          self.orderId = iprot.readI64();
12697 
        else:
12698 
          iprot.skip(ftype)
3226 chandransh 12699 
      elif fid == 2:
12700 
        if ftype == TType.STRING:
12701 
          self.refundedBy = iprot.readString();
12702 
        else:
12703 
          iprot.skip(ftype)
12704 
      elif fid == 3:
12705 
        if ftype == TType.STRING:
12706 
          self.reason = iprot.readString();
12707 
        else:
12708 
          iprot.skip(ftype)
2616 chandransh 12709 
      else:
12710 
        iprot.skip(ftype)
12711 
      iprot.readFieldEnd()
12712 
    iprot.readStructEnd()
12713 
 
12714 
  def write(self, oprot):
12715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12717 
      return
12718 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 12719 
    if self.orderId is not None:
2616 chandransh 12720 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12721 
      oprot.writeI64(self.orderId)
12722 
      oprot.writeFieldEnd()
3431 rajveer 12723 
    if self.refundedBy is not None:
3226 chandransh 12724 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
12725 
      oprot.writeString(self.refundedBy)
12726 
      oprot.writeFieldEnd()
3431 rajveer 12727 
    if self.reason is not None:
3226 chandransh 12728 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
12729 
      oprot.writeString(self.reason)
12730 
      oprot.writeFieldEnd()
2616 chandransh 12731 
    oprot.writeFieldStop()
12732 
    oprot.writeStructEnd()
12733 
 
3431 rajveer 12734 
  def validate(self):
12735 
    return
12736 
 
12737 
 
2616 chandransh 12738 
  def __repr__(self):
12739 
    L = ['%s=%r' % (key, value)
12740 
      for key, value in self.__dict__.iteritems()]
12741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12742 
 
12743 
  def __eq__(self, other):
12744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12745 
 
12746 
  def __ne__(self, other):
12747 
    return not (self == other)
12748 
 
12749 
class refundOrder_result:
12750 
  """
12751 
  Attributes:
12752 
   - success
12753 
   - ex
12754 
  """
12755 
 
12756 
  thrift_spec = (
12757 
    (0, TType.BOOL, 'success', None, None, ), # 0
12758 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12759 
  )
12760 
 
12761 
  def __init__(self, success=None, ex=None,):
12762 
    self.success = success
12763 
    self.ex = ex
12764 
 
12765 
  def read(self, iprot):
12766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12768 
      return
12769 
    iprot.readStructBegin()
12770 
    while True:
12771 
      (fname, ftype, fid) = iprot.readFieldBegin()
12772 
      if ftype == TType.STOP:
12773 
        break
12774 
      if fid == 0:
12775 
        if ftype == TType.BOOL:
12776 
          self.success = iprot.readBool();
12777 
        else:
12778 
          iprot.skip(ftype)
12779 
      elif fid == 1:
12780 
        if ftype == TType.STRUCT:
12781 
          self.ex = TransactionServiceException()
12782 
          self.ex.read(iprot)
12783 
        else:
12784 
          iprot.skip(ftype)
12785 
      else:
12786 
        iprot.skip(ftype)
12787 
      iprot.readFieldEnd()
12788 
    iprot.readStructEnd()
12789 
 
12790 
  def write(self, oprot):
12791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12793 
      return
12794 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 12795 
    if self.success is not None:
2616 chandransh 12796 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12797 
      oprot.writeBool(self.success)
12798 
      oprot.writeFieldEnd()
3431 rajveer 12799 
    if self.ex is not None:
2616 chandransh 12800 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12801 
      self.ex.write(oprot)
12802 
      oprot.writeFieldEnd()
12803 
    oprot.writeFieldStop()
12804 
    oprot.writeStructEnd()
12805 
 
3431 rajveer 12806 
  def validate(self):
12807 
    return
12808 
 
12809 
 
2616 chandransh 12810 
  def __repr__(self):
12811 
    L = ['%s=%r' % (key, value)
12812 
      for key, value in self.__dict__.iteritems()]
12813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12814 
 
12815 
  def __eq__(self, other):
12816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12817 
 
12818 
  def __ne__(self, other):
12819 
    return not (self == other)
12820 
 
2690 chandransh 12821 
class getReturnOrders_args:
12822 
  """
12823 
  Attributes:
12824 
   - warehouseId
12825 
   - fromDate
12826 
   - toDate
12827 
  """
2616 chandransh 12828 
 
2690 chandransh 12829 
  thrift_spec = (
12830 
    None, # 0
12831 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12832 
    (2, TType.I64, 'fromDate', None, None, ), # 2
12833 
    (3, TType.I64, 'toDate', None, None, ), # 3
12834 
  )
12835 
 
12836 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
12837 
    self.warehouseId = warehouseId
12838 
    self.fromDate = fromDate
12839 
    self.toDate = toDate
12840 
 
12841 
  def read(self, iprot):
12842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12844 
      return
12845 
    iprot.readStructBegin()
12846 
    while True:
12847 
      (fname, ftype, fid) = iprot.readFieldBegin()
12848 
      if ftype == TType.STOP:
12849 
        break
12850 
      if fid == 1:
12851 
        if ftype == TType.I64:
12852 
          self.warehouseId = iprot.readI64();
12853 
        else:
12854 
          iprot.skip(ftype)
12855 
      elif fid == 2:
12856 
        if ftype == TType.I64:
12857 
          self.fromDate = iprot.readI64();
12858 
        else:
12859 
          iprot.skip(ftype)
12860 
      elif fid == 3:
12861 
        if ftype == TType.I64:
12862 
          self.toDate = iprot.readI64();
12863 
        else:
12864 
          iprot.skip(ftype)
12865 
      else:
12866 
        iprot.skip(ftype)
12867 
      iprot.readFieldEnd()
12868 
    iprot.readStructEnd()
12869 
 
12870 
  def write(self, oprot):
12871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12873 
      return
12874 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 12875 
    if self.warehouseId is not None:
2690 chandransh 12876 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12877 
      oprot.writeI64(self.warehouseId)
12878 
      oprot.writeFieldEnd()
3431 rajveer 12879 
    if self.fromDate is not None:
2690 chandransh 12880 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
12881 
      oprot.writeI64(self.fromDate)
12882 
      oprot.writeFieldEnd()
3431 rajveer 12883 
    if self.toDate is not None:
2690 chandransh 12884 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
12885 
      oprot.writeI64(self.toDate)
12886 
      oprot.writeFieldEnd()
12887 
    oprot.writeFieldStop()
12888 
    oprot.writeStructEnd()
12889 
 
3431 rajveer 12890 
  def validate(self):
12891 
    return
12892 
 
12893 
 
2690 chandransh 12894 
  def __repr__(self):
12895 
    L = ['%s=%r' % (key, value)
12896 
      for key, value in self.__dict__.iteritems()]
12897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12898 
 
12899 
  def __eq__(self, other):
12900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12901 
 
12902 
  def __ne__(self, other):
12903 
    return not (self == other)
12904 
 
12905 
class getReturnOrders_result:
12906 
  """
12907 
  Attributes:
12908 
   - success
12909 
  """
12910 
 
12911 
  thrift_spec = (
12912 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
12913 
  )
12914 
 
12915 
  def __init__(self, success=None,):
12916 
    self.success = success
12917 
 
12918 
  def read(self, iprot):
12919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12921 
      return
12922 
    iprot.readStructBegin()
12923 
    while True:
12924 
      (fname, ftype, fid) = iprot.readFieldBegin()
12925 
      if ftype == TType.STOP:
12926 
        break
12927 
      if fid == 0:
12928 
        if ftype == TType.LIST:
12929 
          self.success = []
4581 phani.kuma 12930 
          (_etype216, _size213) = iprot.readListBegin()
12931 
          for _i217 in xrange(_size213):
12932 
            _elem218 = ReturnOrder()
12933 
            _elem218.read(iprot)
12934 
            self.success.append(_elem218)
2690 chandransh 12935 
          iprot.readListEnd()
12936 
        else:
12937 
          iprot.skip(ftype)
12938 
      else:
12939 
        iprot.skip(ftype)
12940 
      iprot.readFieldEnd()
12941 
    iprot.readStructEnd()
12942 
 
12943 
  def write(self, oprot):
12944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12946 
      return
12947 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 12948 
    if self.success is not None:
2690 chandransh 12949 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12950 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 12951 
      for iter219 in self.success:
12952 
        iter219.write(oprot)
2690 chandransh 12953 
      oprot.writeListEnd()
12954 
      oprot.writeFieldEnd()
12955 
    oprot.writeFieldStop()
12956 
    oprot.writeStructEnd()
12957 
 
3431 rajveer 12958 
  def validate(self):
12959 
    return
12960 
 
12961 
 
2690 chandransh 12962 
  def __repr__(self):
12963 
    L = ['%s=%r' % (key, value)
12964 
      for key, value in self.__dict__.iteritems()]
12965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12966 
 
12967 
  def __eq__(self, other):
12968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12969 
 
12970 
  def __ne__(self, other):
12971 
    return not (self == other)
12972 
 
2700 chandransh 12973 
class getReturnOrder_args:
12974 
  """
12975 
  Attributes:
12976 
   - id
12977 
  """
12978 
 
12979 
  thrift_spec = (
12980 
    None, # 0
12981 
    (1, TType.I64, 'id', None, None, ), # 1
12982 
  )
12983 
 
12984 
  def __init__(self, id=None,):
12985 
    self.id = id
12986 
 
12987 
  def read(self, iprot):
12988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12990 
      return
12991 
    iprot.readStructBegin()
12992 
    while True:
12993 
      (fname, ftype, fid) = iprot.readFieldBegin()
12994 
      if ftype == TType.STOP:
12995 
        break
12996 
      if fid == 1:
12997 
        if ftype == TType.I64:
12998 
          self.id = iprot.readI64();
12999 
        else:
13000 
          iprot.skip(ftype)
13001 
      else:
13002 
        iprot.skip(ftype)
13003 
      iprot.readFieldEnd()
13004 
    iprot.readStructEnd()
13005 
 
13006 
  def write(self, oprot):
13007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13009 
      return
13010 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 13011 
    if self.id is not None:
2700 chandransh 13012 
      oprot.writeFieldBegin('id', TType.I64, 1)
13013 
      oprot.writeI64(self.id)
13014 
      oprot.writeFieldEnd()
13015 
    oprot.writeFieldStop()
13016 
    oprot.writeStructEnd()
13017 
 
3431 rajveer 13018 
  def validate(self):
13019 
    return
13020 
 
13021 
 
2700 chandransh 13022 
  def __repr__(self):
13023 
    L = ['%s=%r' % (key, value)
13024 
      for key, value in self.__dict__.iteritems()]
13025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13026 
 
13027 
  def __eq__(self, other):
13028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13029 
 
13030 
  def __ne__(self, other):
13031 
    return not (self == other)
13032 
 
13033 
class getReturnOrder_result:
13034 
  """
13035 
  Attributes:
13036 
   - success
13037 
   - ex
13038 
  """
13039 
 
13040 
  thrift_spec = (
13041 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
13042 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13043 
  )
13044 
 
13045 
  def __init__(self, success=None, ex=None,):
13046 
    self.success = success
13047 
    self.ex = ex
13048 
 
13049 
  def read(self, iprot):
13050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13052 
      return
13053 
    iprot.readStructBegin()
13054 
    while True:
13055 
      (fname, ftype, fid) = iprot.readFieldBegin()
13056 
      if ftype == TType.STOP:
13057 
        break
13058 
      if fid == 0:
13059 
        if ftype == TType.STRUCT:
13060 
          self.success = ReturnOrder()
13061 
          self.success.read(iprot)
13062 
        else:
13063 
          iprot.skip(ftype)
13064 
      elif fid == 1:
13065 
        if ftype == TType.STRUCT:
13066 
          self.ex = TransactionServiceException()
13067 
          self.ex.read(iprot)
13068 
        else:
13069 
          iprot.skip(ftype)
13070 
      else:
13071 
        iprot.skip(ftype)
13072 
      iprot.readFieldEnd()
13073 
    iprot.readStructEnd()
13074 
 
13075 
  def write(self, oprot):
13076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13078 
      return
13079 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 13080 
    if self.success is not None:
2700 chandransh 13081 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13082 
      self.success.write(oprot)
13083 
      oprot.writeFieldEnd()
3431 rajveer 13084 
    if self.ex is not None:
2700 chandransh 13085 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13086 
      self.ex.write(oprot)
13087 
      oprot.writeFieldEnd()
13088 
    oprot.writeFieldStop()
13089 
    oprot.writeStructEnd()
13090 
 
3431 rajveer 13091 
  def validate(self):
13092 
    return
13093 
 
13094 
 
2700 chandransh 13095 
  def __repr__(self):
13096 
    L = ['%s=%r' % (key, value)
13097 
      for key, value in self.__dict__.iteritems()]
13098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13099 
 
13100 
  def __eq__(self, other):
13101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13102 
 
13103 
  def __ne__(self, other):
13104 
    return not (self == other)
13105 
 
2690 chandransh 13106 
class processReturn_args:
13107 
  """
13108 
  Attributes:
13109 
   - returnOrderId
13110 
  """
13111 
 
13112 
  thrift_spec = (
13113 
    None, # 0
13114 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
13115 
  )
13116 
 
13117 
  def __init__(self, returnOrderId=None,):
13118 
    self.returnOrderId = returnOrderId
13119 
 
13120 
  def read(self, iprot):
13121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13123 
      return
13124 
    iprot.readStructBegin()
13125 
    while True:
13126 
      (fname, ftype, fid) = iprot.readFieldBegin()
13127 
      if ftype == TType.STOP:
13128 
        break
13129 
      if fid == 1:
13130 
        if ftype == TType.I64:
13131 
          self.returnOrderId = iprot.readI64();
13132 
        else:
13133 
          iprot.skip(ftype)
13134 
      else:
13135 
        iprot.skip(ftype)
13136 
      iprot.readFieldEnd()
13137 
    iprot.readStructEnd()
13138 
 
13139 
  def write(self, oprot):
13140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13142 
      return
13143 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 13144 
    if self.returnOrderId is not None:
2690 chandransh 13145 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
13146 
      oprot.writeI64(self.returnOrderId)
13147 
      oprot.writeFieldEnd()
13148 
    oprot.writeFieldStop()
13149 
    oprot.writeStructEnd()
13150 
 
3431 rajveer 13151 
  def validate(self):
13152 
    return
13153 
 
13154 
 
2690 chandransh 13155 
  def __repr__(self):
13156 
    L = ['%s=%r' % (key, value)
13157 
      for key, value in self.__dict__.iteritems()]
13158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13159 
 
13160 
  def __eq__(self, other):
13161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13162 
 
13163 
  def __ne__(self, other):
13164 
    return not (self == other)
13165 
 
13166 
class processReturn_result:
13167 
  """
13168 
  Attributes:
13169 
   - ex
13170 
  """
13171 
 
13172 
  thrift_spec = (
13173 
    None, # 0
13174 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13175 
  )
13176 
 
13177 
  def __init__(self, ex=None,):
13178 
    self.ex = ex
13179 
 
13180 
  def read(self, iprot):
13181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13183 
      return
13184 
    iprot.readStructBegin()
13185 
    while True:
13186 
      (fname, ftype, fid) = iprot.readFieldBegin()
13187 
      if ftype == TType.STOP:
13188 
        break
13189 
      if fid == 1:
13190 
        if ftype == TType.STRUCT:
13191 
          self.ex = TransactionServiceException()
13192 
          self.ex.read(iprot)
13193 
        else:
13194 
          iprot.skip(ftype)
13195 
      else:
13196 
        iprot.skip(ftype)
13197 
      iprot.readFieldEnd()
13198 
    iprot.readStructEnd()
13199 
 
13200 
  def write(self, oprot):
13201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13203 
      return
13204 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 13205 
    if self.ex is not None:
2690 chandransh 13206 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13207 
      self.ex.write(oprot)
13208 
      oprot.writeFieldEnd()
13209 
    oprot.writeFieldStop()
13210 
    oprot.writeStructEnd()
13211 
 
3431 rajveer 13212 
  def validate(self):
13213 
    return
13214 
 
13215 
 
2690 chandransh 13216 
  def __repr__(self):
13217 
    L = ['%s=%r' % (key, value)
13218 
      for key, value in self.__dict__.iteritems()]
13219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13220 
 
13221 
  def __eq__(self, other):
13222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13223 
 
13224 
  def __ne__(self, other):
13225 
    return not (self == other)
13226 
 
2819 chandransh 13227 
class createPurchaseOrder_args:
13228 
  """
13229 
  Attributes:
13230 
   - warehouseId
13231 
  """
2690 chandransh 13232 
 
2819 chandransh 13233 
  thrift_spec = (
13234 
    None, # 0
13235 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13236 
  )
13237 
 
13238 
  def __init__(self, warehouseId=None,):
13239 
    self.warehouseId = warehouseId
13240 
 
13241 
  def read(self, iprot):
13242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13244 
      return
13245 
    iprot.readStructBegin()
13246 
    while True:
13247 
      (fname, ftype, fid) = iprot.readFieldBegin()
13248 
      if ftype == TType.STOP:
13249 
        break
13250 
      if fid == 1:
13251 
        if ftype == TType.I64:
13252 
          self.warehouseId = iprot.readI64();
13253 
        else:
13254 
          iprot.skip(ftype)
13255 
      else:
13256 
        iprot.skip(ftype)
13257 
      iprot.readFieldEnd()
13258 
    iprot.readStructEnd()
13259 
 
13260 
  def write(self, oprot):
13261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13263 
      return
13264 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 13265 
    if self.warehouseId is not None:
2819 chandransh 13266 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13267 
      oprot.writeI64(self.warehouseId)
13268 
      oprot.writeFieldEnd()
13269 
    oprot.writeFieldStop()
13270 
    oprot.writeStructEnd()
13271 
 
3431 rajveer 13272 
  def validate(self):
13273 
    return
13274 
 
13275 
 
2819 chandransh 13276 
  def __repr__(self):
13277 
    L = ['%s=%r' % (key, value)
13278 
      for key, value in self.__dict__.iteritems()]
13279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13280 
 
13281 
  def __eq__(self, other):
13282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13283 
 
13284 
  def __ne__(self, other):
13285 
    return not (self == other)
13286 
 
13287 
class createPurchaseOrder_result:
13288 
  """
13289 
  Attributes:
13290 
   - success
13291 
   - ex
13292 
  """
13293 
 
13294 
  thrift_spec = (
13295 
    (0, TType.I64, 'success', None, None, ), # 0
13296 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13297 
  )
13298 
 
13299 
  def __init__(self, success=None, ex=None,):
13300 
    self.success = success
13301 
    self.ex = ex
13302 
 
13303 
  def read(self, iprot):
13304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13306 
      return
13307 
    iprot.readStructBegin()
13308 
    while True:
13309 
      (fname, ftype, fid) = iprot.readFieldBegin()
13310 
      if ftype == TType.STOP:
13311 
        break
13312 
      if fid == 0:
13313 
        if ftype == TType.I64:
13314 
          self.success = iprot.readI64();
13315 
        else:
13316 
          iprot.skip(ftype)
13317 
      elif fid == 1:
13318 
        if ftype == TType.STRUCT:
13319 
          self.ex = TransactionServiceException()
13320 
          self.ex.read(iprot)
13321 
        else:
13322 
          iprot.skip(ftype)
13323 
      else:
13324 
        iprot.skip(ftype)
13325 
      iprot.readFieldEnd()
13326 
    iprot.readStructEnd()
13327 
 
13328 
  def write(self, oprot):
13329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13331 
      return
13332 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 13333 
    if self.success is not None:
2819 chandransh 13334 
      oprot.writeFieldBegin('success', TType.I64, 0)
13335 
      oprot.writeI64(self.success)
13336 
      oprot.writeFieldEnd()
3431 rajveer 13337 
    if self.ex is not None:
2819 chandransh 13338 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13339 
      self.ex.write(oprot)
13340 
      oprot.writeFieldEnd()
13341 
    oprot.writeFieldStop()
13342 
    oprot.writeStructEnd()
13343 
 
3431 rajveer 13344 
  def validate(self):
13345 
    return
13346 
 
13347 
 
2819 chandransh 13348 
  def __repr__(self):
13349 
    L = ['%s=%r' % (key, value)
13350 
      for key, value in self.__dict__.iteritems()]
13351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13352 
 
13353 
  def __eq__(self, other):
13354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13355 
 
13356 
  def __ne__(self, other):
13357 
    return not (self == other)
3451 chandransh 13358 
 
13359 
class updateWeight_args:
13360 
  """
13361 
  Attributes:
13362 
   - orderId
13363 
   - weight
13364 
  """
13365 
 
13366 
  thrift_spec = (
13367 
    None, # 0
13368 
    (1, TType.I64, 'orderId', None, None, ), # 1
13369 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
13370 
  )
13371 
 
13372 
  def __init__(self, orderId=None, weight=None,):
13373 
    self.orderId = orderId
13374 
    self.weight = weight
13375 
 
13376 
  def read(self, iprot):
13377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13379 
      return
13380 
    iprot.readStructBegin()
13381 
    while True:
13382 
      (fname, ftype, fid) = iprot.readFieldBegin()
13383 
      if ftype == TType.STOP:
13384 
        break
13385 
      if fid == 1:
13386 
        if ftype == TType.I64:
13387 
          self.orderId = iprot.readI64();
13388 
        else:
13389 
          iprot.skip(ftype)
13390 
      elif fid == 2:
13391 
        if ftype == TType.DOUBLE:
13392 
          self.weight = iprot.readDouble();
13393 
        else:
13394 
          iprot.skip(ftype)
13395 
      else:
13396 
        iprot.skip(ftype)
13397 
      iprot.readFieldEnd()
13398 
    iprot.readStructEnd()
13399 
 
13400 
  def write(self, oprot):
13401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13403 
      return
13404 
    oprot.writeStructBegin('updateWeight_args')
13405 
    if self.orderId is not None:
13406 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13407 
      oprot.writeI64(self.orderId)
13408 
      oprot.writeFieldEnd()
13409 
    if self.weight is not None:
13410 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
13411 
      oprot.writeDouble(self.weight)
13412 
      oprot.writeFieldEnd()
13413 
    oprot.writeFieldStop()
13414 
    oprot.writeStructEnd()
13415 
 
13416 
  def validate(self):
13417 
    return
13418 
 
13419 
 
13420 
  def __repr__(self):
13421 
    L = ['%s=%r' % (key, value)
13422 
      for key, value in self.__dict__.iteritems()]
13423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13424 
 
13425 
  def __eq__(self, other):
13426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13427 
 
13428 
  def __ne__(self, other):
13429 
    return not (self == other)
13430 
 
13431 
class updateWeight_result:
13432 
  """
13433 
  Attributes:
13434 
   - success
13435 
   - ex
13436 
  """
13437 
 
13438 
  thrift_spec = (
13439 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13440 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13441 
  )
13442 
 
13443 
  def __init__(self, success=None, ex=None,):
13444 
    self.success = success
13445 
    self.ex = ex
13446 
 
13447 
  def read(self, iprot):
13448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13450 
      return
13451 
    iprot.readStructBegin()
13452 
    while True:
13453 
      (fname, ftype, fid) = iprot.readFieldBegin()
13454 
      if ftype == TType.STOP:
13455 
        break
13456 
      if fid == 0:
13457 
        if ftype == TType.STRUCT:
13458 
          self.success = Order()
13459 
          self.success.read(iprot)
13460 
        else:
13461 
          iprot.skip(ftype)
13462 
      elif fid == 1:
13463 
        if ftype == TType.STRUCT:
13464 
          self.ex = TransactionServiceException()
13465 
          self.ex.read(iprot)
13466 
        else:
13467 
          iprot.skip(ftype)
13468 
      else:
13469 
        iprot.skip(ftype)
13470 
      iprot.readFieldEnd()
13471 
    iprot.readStructEnd()
13472 
 
13473 
  def write(self, oprot):
13474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13476 
      return
13477 
    oprot.writeStructBegin('updateWeight_result')
13478 
    if self.success is not None:
13479 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13480 
      self.success.write(oprot)
13481 
      oprot.writeFieldEnd()
13482 
    if self.ex is not None:
13483 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13484 
      self.ex.write(oprot)
13485 
      oprot.writeFieldEnd()
13486 
    oprot.writeFieldStop()
13487 
    oprot.writeStructEnd()
13488 
 
13489 
  def validate(self):
13490 
    return
13491 
 
13492 
 
13493 
  def __repr__(self):
13494 
    L = ['%s=%r' % (key, value)
13495 
      for key, value in self.__dict__.iteritems()]
13496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13497 
 
13498 
  def __eq__(self, other):
13499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13500 
 
13501 
  def __ne__(self, other):
13502 
    return not (self == other)
3469 chandransh 13503 
 
13504 
class changeItem_args:
13505 
  """
13506 
  Attributes:
13507 
   - orderId
13508 
   - itemId
13509 
  """
13510 
 
13511 
  thrift_spec = (
13512 
    None, # 0
13513 
    (1, TType.I64, 'orderId', None, None, ), # 1
13514 
    (2, TType.I64, 'itemId', None, None, ), # 2
13515 
  )
13516 
 
13517 
  def __init__(self, orderId=None, itemId=None,):
13518 
    self.orderId = orderId
13519 
    self.itemId = itemId
13520 
 
13521 
  def read(self, iprot):
13522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13524 
      return
13525 
    iprot.readStructBegin()
13526 
    while True:
13527 
      (fname, ftype, fid) = iprot.readFieldBegin()
13528 
      if ftype == TType.STOP:
13529 
        break
13530 
      if fid == 1:
13531 
        if ftype == TType.I64:
13532 
          self.orderId = iprot.readI64();
13533 
        else:
13534 
          iprot.skip(ftype)
13535 
      elif fid == 2:
13536 
        if ftype == TType.I64:
13537 
          self.itemId = iprot.readI64();
13538 
        else:
13539 
          iprot.skip(ftype)
13540 
      else:
13541 
        iprot.skip(ftype)
13542 
      iprot.readFieldEnd()
13543 
    iprot.readStructEnd()
13544 
 
13545 
  def write(self, oprot):
13546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13548 
      return
13549 
    oprot.writeStructBegin('changeItem_args')
13550 
    if self.orderId is not None:
13551 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13552 
      oprot.writeI64(self.orderId)
13553 
      oprot.writeFieldEnd()
13554 
    if self.itemId is not None:
13555 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13556 
      oprot.writeI64(self.itemId)
13557 
      oprot.writeFieldEnd()
13558 
    oprot.writeFieldStop()
13559 
    oprot.writeStructEnd()
13560 
 
13561 
  def validate(self):
13562 
    return
13563 
 
13564 
 
13565 
  def __repr__(self):
13566 
    L = ['%s=%r' % (key, value)
13567 
      for key, value in self.__dict__.iteritems()]
13568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13569 
 
13570 
  def __eq__(self, other):
13571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13572 
 
13573 
  def __ne__(self, other):
13574 
    return not (self == other)
13575 
 
13576 
class changeItem_result:
13577 
  """
13578 
  Attributes:
13579 
   - success
13580 
   - ex
13581 
  """
13582 
 
13583 
  thrift_spec = (
13584 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13585 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13586 
  )
13587 
 
13588 
  def __init__(self, success=None, ex=None,):
13589 
    self.success = success
13590 
    self.ex = ex
13591 
 
13592 
  def read(self, iprot):
13593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13595 
      return
13596 
    iprot.readStructBegin()
13597 
    while True:
13598 
      (fname, ftype, fid) = iprot.readFieldBegin()
13599 
      if ftype == TType.STOP:
13600 
        break
13601 
      if fid == 0:
13602 
        if ftype == TType.STRUCT:
13603 
          self.success = Order()
13604 
          self.success.read(iprot)
13605 
        else:
13606 
          iprot.skip(ftype)
13607 
      elif fid == 1:
13608 
        if ftype == TType.STRUCT:
13609 
          self.ex = TransactionServiceException()
13610 
          self.ex.read(iprot)
13611 
        else:
13612 
          iprot.skip(ftype)
13613 
      else:
13614 
        iprot.skip(ftype)
13615 
      iprot.readFieldEnd()
13616 
    iprot.readStructEnd()
13617 
 
13618 
  def write(self, oprot):
13619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13621 
      return
13622 
    oprot.writeStructBegin('changeItem_result')
13623 
    if self.success is not None:
13624 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13625 
      self.success.write(oprot)
13626 
      oprot.writeFieldEnd()
13627 
    if self.ex is not None:
13628 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13629 
      self.ex.write(oprot)
13630 
      oprot.writeFieldEnd()
13631 
    oprot.writeFieldStop()
13632 
    oprot.writeStructEnd()
13633 
 
13634 
  def validate(self):
13635 
    return
13636 
 
13637 
 
13638 
  def __repr__(self):
13639 
    L = ['%s=%r' % (key, value)
13640 
      for key, value in self.__dict__.iteritems()]
13641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13642 
 
13643 
  def __eq__(self, other):
13644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13645 
 
13646 
  def __ne__(self, other):
13647 
    return not (self == other)
13648 
 
13649 
class shiftToWarehouse_args:
13650 
  """
13651 
  Attributes:
13652 
   - orderId
13653 
   - warehouseId
13654 
  """
13655 
 
13656 
  thrift_spec = (
13657 
    None, # 0
13658 
    (1, TType.I64, 'orderId', None, None, ), # 1
13659 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13660 
  )
13661 
 
13662 
  def __init__(self, orderId=None, warehouseId=None,):
13663 
    self.orderId = orderId
13664 
    self.warehouseId = warehouseId
13665 
 
13666 
  def read(self, iprot):
13667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13669 
      return
13670 
    iprot.readStructBegin()
13671 
    while True:
13672 
      (fname, ftype, fid) = iprot.readFieldBegin()
13673 
      if ftype == TType.STOP:
13674 
        break
13675 
      if fid == 1:
13676 
        if ftype == TType.I64:
13677 
          self.orderId = iprot.readI64();
13678 
        else:
13679 
          iprot.skip(ftype)
13680 
      elif fid == 2:
13681 
        if ftype == TType.I64:
13682 
          self.warehouseId = iprot.readI64();
13683 
        else:
13684 
          iprot.skip(ftype)
13685 
      else:
13686 
        iprot.skip(ftype)
13687 
      iprot.readFieldEnd()
13688 
    iprot.readStructEnd()
13689 
 
13690 
  def write(self, oprot):
13691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13693 
      return
13694 
    oprot.writeStructBegin('shiftToWarehouse_args')
13695 
    if self.orderId is not None:
13696 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13697 
      oprot.writeI64(self.orderId)
13698 
      oprot.writeFieldEnd()
13699 
    if self.warehouseId is not None:
13700 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13701 
      oprot.writeI64(self.warehouseId)
13702 
      oprot.writeFieldEnd()
13703 
    oprot.writeFieldStop()
13704 
    oprot.writeStructEnd()
13705 
 
13706 
  def validate(self):
13707 
    return
13708 
 
13709 
 
13710 
  def __repr__(self):
13711 
    L = ['%s=%r' % (key, value)
13712 
      for key, value in self.__dict__.iteritems()]
13713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13714 
 
13715 
  def __eq__(self, other):
13716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13717 
 
13718 
  def __ne__(self, other):
13719 
    return not (self == other)
13720 
 
13721 
class shiftToWarehouse_result:
13722 
  """
13723 
  Attributes:
13724 
   - success
13725 
   - ex
13726 
  """
13727 
 
13728 
  thrift_spec = (
13729 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13730 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13731 
  )
13732 
 
13733 
  def __init__(self, success=None, ex=None,):
13734 
    self.success = success
13735 
    self.ex = ex
13736 
 
13737 
  def read(self, iprot):
13738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13740 
      return
13741 
    iprot.readStructBegin()
13742 
    while True:
13743 
      (fname, ftype, fid) = iprot.readFieldBegin()
13744 
      if ftype == TType.STOP:
13745 
        break
13746 
      if fid == 0:
13747 
        if ftype == TType.STRUCT:
13748 
          self.success = Order()
13749 
          self.success.read(iprot)
13750 
        else:
13751 
          iprot.skip(ftype)
13752 
      elif fid == 1:
13753 
        if ftype == TType.STRUCT:
13754 
          self.ex = TransactionServiceException()
13755 
          self.ex.read(iprot)
13756 
        else:
13757 
          iprot.skip(ftype)
13758 
      else:
13759 
        iprot.skip(ftype)
13760 
      iprot.readFieldEnd()
13761 
    iprot.readStructEnd()
13762 
 
13763 
  def write(self, oprot):
13764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13766 
      return
13767 
    oprot.writeStructBegin('shiftToWarehouse_result')
13768 
    if self.success is not None:
13769 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13770 
      self.success.write(oprot)
13771 
      oprot.writeFieldEnd()
13772 
    if self.ex is not None:
13773 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13774 
      self.ex.write(oprot)
13775 
      oprot.writeFieldEnd()
13776 
    oprot.writeFieldStop()
13777 
    oprot.writeStructEnd()
13778 
 
13779 
  def validate(self):
13780 
    return
13781 
 
13782 
 
13783 
  def __repr__(self):
13784 
    L = ['%s=%r' % (key, value)
13785 
      for key, value in self.__dict__.iteritems()]
13786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13787 
 
13788 
  def __eq__(self, other):
13789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13790 
 
13791 
  def __ne__(self, other):
13792 
    return not (self == other)
3553 chandransh 13793 
 
13794 
class addDelayReason_args:
13795 
  """
13796 
  Attributes:
13797 
   - orderId
13798 
   - delayReason
3986 chandransh 13799 
   - furtherDelay
3553 chandransh 13800 
  """
13801 
 
13802 
  thrift_spec = (
13803 
    None, # 0
13804 
    (1, TType.I64, 'orderId', None, None, ), # 1
13805 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 13806 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 13807 
  )
13808 
 
3986 chandransh 13809 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 13810 
    self.orderId = orderId
13811 
    self.delayReason = delayReason
3986 chandransh 13812 
    self.furtherDelay = furtherDelay
3553 chandransh 13813 
 
13814 
  def read(self, iprot):
13815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13817 
      return
13818 
    iprot.readStructBegin()
13819 
    while True:
13820 
      (fname, ftype, fid) = iprot.readFieldBegin()
13821 
      if ftype == TType.STOP:
13822 
        break
13823 
      if fid == 1:
13824 
        if ftype == TType.I64:
13825 
          self.orderId = iprot.readI64();
13826 
        else:
13827 
          iprot.skip(ftype)
13828 
      elif fid == 2:
13829 
        if ftype == TType.I32:
13830 
          self.delayReason = iprot.readI32();
13831 
        else:
13832 
          iprot.skip(ftype)
3986 chandransh 13833 
      elif fid == 3:
13834 
        if ftype == TType.I64:
13835 
          self.furtherDelay = iprot.readI64();
13836 
        else:
13837 
          iprot.skip(ftype)
3553 chandransh 13838 
      else:
13839 
        iprot.skip(ftype)
13840 
      iprot.readFieldEnd()
13841 
    iprot.readStructEnd()
13842 
 
13843 
  def write(self, oprot):
13844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13846 
      return
13847 
    oprot.writeStructBegin('addDelayReason_args')
13848 
    if self.orderId is not None:
13849 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13850 
      oprot.writeI64(self.orderId)
13851 
      oprot.writeFieldEnd()
13852 
    if self.delayReason is not None:
13853 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
13854 
      oprot.writeI32(self.delayReason)
13855 
      oprot.writeFieldEnd()
3986 chandransh 13856 
    if self.furtherDelay is not None:
13857 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
13858 
      oprot.writeI64(self.furtherDelay)
13859 
      oprot.writeFieldEnd()
3553 chandransh 13860 
    oprot.writeFieldStop()
13861 
    oprot.writeStructEnd()
13862 
 
13863 
  def validate(self):
13864 
    return
13865 
 
13866 
 
13867 
  def __repr__(self):
13868 
    L = ['%s=%r' % (key, value)
13869 
      for key, value in self.__dict__.iteritems()]
13870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13871 
 
13872 
  def __eq__(self, other):
13873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13874 
 
13875 
  def __ne__(self, other):
13876 
    return not (self == other)
13877 
 
13878 
class addDelayReason_result:
13879 
  """
13880 
  Attributes:
13881 
   - success
13882 
   - ex
13883 
  """
13884 
 
13885 
  thrift_spec = (
13886 
    (0, TType.BOOL, 'success', None, None, ), # 0
13887 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13888 
  )
13889 
 
13890 
  def __init__(self, success=None, ex=None,):
13891 
    self.success = success
13892 
    self.ex = ex
13893 
 
13894 
  def read(self, iprot):
13895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13897 
      return
13898 
    iprot.readStructBegin()
13899 
    while True:
13900 
      (fname, ftype, fid) = iprot.readFieldBegin()
13901 
      if ftype == TType.STOP:
13902 
        break
13903 
      if fid == 0:
13904 
        if ftype == TType.BOOL:
13905 
          self.success = iprot.readBool();
13906 
        else:
13907 
          iprot.skip(ftype)
13908 
      elif fid == 1:
13909 
        if ftype == TType.STRUCT:
13910 
          self.ex = TransactionServiceException()
13911 
          self.ex.read(iprot)
13912 
        else:
13913 
          iprot.skip(ftype)
13914 
      else:
13915 
        iprot.skip(ftype)
13916 
      iprot.readFieldEnd()
13917 
    iprot.readStructEnd()
13918 
 
13919 
  def write(self, oprot):
13920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13922 
      return
13923 
    oprot.writeStructBegin('addDelayReason_result')
13924 
    if self.success is not None:
13925 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13926 
      oprot.writeBool(self.success)
13927 
      oprot.writeFieldEnd()
13928 
    if self.ex is not None:
13929 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13930 
      self.ex.write(oprot)
13931 
      oprot.writeFieldEnd()
13932 
    oprot.writeFieldStop()
13933 
    oprot.writeStructEnd()
13934 
 
13935 
  def validate(self):
13936 
    return
13937 
 
13938 
 
13939 
  def __repr__(self):
13940 
    L = ['%s=%r' % (key, value)
13941 
      for key, value in self.__dict__.iteritems()]
13942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13943 
 
13944 
  def __eq__(self, other):
13945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13946 
 
13947 
  def __ne__(self, other):
13948 
    return not (self == other)
3956 chandransh 13949 
 
13950 
class reconcileCodCollection_args:
13951 
  """
13952 
  Attributes:
13953 
   - collectedAmountMap
13954 
   - xferBy
13955 
   - xferTxnId
13956 
   - xferDate
13957 
  """
13958 
 
13959 
  thrift_spec = (
13960 
    None, # 0
13961 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
13962 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
13963 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
13964 
    (4, TType.I64, 'xferDate', None, None, ), # 4
13965 
  )
13966 
 
13967 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
13968 
    self.collectedAmountMap = collectedAmountMap
13969 
    self.xferBy = xferBy
13970 
    self.xferTxnId = xferTxnId
13971 
    self.xferDate = xferDate
13972 
 
13973 
  def read(self, iprot):
13974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13976 
      return
13977 
    iprot.readStructBegin()
13978 
    while True:
13979 
      (fname, ftype, fid) = iprot.readFieldBegin()
13980 
      if ftype == TType.STOP:
13981 
        break
13982 
      if fid == 1:
13983 
        if ftype == TType.MAP:
13984 
          self.collectedAmountMap = {}
4581 phani.kuma 13985 
          (_ktype221, _vtype222, _size220 ) = iprot.readMapBegin()
13986 
          for _i224 in xrange(_size220):
13987 
            _key225 = iprot.readString();
13988 
            _val226 = iprot.readDouble();
13989 
            self.collectedAmountMap[_key225] = _val226
3956 chandransh 13990 
          iprot.readMapEnd()
13991 
        else:
13992 
          iprot.skip(ftype)
13993 
      elif fid == 2:
13994 
        if ftype == TType.STRING:
13995 
          self.xferBy = iprot.readString();
13996 
        else:
13997 
          iprot.skip(ftype)
13998 
      elif fid == 3:
13999 
        if ftype == TType.STRING:
14000 
          self.xferTxnId = iprot.readString();
14001 
        else:
14002 
          iprot.skip(ftype)
14003 
      elif fid == 4:
14004 
        if ftype == TType.I64:
14005 
          self.xferDate = iprot.readI64();
14006 
        else:
14007 
          iprot.skip(ftype)
14008 
      else:
14009 
        iprot.skip(ftype)
14010 
      iprot.readFieldEnd()
14011 
    iprot.readStructEnd()
14012 
 
14013 
  def write(self, oprot):
14014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14016 
      return
14017 
    oprot.writeStructBegin('reconcileCodCollection_args')
14018 
    if self.collectedAmountMap is not None:
14019 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
14020 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4581 phani.kuma 14021 
      for kiter227,viter228 in self.collectedAmountMap.items():
14022 
        oprot.writeString(kiter227)
14023 
        oprot.writeDouble(viter228)
3956 chandransh 14024 
      oprot.writeMapEnd()
14025 
      oprot.writeFieldEnd()
14026 
    if self.xferBy is not None:
14027 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
14028 
      oprot.writeString(self.xferBy)
14029 
      oprot.writeFieldEnd()
14030 
    if self.xferTxnId is not None:
14031 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
14032 
      oprot.writeString(self.xferTxnId)
14033 
      oprot.writeFieldEnd()
14034 
    if self.xferDate is not None:
14035 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
14036 
      oprot.writeI64(self.xferDate)
14037 
      oprot.writeFieldEnd()
14038 
    oprot.writeFieldStop()
14039 
    oprot.writeStructEnd()
14040 
 
14041 
  def validate(self):
14042 
    return
14043 
 
14044 
 
14045 
  def __repr__(self):
14046 
    L = ['%s=%r' % (key, value)
14047 
      for key, value in self.__dict__.iteritems()]
14048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14049 
 
14050 
  def __eq__(self, other):
14051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14052 
 
14053 
  def __ne__(self, other):
14054 
    return not (self == other)
14055 
 
14056 
class reconcileCodCollection_result:
14057 
  """
14058 
  Attributes:
14059 
   - success
14060 
   - ex
14061 
  """
14062 
 
14063 
  thrift_spec = (
14064 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
14065 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14066 
  )
14067 
 
14068 
  def __init__(self, success=None, ex=None,):
14069 
    self.success = success
14070 
    self.ex = ex
14071 
 
14072 
  def read(self, iprot):
14073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14075 
      return
14076 
    iprot.readStructBegin()
14077 
    while True:
14078 
      (fname, ftype, fid) = iprot.readFieldBegin()
14079 
      if ftype == TType.STOP:
14080 
        break
14081 
      if fid == 0:
14082 
        if ftype == TType.MAP:
14083 
          self.success = {}
4581 phani.kuma 14084 
          (_ktype230, _vtype231, _size229 ) = iprot.readMapBegin()
14085 
          for _i233 in xrange(_size229):
14086 
            _key234 = iprot.readString();
14087 
            _val235 = iprot.readString();
14088 
            self.success[_key234] = _val235
3956 chandransh 14089 
          iprot.readMapEnd()
14090 
        else:
14091 
          iprot.skip(ftype)
14092 
      elif fid == 1:
14093 
        if ftype == TType.STRUCT:
14094 
          self.ex = TransactionServiceException()
14095 
          self.ex.read(iprot)
14096 
        else:
14097 
          iprot.skip(ftype)
14098 
      else:
14099 
        iprot.skip(ftype)
14100 
      iprot.readFieldEnd()
14101 
    iprot.readStructEnd()
14102 
 
14103 
  def write(self, oprot):
14104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14106 
      return
14107 
    oprot.writeStructBegin('reconcileCodCollection_result')
14108 
    if self.success is not None:
14109 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14110 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4581 phani.kuma 14111 
      for kiter236,viter237 in self.success.items():
14112 
        oprot.writeString(kiter236)
14113 
        oprot.writeString(viter237)
3956 chandransh 14114 
      oprot.writeMapEnd()
14115 
      oprot.writeFieldEnd()
14116 
    if self.ex is not None:
14117 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14118 
      self.ex.write(oprot)
14119 
      oprot.writeFieldEnd()
14120 
    oprot.writeFieldStop()
14121 
    oprot.writeStructEnd()
14122 
 
14123 
  def validate(self):
14124 
    return
14125 
 
14126 
 
14127 
  def __repr__(self):
14128 
    L = ['%s=%r' % (key, value)
14129 
      for key, value in self.__dict__.iteritems()]
14130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14131 
 
14132 
  def __eq__(self, other):
14133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14134 
 
14135 
  def __ne__(self, other):
14136 
    return not (self == other)
4008 mandeep.dh 14137 
 
14138 
class getTransactionsRequiringExtraProcessing_args:
14139 
  """
14140 
  Attributes:
14141 
   - category
14142 
  """
14143 
 
14144 
  thrift_spec = (
14145 
    None, # 0
14146 
    (1, TType.I32, 'category', None, None, ), # 1
14147 
  )
14148 
 
14149 
  def __init__(self, category=None,):
14150 
    self.category = category
14151 
 
14152 
  def read(self, iprot):
14153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14155 
      return
14156 
    iprot.readStructBegin()
14157 
    while True:
14158 
      (fname, ftype, fid) = iprot.readFieldBegin()
14159 
      if ftype == TType.STOP:
14160 
        break
14161 
      if fid == 1:
14162 
        if ftype == TType.I32:
14163 
          self.category = iprot.readI32();
14164 
        else:
14165 
          iprot.skip(ftype)
14166 
      else:
14167 
        iprot.skip(ftype)
14168 
      iprot.readFieldEnd()
14169 
    iprot.readStructEnd()
14170 
 
14171 
  def write(self, oprot):
14172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14174 
      return
14175 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
14176 
    if self.category is not None:
14177 
      oprot.writeFieldBegin('category', TType.I32, 1)
14178 
      oprot.writeI32(self.category)
14179 
      oprot.writeFieldEnd()
14180 
    oprot.writeFieldStop()
14181 
    oprot.writeStructEnd()
14182 
 
14183 
  def validate(self):
14184 
    return
14185 
 
14186 
 
14187 
  def __repr__(self):
14188 
    L = ['%s=%r' % (key, value)
14189 
      for key, value in self.__dict__.iteritems()]
14190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14191 
 
14192 
  def __eq__(self, other):
14193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14194 
 
14195 
  def __ne__(self, other):
14196 
    return not (self == other)
14197 
 
14198 
class getTransactionsRequiringExtraProcessing_result:
14199 
  """
14200 
  Attributes:
14201 
   - success
14202 
  """
14203 
 
14204 
  thrift_spec = (
14205 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14206 
  )
14207 
 
14208 
  def __init__(self, success=None,):
14209 
    self.success = success
14210 
 
14211 
  def read(self, iprot):
14212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14214 
      return
14215 
    iprot.readStructBegin()
14216 
    while True:
14217 
      (fname, ftype, fid) = iprot.readFieldBegin()
14218 
      if ftype == TType.STOP:
14219 
        break
14220 
      if fid == 0:
14221 
        if ftype == TType.LIST:
14222 
          self.success = []
4581 phani.kuma 14223 
          (_etype241, _size238) = iprot.readListBegin()
14224 
          for _i242 in xrange(_size238):
14225 
            _elem243 = iprot.readI64();
14226 
            self.success.append(_elem243)
4008 mandeep.dh 14227 
          iprot.readListEnd()
14228 
        else:
14229 
          iprot.skip(ftype)
14230 
      else:
14231 
        iprot.skip(ftype)
14232 
      iprot.readFieldEnd()
14233 
    iprot.readStructEnd()
14234 
 
14235 
  def write(self, oprot):
14236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14238 
      return
14239 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
14240 
    if self.success is not None:
14241 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14242 
      oprot.writeListBegin(TType.I64, len(self.success))
4581 phani.kuma 14243 
      for iter244 in self.success:
14244 
        oprot.writeI64(iter244)
4008 mandeep.dh 14245 
      oprot.writeListEnd()
14246 
      oprot.writeFieldEnd()
14247 
    oprot.writeFieldStop()
14248 
    oprot.writeStructEnd()
14249 
 
14250 
  def validate(self):
14251 
    return
14252 
 
14253 
 
14254 
  def __repr__(self):
14255 
    L = ['%s=%r' % (key, value)
14256 
      for key, value in self.__dict__.iteritems()]
14257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14258 
 
14259 
  def __eq__(self, other):
14260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14261 
 
14262 
  def __ne__(self, other):
14263 
    return not (self == other)
14264 
 
14265 
class markTransactionAsProcessed_args:
14266 
  """
14267 
  Attributes:
14268 
   - transactionId
14269 
   - category
14270 
  """
14271 
 
14272 
  thrift_spec = (
14273 
    None, # 0
14274 
    (1, TType.I64, 'transactionId', None, None, ), # 1
14275 
    (2, TType.I32, 'category', None, None, ), # 2
14276 
  )
14277 
 
14278 
  def __init__(self, transactionId=None, category=None,):
14279 
    self.transactionId = transactionId
14280 
    self.category = category
14281 
 
14282 
  def read(self, iprot):
14283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14285 
      return
14286 
    iprot.readStructBegin()
14287 
    while True:
14288 
      (fname, ftype, fid) = iprot.readFieldBegin()
14289 
      if ftype == TType.STOP:
14290 
        break
14291 
      if fid == 1:
14292 
        if ftype == TType.I64:
14293 
          self.transactionId = iprot.readI64();
14294 
        else:
14295 
          iprot.skip(ftype)
14296 
      elif fid == 2:
14297 
        if ftype == TType.I32:
14298 
          self.category = iprot.readI32();
14299 
        else:
14300 
          iprot.skip(ftype)
14301 
      else:
14302 
        iprot.skip(ftype)
14303 
      iprot.readFieldEnd()
14304 
    iprot.readStructEnd()
14305 
 
14306 
  def write(self, oprot):
14307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14309 
      return
14310 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
14311 
    if self.transactionId is not None:
14312 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14313 
      oprot.writeI64(self.transactionId)
14314 
      oprot.writeFieldEnd()
14315 
    if self.category is not None:
14316 
      oprot.writeFieldBegin('category', TType.I32, 2)
14317 
      oprot.writeI32(self.category)
14318 
      oprot.writeFieldEnd()
14319 
    oprot.writeFieldStop()
14320 
    oprot.writeStructEnd()
14321 
 
14322 
  def validate(self):
14323 
    return
14324 
 
14325 
 
14326 
  def __repr__(self):
14327 
    L = ['%s=%r' % (key, value)
14328 
      for key, value in self.__dict__.iteritems()]
14329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14330 
 
14331 
  def __eq__(self, other):
14332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14333 
 
14334 
  def __ne__(self, other):
14335 
    return not (self == other)
14336 
 
14337 
class markTransactionAsProcessed_result:
14338 
 
14339 
  thrift_spec = (
14340 
  )
14341 
 
14342 
  def read(self, iprot):
14343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14345 
      return
14346 
    iprot.readStructBegin()
14347 
    while True:
14348 
      (fname, ftype, fid) = iprot.readFieldBegin()
14349 
      if ftype == TType.STOP:
14350 
        break
14351 
      else:
14352 
        iprot.skip(ftype)
14353 
      iprot.readFieldEnd()
14354 
    iprot.readStructEnd()
14355 
 
14356 
  def write(self, oprot):
14357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14359 
      return
14360 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
14361 
    oprot.writeFieldStop()
14362 
    oprot.writeStructEnd()
14363 
 
14364 
  def validate(self):
14365 
    return
14366 
 
14367 
 
14368 
  def __repr__(self):
14369 
    L = ['%s=%r' % (key, value)
14370 
      for key, value in self.__dict__.iteritems()]
14371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14372 
 
14373 
  def __eq__(self, other):
14374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14375 
 
14376 
  def __ne__(self, other):
14377 
    return not (self == other)
4018 chandransh 14378 
 
14379 
class getItemWiseRiskyOrdersCount_args:
14380 
 
14381 
  thrift_spec = (
14382 
  )
14383 
 
14384 
  def read(self, iprot):
14385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14387 
      return
14388 
    iprot.readStructBegin()
14389 
    while True:
14390 
      (fname, ftype, fid) = iprot.readFieldBegin()
14391 
      if ftype == TType.STOP:
14392 
        break
14393 
      else:
14394 
        iprot.skip(ftype)
14395 
      iprot.readFieldEnd()
14396 
    iprot.readStructEnd()
14397 
 
14398 
  def write(self, oprot):
14399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14401 
      return
14402 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
14403 
    oprot.writeFieldStop()
14404 
    oprot.writeStructEnd()
14405 
 
14406 
  def validate(self):
14407 
    return
14408 
 
14409 
 
14410 
  def __repr__(self):
14411 
    L = ['%s=%r' % (key, value)
14412 
      for key, value in self.__dict__.iteritems()]
14413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14414 
 
14415 
  def __eq__(self, other):
14416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14417 
 
14418 
  def __ne__(self, other):
14419 
    return not (self == other)
14420 
 
14421 
class getItemWiseRiskyOrdersCount_result:
14422 
  """
14423 
  Attributes:
14424 
   - success
14425 
  """
14426 
 
14427 
  thrift_spec = (
14428 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
14429 
  )
14430 
 
14431 
  def __init__(self, success=None,):
14432 
    self.success = success
14433 
 
14434 
  def read(self, iprot):
14435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14437 
      return
14438 
    iprot.readStructBegin()
14439 
    while True:
14440 
      (fname, ftype, fid) = iprot.readFieldBegin()
14441 
      if ftype == TType.STOP:
14442 
        break
14443 
      if fid == 0:
14444 
        if ftype == TType.MAP:
14445 
          self.success = {}
4581 phani.kuma 14446 
          (_ktype246, _vtype247, _size245 ) = iprot.readMapBegin()
14447 
          for _i249 in xrange(_size245):
14448 
            _key250 = iprot.readI64();
14449 
            _val251 = iprot.readI64();
14450 
            self.success[_key250] = _val251
4018 chandransh 14451 
          iprot.readMapEnd()
14452 
        else:
14453 
          iprot.skip(ftype)
14454 
      else:
14455 
        iprot.skip(ftype)
14456 
      iprot.readFieldEnd()
14457 
    iprot.readStructEnd()
14458 
 
14459 
  def write(self, oprot):
14460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14462 
      return
14463 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
14464 
    if self.success is not None:
14465 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14466 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4581 phani.kuma 14467 
      for kiter252,viter253 in self.success.items():
14468 
        oprot.writeI64(kiter252)
14469 
        oprot.writeI64(viter253)
4018 chandransh 14470 
      oprot.writeMapEnd()
14471 
      oprot.writeFieldEnd()
14472 
    oprot.writeFieldStop()
14473 
    oprot.writeStructEnd()
14474 
 
14475 
  def validate(self):
14476 
    return
14477 
 
14478 
 
14479 
  def __repr__(self):
14480 
    L = ['%s=%r' % (key, value)
14481 
      for key, value in self.__dict__.iteritems()]
14482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14483 
 
14484 
  def __eq__(self, other):
14485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14486 
 
14487 
  def __ne__(self, other):
14488 
    return not (self == other)
4247 rajveer 14489 
 
4295 varun.gupt 14490 
class getOrdersForItemIds_args:
14491 
  """
14492 
  Attributes:
14493 
   - itemIds
14494 
  """
14495 
 
14496 
  thrift_spec = (
14497 
    None, # 0
14498 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
14499 
  )
14500 
 
14501 
  def __init__(self, itemIds=None,):
14502 
    self.itemIds = itemIds
14503 
 
14504 
  def read(self, iprot):
14505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14507 
      return
14508 
    iprot.readStructBegin()
14509 
    while True:
14510 
      (fname, ftype, fid) = iprot.readFieldBegin()
14511 
      if ftype == TType.STOP:
14512 
        break
14513 
      if fid == 1:
14514 
        if ftype == TType.LIST:
14515 
          self.itemIds = []
4581 phani.kuma 14516 
          (_etype257, _size254) = iprot.readListBegin()
14517 
          for _i258 in xrange(_size254):
14518 
            _elem259 = iprot.readI64();
14519 
            self.itemIds.append(_elem259)
4295 varun.gupt 14520 
          iprot.readListEnd()
14521 
        else:
14522 
          iprot.skip(ftype)
14523 
      else:
14524 
        iprot.skip(ftype)
14525 
      iprot.readFieldEnd()
14526 
    iprot.readStructEnd()
14527 
 
14528 
  def write(self, oprot):
14529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14531 
      return
14532 
    oprot.writeStructBegin('getOrdersForItemIds_args')
14533 
    if self.itemIds is not None:
14534 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
14535 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4581 phani.kuma 14536 
      for iter260 in self.itemIds:
14537 
        oprot.writeI64(iter260)
4295 varun.gupt 14538 
      oprot.writeListEnd()
14539 
      oprot.writeFieldEnd()
14540 
    oprot.writeFieldStop()
14541 
    oprot.writeStructEnd()
14542 
 
14543 
  def validate(self):
14544 
    return
14545 
 
14546 
 
14547 
  def __repr__(self):
14548 
    L = ['%s=%r' % (key, value)
14549 
      for key, value in self.__dict__.iteritems()]
14550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14551 
 
14552 
  def __eq__(self, other):
14553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14554 
 
14555 
  def __ne__(self, other):
14556 
    return not (self == other)
14557 
 
14558 
class getOrdersForItemIds_result:
14559 
  """
14560 
  Attributes:
14561 
   - success
14562 
  """
14563 
 
14564 
  thrift_spec = (
14565 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14566 
  )
14567 
 
14568 
  def __init__(self, success=None,):
14569 
    self.success = success
14570 
 
14571 
  def read(self, iprot):
14572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14574 
      return
14575 
    iprot.readStructBegin()
14576 
    while True:
14577 
      (fname, ftype, fid) = iprot.readFieldBegin()
14578 
      if ftype == TType.STOP:
14579 
        break
14580 
      if fid == 0:
14581 
        if ftype == TType.LIST:
14582 
          self.success = []
4581 phani.kuma 14583 
          (_etype264, _size261) = iprot.readListBegin()
14584 
          for _i265 in xrange(_size261):
14585 
            _elem266 = Order()
14586 
            _elem266.read(iprot)
14587 
            self.success.append(_elem266)
4295 varun.gupt 14588 
          iprot.readListEnd()
14589 
        else:
14590 
          iprot.skip(ftype)
14591 
      else:
14592 
        iprot.skip(ftype)
14593 
      iprot.readFieldEnd()
14594 
    iprot.readStructEnd()
14595 
 
14596 
  def write(self, oprot):
14597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14599 
      return
14600 
    oprot.writeStructBegin('getOrdersForItemIds_result')
14601 
    if self.success is not None:
14602 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14603 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 14604 
      for iter267 in self.success:
14605 
        iter267.write(oprot)
4295 varun.gupt 14606 
      oprot.writeListEnd()
14607 
      oprot.writeFieldEnd()
14608 
    oprot.writeFieldStop()
14609 
    oprot.writeStructEnd()
14610 
 
14611 
  def validate(self):
14612 
    return
14613 
 
14614 
 
14615 
  def __repr__(self):
14616 
    L = ['%s=%r' % (key, value)
14617 
      for key, value in self.__dict__.iteritems()]
14618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14619 
 
14620 
  def __eq__(self, other):
14621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14622 
 
14623 
  def __ne__(self, other):
14624 
    return not (self == other)
14625 
 
4247 rajveer 14626 
class markOrderCancellationRequestReceived_args:
14627 
  """
14628 
  Attributes:
14629 
   - orderId
14630 
  """
14631 
 
14632 
  thrift_spec = (
14633 
    None, # 0
14634 
    (1, TType.I64, 'orderId', None, None, ), # 1
14635 
  )
14636 
 
14637 
  def __init__(self, orderId=None,):
14638 
    self.orderId = orderId
14639 
 
14640 
  def read(self, iprot):
14641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14643 
      return
14644 
    iprot.readStructBegin()
14645 
    while True:
14646 
      (fname, ftype, fid) = iprot.readFieldBegin()
14647 
      if ftype == TType.STOP:
14648 
        break
14649 
      if fid == 1:
14650 
        if ftype == TType.I64:
14651 
          self.orderId = iprot.readI64();
14652 
        else:
14653 
          iprot.skip(ftype)
14654 
      else:
14655 
        iprot.skip(ftype)
14656 
      iprot.readFieldEnd()
14657 
    iprot.readStructEnd()
14658 
 
14659 
  def write(self, oprot):
14660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14662 
      return
14663 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
14664 
    if self.orderId is not None:
14665 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14666 
      oprot.writeI64(self.orderId)
14667 
      oprot.writeFieldEnd()
14668 
    oprot.writeFieldStop()
14669 
    oprot.writeStructEnd()
14670 
 
14671 
  def validate(self):
14672 
    return
14673 
 
14674 
 
14675 
  def __repr__(self):
14676 
    L = ['%s=%r' % (key, value)
14677 
      for key, value in self.__dict__.iteritems()]
14678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14679 
 
14680 
  def __eq__(self, other):
14681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14682 
 
14683 
  def __ne__(self, other):
14684 
    return not (self == other)
14685 
 
14686 
class markOrderCancellationRequestReceived_result:
14687 
  """
14688 
  Attributes:
14689 
   - ex
14690 
  """
14691 
 
14692 
  thrift_spec = (
14693 
    None, # 0
14694 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14695 
  )
14696 
 
14697 
  def __init__(self, ex=None,):
14698 
    self.ex = ex
14699 
 
14700 
  def read(self, iprot):
14701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14703 
      return
14704 
    iprot.readStructBegin()
14705 
    while True:
14706 
      (fname, ftype, fid) = iprot.readFieldBegin()
14707 
      if ftype == TType.STOP:
14708 
        break
14709 
      if fid == 1:
14710 
        if ftype == TType.STRUCT:
14711 
          self.ex = TransactionServiceException()
14712 
          self.ex.read(iprot)
14713 
        else:
14714 
          iprot.skip(ftype)
14715 
      else:
14716 
        iprot.skip(ftype)
14717 
      iprot.readFieldEnd()
14718 
    iprot.readStructEnd()
14719 
 
14720 
  def write(self, oprot):
14721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14723 
      return
14724 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
14725 
    if self.ex is not None:
14726 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14727 
      self.ex.write(oprot)
14728 
      oprot.writeFieldEnd()
14729 
    oprot.writeFieldStop()
14730 
    oprot.writeStructEnd()
14731 
 
14732 
  def validate(self):
14733 
    return
14734 
 
14735 
 
14736 
  def __repr__(self):
14737 
    L = ['%s=%r' % (key, value)
14738 
      for key, value in self.__dict__.iteritems()]
14739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14740 
 
14741 
  def __eq__(self, other):
14742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14743 
 
14744 
  def __ne__(self, other):
14745 
    return not (self == other)
14746 
 
14747 
class markOrderCancellationRequestConfirmed_args:
14748 
  """
14749 
  Attributes:
14750 
   - orderId
14751 
  """
14752 
 
14753 
  thrift_spec = (
14754 
    None, # 0
14755 
    (1, TType.I64, 'orderId', None, None, ), # 1
14756 
  )
14757 
 
14758 
  def __init__(self, orderId=None,):
14759 
    self.orderId = orderId
14760 
 
14761 
  def read(self, iprot):
14762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14764 
      return
14765 
    iprot.readStructBegin()
14766 
    while True:
14767 
      (fname, ftype, fid) = iprot.readFieldBegin()
14768 
      if ftype == TType.STOP:
14769 
        break
14770 
      if fid == 1:
14771 
        if ftype == TType.I64:
14772 
          self.orderId = iprot.readI64();
14773 
        else:
14774 
          iprot.skip(ftype)
14775 
      else:
14776 
        iprot.skip(ftype)
14777 
      iprot.readFieldEnd()
14778 
    iprot.readStructEnd()
14779 
 
14780 
  def write(self, oprot):
14781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14783 
      return
14784 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
14785 
    if self.orderId is not None:
14786 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14787 
      oprot.writeI64(self.orderId)
14788 
      oprot.writeFieldEnd()
14789 
    oprot.writeFieldStop()
14790 
    oprot.writeStructEnd()
14791 
 
14792 
  def validate(self):
14793 
    return
14794 
 
14795 
 
14796 
  def __repr__(self):
14797 
    L = ['%s=%r' % (key, value)
14798 
      for key, value in self.__dict__.iteritems()]
14799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14800 
 
14801 
  def __eq__(self, other):
14802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14803 
 
14804 
  def __ne__(self, other):
14805 
    return not (self == other)
14806 
 
14807 
class markOrderCancellationRequestConfirmed_result:
14808 
  """
14809 
  Attributes:
14810 
   - ex
14811 
  """
14812 
 
14813 
  thrift_spec = (
14814 
    None, # 0
14815 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14816 
  )
14817 
 
14818 
  def __init__(self, ex=None,):
14819 
    self.ex = ex
14820 
 
14821 
  def read(self, iprot):
14822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14824 
      return
14825 
    iprot.readStructBegin()
14826 
    while True:
14827 
      (fname, ftype, fid) = iprot.readFieldBegin()
14828 
      if ftype == TType.STOP:
14829 
        break
14830 
      if fid == 1:
14831 
        if ftype == TType.STRUCT:
14832 
          self.ex = TransactionServiceException()
14833 
          self.ex.read(iprot)
14834 
        else:
14835 
          iprot.skip(ftype)
14836 
      else:
14837 
        iprot.skip(ftype)
14838 
      iprot.readFieldEnd()
14839 
    iprot.readStructEnd()
14840 
 
14841 
  def write(self, oprot):
14842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14844 
      return
14845 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
14846 
    if self.ex is not None:
14847 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14848 
      self.ex.write(oprot)
14849 
      oprot.writeFieldEnd()
14850 
    oprot.writeFieldStop()
14851 
    oprot.writeStructEnd()
14852 
 
14853 
  def validate(self):
14854 
    return
14855 
 
14856 
 
14857 
  def __repr__(self):
14858 
    L = ['%s=%r' % (key, value)
14859 
      for key, value in self.__dict__.iteritems()]
14860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14861 
 
14862 
  def __eq__(self, other):
14863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14864 
 
14865 
  def __ne__(self, other):
14866 
    return not (self == other)
14867 
 
14868 
class markOrderCancellationRequestDenied_args:
14869 
  """
14870 
  Attributes:
14871 
   - orderId
14872 
  """
14873 
 
14874 
  thrift_spec = (
14875 
    None, # 0
14876 
    (1, TType.I64, 'orderId', None, None, ), # 1
14877 
  )
14878 
 
14879 
  def __init__(self, orderId=None,):
14880 
    self.orderId = orderId
14881 
 
14882 
  def read(self, iprot):
14883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14885 
      return
14886 
    iprot.readStructBegin()
14887 
    while True:
14888 
      (fname, ftype, fid) = iprot.readFieldBegin()
14889 
      if ftype == TType.STOP:
14890 
        break
14891 
      if fid == 1:
14892 
        if ftype == TType.I64:
14893 
          self.orderId = iprot.readI64();
14894 
        else:
14895 
          iprot.skip(ftype)
14896 
      else:
14897 
        iprot.skip(ftype)
14898 
      iprot.readFieldEnd()
14899 
    iprot.readStructEnd()
14900 
 
14901 
  def write(self, oprot):
14902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14904 
      return
14905 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
14906 
    if self.orderId is not None:
14907 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14908 
      oprot.writeI64(self.orderId)
14909 
      oprot.writeFieldEnd()
14910 
    oprot.writeFieldStop()
14911 
    oprot.writeStructEnd()
14912 
 
14913 
  def validate(self):
14914 
    return
14915 
 
14916 
 
14917 
  def __repr__(self):
14918 
    L = ['%s=%r' % (key, value)
14919 
      for key, value in self.__dict__.iteritems()]
14920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14921 
 
14922 
  def __eq__(self, other):
14923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14924 
 
14925 
  def __ne__(self, other):
14926 
    return not (self == other)
14927 
 
14928 
class markOrderCancellationRequestDenied_result:
14929 
  """
14930 
  Attributes:
14931 
   - ex
14932 
  """
14933 
 
14934 
  thrift_spec = (
14935 
    None, # 0
14936 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14937 
  )
14938 
 
14939 
  def __init__(self, ex=None,):
14940 
    self.ex = ex
14941 
 
14942 
  def read(self, iprot):
14943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14945 
      return
14946 
    iprot.readStructBegin()
14947 
    while True:
14948 
      (fname, ftype, fid) = iprot.readFieldBegin()
14949 
      if ftype == TType.STOP:
14950 
        break
14951 
      if fid == 1:
14952 
        if ftype == TType.STRUCT:
14953 
          self.ex = TransactionServiceException()
14954 
          self.ex.read(iprot)
14955 
        else:
14956 
          iprot.skip(ftype)
14957 
      else:
14958 
        iprot.skip(ftype)
14959 
      iprot.readFieldEnd()
14960 
    iprot.readStructEnd()
14961 
 
14962 
  def write(self, oprot):
14963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14965 
      return
14966 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
14967 
    if self.ex is not None:
14968 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14969 
      self.ex.write(oprot)
14970 
      oprot.writeFieldEnd()
14971 
    oprot.writeFieldStop()
14972 
    oprot.writeStructEnd()
14973 
 
14974 
  def validate(self):
14975 
    return
14976 
 
14977 
 
14978 
  def __repr__(self):
14979 
    L = ['%s=%r' % (key, value)
14980 
      for key, value in self.__dict__.iteritems()]
14981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14982 
 
14983 
  def __eq__(self, other):
14984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14985 
 
14986 
  def __ne__(self, other):
14987 
    return not (self == other)
14988 
 
4258 rajveer 14989 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 14990 
  """
14991 
  Attributes:
4258 rajveer 14992 
   - transactionId
4247 rajveer 14993 
  """
14994 
 
14995 
  thrift_spec = (
14996 
    None, # 0
4258 rajveer 14997 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 14998 
  )
14999 
 
4258 rajveer 15000 
  def __init__(self, transactionId=None,):
15001 
    self.transactionId = transactionId
4247 rajveer 15002 
 
15003 
  def read(self, iprot):
15004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15006 
      return
15007 
    iprot.readStructBegin()
15008 
    while True:
15009 
      (fname, ftype, fid) = iprot.readFieldBegin()
15010 
      if ftype == TType.STOP:
15011 
        break
15012 
      if fid == 1:
15013 
        if ftype == TType.I64:
4258 rajveer 15014 
          self.transactionId = iprot.readI64();
4247 rajveer 15015 
        else:
15016 
          iprot.skip(ftype)
15017 
      else:
15018 
        iprot.skip(ftype)
15019 
      iprot.readFieldEnd()
15020 
    iprot.readStructEnd()
15021 
 
15022 
  def write(self, oprot):
15023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15025 
      return
4258 rajveer 15026 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
15027 
    if self.transactionId is not None:
15028 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15029 
      oprot.writeI64(self.transactionId)
4247 rajveer 15030 
      oprot.writeFieldEnd()
15031 
    oprot.writeFieldStop()
15032 
    oprot.writeStructEnd()
15033 
 
15034 
  def validate(self):
15035 
    return
15036 
 
15037 
 
15038 
  def __repr__(self):
15039 
    L = ['%s=%r' % (key, value)
15040 
      for key, value in self.__dict__.iteritems()]
15041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15042 
 
15043 
  def __eq__(self, other):
15044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15045 
 
15046 
  def __ne__(self, other):
15047 
    return not (self == other)
15048 
 
4258 rajveer 15049 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 15050 
  """
15051 
  Attributes:
15052 
   - ex
15053 
  """
15054 
 
15055 
  thrift_spec = (
15056 
    None, # 0
15057 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15058 
  )
15059 
 
15060 
  def __init__(self, ex=None,):
15061 
    self.ex = ex
15062 
 
15063 
  def read(self, iprot):
15064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15066 
      return
15067 
    iprot.readStructBegin()
15068 
    while True:
15069 
      (fname, ftype, fid) = iprot.readFieldBegin()
15070 
      if ftype == TType.STOP:
15071 
        break
15072 
      if fid == 1:
15073 
        if ftype == TType.STRUCT:
15074 
          self.ex = TransactionServiceException()
15075 
          self.ex.read(iprot)
15076 
        else:
15077 
          iprot.skip(ftype)
15078 
      else:
15079 
        iprot.skip(ftype)
15080 
      iprot.readFieldEnd()
15081 
    iprot.readStructEnd()
15082 
 
15083 
  def write(self, oprot):
15084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15086 
      return
4258 rajveer 15087 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 15088 
    if self.ex is not None:
15089 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15090 
      self.ex.write(oprot)
15091 
      oprot.writeFieldEnd()
15092 
    oprot.writeFieldStop()
15093 
    oprot.writeStructEnd()
15094 
 
15095 
  def validate(self):
15096 
    return
15097 
 
15098 
 
15099 
  def __repr__(self):
15100 
    L = ['%s=%r' % (key, value)
15101 
      for key, value in self.__dict__.iteritems()]
15102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15103 
 
15104 
  def __eq__(self, other):
15105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15106 
 
15107 
  def __ne__(self, other):
15108 
    return not (self == other)
4259 anupam.sin 15109 
 
15110 
class refundTransaction_args:
15111 
  """
15112 
  Attributes:
15113 
   - transactionId
15114 
   - refundedBy
15115 
   - reason
15116 
  """
15117 
 
15118 
  thrift_spec = (
15119 
    None, # 0
15120 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15121 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15122 
    (3, TType.STRING, 'reason', None, None, ), # 3
15123 
  )
15124 
 
15125 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
15126 
    self.transactionId = transactionId
15127 
    self.refundedBy = refundedBy
15128 
    self.reason = reason
15129 
 
15130 
  def read(self, iprot):
15131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15133 
      return
15134 
    iprot.readStructBegin()
15135 
    while True:
15136 
      (fname, ftype, fid) = iprot.readFieldBegin()
15137 
      if ftype == TType.STOP:
15138 
        break
15139 
      if fid == 1:
15140 
        if ftype == TType.I64:
15141 
          self.transactionId = iprot.readI64();
15142 
        else:
15143 
          iprot.skip(ftype)
15144 
      elif fid == 2:
15145 
        if ftype == TType.STRING:
15146 
          self.refundedBy = iprot.readString();
15147 
        else:
15148 
          iprot.skip(ftype)
15149 
      elif fid == 3:
15150 
        if ftype == TType.STRING:
15151 
          self.reason = iprot.readString();
15152 
        else:
15153 
          iprot.skip(ftype)
15154 
      else:
15155 
        iprot.skip(ftype)
15156 
      iprot.readFieldEnd()
15157 
    iprot.readStructEnd()
15158 
 
15159 
  def write(self, oprot):
15160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15162 
      return
15163 
    oprot.writeStructBegin('refundTransaction_args')
15164 
    if self.transactionId is not None:
15165 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15166 
      oprot.writeI64(self.transactionId)
15167 
      oprot.writeFieldEnd()
15168 
    if self.refundedBy is not None:
15169 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15170 
      oprot.writeString(self.refundedBy)
15171 
      oprot.writeFieldEnd()
15172 
    if self.reason is not None:
15173 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15174 
      oprot.writeString(self.reason)
15175 
      oprot.writeFieldEnd()
15176 
    oprot.writeFieldStop()
15177 
    oprot.writeStructEnd()
15178 
 
15179 
  def validate(self):
15180 
    return
15181 
 
15182 
 
15183 
  def __repr__(self):
15184 
    L = ['%s=%r' % (key, value)
15185 
      for key, value in self.__dict__.iteritems()]
15186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15187 
 
15188 
  def __eq__(self, other):
15189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15190 
 
15191 
  def __ne__(self, other):
15192 
    return not (self == other)
15193 
 
15194 
class refundTransaction_result:
15195 
  """
15196 
  Attributes:
15197 
   - ex
15198 
  """
15199 
 
15200 
  thrift_spec = (
15201 
    None, # 0
15202 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15203 
  )
15204 
 
15205 
  def __init__(self, ex=None,):
15206 
    self.ex = ex
15207 
 
15208 
  def read(self, iprot):
15209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15211 
      return
15212 
    iprot.readStructBegin()
15213 
    while True:
15214 
      (fname, ftype, fid) = iprot.readFieldBegin()
15215 
      if ftype == TType.STOP:
15216 
        break
15217 
      if fid == 1:
15218 
        if ftype == TType.STRUCT:
15219 
          self.ex = TransactionServiceException()
15220 
          self.ex.read(iprot)
15221 
        else:
15222 
          iprot.skip(ftype)
15223 
      else:
15224 
        iprot.skip(ftype)
15225 
      iprot.readFieldEnd()
15226 
    iprot.readStructEnd()
15227 
 
15228 
  def write(self, oprot):
15229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15231 
      return
15232 
    oprot.writeStructBegin('refundTransaction_result')
15233 
    if self.ex is not None:
15234 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15235 
      self.ex.write(oprot)
15236 
      oprot.writeFieldEnd()
15237 
    oprot.writeFieldStop()
15238 
    oprot.writeStructEnd()
15239 
 
15240 
  def validate(self):
15241 
    return
15242 
 
15243 
 
15244 
  def __repr__(self):
15245 
    L = ['%s=%r' % (key, value)
15246 
      for key, value in self.__dict__.iteritems()]
15247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15248 
 
15249 
  def __eq__(self, other):
15250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15251 
 
15252 
  def __ne__(self, other):
15253 
    return not (self == other)
4285 rajveer 15254 
 
4324 mandeep.dh 15255 
class updateShipmentAddress_args:
15256 
  """
15257 
  Attributes:
15258 
   - orderId
15259 
   - addressId
15260 
  """
15261 
 
15262 
  thrift_spec = (
15263 
    None, # 0
15264 
    (1, TType.I64, 'orderId', None, None, ), # 1
15265 
    (2, TType.I64, 'addressId', None, None, ), # 2
15266 
  )
15267 
 
15268 
  def __init__(self, orderId=None, addressId=None,):
15269 
    self.orderId = orderId
15270 
    self.addressId = addressId
15271 
 
15272 
  def read(self, iprot):
15273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15275 
      return
15276 
    iprot.readStructBegin()
15277 
    while True:
15278 
      (fname, ftype, fid) = iprot.readFieldBegin()
15279 
      if ftype == TType.STOP:
15280 
        break
15281 
      if fid == 1:
15282 
        if ftype == TType.I64:
15283 
          self.orderId = iprot.readI64();
15284 
        else:
15285 
          iprot.skip(ftype)
15286 
      elif fid == 2:
15287 
        if ftype == TType.I64:
15288 
          self.addressId = iprot.readI64();
15289 
        else:
15290 
          iprot.skip(ftype)
15291 
      else:
15292 
        iprot.skip(ftype)
15293 
      iprot.readFieldEnd()
15294 
    iprot.readStructEnd()
15295 
 
15296 
  def write(self, oprot):
15297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15299 
      return
15300 
    oprot.writeStructBegin('updateShipmentAddress_args')
15301 
    if self.orderId is not None:
15302 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15303 
      oprot.writeI64(self.orderId)
15304 
      oprot.writeFieldEnd()
15305 
    if self.addressId is not None:
15306 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
15307 
      oprot.writeI64(self.addressId)
15308 
      oprot.writeFieldEnd()
15309 
    oprot.writeFieldStop()
15310 
    oprot.writeStructEnd()
15311 
 
15312 
  def validate(self):
15313 
    return
15314 
 
15315 
 
15316 
  def __repr__(self):
15317 
    L = ['%s=%r' % (key, value)
15318 
      for key, value in self.__dict__.iteritems()]
15319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15320 
 
15321 
  def __eq__(self, other):
15322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15323 
 
15324 
  def __ne__(self, other):
15325 
    return not (self == other)
15326 
 
15327 
class updateShipmentAddress_result:
15328 
  """
15329 
  Attributes:
15330 
   - ex
15331 
  """
15332 
 
15333 
  thrift_spec = (
15334 
    None, # 0
15335 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15336 
  )
15337 
 
15338 
  def __init__(self, ex=None,):
15339 
    self.ex = ex
15340 
 
15341 
  def read(self, iprot):
15342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15344 
      return
15345 
    iprot.readStructBegin()
15346 
    while True:
15347 
      (fname, ftype, fid) = iprot.readFieldBegin()
15348 
      if ftype == TType.STOP:
15349 
        break
15350 
      if fid == 1:
15351 
        if ftype == TType.STRUCT:
15352 
          self.ex = TransactionServiceException()
15353 
          self.ex.read(iprot)
15354 
        else:
15355 
          iprot.skip(ftype)
15356 
      else:
15357 
        iprot.skip(ftype)
15358 
      iprot.readFieldEnd()
15359 
    iprot.readStructEnd()
15360 
 
15361 
  def write(self, oprot):
15362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15364 
      return
15365 
    oprot.writeStructBegin('updateShipmentAddress_result')
15366 
    if self.ex is not None:
15367 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15368 
      self.ex.write(oprot)
15369 
      oprot.writeFieldEnd()
15370 
    oprot.writeFieldStop()
15371 
    oprot.writeStructEnd()
15372 
 
15373 
  def validate(self):
15374 
    return
15375 
 
15376 
 
15377 
  def __repr__(self):
15378 
    L = ['%s=%r' % (key, value)
15379 
      for key, value in self.__dict__.iteritems()]
15380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15381 
 
15382 
  def __eq__(self, other):
15383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15384 
 
15385 
  def __ne__(self, other):
15386 
    return not (self == other)
15387 
 
4285 rajveer 15388 
class acceptOrdersForItemId_args:
15389 
  """
15390 
  Attributes:
15391 
   - itemId
15392 
   - inventory
15393 
  """
15394 
 
15395 
  thrift_spec = (
15396 
    None, # 0
15397 
    (1, TType.I64, 'itemId', None, None, ), # 1
15398 
    (2, TType.I64, 'inventory', None, None, ), # 2
15399 
  )
15400 
 
15401 
  def __init__(self, itemId=None, inventory=None,):
15402 
    self.itemId = itemId
15403 
    self.inventory = inventory
15404 
 
15405 
  def read(self, iprot):
15406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15408 
      return
15409 
    iprot.readStructBegin()
15410 
    while True:
15411 
      (fname, ftype, fid) = iprot.readFieldBegin()
15412 
      if ftype == TType.STOP:
15413 
        break
15414 
      if fid == 1:
15415 
        if ftype == TType.I64:
15416 
          self.itemId = iprot.readI64();
15417 
        else:
15418 
          iprot.skip(ftype)
15419 
      elif fid == 2:
15420 
        if ftype == TType.I64:
15421 
          self.inventory = iprot.readI64();
15422 
        else:
15423 
          iprot.skip(ftype)
15424 
      else:
15425 
        iprot.skip(ftype)
15426 
      iprot.readFieldEnd()
15427 
    iprot.readStructEnd()
15428 
 
15429 
  def write(self, oprot):
15430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15432 
      return
15433 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
15434 
    if self.itemId is not None:
15435 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15436 
      oprot.writeI64(self.itemId)
15437 
      oprot.writeFieldEnd()
15438 
    if self.inventory is not None:
15439 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
15440 
      oprot.writeI64(self.inventory)
15441 
      oprot.writeFieldEnd()
15442 
    oprot.writeFieldStop()
15443 
    oprot.writeStructEnd()
15444 
 
15445 
  def validate(self):
15446 
    return
15447 
 
15448 
 
15449 
  def __repr__(self):
15450 
    L = ['%s=%r' % (key, value)
15451 
      for key, value in self.__dict__.iteritems()]
15452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15453 
 
15454 
  def __eq__(self, other):
15455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15456 
 
15457 
  def __ne__(self, other):
15458 
    return not (self == other)
15459 
 
15460 
class acceptOrdersForItemId_result:
15461 
  """
15462 
  Attributes:
15463 
   - success
15464 
   - ex
15465 
  """
15466 
 
15467 
  thrift_spec = (
15468 
    (0, TType.BOOL, 'success', None, None, ), # 0
15469 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15470 
  )
15471 
 
15472 
  def __init__(self, success=None, ex=None,):
15473 
    self.success = success
15474 
    self.ex = ex
15475 
 
15476 
  def read(self, iprot):
15477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15479 
      return
15480 
    iprot.readStructBegin()
15481 
    while True:
15482 
      (fname, ftype, fid) = iprot.readFieldBegin()
15483 
      if ftype == TType.STOP:
15484 
        break
15485 
      if fid == 0:
15486 
        if ftype == TType.BOOL:
15487 
          self.success = iprot.readBool();
15488 
        else:
15489 
          iprot.skip(ftype)
15490 
      elif fid == 1:
15491 
        if ftype == TType.STRUCT:
15492 
          self.ex = TransactionServiceException()
15493 
          self.ex.read(iprot)
15494 
        else:
15495 
          iprot.skip(ftype)
15496 
      else:
15497 
        iprot.skip(ftype)
15498 
      iprot.readFieldEnd()
15499 
    iprot.readStructEnd()
15500 
 
15501 
  def write(self, oprot):
15502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15504 
      return
15505 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
15506 
    if self.success is not None:
15507 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15508 
      oprot.writeBool(self.success)
15509 
      oprot.writeFieldEnd()
15510 
    if self.ex is not None:
15511 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15512 
      self.ex.write(oprot)
15513 
      oprot.writeFieldEnd()
15514 
    oprot.writeFieldStop()
15515 
    oprot.writeStructEnd()
15516 
 
15517 
  def validate(self):
15518 
    return
15519 
 
15520 
 
15521 
  def __repr__(self):
15522 
    L = ['%s=%r' % (key, value)
15523 
      for key, value in self.__dict__.iteritems()]
15524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15525 
 
15526 
  def __eq__(self, other):
15527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15528 
 
15529 
  def __ne__(self, other):
15530 
    return not (self == other)
4303 rajveer 15531 
 
15532 
class markOrdersAsPORaised_args:
15533 
  """
15534 
  Attributes:
15535 
   - vendorId
15536 
   - itemId
15537 
   - quantity
15538 
   - estimate
4369 rajveer 15539 
   - isReminder
4303 rajveer 15540 
  """
15541 
 
15542 
  thrift_spec = (
15543 
    None, # 0
15544 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15545 
    (2, TType.I64, 'itemId', None, None, ), # 2
15546 
    (3, TType.I64, 'quantity', None, None, ), # 3
15547 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15548 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15549 
  )
15550 
 
4369 rajveer 15551 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15552 
    self.vendorId = vendorId
15553 
    self.itemId = itemId
15554 
    self.quantity = quantity
15555 
    self.estimate = estimate
4369 rajveer 15556 
    self.isReminder = isReminder
4303 rajveer 15557 
 
15558 
  def read(self, iprot):
15559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15561 
      return
15562 
    iprot.readStructBegin()
15563 
    while True:
15564 
      (fname, ftype, fid) = iprot.readFieldBegin()
15565 
      if ftype == TType.STOP:
15566 
        break
15567 
      if fid == 1:
15568 
        if ftype == TType.I64:
15569 
          self.vendorId = iprot.readI64();
15570 
        else:
15571 
          iprot.skip(ftype)
15572 
      elif fid == 2:
15573 
        if ftype == TType.I64:
15574 
          self.itemId = iprot.readI64();
15575 
        else:
15576 
          iprot.skip(ftype)
15577 
      elif fid == 3:
15578 
        if ftype == TType.I64:
15579 
          self.quantity = iprot.readI64();
15580 
        else:
15581 
          iprot.skip(ftype)
15582 
      elif fid == 4:
15583 
        if ftype == TType.I64:
15584 
          self.estimate = iprot.readI64();
15585 
        else:
15586 
          iprot.skip(ftype)
4369 rajveer 15587 
      elif fid == 5:
15588 
        if ftype == TType.BOOL:
15589 
          self.isReminder = iprot.readBool();
15590 
        else:
15591 
          iprot.skip(ftype)
4303 rajveer 15592 
      else:
15593 
        iprot.skip(ftype)
15594 
      iprot.readFieldEnd()
15595 
    iprot.readStructEnd()
15596 
 
15597 
  def write(self, oprot):
15598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15600 
      return
15601 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
15602 
    if self.vendorId is not None:
15603 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15604 
      oprot.writeI64(self.vendorId)
15605 
      oprot.writeFieldEnd()
15606 
    if self.itemId is not None:
15607 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15608 
      oprot.writeI64(self.itemId)
15609 
      oprot.writeFieldEnd()
15610 
    if self.quantity is not None:
15611 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15612 
      oprot.writeI64(self.quantity)
15613 
      oprot.writeFieldEnd()
15614 
    if self.estimate is not None:
15615 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15616 
      oprot.writeI64(self.estimate)
15617 
      oprot.writeFieldEnd()
4369 rajveer 15618 
    if self.isReminder is not None:
15619 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15620 
      oprot.writeBool(self.isReminder)
15621 
      oprot.writeFieldEnd()
4303 rajveer 15622 
    oprot.writeFieldStop()
15623 
    oprot.writeStructEnd()
15624 
 
15625 
  def validate(self):
15626 
    return
15627 
 
15628 
 
15629 
  def __repr__(self):
15630 
    L = ['%s=%r' % (key, value)
15631 
      for key, value in self.__dict__.iteritems()]
15632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15633 
 
15634 
  def __eq__(self, other):
15635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15636 
 
15637 
  def __ne__(self, other):
15638 
    return not (self == other)
15639 
 
15640 
class markOrdersAsPORaised_result:
15641 
  """
15642 
  Attributes:
15643 
   - ex
15644 
  """
15645 
 
15646 
  thrift_spec = (
15647 
    None, # 0
15648 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15649 
  )
15650 
 
15651 
  def __init__(self, ex=None,):
15652 
    self.ex = ex
15653 
 
15654 
  def read(self, iprot):
15655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15657 
      return
15658 
    iprot.readStructBegin()
15659 
    while True:
15660 
      (fname, ftype, fid) = iprot.readFieldBegin()
15661 
      if ftype == TType.STOP:
15662 
        break
15663 
      if fid == 1:
15664 
        if ftype == TType.STRUCT:
15665 
          self.ex = TransactionServiceException()
15666 
          self.ex.read(iprot)
15667 
        else:
15668 
          iprot.skip(ftype)
15669 
      else:
15670 
        iprot.skip(ftype)
15671 
      iprot.readFieldEnd()
15672 
    iprot.readStructEnd()
15673 
 
15674 
  def write(self, oprot):
15675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15677 
      return
15678 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
15679 
    if self.ex is not None:
15680 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15681 
      self.ex.write(oprot)
15682 
      oprot.writeFieldEnd()
15683 
    oprot.writeFieldStop()
15684 
    oprot.writeStructEnd()
15685 
 
15686 
  def validate(self):
15687 
    return
15688 
 
15689 
 
15690 
  def __repr__(self):
15691 
    L = ['%s=%r' % (key, value)
15692 
      for key, value in self.__dict__.iteritems()]
15693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15694 
 
15695 
  def __eq__(self, other):
15696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15697 
 
15698 
  def __ne__(self, other):
15699 
    return not (self == other)
15700 
 
15701 
class markOrdersAsReversalInitiated_args:
15702 
  """
15703 
  Attributes:
15704 
   - vendorId
15705 
   - itemId
15706 
   - quantity
15707 
   - estimate
4369 rajveer 15708 
   - isReminder
4303 rajveer 15709 
  """
15710 
 
15711 
  thrift_spec = (
15712 
    None, # 0
15713 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15714 
    (2, TType.I64, 'itemId', None, None, ), # 2
15715 
    (3, TType.I64, 'quantity', None, None, ), # 3
15716 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15717 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15718 
  )
15719 
 
4369 rajveer 15720 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15721 
    self.vendorId = vendorId
15722 
    self.itemId = itemId
15723 
    self.quantity = quantity
15724 
    self.estimate = estimate
4369 rajveer 15725 
    self.isReminder = isReminder
4303 rajveer 15726 
 
15727 
  def read(self, iprot):
15728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15730 
      return
15731 
    iprot.readStructBegin()
15732 
    while True:
15733 
      (fname, ftype, fid) = iprot.readFieldBegin()
15734 
      if ftype == TType.STOP:
15735 
        break
15736 
      if fid == 1:
15737 
        if ftype == TType.I64:
15738 
          self.vendorId = iprot.readI64();
15739 
        else:
15740 
          iprot.skip(ftype)
15741 
      elif fid == 2:
15742 
        if ftype == TType.I64:
15743 
          self.itemId = iprot.readI64();
15744 
        else:
15745 
          iprot.skip(ftype)
15746 
      elif fid == 3:
15747 
        if ftype == TType.I64:
15748 
          self.quantity = iprot.readI64();
15749 
        else:
15750 
          iprot.skip(ftype)
15751 
      elif fid == 4:
15752 
        if ftype == TType.I64:
15753 
          self.estimate = iprot.readI64();
15754 
        else:
15755 
          iprot.skip(ftype)
4369 rajveer 15756 
      elif fid == 5:
15757 
        if ftype == TType.BOOL:
15758 
          self.isReminder = iprot.readBool();
15759 
        else:
15760 
          iprot.skip(ftype)
4303 rajveer 15761 
      else:
15762 
        iprot.skip(ftype)
15763 
      iprot.readFieldEnd()
15764 
    iprot.readStructEnd()
15765 
 
15766 
  def write(self, oprot):
15767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15769 
      return
15770 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
15771 
    if self.vendorId is not None:
15772 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15773 
      oprot.writeI64(self.vendorId)
15774 
      oprot.writeFieldEnd()
15775 
    if self.itemId is not None:
15776 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15777 
      oprot.writeI64(self.itemId)
15778 
      oprot.writeFieldEnd()
15779 
    if self.quantity is not None:
15780 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15781 
      oprot.writeI64(self.quantity)
15782 
      oprot.writeFieldEnd()
15783 
    if self.estimate is not None:
15784 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15785 
      oprot.writeI64(self.estimate)
15786 
      oprot.writeFieldEnd()
4369 rajveer 15787 
    if self.isReminder is not None:
15788 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15789 
      oprot.writeBool(self.isReminder)
15790 
      oprot.writeFieldEnd()
4303 rajveer 15791 
    oprot.writeFieldStop()
15792 
    oprot.writeStructEnd()
15793 
 
15794 
  def validate(self):
15795 
    return
15796 
 
15797 
 
15798 
  def __repr__(self):
15799 
    L = ['%s=%r' % (key, value)
15800 
      for key, value in self.__dict__.iteritems()]
15801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15802 
 
15803 
  def __eq__(self, other):
15804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15805 
 
15806 
  def __ne__(self, other):
15807 
    return not (self == other)
15808 
 
15809 
class markOrdersAsReversalInitiated_result:
15810 
  """
15811 
  Attributes:
15812 
   - ex
15813 
  """
15814 
 
15815 
  thrift_spec = (
15816 
    None, # 0
15817 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15818 
  )
15819 
 
15820 
  def __init__(self, ex=None,):
15821 
    self.ex = ex
15822 
 
15823 
  def read(self, iprot):
15824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15826 
      return
15827 
    iprot.readStructBegin()
15828 
    while True:
15829 
      (fname, ftype, fid) = iprot.readFieldBegin()
15830 
      if ftype == TType.STOP:
15831 
        break
15832 
      if fid == 1:
15833 
        if ftype == TType.STRUCT:
15834 
          self.ex = TransactionServiceException()
15835 
          self.ex.read(iprot)
15836 
        else:
15837 
          iprot.skip(ftype)
15838 
      else:
15839 
        iprot.skip(ftype)
15840 
      iprot.readFieldEnd()
15841 
    iprot.readStructEnd()
15842 
 
15843 
  def write(self, oprot):
15844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15846 
      return
15847 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
15848 
    if self.ex is not None:
15849 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15850 
      self.ex.write(oprot)
15851 
      oprot.writeFieldEnd()
15852 
    oprot.writeFieldStop()
15853 
    oprot.writeStructEnd()
15854 
 
15855 
  def validate(self):
15856 
    return
15857 
 
15858 
 
15859 
  def __repr__(self):
15860 
    L = ['%s=%r' % (key, value)
15861 
      for key, value in self.__dict__.iteritems()]
15862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15863 
 
15864 
  def __eq__(self, other):
15865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15866 
 
15867 
  def __ne__(self, other):
15868 
    return not (self == other)
15869 
 
15870 
class markOrdersAsNotAvailabke_args:
15871 
  """
15872 
  Attributes:
15873 
   - vendorId
15874 
   - itemId
15875 
   - quantity
15876 
   - estimate
4369 rajveer 15877 
   - isReminder
4303 rajveer 15878 
  """
15879 
 
15880 
  thrift_spec = (
15881 
    None, # 0
15882 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15883 
    (2, TType.I64, 'itemId', None, None, ), # 2
15884 
    (3, TType.I64, 'quantity', None, None, ), # 3
15885 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15886 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15887 
  )
15888 
 
4369 rajveer 15889 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15890 
    self.vendorId = vendorId
15891 
    self.itemId = itemId
15892 
    self.quantity = quantity
15893 
    self.estimate = estimate
4369 rajveer 15894 
    self.isReminder = isReminder
4303 rajveer 15895 
 
15896 
  def read(self, iprot):
15897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15899 
      return
15900 
    iprot.readStructBegin()
15901 
    while True:
15902 
      (fname, ftype, fid) = iprot.readFieldBegin()
15903 
      if ftype == TType.STOP:
15904 
        break
15905 
      if fid == 1:
15906 
        if ftype == TType.I64:
15907 
          self.vendorId = iprot.readI64();
15908 
        else:
15909 
          iprot.skip(ftype)
15910 
      elif fid == 2:
15911 
        if ftype == TType.I64:
15912 
          self.itemId = iprot.readI64();
15913 
        else:
15914 
          iprot.skip(ftype)
15915 
      elif fid == 3:
15916 
        if ftype == TType.I64:
15917 
          self.quantity = iprot.readI64();
15918 
        else:
15919 
          iprot.skip(ftype)
15920 
      elif fid == 4:
15921 
        if ftype == TType.I64:
15922 
          self.estimate = iprot.readI64();
15923 
        else:
15924 
          iprot.skip(ftype)
4369 rajveer 15925 
      elif fid == 5:
15926 
        if ftype == TType.BOOL:
15927 
          self.isReminder = iprot.readBool();
15928 
        else:
15929 
          iprot.skip(ftype)
4303 rajveer 15930 
      else:
15931 
        iprot.skip(ftype)
15932 
      iprot.readFieldEnd()
15933 
    iprot.readStructEnd()
15934 
 
15935 
  def write(self, oprot):
15936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15938 
      return
15939 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
15940 
    if self.vendorId is not None:
15941 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15942 
      oprot.writeI64(self.vendorId)
15943 
      oprot.writeFieldEnd()
15944 
    if self.itemId is not None:
15945 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15946 
      oprot.writeI64(self.itemId)
15947 
      oprot.writeFieldEnd()
15948 
    if self.quantity is not None:
15949 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15950 
      oprot.writeI64(self.quantity)
15951 
      oprot.writeFieldEnd()
15952 
    if self.estimate is not None:
15953 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15954 
      oprot.writeI64(self.estimate)
15955 
      oprot.writeFieldEnd()
4369 rajveer 15956 
    if self.isReminder is not None:
15957 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15958 
      oprot.writeBool(self.isReminder)
15959 
      oprot.writeFieldEnd()
4303 rajveer 15960 
    oprot.writeFieldStop()
15961 
    oprot.writeStructEnd()
15962 
 
15963 
  def validate(self):
15964 
    return
15965 
 
15966 
 
15967 
  def __repr__(self):
15968 
    L = ['%s=%r' % (key, value)
15969 
      for key, value in self.__dict__.iteritems()]
15970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15971 
 
15972 
  def __eq__(self, other):
15973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15974 
 
15975 
  def __ne__(self, other):
15976 
    return not (self == other)
15977 
 
15978 
class markOrdersAsNotAvailabke_result:
15979 
  """
15980 
  Attributes:
15981 
   - ex
15982 
  """
15983 
 
15984 
  thrift_spec = (
15985 
    None, # 0
15986 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15987 
  )
15988 
 
15989 
  def __init__(self, ex=None,):
15990 
    self.ex = ex
15991 
 
15992 
  def read(self, iprot):
15993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15995 
      return
15996 
    iprot.readStructBegin()
15997 
    while True:
15998 
      (fname, ftype, fid) = iprot.readFieldBegin()
15999 
      if ftype == TType.STOP:
16000 
        break
16001 
      if fid == 1:
16002 
        if ftype == TType.STRUCT:
16003 
          self.ex = TransactionServiceException()
16004 
          self.ex.read(iprot)
16005 
        else:
16006 
          iprot.skip(ftype)
16007 
      else:
16008 
        iprot.skip(ftype)
16009 
      iprot.readFieldEnd()
16010 
    iprot.readStructEnd()
16011 
 
16012 
  def write(self, oprot):
16013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16015 
      return
16016 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
16017 
    if self.ex is not None:
16018 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16019 
      self.ex.write(oprot)
16020 
      oprot.writeFieldEnd()
16021 
    oprot.writeFieldStop()
16022 
    oprot.writeStructEnd()
16023 
 
16024 
  def validate(self):
16025 
    return
16026 
 
16027 
 
16028 
  def __repr__(self):
16029 
    L = ['%s=%r' % (key, value)
16030 
      for key, value in self.__dict__.iteritems()]
16031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16032 
 
16033 
  def __eq__(self, other):
16034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16035 
 
16036 
  def __ne__(self, other):
16037 
    return not (self == other)
4369 rajveer 16038 
 
16039 
class markOrdersAsTimeout_args:
16040 
  """
16041 
  Attributes:
16042 
   - vendorId
16043 
  """
16044 
 
16045 
  thrift_spec = (
16046 
    None, # 0
16047 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16048 
  )
16049 
 
16050 
  def __init__(self, vendorId=None,):
16051 
    self.vendorId = vendorId
16052 
 
16053 
  def read(self, iprot):
16054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16056 
      return
16057 
    iprot.readStructBegin()
16058 
    while True:
16059 
      (fname, ftype, fid) = iprot.readFieldBegin()
16060 
      if ftype == TType.STOP:
16061 
        break
16062 
      if fid == 1:
16063 
        if ftype == TType.I64:
16064 
          self.vendorId = iprot.readI64();
16065 
        else:
16066 
          iprot.skip(ftype)
16067 
      else:
16068 
        iprot.skip(ftype)
16069 
      iprot.readFieldEnd()
16070 
    iprot.readStructEnd()
16071 
 
16072 
  def write(self, oprot):
16073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16075 
      return
16076 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
16077 
    if self.vendorId is not None:
16078 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16079 
      oprot.writeI64(self.vendorId)
16080 
      oprot.writeFieldEnd()
16081 
    oprot.writeFieldStop()
16082 
    oprot.writeStructEnd()
16083 
 
16084 
  def validate(self):
16085 
    return
16086 
 
16087 
 
16088 
  def __repr__(self):
16089 
    L = ['%s=%r' % (key, value)
16090 
      for key, value in self.__dict__.iteritems()]
16091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16092 
 
16093 
  def __eq__(self, other):
16094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16095 
 
16096 
  def __ne__(self, other):
16097 
    return not (self == other)
16098 
 
16099 
class markOrdersAsTimeout_result:
16100 
  """
16101 
  Attributes:
16102 
   - success
16103 
   - ex
16104 
  """
16105 
 
16106 
  thrift_spec = (
16107 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
16108 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16109 
  )
16110 
 
16111 
  def __init__(self, success=None, ex=None,):
16112 
    self.success = success
16113 
    self.ex = ex
16114 
 
16115 
  def read(self, iprot):
16116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16118 
      return
16119 
    iprot.readStructBegin()
16120 
    while True:
16121 
      (fname, ftype, fid) = iprot.readFieldBegin()
16122 
      if ftype == TType.STOP:
16123 
        break
16124 
      if fid == 0:
16125 
        if ftype == TType.MAP:
16126 
          self.success = {}
4581 phani.kuma 16127 
          (_ktype269, _vtype270, _size268 ) = iprot.readMapBegin()
16128 
          for _i272 in xrange(_size268):
16129 
            _key273 = iprot.readI32();
16130 
            _val274 = TimeoutSummary()
16131 
            _val274.read(iprot)
16132 
            self.success[_key273] = _val274
4369 rajveer 16133 
          iprot.readMapEnd()
16134 
        else:
16135 
          iprot.skip(ftype)
16136 
      elif fid == 1:
16137 
        if ftype == TType.STRUCT:
16138 
          self.ex = TransactionServiceException()
16139 
          self.ex.read(iprot)
16140 
        else:
16141 
          iprot.skip(ftype)
16142 
      else:
16143 
        iprot.skip(ftype)
16144 
      iprot.readFieldEnd()
16145 
    iprot.readStructEnd()
16146 
 
16147 
  def write(self, oprot):
16148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16150 
      return
16151 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
16152 
    if self.success is not None:
16153 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16154 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4581 phani.kuma 16155 
      for kiter275,viter276 in self.success.items():
16156 
        oprot.writeI32(kiter275)
16157 
        viter276.write(oprot)
4369 rajveer 16158 
      oprot.writeMapEnd()
16159 
      oprot.writeFieldEnd()
16160 
    if self.ex is not None:
16161 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16162 
      self.ex.write(oprot)
16163 
      oprot.writeFieldEnd()
16164 
    oprot.writeFieldStop()
16165 
    oprot.writeStructEnd()
16166 
 
16167 
  def validate(self):
16168 
    return
16169 
 
16170 
 
16171 
  def __repr__(self):
16172 
    L = ['%s=%r' % (key, value)
16173 
      for key, value in self.__dict__.iteritems()]
16174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16175 
 
16176 
  def __eq__(self, other):
16177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16178 
 
16179 
  def __ne__(self, other):
16180 
    return not (self == other)
4386 anupam.sin 16181 
 
16182 
class getOrderForAwb_args:
16183 
  """
16184 
  Attributes:
16185 
   - awb
16186 
  """
16187 
 
16188 
  thrift_spec = (
16189 
    None, # 0
16190 
    (1, TType.STRING, 'awb', None, None, ), # 1
16191 
  )
16192 
 
16193 
  def __init__(self, awb=None,):
16194 
    self.awb = awb
16195 
 
16196 
  def read(self, iprot):
16197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16199 
      return
16200 
    iprot.readStructBegin()
16201 
    while True:
16202 
      (fname, ftype, fid) = iprot.readFieldBegin()
16203 
      if ftype == TType.STOP:
16204 
        break
16205 
      if fid == 1:
16206 
        if ftype == TType.STRING:
16207 
          self.awb = iprot.readString();
16208 
        else:
16209 
          iprot.skip(ftype)
16210 
      else:
16211 
        iprot.skip(ftype)
16212 
      iprot.readFieldEnd()
16213 
    iprot.readStructEnd()
16214 
 
16215 
  def write(self, oprot):
16216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16218 
      return
16219 
    oprot.writeStructBegin('getOrderForAwb_args')
16220 
    if self.awb is not None:
16221 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
16222 
      oprot.writeString(self.awb)
16223 
      oprot.writeFieldEnd()
16224 
    oprot.writeFieldStop()
16225 
    oprot.writeStructEnd()
16226 
 
16227 
  def validate(self):
16228 
    return
16229 
 
16230 
 
16231 
  def __repr__(self):
16232 
    L = ['%s=%r' % (key, value)
16233 
      for key, value in self.__dict__.iteritems()]
16234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16235 
 
16236 
  def __eq__(self, other):
16237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16238 
 
16239 
  def __ne__(self, other):
16240 
    return not (self == other)
16241 
 
16242 
class getOrderForAwb_result:
16243 
  """
16244 
  Attributes:
16245 
   - success
16246 
   - ex
16247 
  """
16248 
 
16249 
  thrift_spec = (
16250 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16251 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16252 
  )
16253 
 
16254 
  def __init__(self, success=None, ex=None,):
16255 
    self.success = success
16256 
    self.ex = ex
16257 
 
16258 
  def read(self, iprot):
16259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16261 
      return
16262 
    iprot.readStructBegin()
16263 
    while True:
16264 
      (fname, ftype, fid) = iprot.readFieldBegin()
16265 
      if ftype == TType.STOP:
16266 
        break
16267 
      if fid == 0:
16268 
        if ftype == TType.STRUCT:
16269 
          self.success = Order()
16270 
          self.success.read(iprot)
16271 
        else:
16272 
          iprot.skip(ftype)
16273 
      elif fid == 1:
16274 
        if ftype == TType.STRUCT:
16275 
          self.ex = TransactionServiceException()
16276 
          self.ex.read(iprot)
16277 
        else:
16278 
          iprot.skip(ftype)
16279 
      else:
16280 
        iprot.skip(ftype)
16281 
      iprot.readFieldEnd()
16282 
    iprot.readStructEnd()
16283 
 
16284 
  def write(self, oprot):
16285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16287 
      return
16288 
    oprot.writeStructBegin('getOrderForAwb_result')
16289 
    if self.success is not None:
16290 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16291 
      self.success.write(oprot)
16292 
      oprot.writeFieldEnd()
16293 
    if self.ex is not None:
16294 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16295 
      self.ex.write(oprot)
16296 
      oprot.writeFieldEnd()
16297 
    oprot.writeFieldStop()
16298 
    oprot.writeStructEnd()
16299 
 
16300 
  def validate(self):
16301 
    return
16302 
 
16303 
 
16304 
  def __repr__(self):
16305 
    L = ['%s=%r' % (key, value)
16306 
      for key, value in self.__dict__.iteritems()]
16307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16308 
 
16309 
  def __eq__(self, other):
16310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16311 
 
16312 
  def __ne__(self, other):
16313 
    return not (self == other)
4506 phani.kuma 16314 
 
16315 
class getOrdersForProviderForStatus_args:
16316 
  """
16317 
  Attributes:
16318 
   - logistics_provider_id
16319 
   - order_status
16320 
  """
16321 
 
16322 
  thrift_spec = (
16323 
    None, # 0
16324 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
16325 
    (2, TType.I32, 'order_status', None, None, ), # 2
16326 
  )
16327 
 
16328 
  def __init__(self, logistics_provider_id=None, order_status=None,):
16329 
    self.logistics_provider_id = logistics_provider_id
16330 
    self.order_status = order_status
16331 
 
16332 
  def read(self, iprot):
16333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16335 
      return
16336 
    iprot.readStructBegin()
16337 
    while True:
16338 
      (fname, ftype, fid) = iprot.readFieldBegin()
16339 
      if ftype == TType.STOP:
16340 
        break
16341 
      if fid == 1:
16342 
        if ftype == TType.I64:
16343 
          self.logistics_provider_id = iprot.readI64();
16344 
        else:
16345 
          iprot.skip(ftype)
16346 
      elif fid == 2:
16347 
        if ftype == TType.I32:
16348 
          self.order_status = iprot.readI32();
16349 
        else:
16350 
          iprot.skip(ftype)
16351 
      else:
16352 
        iprot.skip(ftype)
16353 
      iprot.readFieldEnd()
16354 
    iprot.readStructEnd()
16355 
 
16356 
  def write(self, oprot):
16357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16359 
      return
16360 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
16361 
    if self.logistics_provider_id is not None:
16362 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
16363 
      oprot.writeI64(self.logistics_provider_id)
16364 
      oprot.writeFieldEnd()
16365 
    if self.order_status is not None:
16366 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
16367 
      oprot.writeI32(self.order_status)
16368 
      oprot.writeFieldEnd()
16369 
    oprot.writeFieldStop()
16370 
    oprot.writeStructEnd()
16371 
 
16372 
  def validate(self):
16373 
    return
16374 
 
16375 
 
16376 
  def __repr__(self):
16377 
    L = ['%s=%r' % (key, value)
16378 
      for key, value in self.__dict__.iteritems()]
16379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16380 
 
16381 
  def __eq__(self, other):
16382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16383 
 
16384 
  def __ne__(self, other):
16385 
    return not (self == other)
16386 
 
16387 
class getOrdersForProviderForStatus_result:
16388 
  """
16389 
  Attributes:
16390 
   - success
16391 
   - ex
16392 
  """
16393 
 
16394 
  thrift_spec = (
16395 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16396 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16397 
  )
16398 
 
16399 
  def __init__(self, success=None, ex=None,):
16400 
    self.success = success
16401 
    self.ex = ex
16402 
 
16403 
  def read(self, iprot):
16404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16406 
      return
16407 
    iprot.readStructBegin()
16408 
    while True:
16409 
      (fname, ftype, fid) = iprot.readFieldBegin()
16410 
      if ftype == TType.STOP:
16411 
        break
16412 
      if fid == 0:
16413 
        if ftype == TType.LIST:
16414 
          self.success = []
4581 phani.kuma 16415 
          (_etype280, _size277) = iprot.readListBegin()
16416 
          for _i281 in xrange(_size277):
16417 
            _elem282 = Order()
16418 
            _elem282.read(iprot)
16419 
            self.success.append(_elem282)
4506 phani.kuma 16420 
          iprot.readListEnd()
16421 
        else:
16422 
          iprot.skip(ftype)
16423 
      elif fid == 1:
16424 
        if ftype == TType.STRUCT:
16425 
          self.ex = TransactionServiceException()
16426 
          self.ex.read(iprot)
16427 
        else:
16428 
          iprot.skip(ftype)
16429 
      else:
16430 
        iprot.skip(ftype)
16431 
      iprot.readFieldEnd()
16432 
    iprot.readStructEnd()
16433 
 
16434 
  def write(self, oprot):
16435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16437 
      return
16438 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
16439 
    if self.success is not None:
16440 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16441 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 16442 
      for iter283 in self.success:
16443 
        iter283.write(oprot)
4506 phani.kuma 16444 
      oprot.writeListEnd()
16445 
      oprot.writeFieldEnd()
16446 
    if self.ex is not None:
16447 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16448 
      self.ex.write(oprot)
16449 
      oprot.writeFieldEnd()
16450 
    oprot.writeFieldStop()
16451 
    oprot.writeStructEnd()
16452 
 
16453 
  def validate(self):
16454 
    return
16455 
 
16456 
 
16457 
  def __repr__(self):
16458 
    L = ['%s=%r' % (key, value)
16459 
      for key, value in self.__dict__.iteritems()]
16460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16461 
 
16462 
  def __eq__(self, other):
16463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16464 
 
16465 
  def __ne__(self, other):
16466 
    return not (self == other)