Subversion Repositories SmartDukaan

Rev

Rev 3469 | Rev 3956 | 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 
 
999 varun.gupt 84 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
85 
    """
1132 chandransh 86 
    Returns orders within a range of their billing dates
3431 rajveer 87 
 
999 varun.gupt 88 
    Parameters:
89 
     - status
90 
     - start_billing_date
91 
     - end_billing_date
92 
     - warehouse_id
93 
    """
94 
    pass
95 
 
3451 chandransh 96 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 97 
    """
98 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 99 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
100 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 101 
 
3427 chandransh 102 
    Parameters:
103 
     - fromShippingDate
104 
     - toShippingDate
105 
     - providerId
106 
     - warehouseId
3451 chandransh 107 
     - cod
3427 chandransh 108 
    """
109 
    pass
110 
 
1382 varun.gupt 111 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
112 
    """
113 
    Returns order ids for orders which can be returned
3431 rajveer 114 
 
1382 varun.gupt 115 
    Parameters:
116 
     - customer_id
117 
     - limit
118 
    """
119 
    pass
120 
 
121 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
122 
    """
123 
    Returns order ids for orders which can be cancelled
3431 rajveer 124 
 
1382 varun.gupt 125 
    Parameters:
126 
     - customer_id
127 
     - limit
128 
    """
129 
    pass
130 
 
483 rajveer 131 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 132 
    """
133 
    Parameters:
483 rajveer 134 
     - orderId
135 
     - status
136 
     - description
94 ashish 137 
    """
138 
    pass
139 
 
1528 ankur.sing 140 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 141 
    """
1528 ankur.sing 142 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
143 
    only user who owns the transaction can view its order details.
3431 rajveer 144 
 
94 ashish 145 
    Parameters:
146 
     - transactionId
1528 ankur.sing 147 
     - customerId
94 ashish 148 
    """
149 
    pass
150 
 
3014 chandransh 151 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 152 
    """
3014 chandransh 153 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
154 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 155 
 
94 ashish 156 
    Parameters:
483 rajveer 157 
     - customerId
158 
     - from_date
159 
     - to_date
3014 chandransh 160 
     - statuses
94 ashish 161 
    """
162 
    pass
163 
 
483 rajveer 164 
  def createOrder(self, order):
94 ashish 165 
    """
166 
    Parameters:
483 rajveer 167 
     - order
94 ashish 168 
    """
169 
    pass
170 
 
483 rajveer 171 
  def getOrder(self, id):
94 ashish 172 
    """
173 
    Parameters:
483 rajveer 174 
     - id
94 ashish 175 
    """
176 
    pass
177 
 
483 rajveer 178 
  def getLineItemsForOrder(self, orderId):
94 ashish 179 
    """
180 
    Parameters:
483 rajveer 181 
     - orderId
94 ashish 182 
    """
183 
    pass
184 
 
1528 ankur.sing 185 
  def getOrderForCustomer(self, orderId, customerId):
186 
    """
187 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
188 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 189 
 
1528 ankur.sing 190 
    Parameters:
191 
     - orderId
192 
     - customerId
193 
    """
194 
    pass
195 
 
3064 chandransh 196 
  def getAlerts(self, orderId, valid):
197 
    """
198 
    Parameters:
199 
     - orderId
200 
     - valid
201 
    """
202 
    pass
203 
 
204 
  def setAlert(self, orderId, unset, type, comment):
205 
    """
206 
    Parameters:
207 
     - orderId
208 
     - unset
209 
     - type
210 
     - comment
211 
    """
212 
    pass
213 
 
214 
  def getValidOrderCount(self, ):
215 
    """
216 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
217 
    """
218 
    pass
219 
 
220 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
221 
    """
222 
    Returns the number of distinct customers who have done successful transactions
223 
    """
224 
    pass
225 
 
226 
  def getValidOrdersAmountRange(self, ):
227 
    """
228 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
229 
    List contains two values, first minimum amount and second maximum amount.
230 
    """
231 
    pass
232 
 
233 
  def getValidOrders(self, limit):
234 
    """
235 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
236 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 237 
 
3064 chandransh 238 
    Parameters:
239 
     - limit
240 
    """
241 
    pass
242 
 
1220 chandransh 243 
  def batchOrders(self, warehouseId):
244 
    """
245 
    Create a batch of all the pending orders for the given warehouse.
246 
    The returned list is orderd by created_timestamp.
247 
    If there are no pending orders, an empty list is returned.
3431 rajveer 248 
 
1220 chandransh 249 
    Parameters:
250 
     - warehouseId
251 
    """
252 
    pass
253 
 
1208 chandransh 254 
  def markOrderAsOutOfStock(self, orderId):
255 
    """
256 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 257 
 
1208 chandransh 258 
    Parameters:
259 
     - orderId
260 
    """
261 
    pass
262 
 
3064 chandransh 263 
  def verifyOrder(self, orderId):
759 chandransh 264 
    """
3064 chandransh 265 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
266 
    timestamp. It is intended to be used for COD orders but can be harmlessly
267 
    used for all other orders as well.
268 
    Throws an exception if no such order exists.
3431 rajveer 269 
 
759 chandransh 270 
    Parameters:
3064 chandransh 271 
     - orderId
272 
    """
273 
    pass
274 
 
275 
  def acceptOrder(self, orderId):
276 
    """
277 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
278 
    given order is not a COD order, it also captures the payment if the same has
279 
    not been captured.
280 
    Throws an exception if no such order exists.
3431 rajveer 281 
 
3064 chandransh 282 
    Parameters:
283 
     - orderId
284 
    """
285 
    pass
286 
 
287 
  def billOrder(self, orderId):
288 
    """
289 
    Parameters:
290 
     - orderId
291 
    """
292 
    pass
293 
 
294 
  def addBillingDetails(self, orderId, invoice_number, billed_by):
295 
    """
296 
    Add billing details such as the bill number and the biller to the Order.
297 
    Should be used when the bill is issued by a 3rd party and we've to feed
298 
    the information into our system.
3431 rajveer 299 
 
3064 chandransh 300 
    Parameters:
301 
     - orderId
302 
     - invoice_number
303 
     - billed_by
304 
    """
305 
    pass
306 
 
307 
  def addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
308 
    """
309 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
310 
    the IMEI no. if a -1 is supplied.
311 
    Also, it generates an invoice number for the order, marks the order as
312 
    BILLED and sets the billing timestamp.
313 
    It should be used when we are billing the orders ourselves.
3431 rajveer 314 
 
3064 chandransh 315 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 316 
 
3064 chandransh 317 
    Parameters:
318 
     - orderId
319 
     - jacketNumber
320 
     - imeiNumber
321 
     - itemNumber
322 
     - billedBy
323 
     - billingType
324 
    """
325 
    pass
326 
 
327 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
328 
    """
329 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
330 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 331 
 
3064 chandransh 332 
    Parameters:
759 chandransh 333 
     - warehouseId
334 
     - providerId
3064 chandransh 335 
     - cod
759 chandransh 336 
    """
337 
    pass
338 
 
1113 chandransh 339 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
340 
    """
341 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
342 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
343 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 344 
 
1113 chandransh 345 
    Parameters:
346 
     - providerId
347 
     - pickupDetails
348 
    """
349 
    pass
350 
 
1132 chandransh 351 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
352 
    """
353 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
354 
    the name of the receiver.
355 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 356 
 
1132 chandransh 357 
    Parameters:
358 
     - providerId
359 
     - deliveredOrders
360 
    """
361 
    pass
362 
 
1135 chandransh 363 
  def markOrdersAsFailed(self, providerId, returnedOrders):
364 
    """
365 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
366 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 367 
 
1135 chandransh 368 
    Parameters:
369 
     - providerId
370 
     - returnedOrders
371 
    """
372 
    pass
373 
 
1246 chandransh 374 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
375 
    """
376 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 377 
 
1246 chandransh 378 
    Parameters:
379 
     - providerId
380 
     - undeliveredOrders
381 
    """
382 
    pass
383 
 
1408 ankur.sing 384 
  def getUndeliveredOrders(self, providerId, warehouseId):
385 
    """
386 
    Returns the list of orders whose delivery time has passed but have not been
387 
    delivered yet for the given provider and warehouse. To get a complete list of
388 
    undelivered orders, pass them as -1.
389 
    Returns an empty list if no such orders exist.
3431 rajveer 390 
 
1408 ankur.sing 391 
    Parameters:
392 
     - providerId
393 
     - warehouseId
394 
    """
395 
    pass
396 
 
2536 chandransh 397 
  def toggleDOAFlag(self, orderId):
398 
    """
399 
    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.
400 
    Returns the final flag status.
401 
    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 402 
 
2536 chandransh 403 
    Parameters:
404 
     - orderId
405 
    """
406 
    pass
1886 ankur.sing 407 
 
2536 chandransh 408 
  def requestPickupNumber(self, orderId):
409 
    """
410 
    Sends out an email to the account manager of the original courier provider used to ship the order.
411 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
412 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
413 
    For any other status, it returns false.
414 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 415 
 
2536 chandransh 416 
    Parameters:
417 
     - orderId
418 
    """
419 
    pass
420 
 
421 
  def authorizePickup(self, orderId, pickupNumber):
422 
    """
423 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
424 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
425 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
426 
    	3. Returns true
2591 chandransh 427 
    If the order is in any other status, it returns false.
2536 chandransh 428 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 429 
 
2536 chandransh 430 
    Parameters:
431 
     - orderId
432 
     - pickupNumber
433 
    """
434 
    pass
435 
 
2764 chandransh 436 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
437 
    """
438 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
439 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 440 
 
2764 chandransh 441 
    Parameters:
442 
     - providerId
443 
     - pickupDetails
444 
    """
445 
    pass
446 
 
2616 chandransh 447 
  def receiveReturn(self, orderId):
2591 chandransh 448 
    """
2599 chandransh 449 
    If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED and returns true.
2616 chandransh 450 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 451 
    If the order is in any other state, it returns false.
452 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 453 
 
2591 chandransh 454 
    Parameters:
455 
     - orderId
456 
    """
457 
    pass
2536 chandransh 458 
 
2591 chandransh 459 
  def validateDoa(self, orderId, isValid):
460 
    """
2599 chandransh 461 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 462 
    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 463 
    If the order is in any other state, it returns false.
464 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 465 
 
2591 chandransh 466 
    Parameters:
467 
     - orderId
468 
     - isValid
469 
    """
470 
    pass
471 
 
2616 chandransh 472 
  def reshipOrder(self, orderId):
473 
    """
474 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
475 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
476 
    	2. Marks the current order as one of the final states SALES_RET_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
477 
 
478 
    If the order is in DOA_CERT_VALID state, it does the following:
479 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
480 
    	2. Creates a return order for the warehouse executive to return the DOA material.
481 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 482 
 
2616 chandransh 483 
    Returns the id of the newly created order.
3431 rajveer 484 
 
2616 chandransh 485 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 486 
 
2616 chandransh 487 
    Parameters:
488 
     - orderId
489 
    """
490 
    pass
2591 chandransh 491 
 
3226 chandransh 492 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 493 
    """
494 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
495 
    	1. Creates a refund request for batch processing.
496 
    	2. Creates a return order for the warehouse executive to return the shipped material.
497 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 498 
 
2616 chandransh 499 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
500 
    	1. Creates a refund request for batch processing.
3226 chandransh 501 
    	2. Cancels the reservation of the item in the warehouse.
502 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 503 
 
3226 chandransh 504 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
505 
    	1. Cancels the reservation of the item in the warehouse.
506 
    	2. Marks the current order as CANCELED.
507 
 
508 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
509 
 
2616 chandransh 510 
    Returns True if it is successful, False otherwise.
3431 rajveer 511 
 
2616 chandransh 512 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 513 
 
2616 chandransh 514 
    Parameters:
515 
     - orderId
3226 chandransh 516 
     - refundedBy
517 
     - reason
2616 chandransh 518 
    """
519 
    pass
520 
 
2690 chandransh 521 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
522 
    """
523 
    Get all return orders created between the from and to dates for the given warehouse.
524 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 525 
 
2690 chandransh 526 
    Parameters:
527 
     - warehouseId
528 
     - fromDate
529 
     - toDate
530 
    """
531 
    pass
2616 chandransh 532 
 
2700 chandransh 533 
  def getReturnOrder(self, id):
534 
    """
535 
    Returns the ReturnOrder corresponding to the given id.
536 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 537 
 
2700 chandransh 538 
    Parameters:
539 
     - id
540 
    """
541 
    pass
542 
 
2690 chandransh 543 
  def processReturn(self, returnOrderId):
544 
    """
545 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 546 
 
2690 chandransh 547 
    Parameters:
548 
     - returnOrderId
549 
    """
550 
    pass
551 
 
2819 chandransh 552 
  def createPurchaseOrder(self, warehouseId):
553 
    """
554 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 555 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 556 
 
2819 chandransh 557 
    Parameters:
558 
     - warehouseId
559 
    """
560 
    pass
2690 chandransh 561 
 
3451 chandransh 562 
  def updateWeight(self, orderId, weight):
563 
    """
564 
    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 565 
 
3451 chandransh 566 
    Parameters:
567 
     - orderId
568 
     - weight
569 
    """
570 
    pass
571 
 
3469 chandransh 572 
  def changeItem(self, orderId, itemId):
573 
    """
574 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
575 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 576 
 
3469 chandransh 577 
    Parameters:
578 
     - orderId
579 
     - itemId
580 
    """
581 
    pass
582 
 
583 
  def shiftToWarehouse(self, orderId, warehouseId):
584 
    """
585 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
586 
 
587 
    Parameters:
588 
     - orderId
589 
     - warehouseId
590 
    """
591 
    pass
592 
 
3553 chandransh 593 
  def addDelayReason(self, orderId, delayReason):
594 
    """
595 
    Adds the given delay reason to the given order.
596 
    Raises an exception if no order with the given id can be found.
3469 chandransh 597 
 
3553 chandransh 598 
    Parameters:
599 
     - orderId
600 
     - delayReason
601 
    """
602 
    pass
603 
 
604 
 
3376 rajveer 605 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 606 
  def __init__(self, iprot, oprot=None):
3376 rajveer 607 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 608 
 
609 
  def createTransaction(self, transaction):
610 
    """
611 
    Parameters:
612 
     - transaction
613 
    """
614 
    self.send_createTransaction(transaction)
132 ashish 615 
    return self.recv_createTransaction()
94 ashish 616 
 
617 
  def send_createTransaction(self, transaction):
618 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
619 
    args = createTransaction_args()
620 
    args.transaction = transaction
621 
    args.write(self._oprot)
622 
    self._oprot.writeMessageEnd()
623 
    self._oprot.trans.flush()
624 
 
625 
  def recv_createTransaction(self, ):
626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
627 
    if mtype == TMessageType.EXCEPTION:
628 
      x = TApplicationException()
629 
      x.read(self._iprot)
630 
      self._iprot.readMessageEnd()
631 
      raise x
632 
    result = createTransaction_result()
633 
    result.read(self._iprot)
634 
    self._iprot.readMessageEnd()
3431 rajveer 635 
    if result.success is not None:
132 ashish 636 
      return result.success
3431 rajveer 637 
    if result.ex is not None:
94 ashish 638 
      raise result.ex
132 ashish 639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 640 
 
641 
  def getTransaction(self, id):
642 
    """
643 
    Parameters:
644 
     - id
645 
    """
646 
    self.send_getTransaction(id)
647 
    return self.recv_getTransaction()
648 
 
649 
  def send_getTransaction(self, id):
650 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
651 
    args = getTransaction_args()
652 
    args.id = id
653 
    args.write(self._oprot)
654 
    self._oprot.writeMessageEnd()
655 
    self._oprot.trans.flush()
656 
 
657 
  def recv_getTransaction(self, ):
658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
659 
    if mtype == TMessageType.EXCEPTION:
660 
      x = TApplicationException()
661 
      x.read(self._iprot)
662 
      self._iprot.readMessageEnd()
663 
      raise x
664 
    result = getTransaction_result()
665 
    result.read(self._iprot)
666 
    self._iprot.readMessageEnd()
3431 rajveer 667 
    if result.success is not None:
94 ashish 668 
      return result.success
3431 rajveer 669 
    if result.ex is not None:
94 ashish 670 
      raise result.ex
671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
672 
 
673 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
674 
    """
675 
    Parameters:
676 
     - customerId
677 
     - from_date
678 
     - to_date
679 
     - status
680 
    """
681 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
682 
    return self.recv_getTransactionsForCustomer()
683 
 
684 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
685 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
686 
    args = getTransactionsForCustomer_args()
687 
    args.customerId = customerId
688 
    args.from_date = from_date
689 
    args.to_date = to_date
690 
    args.status = status
691 
    args.write(self._oprot)
692 
    self._oprot.writeMessageEnd()
693 
    self._oprot.trans.flush()
694 
 
695 
  def recv_getTransactionsForCustomer(self, ):
696 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
697 
    if mtype == TMessageType.EXCEPTION:
698 
      x = TApplicationException()
699 
      x.read(self._iprot)
700 
      self._iprot.readMessageEnd()
701 
      raise x
702 
    result = getTransactionsForCustomer_result()
703 
    result.read(self._iprot)
704 
    self._iprot.readMessageEnd()
3431 rajveer 705 
    if result.success is not None:
94 ashish 706 
      return result.success
3431 rajveer 707 
    if result.ex is not None:
94 ashish 708 
      raise result.ex
709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
710 
 
132 ashish 711 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
712 
    """
713 
    Parameters:
714 
     - shoppingCartId
715 
    """
716 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
717 
    return self.recv_getTransactionsForShoppingCartId()
718 
 
719 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
720 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
721 
    args = getTransactionsForShoppingCartId_args()
722 
    args.shoppingCartId = shoppingCartId
723 
    args.write(self._oprot)
724 
    self._oprot.writeMessageEnd()
725 
    self._oprot.trans.flush()
726 
 
727 
  def recv_getTransactionsForShoppingCartId(self, ):
728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
729 
    if mtype == TMessageType.EXCEPTION:
730 
      x = TApplicationException()
731 
      x.read(self._iprot)
732 
      self._iprot.readMessageEnd()
733 
      raise x
734 
    result = getTransactionsForShoppingCartId_result()
735 
    result.read(self._iprot)
736 
    self._iprot.readMessageEnd()
3431 rajveer 737 
    if result.success is not None:
132 ashish 738 
      return result.success
3431 rajveer 739 
    if result.ex is not None:
132 ashish 740 
      raise result.ex
741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
742 
 
94 ashish 743 
  def getTransactionStatus(self, transactionId):
744 
    """
745 
    Parameters:
746 
     - transactionId
747 
    """
748 
    self.send_getTransactionStatus(transactionId)
749 
    return self.recv_getTransactionStatus()
750 
 
751 
  def send_getTransactionStatus(self, transactionId):
752 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
753 
    args = getTransactionStatus_args()
754 
    args.transactionId = transactionId
755 
    args.write(self._oprot)
756 
    self._oprot.writeMessageEnd()
757 
    self._oprot.trans.flush()
758 
 
759 
  def recv_getTransactionStatus(self, ):
760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
761 
    if mtype == TMessageType.EXCEPTION:
762 
      x = TApplicationException()
763 
      x.read(self._iprot)
764 
      self._iprot.readMessageEnd()
765 
      raise x
766 
    result = getTransactionStatus_result()
767 
    result.read(self._iprot)
768 
    self._iprot.readMessageEnd()
3431 rajveer 769 
    if result.success is not None:
94 ashish 770 
      return result.success
3431 rajveer 771 
    if result.ex is not None:
94 ashish 772 
      raise result.ex
773 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
774 
 
775 
  def changeTransactionStatus(self, transactionId, status, description):
776 
    """
777 
    Parameters:
778 
     - transactionId
779 
     - status
780 
     - description
781 
    """
782 
    self.send_changeTransactionStatus(transactionId, status, description)
783 
    return self.recv_changeTransactionStatus()
784 
 
785 
  def send_changeTransactionStatus(self, transactionId, status, description):
786 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
787 
    args = changeTransactionStatus_args()
788 
    args.transactionId = transactionId
789 
    args.status = status
790 
    args.description = description
791 
    args.write(self._oprot)
792 
    self._oprot.writeMessageEnd()
793 
    self._oprot.trans.flush()
794 
 
795 
  def recv_changeTransactionStatus(self, ):
796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
797 
    if mtype == TMessageType.EXCEPTION:
798 
      x = TApplicationException()
799 
      x.read(self._iprot)
800 
      self._iprot.readMessageEnd()
801 
      raise x
802 
    result = changeTransactionStatus_result()
803 
    result.read(self._iprot)
804 
    self._iprot.readMessageEnd()
3431 rajveer 805 
    if result.success is not None:
94 ashish 806 
      return result.success
3431 rajveer 807 
    if result.ex is not None:
94 ashish 808 
      raise result.ex
809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
810 
 
1398 varun.gupt 811 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 812 
    """
813 
    Parameters:
814 
     - transactionId
815 
    """
1398 varun.gupt 816 
    self.send_enqueueTransactionInfoEmail(transactionId)
817 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 818 
 
1398 varun.gupt 819 
  def send_enqueueTransactionInfoEmail(self, transactionId):
820 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
821 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 822 
    args.transactionId = transactionId
823 
    args.write(self._oprot)
824 
    self._oprot.writeMessageEnd()
825 
    self._oprot.trans.flush()
826 
 
1398 varun.gupt 827 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 828 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
829 
    if mtype == TMessageType.EXCEPTION:
830 
      x = TApplicationException()
831 
      x.read(self._iprot)
832 
      self._iprot.readMessageEnd()
833 
      raise x
1398 varun.gupt 834 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 835 
    result.read(self._iprot)
836 
    self._iprot.readMessageEnd()
3431 rajveer 837 
    if result.success is not None:
1382 varun.gupt 838 
      return result.success
3431 rajveer 839 
    if result.ex is not None:
1382 varun.gupt 840 
      raise result.ex
1398 varun.gupt 841 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 842 
 
483 rajveer 843 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 844 
    """
845 
    Parameters:
483 rajveer 846 
     - status
847 
     - from_date
848 
     - to_date
849 
     - warehouse_id
94 ashish 850 
    """
483 rajveer 851 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
852 
    return self.recv_getAllOrders()
94 ashish 853 
 
483 rajveer 854 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
855 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
856 
    args = getAllOrders_args()
857 
    args.status = status
858 
    args.from_date = from_date
859 
    args.to_date = to_date
860 
    args.warehouse_id = warehouse_id
94 ashish 861 
    args.write(self._oprot)
862 
    self._oprot.writeMessageEnd()
863 
    self._oprot.trans.flush()
864 
 
483 rajveer 865 
  def recv_getAllOrders(self, ):
94 ashish 866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
867 
    if mtype == TMessageType.EXCEPTION:
868 
      x = TApplicationException()
869 
      x.read(self._iprot)
870 
      self._iprot.readMessageEnd()
871 
      raise x
483 rajveer 872 
    result = getAllOrders_result()
94 ashish 873 
    result.read(self._iprot)
874 
    self._iprot.readMessageEnd()
3431 rajveer 875 
    if result.success is not None:
94 ashish 876 
      return result.success
3431 rajveer 877 
    if result.ex is not None:
94 ashish 878 
      raise result.ex
483 rajveer 879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 880 
 
999 varun.gupt 881 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
882 
    """
1132 chandransh 883 
    Returns orders within a range of their billing dates
3431 rajveer 884 
 
999 varun.gupt 885 
    Parameters:
886 
     - status
887 
     - start_billing_date
888 
     - end_billing_date
889 
     - warehouse_id
890 
    """
891 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
892 
    return self.recv_getOrdersByBillingDate()
893 
 
894 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
895 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
896 
    args = getOrdersByBillingDate_args()
897 
    args.status = status
898 
    args.start_billing_date = start_billing_date
899 
    args.end_billing_date = end_billing_date
900 
    args.warehouse_id = warehouse_id
901 
    args.write(self._oprot)
902 
    self._oprot.writeMessageEnd()
903 
    self._oprot.trans.flush()
904 
 
905 
  def recv_getOrdersByBillingDate(self, ):
906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
907 
    if mtype == TMessageType.EXCEPTION:
908 
      x = TApplicationException()
909 
      x.read(self._iprot)
910 
      self._iprot.readMessageEnd()
911 
      raise x
912 
    result = getOrdersByBillingDate_result()
913 
    result.read(self._iprot)
914 
    self._iprot.readMessageEnd()
3431 rajveer 915 
    if result.success is not None:
999 varun.gupt 916 
      return result.success
3431 rajveer 917 
    if result.ex is not None:
999 varun.gupt 918 
      raise result.ex
919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
920 
 
3451 chandransh 921 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 922 
    """
923 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 924 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
925 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 926 
 
3427 chandransh 927 
    Parameters:
928 
     - fromShippingDate
929 
     - toShippingDate
930 
     - providerId
931 
     - warehouseId
3451 chandransh 932 
     - cod
3427 chandransh 933 
    """
3451 chandransh 934 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 935 
    return self.recv_getOrdersByShippingDate()
936 
 
3451 chandransh 937 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 938 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
939 
    args = getOrdersByShippingDate_args()
940 
    args.fromShippingDate = fromShippingDate
941 
    args.toShippingDate = toShippingDate
942 
    args.providerId = providerId
943 
    args.warehouseId = warehouseId
3451 chandransh 944 
    args.cod = cod
3427 chandransh 945 
    args.write(self._oprot)
946 
    self._oprot.writeMessageEnd()
947 
    self._oprot.trans.flush()
948 
 
949 
  def recv_getOrdersByShippingDate(self, ):
950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
951 
    if mtype == TMessageType.EXCEPTION:
952 
      x = TApplicationException()
953 
      x.read(self._iprot)
954 
      self._iprot.readMessageEnd()
955 
      raise x
956 
    result = getOrdersByShippingDate_result()
957 
    result.read(self._iprot)
958 
    self._iprot.readMessageEnd()
3431 rajveer 959 
    if result.success is not None:
3427 chandransh 960 
      return result.success
3431 rajveer 961 
    if result.ex is not None:
3427 chandransh 962 
      raise result.ex
963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
964 
 
1382 varun.gupt 965 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
966 
    """
967 
    Returns order ids for orders which can be returned
3431 rajveer 968 
 
1382 varun.gupt 969 
    Parameters:
970 
     - customer_id
971 
     - limit
972 
    """
973 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
974 
    return self.recv_getReturnableOrdersForCustomer()
975 
 
976 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
977 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
978 
    args = getReturnableOrdersForCustomer_args()
979 
    args.customer_id = customer_id
980 
    args.limit = limit
981 
    args.write(self._oprot)
982 
    self._oprot.writeMessageEnd()
983 
    self._oprot.trans.flush()
984 
 
985 
  def recv_getReturnableOrdersForCustomer(self, ):
986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
987 
    if mtype == TMessageType.EXCEPTION:
988 
      x = TApplicationException()
989 
      x.read(self._iprot)
990 
      self._iprot.readMessageEnd()
991 
      raise x
992 
    result = getReturnableOrdersForCustomer_result()
993 
    result.read(self._iprot)
994 
    self._iprot.readMessageEnd()
3431 rajveer 995 
    if result.success is not None:
1382 varun.gupt 996 
      return result.success
3431 rajveer 997 
    if result.ex is not None:
1382 varun.gupt 998 
      raise result.ex
999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1000 
 
1001 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1002 
    """
1003 
    Returns order ids for orders which can be cancelled
3431 rajveer 1004 
 
1382 varun.gupt 1005 
    Parameters:
1006 
     - customer_id
1007 
     - limit
1008 
    """
1009 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1010 
    return self.recv_getCancellableOrdersForCustomer()
1011 
 
1012 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1013 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1014 
    args = getCancellableOrdersForCustomer_args()
1015 
    args.customer_id = customer_id
1016 
    args.limit = limit
1017 
    args.write(self._oprot)
1018 
    self._oprot.writeMessageEnd()
1019 
    self._oprot.trans.flush()
1020 
 
1021 
  def recv_getCancellableOrdersForCustomer(self, ):
1022 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1023 
    if mtype == TMessageType.EXCEPTION:
1024 
      x = TApplicationException()
1025 
      x.read(self._iprot)
1026 
      self._iprot.readMessageEnd()
1027 
      raise x
1028 
    result = getCancellableOrdersForCustomer_result()
1029 
    result.read(self._iprot)
1030 
    self._iprot.readMessageEnd()
3431 rajveer 1031 
    if result.success is not None:
1382 varun.gupt 1032 
      return result.success
3431 rajveer 1033 
    if result.ex is not None:
1382 varun.gupt 1034 
      raise result.ex
1035 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1036 
 
483 rajveer 1037 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1038 
    """
1039 
    Parameters:
483 rajveer 1040 
     - orderId
1041 
     - status
1042 
     - description
94 ashish 1043 
    """
483 rajveer 1044 
    self.send_changeOrderStatus(orderId, status, description)
1045 
    return self.recv_changeOrderStatus()
94 ashish 1046 
 
483 rajveer 1047 
  def send_changeOrderStatus(self, orderId, status, description):
1048 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1049 
    args = changeOrderStatus_args()
1050 
    args.orderId = orderId
1051 
    args.status = status
1052 
    args.description = description
94 ashish 1053 
    args.write(self._oprot)
1054 
    self._oprot.writeMessageEnd()
1055 
    self._oprot.trans.flush()
1056 
 
483 rajveer 1057 
  def recv_changeOrderStatus(self, ):
94 ashish 1058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1059 
    if mtype == TMessageType.EXCEPTION:
1060 
      x = TApplicationException()
1061 
      x.read(self._iprot)
1062 
      self._iprot.readMessageEnd()
1063 
      raise x
483 rajveer 1064 
    result = changeOrderStatus_result()
94 ashish 1065 
    result.read(self._iprot)
1066 
    self._iprot.readMessageEnd()
3431 rajveer 1067 
    if result.success is not None:
94 ashish 1068 
      return result.success
3431 rajveer 1069 
    if result.ex is not None:
94 ashish 1070 
      raise result.ex
483 rajveer 1071 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1072 
 
1528 ankur.sing 1073 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1074 
    """
1528 ankur.sing 1075 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1076 
    only user who owns the transaction can view its order details.
3431 rajveer 1077 
 
94 ashish 1078 
    Parameters:
1079 
     - transactionId
1528 ankur.sing 1080 
     - customerId
94 ashish 1081 
    """
1528 ankur.sing 1082 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1083 
    return self.recv_getOrdersForTransaction()
94 ashish 1084 
 
1528 ankur.sing 1085 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1086 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1087 
    args = getOrdersForTransaction_args()
94 ashish 1088 
    args.transactionId = transactionId
1528 ankur.sing 1089 
    args.customerId = customerId
94 ashish 1090 
    args.write(self._oprot)
1091 
    self._oprot.writeMessageEnd()
1092 
    self._oprot.trans.flush()
1093 
 
483 rajveer 1094 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1096 
    if mtype == TMessageType.EXCEPTION:
1097 
      x = TApplicationException()
1098 
      x.read(self._iprot)
1099 
      self._iprot.readMessageEnd()
1100 
      raise x
483 rajveer 1101 
    result = getOrdersForTransaction_result()
94 ashish 1102 
    result.read(self._iprot)
1103 
    self._iprot.readMessageEnd()
3431 rajveer 1104 
    if result.success is not None:
94 ashish 1105 
      return result.success
3431 rajveer 1106 
    if result.ex is not None:
94 ashish 1107 
      raise result.ex
483 rajveer 1108 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1109 
 
3014 chandransh 1110 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1111 
    """
3014 chandransh 1112 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1113 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1114 
 
94 ashish 1115 
    Parameters:
483 rajveer 1116 
     - customerId
1117 
     - from_date
1118 
     - to_date
3014 chandransh 1119 
     - statuses
94 ashish 1120 
    """
3014 chandransh 1121 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1122 
    return self.recv_getOrdersForCustomer()
94 ashish 1123 
 
3014 chandransh 1124 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1125 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1126 
    args = getOrdersForCustomer_args()
1127 
    args.customerId = customerId
1128 
    args.from_date = from_date
1129 
    args.to_date = to_date
3014 chandransh 1130 
    args.statuses = statuses
94 ashish 1131 
    args.write(self._oprot)
1132 
    self._oprot.writeMessageEnd()
1133 
    self._oprot.trans.flush()
1134 
 
483 rajveer 1135 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1136 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1137 
    if mtype == TMessageType.EXCEPTION:
1138 
      x = TApplicationException()
1139 
      x.read(self._iprot)
1140 
      self._iprot.readMessageEnd()
1141 
      raise x
483 rajveer 1142 
    result = getOrdersForCustomer_result()
94 ashish 1143 
    result.read(self._iprot)
1144 
    self._iprot.readMessageEnd()
3431 rajveer 1145 
    if result.success is not None:
94 ashish 1146 
      return result.success
3431 rajveer 1147 
    if result.ex is not None:
94 ashish 1148 
      raise result.ex
483 rajveer 1149 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1150 
 
483 rajveer 1151 
  def createOrder(self, order):
94 ashish 1152 
    """
1153 
    Parameters:
483 rajveer 1154 
     - order
94 ashish 1155 
    """
483 rajveer 1156 
    self.send_createOrder(order)
1157 
    return self.recv_createOrder()
94 ashish 1158 
 
483 rajveer 1159 
  def send_createOrder(self, order):
1160 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1161 
    args = createOrder_args()
1162 
    args.order = order
94 ashish 1163 
    args.write(self._oprot)
1164 
    self._oprot.writeMessageEnd()
1165 
    self._oprot.trans.flush()
1166 
 
483 rajveer 1167 
  def recv_createOrder(self, ):
94 ashish 1168 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1169 
    if mtype == TMessageType.EXCEPTION:
1170 
      x = TApplicationException()
1171 
      x.read(self._iprot)
1172 
      self._iprot.readMessageEnd()
1173 
      raise x
483 rajveer 1174 
    result = createOrder_result()
94 ashish 1175 
    result.read(self._iprot)
1176 
    self._iprot.readMessageEnd()
3431 rajveer 1177 
    if result.success is not None:
94 ashish 1178 
      return result.success
3431 rajveer 1179 
    if result.ex is not None:
94 ashish 1180 
      raise result.ex
483 rajveer 1181 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1182 
 
483 rajveer 1183 
  def getOrder(self, id):
94 ashish 1184 
    """
1185 
    Parameters:
483 rajveer 1186 
     - id
94 ashish 1187 
    """
483 rajveer 1188 
    self.send_getOrder(id)
1189 
    return self.recv_getOrder()
94 ashish 1190 
 
483 rajveer 1191 
  def send_getOrder(self, id):
1192 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1193 
    args = getOrder_args()
1194 
    args.id = id
94 ashish 1195 
    args.write(self._oprot)
1196 
    self._oprot.writeMessageEnd()
1197 
    self._oprot.trans.flush()
1198 
 
483 rajveer 1199 
  def recv_getOrder(self, ):
94 ashish 1200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1201 
    if mtype == TMessageType.EXCEPTION:
1202 
      x = TApplicationException()
1203 
      x.read(self._iprot)
1204 
      self._iprot.readMessageEnd()
1205 
      raise x
483 rajveer 1206 
    result = getOrder_result()
94 ashish 1207 
    result.read(self._iprot)
1208 
    self._iprot.readMessageEnd()
3431 rajveer 1209 
    if result.success is not None:
94 ashish 1210 
      return result.success
3431 rajveer 1211 
    if result.ex is not None:
94 ashish 1212 
      raise result.ex
483 rajveer 1213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1214 
 
483 rajveer 1215 
  def getLineItemsForOrder(self, orderId):
94 ashish 1216 
    """
1217 
    Parameters:
483 rajveer 1218 
     - orderId
94 ashish 1219 
    """
483 rajveer 1220 
    self.send_getLineItemsForOrder(orderId)
1221 
    return self.recv_getLineItemsForOrder()
94 ashish 1222 
 
483 rajveer 1223 
  def send_getLineItemsForOrder(self, orderId):
1224 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1225 
    args = getLineItemsForOrder_args()
1226 
    args.orderId = orderId
94 ashish 1227 
    args.write(self._oprot)
1228 
    self._oprot.writeMessageEnd()
1229 
    self._oprot.trans.flush()
1230 
 
483 rajveer 1231 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1232 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1233 
    if mtype == TMessageType.EXCEPTION:
1234 
      x = TApplicationException()
1235 
      x.read(self._iprot)
1236 
      self._iprot.readMessageEnd()
1237 
      raise x
483 rajveer 1238 
    result = getLineItemsForOrder_result()
94 ashish 1239 
    result.read(self._iprot)
1240 
    self._iprot.readMessageEnd()
3431 rajveer 1241 
    if result.success is not None:
94 ashish 1242 
      return result.success
3431 rajveer 1243 
    if result.ex is not None:
94 ashish 1244 
      raise result.ex
483 rajveer 1245 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1246 
 
1528 ankur.sing 1247 
  def getOrderForCustomer(self, orderId, customerId):
1248 
    """
1249 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1250 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1251 
 
1528 ankur.sing 1252 
    Parameters:
1253 
     - orderId
1254 
     - customerId
1255 
    """
1256 
    self.send_getOrderForCustomer(orderId, customerId)
1257 
    return self.recv_getOrderForCustomer()
1258 
 
1259 
  def send_getOrderForCustomer(self, orderId, customerId):
1260 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1261 
    args = getOrderForCustomer_args()
1262 
    args.orderId = orderId
1263 
    args.customerId = customerId
1264 
    args.write(self._oprot)
1265 
    self._oprot.writeMessageEnd()
1266 
    self._oprot.trans.flush()
1267 
 
1268 
  def recv_getOrderForCustomer(self, ):
1269 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1270 
    if mtype == TMessageType.EXCEPTION:
1271 
      x = TApplicationException()
1272 
      x.read(self._iprot)
1273 
      self._iprot.readMessageEnd()
1274 
      raise x
1275 
    result = getOrderForCustomer_result()
1276 
    result.read(self._iprot)
1277 
    self._iprot.readMessageEnd()
3431 rajveer 1278 
    if result.success is not None:
1528 ankur.sing 1279 
      return result.success
3431 rajveer 1280 
    if result.ex is not None:
1528 ankur.sing 1281 
      raise result.ex
1282 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1283 
 
3064 chandransh 1284 
  def getAlerts(self, orderId, valid):
1285 
    """
1286 
    Parameters:
1287 
     - orderId
1288 
     - valid
1289 
    """
1290 
    self.send_getAlerts(orderId, valid)
1291 
    return self.recv_getAlerts()
1292 
 
1293 
  def send_getAlerts(self, orderId, valid):
1294 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1295 
    args = getAlerts_args()
1296 
    args.orderId = orderId
1297 
    args.valid = valid
1298 
    args.write(self._oprot)
1299 
    self._oprot.writeMessageEnd()
1300 
    self._oprot.trans.flush()
1301 
 
1302 
  def recv_getAlerts(self, ):
1303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1304 
    if mtype == TMessageType.EXCEPTION:
1305 
      x = TApplicationException()
1306 
      x.read(self._iprot)
1307 
      self._iprot.readMessageEnd()
1308 
      raise x
1309 
    result = getAlerts_result()
1310 
    result.read(self._iprot)
1311 
    self._iprot.readMessageEnd()
3431 rajveer 1312 
    if result.success is not None:
3064 chandransh 1313 
      return result.success
1314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1315 
 
1316 
  def setAlert(self, orderId, unset, type, comment):
1317 
    """
1318 
    Parameters:
1319 
     - orderId
1320 
     - unset
1321 
     - type
1322 
     - comment
1323 
    """
1324 
    self.send_setAlert(orderId, unset, type, comment)
1325 
    self.recv_setAlert()
1326 
 
1327 
  def send_setAlert(self, orderId, unset, type, comment):
1328 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
1329 
    args = setAlert_args()
1330 
    args.orderId = orderId
1331 
    args.unset = unset
1332 
    args.type = type
1333 
    args.comment = comment
1334 
    args.write(self._oprot)
1335 
    self._oprot.writeMessageEnd()
1336 
    self._oprot.trans.flush()
1337 
 
1338 
  def recv_setAlert(self, ):
1339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1340 
    if mtype == TMessageType.EXCEPTION:
1341 
      x = TApplicationException()
1342 
      x.read(self._iprot)
1343 
      self._iprot.readMessageEnd()
1344 
      raise x
1345 
    result = setAlert_result()
1346 
    result.read(self._iprot)
1347 
    self._iprot.readMessageEnd()
1348 
    return
1349 
 
1350 
  def getValidOrderCount(self, ):
1351 
    """
1352 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1353 
    """
1354 
    self.send_getValidOrderCount()
1355 
    return self.recv_getValidOrderCount()
1356 
 
1357 
  def send_getValidOrderCount(self, ):
1358 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1359 
    args = getValidOrderCount_args()
1360 
    args.write(self._oprot)
1361 
    self._oprot.writeMessageEnd()
1362 
    self._oprot.trans.flush()
1363 
 
1364 
  def recv_getValidOrderCount(self, ):
1365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1366 
    if mtype == TMessageType.EXCEPTION:
1367 
      x = TApplicationException()
1368 
      x.read(self._iprot)
1369 
      self._iprot.readMessageEnd()
1370 
      raise x
1371 
    result = getValidOrderCount_result()
1372 
    result.read(self._iprot)
1373 
    self._iprot.readMessageEnd()
3431 rajveer 1374 
    if result.success is not None:
3064 chandransh 1375 
      return result.success
1376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1377 
 
1378 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1379 
    """
1380 
    Returns the number of distinct customers who have done successful transactions
1381 
    """
1382 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1383 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1384 
 
1385 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1386 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1387 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1388 
    args.write(self._oprot)
1389 
    self._oprot.writeMessageEnd()
1390 
    self._oprot.trans.flush()
1391 
 
1392 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1394 
    if mtype == TMessageType.EXCEPTION:
1395 
      x = TApplicationException()
1396 
      x.read(self._iprot)
1397 
      self._iprot.readMessageEnd()
1398 
      raise x
1399 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1400 
    result.read(self._iprot)
1401 
    self._iprot.readMessageEnd()
3431 rajveer 1402 
    if result.success is not None:
3064 chandransh 1403 
      return result.success
1404 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1405 
 
1406 
  def getValidOrdersAmountRange(self, ):
1407 
    """
1408 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1409 
    List contains two values, first minimum amount and second maximum amount.
1410 
    """
1411 
    self.send_getValidOrdersAmountRange()
1412 
    return self.recv_getValidOrdersAmountRange()
1413 
 
1414 
  def send_getValidOrdersAmountRange(self, ):
1415 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1416 
    args = getValidOrdersAmountRange_args()
1417 
    args.write(self._oprot)
1418 
    self._oprot.writeMessageEnd()
1419 
    self._oprot.trans.flush()
1420 
 
1421 
  def recv_getValidOrdersAmountRange(self, ):
1422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1423 
    if mtype == TMessageType.EXCEPTION:
1424 
      x = TApplicationException()
1425 
      x.read(self._iprot)
1426 
      self._iprot.readMessageEnd()
1427 
      raise x
1428 
    result = getValidOrdersAmountRange_result()
1429 
    result.read(self._iprot)
1430 
    self._iprot.readMessageEnd()
3431 rajveer 1431 
    if result.success is not None:
3064 chandransh 1432 
      return result.success
1433 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1434 
 
1435 
  def getValidOrders(self, limit):
1436 
    """
1437 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1438 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1439 
 
3064 chandransh 1440 
    Parameters:
1441 
     - limit
1442 
    """
1443 
    self.send_getValidOrders(limit)
1444 
    return self.recv_getValidOrders()
1445 
 
1446 
  def send_getValidOrders(self, limit):
1447 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1448 
    args = getValidOrders_args()
1449 
    args.limit = limit
1450 
    args.write(self._oprot)
1451 
    self._oprot.writeMessageEnd()
1452 
    self._oprot.trans.flush()
1453 
 
1454 
  def recv_getValidOrders(self, ):
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
1461 
    result = getValidOrders_result()
1462 
    result.read(self._iprot)
1463 
    self._iprot.readMessageEnd()
3431 rajveer 1464 
    if result.success is not None:
3064 chandransh 1465 
      return result.success
1466 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1467 
 
1220 chandransh 1468 
  def batchOrders(self, warehouseId):
1469 
    """
1470 
    Create a batch of all the pending orders for the given warehouse.
1471 
    The returned list is orderd by created_timestamp.
1472 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1473 
 
1220 chandransh 1474 
    Parameters:
1475 
     - warehouseId
1476 
    """
1477 
    self.send_batchOrders(warehouseId)
1478 
    return self.recv_batchOrders()
1479 
 
1480 
  def send_batchOrders(self, warehouseId):
1481 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1482 
    args = batchOrders_args()
1483 
    args.warehouseId = warehouseId
1484 
    args.write(self._oprot)
1485 
    self._oprot.writeMessageEnd()
1486 
    self._oprot.trans.flush()
1487 
 
1488 
  def recv_batchOrders(self, ):
1489 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1490 
    if mtype == TMessageType.EXCEPTION:
1491 
      x = TApplicationException()
1492 
      x.read(self._iprot)
1493 
      self._iprot.readMessageEnd()
1494 
      raise x
1495 
    result = batchOrders_result()
1496 
    result.read(self._iprot)
1497 
    self._iprot.readMessageEnd()
3431 rajveer 1498 
    if result.success is not None:
1220 chandransh 1499 
      return result.success
3431 rajveer 1500 
    if result.ex is not None:
1220 chandransh 1501 
      raise result.ex
1502 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1503 
 
1208 chandransh 1504 
  def markOrderAsOutOfStock(self, orderId):
1505 
    """
1506 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1507 
 
1208 chandransh 1508 
    Parameters:
1509 
     - orderId
1510 
    """
1511 
    self.send_markOrderAsOutOfStock(orderId)
1512 
    return self.recv_markOrderAsOutOfStock()
1513 
 
1514 
  def send_markOrderAsOutOfStock(self, orderId):
1515 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1516 
    args = markOrderAsOutOfStock_args()
1517 
    args.orderId = orderId
1518 
    args.write(self._oprot)
1519 
    self._oprot.writeMessageEnd()
1520 
    self._oprot.trans.flush()
1521 
 
1522 
  def recv_markOrderAsOutOfStock(self, ):
1523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1524 
    if mtype == TMessageType.EXCEPTION:
1525 
      x = TApplicationException()
1526 
      x.read(self._iprot)
1527 
      self._iprot.readMessageEnd()
1528 
      raise x
1529 
    result = markOrderAsOutOfStock_result()
1530 
    result.read(self._iprot)
1531 
    self._iprot.readMessageEnd()
3431 rajveer 1532 
    if result.success is not None:
1208 chandransh 1533 
      return result.success
3431 rajveer 1534 
    if result.ex is not None:
1208 chandransh 1535 
      raise result.ex
1536 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1537 
 
3064 chandransh 1538 
  def verifyOrder(self, orderId):
759 chandransh 1539 
    """
3064 chandransh 1540 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1541 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1542 
    used for all other orders as well.
1543 
    Throws an exception if no such order exists.
3431 rajveer 1544 
 
759 chandransh 1545 
    Parameters:
3064 chandransh 1546 
     - orderId
759 chandransh 1547 
    """
3064 chandransh 1548 
    self.send_verifyOrder(orderId)
1549 
    return self.recv_verifyOrder()
759 chandransh 1550 
 
3064 chandransh 1551 
  def send_verifyOrder(self, orderId):
1552 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1553 
    args = verifyOrder_args()
1554 
    args.orderId = orderId
759 chandransh 1555 
    args.write(self._oprot)
1556 
    self._oprot.writeMessageEnd()
1557 
    self._oprot.trans.flush()
1558 
 
3064 chandransh 1559 
  def recv_verifyOrder(self, ):
759 chandransh 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
3064 chandransh 1566 
    result = verifyOrder_result()
759 chandransh 1567 
    result.read(self._iprot)
1568 
    self._iprot.readMessageEnd()
3431 rajveer 1569 
    if result.success is not None:
759 chandransh 1570 
      return result.success
3431 rajveer 1571 
    if result.ex is not None:
759 chandransh 1572 
      raise result.ex
3064 chandransh 1573 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1574 
 
3064 chandransh 1575 
  def acceptOrder(self, orderId):
1113 chandransh 1576 
    """
3064 chandransh 1577 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1578 
    given order is not a COD order, it also captures the payment if the same has
1579 
    not been captured.
1580 
    Throws an exception if no such order exists.
3431 rajveer 1581 
 
1113 chandransh 1582 
    Parameters:
3064 chandransh 1583 
     - orderId
1113 chandransh 1584 
    """
3064 chandransh 1585 
    self.send_acceptOrder(orderId)
1586 
    return self.recv_acceptOrder()
1113 chandransh 1587 
 
3064 chandransh 1588 
  def send_acceptOrder(self, orderId):
1589 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1590 
    args = acceptOrder_args()
1591 
    args.orderId = orderId
1113 chandransh 1592 
    args.write(self._oprot)
1593 
    self._oprot.writeMessageEnd()
1594 
    self._oprot.trans.flush()
1595 
 
3064 chandransh 1596 
  def recv_acceptOrder(self, ):
1113 chandransh 1597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1598 
    if mtype == TMessageType.EXCEPTION:
1599 
      x = TApplicationException()
1600 
      x.read(self._iprot)
1601 
      self._iprot.readMessageEnd()
1602 
      raise x
3064 chandransh 1603 
    result = acceptOrder_result()
1113 chandransh 1604 
    result.read(self._iprot)
1605 
    self._iprot.readMessageEnd()
3431 rajveer 1606 
    if result.success is not None:
1113 chandransh 1607 
      return result.success
3431 rajveer 1608 
    if result.ex is not None:
1113 chandransh 1609 
      raise result.ex
3064 chandransh 1610 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1611 
 
3064 chandransh 1612 
  def billOrder(self, orderId):
1132 chandransh 1613 
    """
1614 
    Parameters:
3064 chandransh 1615 
     - orderId
1132 chandransh 1616 
    """
3064 chandransh 1617 
    self.send_billOrder(orderId)
1618 
    return self.recv_billOrder()
1132 chandransh 1619 
 
3064 chandransh 1620 
  def send_billOrder(self, orderId):
1621 
    self._oprot.writeMessageBegin('billOrder', TMessageType.CALL, self._seqid)
1622 
    args = billOrder_args()
1623 
    args.orderId = orderId
1132 chandransh 1624 
    args.write(self._oprot)
1625 
    self._oprot.writeMessageEnd()
1626 
    self._oprot.trans.flush()
1627 
 
3064 chandransh 1628 
  def recv_billOrder(self, ):
1132 chandransh 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
3064 chandransh 1635 
    result = billOrder_result()
1132 chandransh 1636 
    result.read(self._iprot)
1637 
    self._iprot.readMessageEnd()
3431 rajveer 1638 
    if result.success is not None:
3064 chandransh 1639 
      return result.success
3431 rajveer 1640 
    if result.ex is not None:
1132 chandransh 1641 
      raise result.ex
3064 chandransh 1642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "billOrder failed: unknown result");
1132 chandransh 1643 
 
3064 chandransh 1644 
  def addBillingDetails(self, orderId, invoice_number, billed_by):
1135 chandransh 1645 
    """
3064 chandransh 1646 
    Add billing details such as the bill number and the biller to the Order.
1647 
    Should be used when the bill is issued by a 3rd party and we've to feed
1648 
    the information into our system.
3431 rajveer 1649 
 
1135 chandransh 1650 
    Parameters:
3064 chandransh 1651 
     - orderId
1652 
     - invoice_number
1653 
     - billed_by
1135 chandransh 1654 
    """
3064 chandransh 1655 
    self.send_addBillingDetails(orderId, invoice_number, billed_by)
1656 
    return self.recv_addBillingDetails()
1135 chandransh 1657 
 
3064 chandransh 1658 
  def send_addBillingDetails(self, orderId, invoice_number, billed_by):
1659 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1660 
    args = addBillingDetails_args()
1661 
    args.orderId = orderId
1662 
    args.invoice_number = invoice_number
1663 
    args.billed_by = billed_by
1135 chandransh 1664 
    args.write(self._oprot)
1665 
    self._oprot.writeMessageEnd()
1666 
    self._oprot.trans.flush()
1667 
 
3064 chandransh 1668 
  def recv_addBillingDetails(self, ):
1135 chandransh 1669 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1670 
    if mtype == TMessageType.EXCEPTION:
1671 
      x = TApplicationException()
1672 
      x.read(self._iprot)
1673 
      self._iprot.readMessageEnd()
1674 
      raise x
3064 chandransh 1675 
    result = addBillingDetails_result()
1135 chandransh 1676 
    result.read(self._iprot)
1677 
    self._iprot.readMessageEnd()
3431 rajveer 1678 
    if result.success is not None:
3064 chandransh 1679 
      return result.success
3431 rajveer 1680 
    if result.ex is not None:
1135 chandransh 1681 
      raise result.ex
3064 chandransh 1682 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 1683 
 
3064 chandransh 1684 
  def addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
1246 chandransh 1685 
    """
3064 chandransh 1686 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1687 
    the IMEI no. if a -1 is supplied.
1688 
    Also, it generates an invoice number for the order, marks the order as
1689 
    BILLED and sets the billing timestamp.
1690 
    It should be used when we are billing the orders ourselves.
3431 rajveer 1691 
 
3064 chandransh 1692 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1693 
 
1246 chandransh 1694 
    Parameters:
3064 chandransh 1695 
     - orderId
1696 
     - jacketNumber
1697 
     - imeiNumber
1698 
     - itemNumber
1699 
     - billedBy
1700 
     - billingType
1246 chandransh 1701 
    """
3064 chandransh 1702 
    self.send_addJacketNumber(orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType)
1703 
    return self.recv_addJacketNumber()
1246 chandransh 1704 
 
3064 chandransh 1705 
  def send_addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
1706 
    self._oprot.writeMessageBegin('addJacketNumber', TMessageType.CALL, self._seqid)
1707 
    args = addJacketNumber_args()
1708 
    args.orderId = orderId
1709 
    args.jacketNumber = jacketNumber
1710 
    args.imeiNumber = imeiNumber
1711 
    args.itemNumber = itemNumber
1712 
    args.billedBy = billedBy
1713 
    args.billingType = billingType
1246 chandransh 1714 
    args.write(self._oprot)
1715 
    self._oprot.writeMessageEnd()
1716 
    self._oprot.trans.flush()
1717 
 
3064 chandransh 1718 
  def recv_addJacketNumber(self, ):
1246 chandransh 1719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1720 
    if mtype == TMessageType.EXCEPTION:
1721 
      x = TApplicationException()
1722 
      x.read(self._iprot)
1723 
      self._iprot.readMessageEnd()
1724 
      raise x
3064 chandransh 1725 
    result = addJacketNumber_result()
1246 chandransh 1726 
    result.read(self._iprot)
1727 
    self._iprot.readMessageEnd()
3431 rajveer 1728 
    if result.success is not None:
3064 chandransh 1729 
      return result.success
3431 rajveer 1730 
    if result.ex is not None:
1246 chandransh 1731 
      raise result.ex
3064 chandransh 1732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addJacketNumber failed: unknown result");
1246 chandransh 1733 
 
3064 chandransh 1734 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 1735 
    """
3064 chandransh 1736 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
1737 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 1738 
 
1408 ankur.sing 1739 
    Parameters:
3064 chandransh 1740 
     - warehouseId
1408 ankur.sing 1741 
     - providerId
3064 chandransh 1742 
     - cod
1408 ankur.sing 1743 
    """
3064 chandransh 1744 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
1745 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 1746 
 
3064 chandransh 1747 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
1748 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1749 
    args = markOrdersAsManifested_args()
1750 
    args.warehouseId = warehouseId
1408 ankur.sing 1751 
    args.providerId = providerId
3064 chandransh 1752 
    args.cod = cod
1408 ankur.sing 1753 
    args.write(self._oprot)
1754 
    self._oprot.writeMessageEnd()
1755 
    self._oprot.trans.flush()
1756 
 
3064 chandransh 1757 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 1758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1759 
    if mtype == TMessageType.EXCEPTION:
1760 
      x = TApplicationException()
1761 
      x.read(self._iprot)
1762 
      self._iprot.readMessageEnd()
1763 
      raise x
3064 chandransh 1764 
    result = markOrdersAsManifested_result()
1408 ankur.sing 1765 
    result.read(self._iprot)
1766 
    self._iprot.readMessageEnd()
3431 rajveer 1767 
    if result.success is not None:
1408 ankur.sing 1768 
      return result.success
3431 rajveer 1769 
    if result.ex is not None:
3064 chandransh 1770 
      raise result.ex
1771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 1772 
 
3064 chandransh 1773 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 1774 
    """
3064 chandransh 1775 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
1776 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
1777 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1778 
 
94 ashish 1779 
    Parameters:
3064 chandransh 1780 
     - providerId
1781 
     - pickupDetails
304 ashish 1782 
    """
3064 chandransh 1783 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
1784 
    return self.recv_markOrdersAsPickedUp()
94 ashish 1785 
 
3064 chandransh 1786 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
1787 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
1788 
    args = markOrdersAsPickedUp_args()
1789 
    args.providerId = providerId
1790 
    args.pickupDetails = pickupDetails
304 ashish 1791 
    args.write(self._oprot)
1792 
    self._oprot.writeMessageEnd()
1793 
    self._oprot.trans.flush()
1794 
 
3064 chandransh 1795 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 1796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1797 
    if mtype == TMessageType.EXCEPTION:
1798 
      x = TApplicationException()
1799 
      x.read(self._iprot)
1800 
      self._iprot.readMessageEnd()
1801 
      raise x
3064 chandransh 1802 
    result = markOrdersAsPickedUp_result()
304 ashish 1803 
    result.read(self._iprot)
1804 
    self._iprot.readMessageEnd()
3431 rajveer 1805 
    if result.success is not None:
304 ashish 1806 
      return result.success
3431 rajveer 1807 
    if result.ex is not None:
3064 chandransh 1808 
      raise result.ex
1809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 1810 
 
3064 chandransh 1811 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 1812 
    """
3064 chandransh 1813 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
1814 
    the name of the receiver.
1815 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1816 
 
304 ashish 1817 
    Parameters:
3064 chandransh 1818 
     - providerId
1819 
     - deliveredOrders
304 ashish 1820 
    """
3064 chandransh 1821 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
1822 
    self.recv_markOrdersAsDelivered()
304 ashish 1823 
 
3064 chandransh 1824 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
1825 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
1826 
    args = markOrdersAsDelivered_args()
1827 
    args.providerId = providerId
1828 
    args.deliveredOrders = deliveredOrders
304 ashish 1829 
    args.write(self._oprot)
1830 
    self._oprot.writeMessageEnd()
1831 
    self._oprot.trans.flush()
1832 
 
3064 chandransh 1833 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 1834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1835 
    if mtype == TMessageType.EXCEPTION:
1836 
      x = TApplicationException()
1837 
      x.read(self._iprot)
1838 
      self._iprot.readMessageEnd()
1839 
      raise x
3064 chandransh 1840 
    result = markOrdersAsDelivered_result()
304 ashish 1841 
    result.read(self._iprot)
1842 
    self._iprot.readMessageEnd()
3431 rajveer 1843 
    if result.ex is not None:
3064 chandransh 1844 
      raise result.ex
304 ashish 1845 
    return
1846 
 
3064 chandransh 1847 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 1848 
    """
3064 chandransh 1849 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
1850 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1851 
 
3064 chandransh 1852 
    Parameters:
1853 
     - providerId
1854 
     - returnedOrders
1596 ankur.sing 1855 
    """
3064 chandransh 1856 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
1857 
    self.recv_markOrdersAsFailed()
304 ashish 1858 
 
3064 chandransh 1859 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
1860 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
1861 
    args = markOrdersAsFailed_args()
1862 
    args.providerId = providerId
1863 
    args.returnedOrders = returnedOrders
1596 ankur.sing 1864 
    args.write(self._oprot)
1865 
    self._oprot.writeMessageEnd()
1866 
    self._oprot.trans.flush()
1867 
 
3064 chandransh 1868 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 1869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1870 
    if mtype == TMessageType.EXCEPTION:
1871 
      x = TApplicationException()
1872 
      x.read(self._iprot)
1873 
      self._iprot.readMessageEnd()
1874 
      raise x
3064 chandransh 1875 
    result = markOrdersAsFailed_result()
1596 ankur.sing 1876 
    result.read(self._iprot)
1877 
    self._iprot.readMessageEnd()
3431 rajveer 1878 
    if result.ex is not None:
3064 chandransh 1879 
      raise result.ex
1880 
    return
1596 ankur.sing 1881 
 
3064 chandransh 1882 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 1883 
    """
3064 chandransh 1884 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 1885 
 
3064 chandransh 1886 
    Parameters:
1887 
     - providerId
1888 
     - undeliveredOrders
1627 ankur.sing 1889 
    """
3064 chandransh 1890 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
1891 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 1892 
 
3064 chandransh 1893 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
1894 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
1895 
    args = updateNonDeliveryReason_args()
1896 
    args.providerId = providerId
1897 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 1898 
    args.write(self._oprot)
1899 
    self._oprot.writeMessageEnd()
1900 
    self._oprot.trans.flush()
1901 
 
3064 chandransh 1902 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 1903 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1904 
    if mtype == TMessageType.EXCEPTION:
1905 
      x = TApplicationException()
1906 
      x.read(self._iprot)
1907 
      self._iprot.readMessageEnd()
1908 
      raise x
3064 chandransh 1909 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 1910 
    result.read(self._iprot)
1911 
    self._iprot.readMessageEnd()
3431 rajveer 1912 
    if result.ex is not None:
3064 chandransh 1913 
      raise result.ex
1914 
    return
1627 ankur.sing 1915 
 
3064 chandransh 1916 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 1917 
    """
3064 chandransh 1918 
    Returns the list of orders whose delivery time has passed but have not been
1919 
    delivered yet for the given provider and warehouse. To get a complete list of
1920 
    undelivered orders, pass them as -1.
1921 
    Returns an empty list if no such orders exist.
3431 rajveer 1922 
 
1886 ankur.sing 1923 
    Parameters:
3064 chandransh 1924 
     - providerId
1925 
     - warehouseId
1886 ankur.sing 1926 
    """
3064 chandransh 1927 
    self.send_getUndeliveredOrders(providerId, warehouseId)
1928 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 1929 
 
3064 chandransh 1930 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
1931 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
1932 
    args = getUndeliveredOrders_args()
1933 
    args.providerId = providerId
1934 
    args.warehouseId = warehouseId
1886 ankur.sing 1935 
    args.write(self._oprot)
1936 
    self._oprot.writeMessageEnd()
1937 
    self._oprot.trans.flush()
1938 
 
3064 chandransh 1939 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 1940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1941 
    if mtype == TMessageType.EXCEPTION:
1942 
      x = TApplicationException()
1943 
      x.read(self._iprot)
1944 
      self._iprot.readMessageEnd()
1945 
      raise x
3064 chandransh 1946 
    result = getUndeliveredOrders_result()
1886 ankur.sing 1947 
    result.read(self._iprot)
1948 
    self._iprot.readMessageEnd()
3431 rajveer 1949 
    if result.success is not None:
1886 ankur.sing 1950 
      return result.success
3064 chandransh 1951 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 1952 
 
2536 chandransh 1953 
  def toggleDOAFlag(self, orderId):
1954 
    """
1955 
    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.
1956 
    Returns the final flag status.
1957 
    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 1958 
 
2536 chandransh 1959 
    Parameters:
1960 
     - orderId
1961 
    """
1962 
    self.send_toggleDOAFlag(orderId)
1963 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 1964 
 
2536 chandransh 1965 
  def send_toggleDOAFlag(self, orderId):
1966 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
1967 
    args = toggleDOAFlag_args()
1968 
    args.orderId = orderId
1969 
    args.write(self._oprot)
1970 
    self._oprot.writeMessageEnd()
1971 
    self._oprot.trans.flush()
1972 
 
1973 
  def recv_toggleDOAFlag(self, ):
1974 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1975 
    if mtype == TMessageType.EXCEPTION:
1976 
      x = TApplicationException()
1977 
      x.read(self._iprot)
1978 
      self._iprot.readMessageEnd()
1979 
      raise x
1980 
    result = toggleDOAFlag_result()
1981 
    result.read(self._iprot)
1982 
    self._iprot.readMessageEnd()
3431 rajveer 1983 
    if result.success is not None:
2536 chandransh 1984 
      return result.success
3431 rajveer 1985 
    if result.ex is not None:
2536 chandransh 1986 
      raise result.ex
1987 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
1988 
 
1989 
  def requestPickupNumber(self, orderId):
1990 
    """
1991 
    Sends out an email to the account manager of the original courier provider used to ship the order.
1992 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
1993 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
1994 
    For any other status, it returns false.
1995 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 1996 
 
2536 chandransh 1997 
    Parameters:
1998 
     - orderId
1999 
    """
2000 
    self.send_requestPickupNumber(orderId)
2001 
    return self.recv_requestPickupNumber()
2002 
 
2003 
  def send_requestPickupNumber(self, orderId):
2004 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2005 
    args = requestPickupNumber_args()
2006 
    args.orderId = orderId
2007 
    args.write(self._oprot)
2008 
    self._oprot.writeMessageEnd()
2009 
    self._oprot.trans.flush()
2010 
 
2011 
  def recv_requestPickupNumber(self, ):
2012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2013 
    if mtype == TMessageType.EXCEPTION:
2014 
      x = TApplicationException()
2015 
      x.read(self._iprot)
2016 
      self._iprot.readMessageEnd()
2017 
      raise x
2018 
    result = requestPickupNumber_result()
2019 
    result.read(self._iprot)
2020 
    self._iprot.readMessageEnd()
3431 rajveer 2021 
    if result.success is not None:
2536 chandransh 2022 
      return result.success
3431 rajveer 2023 
    if result.ex is not None:
2536 chandransh 2024 
      raise result.ex
2025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2026 
 
2027 
  def authorizePickup(self, orderId, pickupNumber):
2028 
    """
2029 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
2030 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2031 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2032 
    	3. Returns true
2591 chandransh 2033 
    If the order is in any other status, it returns false.
2536 chandransh 2034 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2035 
 
2536 chandransh 2036 
    Parameters:
2037 
     - orderId
2038 
     - pickupNumber
2039 
    """
2040 
    self.send_authorizePickup(orderId, pickupNumber)
2041 
    return self.recv_authorizePickup()
2042 
 
2043 
  def send_authorizePickup(self, orderId, pickupNumber):
2044 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2045 
    args = authorizePickup_args()
2046 
    args.orderId = orderId
2047 
    args.pickupNumber = pickupNumber
2048 
    args.write(self._oprot)
2049 
    self._oprot.writeMessageEnd()
2050 
    self._oprot.trans.flush()
2051 
 
2052 
  def recv_authorizePickup(self, ):
2053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2054 
    if mtype == TMessageType.EXCEPTION:
2055 
      x = TApplicationException()
2056 
      x.read(self._iprot)
2057 
      self._iprot.readMessageEnd()
2058 
      raise x
2059 
    result = authorizePickup_result()
2060 
    result.read(self._iprot)
2061 
    self._iprot.readMessageEnd()
3431 rajveer 2062 
    if result.success is not None:
2536 chandransh 2063 
      return result.success
3431 rajveer 2064 
    if result.ex is not None:
2536 chandransh 2065 
      raise result.ex
2066 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2067 
 
2764 chandransh 2068 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2069 
    """
2070 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2071 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2072 
 
2764 chandransh 2073 
    Parameters:
2074 
     - providerId
2075 
     - pickupDetails
2076 
    """
2077 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2078 
    return self.recv_markDoasAsPickedUp()
2079 
 
2080 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2081 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2082 
    args = markDoasAsPickedUp_args()
2083 
    args.providerId = providerId
2084 
    args.pickupDetails = pickupDetails
2085 
    args.write(self._oprot)
2086 
    self._oprot.writeMessageEnd()
2087 
    self._oprot.trans.flush()
2088 
 
2089 
  def recv_markDoasAsPickedUp(self, ):
2090 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2091 
    if mtype == TMessageType.EXCEPTION:
2092 
      x = TApplicationException()
2093 
      x.read(self._iprot)
2094 
      self._iprot.readMessageEnd()
2095 
      raise x
2096 
    result = markDoasAsPickedUp_result()
2097 
    result.read(self._iprot)
2098 
    self._iprot.readMessageEnd()
3431 rajveer 2099 
    if result.success is not None:
2764 chandransh 2100 
      return result.success
2101 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2102 
 
2616 chandransh 2103 
  def receiveReturn(self, orderId):
2591 chandransh 2104 
    """
2599 chandransh 2105 
    If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED and returns true.
2616 chandransh 2106 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 2107 
    If the order is in any other state, it returns false.
2108 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2109 
 
2591 chandransh 2110 
    Parameters:
2111 
     - orderId
2112 
    """
2616 chandransh 2113 
    self.send_receiveReturn(orderId)
2114 
    return self.recv_receiveReturn()
2536 chandransh 2115 
 
2616 chandransh 2116 
  def send_receiveReturn(self, orderId):
2117 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2118 
    args = receiveReturn_args()
2591 chandransh 2119 
    args.orderId = orderId
2120 
    args.write(self._oprot)
2121 
    self._oprot.writeMessageEnd()
2122 
    self._oprot.trans.flush()
2123 
 
2616 chandransh 2124 
  def recv_receiveReturn(self, ):
2591 chandransh 2125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2126 
    if mtype == TMessageType.EXCEPTION:
2127 
      x = TApplicationException()
2128 
      x.read(self._iprot)
2129 
      self._iprot.readMessageEnd()
2130 
      raise x
2616 chandransh 2131 
    result = receiveReturn_result()
2591 chandransh 2132 
    result.read(self._iprot)
2133 
    self._iprot.readMessageEnd()
3431 rajveer 2134 
    if result.success is not None:
2591 chandransh 2135 
      return result.success
3431 rajveer 2136 
    if result.ex is not None:
2591 chandransh 2137 
      raise result.ex
2616 chandransh 2138 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2139 
 
2140 
  def validateDoa(self, orderId, isValid):
2141 
    """
2599 chandransh 2142 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 2143 
    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 2144 
    If the order is in any other state, it returns false.
2145 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2146 
 
2591 chandransh 2147 
    Parameters:
2148 
     - orderId
2149 
     - isValid
2150 
    """
2151 
    self.send_validateDoa(orderId, isValid)
2152 
    return self.recv_validateDoa()
2153 
 
2154 
  def send_validateDoa(self, orderId, isValid):
2155 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2156 
    args = validateDoa_args()
2157 
    args.orderId = orderId
2158 
    args.isValid = isValid
2159 
    args.write(self._oprot)
2160 
    self._oprot.writeMessageEnd()
2161 
    self._oprot.trans.flush()
2162 
 
2163 
  def recv_validateDoa(self, ):
2164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2165 
    if mtype == TMessageType.EXCEPTION:
2166 
      x = TApplicationException()
2167 
      x.read(self._iprot)
2168 
      self._iprot.readMessageEnd()
2169 
      raise x
2170 
    result = validateDoa_result()
2171 
    result.read(self._iprot)
2172 
    self._iprot.readMessageEnd()
3431 rajveer 2173 
    if result.success is not None:
2591 chandransh 2174 
      return result.success
3431 rajveer 2175 
    if result.ex is not None:
2591 chandransh 2176 
      raise result.ex
2177 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2178 
 
2616 chandransh 2179 
  def reshipOrder(self, orderId):
2180 
    """
2181 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2182 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2183 
    	2. Marks the current order as one of the final states SALES_RET_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2184 
 
2185 
    If the order is in DOA_CERT_VALID state, it does the following:
2186 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2187 
    	2. Creates a return order for the warehouse executive to return the DOA material.
2188 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 2189 
 
2616 chandransh 2190 
    Returns the id of the newly created order.
3431 rajveer 2191 
 
2616 chandransh 2192 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2193 
 
2616 chandransh 2194 
    Parameters:
2195 
     - orderId
2196 
    """
2197 
    self.send_reshipOrder(orderId)
2198 
    return self.recv_reshipOrder()
2591 chandransh 2199 
 
2616 chandransh 2200 
  def send_reshipOrder(self, orderId):
2201 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2202 
    args = reshipOrder_args()
2203 
    args.orderId = orderId
2204 
    args.write(self._oprot)
2205 
    self._oprot.writeMessageEnd()
2206 
    self._oprot.trans.flush()
2207 
 
2208 
  def recv_reshipOrder(self, ):
2209 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2210 
    if mtype == TMessageType.EXCEPTION:
2211 
      x = TApplicationException()
2212 
      x.read(self._iprot)
2213 
      self._iprot.readMessageEnd()
2214 
      raise x
2215 
    result = reshipOrder_result()
2216 
    result.read(self._iprot)
2217 
    self._iprot.readMessageEnd()
3431 rajveer 2218 
    if result.success is not None:
2616 chandransh 2219 
      return result.success
3431 rajveer 2220 
    if result.ex is not None:
2616 chandransh 2221 
      raise result.ex
2222 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2223 
 
3226 chandransh 2224 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2225 
    """
2226 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2227 
    	1. Creates a refund request for batch processing.
2228 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2229 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2230 
 
2616 chandransh 2231 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2232 
    	1. Creates a refund request for batch processing.
3226 chandransh 2233 
    	2. Cancels the reservation of the item in the warehouse.
2234 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2235 
 
3226 chandransh 2236 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2237 
    	1. Cancels the reservation of the item in the warehouse.
2238 
    	2. Marks the current order as CANCELED.
2239 
 
2240 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2241 
 
2616 chandransh 2242 
    Returns True if it is successful, False otherwise.
3431 rajveer 2243 
 
2616 chandransh 2244 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2245 
 
2616 chandransh 2246 
    Parameters:
2247 
     - orderId
3226 chandransh 2248 
     - refundedBy
2249 
     - reason
2616 chandransh 2250 
    """
3226 chandransh 2251 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2252 
    return self.recv_refundOrder()
2253 
 
3226 chandransh 2254 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2255 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2256 
    args = refundOrder_args()
2257 
    args.orderId = orderId
3226 chandransh 2258 
    args.refundedBy = refundedBy
2259 
    args.reason = reason
2616 chandransh 2260 
    args.write(self._oprot)
2261 
    self._oprot.writeMessageEnd()
2262 
    self._oprot.trans.flush()
2263 
 
2264 
  def recv_refundOrder(self, ):
2265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2266 
    if mtype == TMessageType.EXCEPTION:
2267 
      x = TApplicationException()
2268 
      x.read(self._iprot)
2269 
      self._iprot.readMessageEnd()
2270 
      raise x
2271 
    result = refundOrder_result()
2272 
    result.read(self._iprot)
2273 
    self._iprot.readMessageEnd()
3431 rajveer 2274 
    if result.success is not None:
2616 chandransh 2275 
      return result.success
3431 rajveer 2276 
    if result.ex is not None:
2616 chandransh 2277 
      raise result.ex
2278 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2279 
 
2690 chandransh 2280 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2281 
    """
2282 
    Get all return orders created between the from and to dates for the given warehouse.
2283 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2284 
 
2690 chandransh 2285 
    Parameters:
2286 
     - warehouseId
2287 
     - fromDate
2288 
     - toDate
2289 
    """
2290 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2291 
    return self.recv_getReturnOrders()
2616 chandransh 2292 
 
2690 chandransh 2293 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2294 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2295 
    args = getReturnOrders_args()
2296 
    args.warehouseId = warehouseId
2297 
    args.fromDate = fromDate
2298 
    args.toDate = toDate
2299 
    args.write(self._oprot)
2300 
    self._oprot.writeMessageEnd()
2301 
    self._oprot.trans.flush()
2302 
 
2303 
  def recv_getReturnOrders(self, ):
2304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2305 
    if mtype == TMessageType.EXCEPTION:
2306 
      x = TApplicationException()
2307 
      x.read(self._iprot)
2308 
      self._iprot.readMessageEnd()
2309 
      raise x
2310 
    result = getReturnOrders_result()
2311 
    result.read(self._iprot)
2312 
    self._iprot.readMessageEnd()
3431 rajveer 2313 
    if result.success is not None:
2690 chandransh 2314 
      return result.success
2315 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2316 
 
2700 chandransh 2317 
  def getReturnOrder(self, id):
2318 
    """
2319 
    Returns the ReturnOrder corresponding to the given id.
2320 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2321 
 
2700 chandransh 2322 
    Parameters:
2323 
     - id
2324 
    """
2325 
    self.send_getReturnOrder(id)
2326 
    return self.recv_getReturnOrder()
2327 
 
2328 
  def send_getReturnOrder(self, id):
2329 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2330 
    args = getReturnOrder_args()
2331 
    args.id = id
2332 
    args.write(self._oprot)
2333 
    self._oprot.writeMessageEnd()
2334 
    self._oprot.trans.flush()
2335 
 
2336 
  def recv_getReturnOrder(self, ):
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
2343 
    result = getReturnOrder_result()
2344 
    result.read(self._iprot)
2345 
    self._iprot.readMessageEnd()
3431 rajveer 2346 
    if result.success is not None:
2700 chandransh 2347 
      return result.success
3431 rajveer 2348 
    if result.ex is not None:
2700 chandransh 2349 
      raise result.ex
2350 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2351 
 
2690 chandransh 2352 
  def processReturn(self, returnOrderId):
2353 
    """
2354 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2355 
 
2690 chandransh 2356 
    Parameters:
2357 
     - returnOrderId
2358 
    """
2359 
    self.send_processReturn(returnOrderId)
2360 
    self.recv_processReturn()
2361 
 
2362 
  def send_processReturn(self, returnOrderId):
2363 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2364 
    args = processReturn_args()
2365 
    args.returnOrderId = returnOrderId
2366 
    args.write(self._oprot)
2367 
    self._oprot.writeMessageEnd()
2368 
    self._oprot.trans.flush()
2369 
 
2370 
  def recv_processReturn(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 = processReturn_result()
2378 
    result.read(self._iprot)
2379 
    self._iprot.readMessageEnd()
3431 rajveer 2380 
    if result.ex is not None:
2690 chandransh 2381 
      raise result.ex
2382 
    return
2383 
 
2819 chandransh 2384 
  def createPurchaseOrder(self, warehouseId):
2385 
    """
2386 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2387 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2388 
 
2819 chandransh 2389 
    Parameters:
2390 
     - warehouseId
2391 
    """
2392 
    self.send_createPurchaseOrder(warehouseId)
2393 
    return self.recv_createPurchaseOrder()
2690 chandransh 2394 
 
2819 chandransh 2395 
  def send_createPurchaseOrder(self, warehouseId):
2396 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2397 
    args = createPurchaseOrder_args()
2398 
    args.warehouseId = warehouseId
2399 
    args.write(self._oprot)
2400 
    self._oprot.writeMessageEnd()
2401 
    self._oprot.trans.flush()
2402 
 
2403 
  def recv_createPurchaseOrder(self, ):
2404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2405 
    if mtype == TMessageType.EXCEPTION:
2406 
      x = TApplicationException()
2407 
      x.read(self._iprot)
2408 
      self._iprot.readMessageEnd()
2409 
      raise x
2410 
    result = createPurchaseOrder_result()
2411 
    result.read(self._iprot)
2412 
    self._iprot.readMessageEnd()
3431 rajveer 2413 
    if result.success is not None:
2819 chandransh 2414 
      return result.success
3431 rajveer 2415 
    if result.ex is not None:
2819 chandransh 2416 
      raise result.ex
2417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2418 
 
3451 chandransh 2419 
  def updateWeight(self, orderId, weight):
2420 
    """
2421 
    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 2422 
 
3451 chandransh 2423 
    Parameters:
2424 
     - orderId
2425 
     - weight
2426 
    """
2427 
    self.send_updateWeight(orderId, weight)
2428 
    return self.recv_updateWeight()
2429 
 
2430 
  def send_updateWeight(self, orderId, weight):
2431 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2432 
    args = updateWeight_args()
2433 
    args.orderId = orderId
2434 
    args.weight = weight
2435 
    args.write(self._oprot)
2436 
    self._oprot.writeMessageEnd()
2437 
    self._oprot.trans.flush()
2438 
 
2439 
  def recv_updateWeight(self, ):
2440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2441 
    if mtype == TMessageType.EXCEPTION:
2442 
      x = TApplicationException()
2443 
      x.read(self._iprot)
2444 
      self._iprot.readMessageEnd()
2445 
      raise x
2446 
    result = updateWeight_result()
2447 
    result.read(self._iprot)
2448 
    self._iprot.readMessageEnd()
2449 
    if result.success is not None:
2450 
      return result.success
2451 
    if result.ex is not None:
2452 
      raise result.ex
2453 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2454 
 
3469 chandransh 2455 
  def changeItem(self, orderId, itemId):
2456 
    """
2457 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2458 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2459 
 
3469 chandransh 2460 
    Parameters:
2461 
     - orderId
2462 
     - itemId
2463 
    """
2464 
    self.send_changeItem(orderId, itemId)
2465 
    return self.recv_changeItem()
2466 
 
2467 
  def send_changeItem(self, orderId, itemId):
2468 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2469 
    args = changeItem_args()
2470 
    args.orderId = orderId
2471 
    args.itemId = itemId
2472 
    args.write(self._oprot)
2473 
    self._oprot.writeMessageEnd()
2474 
    self._oprot.trans.flush()
2475 
 
2476 
  def recv_changeItem(self, ):
2477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2478 
    if mtype == TMessageType.EXCEPTION:
2479 
      x = TApplicationException()
2480 
      x.read(self._iprot)
2481 
      self._iprot.readMessageEnd()
2482 
      raise x
2483 
    result = changeItem_result()
2484 
    result.read(self._iprot)
2485 
    self._iprot.readMessageEnd()
2486 
    if result.success is not None:
2487 
      return result.success
2488 
    if result.ex is not None:
2489 
      raise result.ex
2490 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2491 
 
2492 
  def shiftToWarehouse(self, orderId, warehouseId):
2493 
    """
2494 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2495 
 
2496 
    Parameters:
2497 
     - orderId
2498 
     - warehouseId
2499 
    """
2500 
    self.send_shiftToWarehouse(orderId, warehouseId)
2501 
    return self.recv_shiftToWarehouse()
2502 
 
2503 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2504 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2505 
    args = shiftToWarehouse_args()
2506 
    args.orderId = orderId
2507 
    args.warehouseId = warehouseId
2508 
    args.write(self._oprot)
2509 
    self._oprot.writeMessageEnd()
2510 
    self._oprot.trans.flush()
2511 
 
2512 
  def recv_shiftToWarehouse(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 = shiftToWarehouse_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, "shiftToWarehouse failed: unknown result");
2527 
 
3553 chandransh 2528 
  def addDelayReason(self, orderId, delayReason):
2529 
    """
2530 
    Adds the given delay reason to the given order.
2531 
    Raises an exception if no order with the given id can be found.
3469 chandransh 2532 
 
3553 chandransh 2533 
    Parameters:
2534 
     - orderId
2535 
     - delayReason
2536 
    """
2537 
    self.send_addDelayReason(orderId, delayReason)
2538 
    return self.recv_addDelayReason()
2539 
 
2540 
  def send_addDelayReason(self, orderId, delayReason):
2541 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
2542 
    args = addDelayReason_args()
2543 
    args.orderId = orderId
2544 
    args.delayReason = delayReason
2545 
    args.write(self._oprot)
2546 
    self._oprot.writeMessageEnd()
2547 
    self._oprot.trans.flush()
2548 
 
2549 
  def recv_addDelayReason(self, ):
2550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2551 
    if mtype == TMessageType.EXCEPTION:
2552 
      x = TApplicationException()
2553 
      x.read(self._iprot)
2554 
      self._iprot.readMessageEnd()
2555 
      raise x
2556 
    result = addDelayReason_result()
2557 
    result.read(self._iprot)
2558 
    self._iprot.readMessageEnd()
2559 
    if result.success is not None:
2560 
      return result.success
2561 
    if result.ex is not None:
2562 
      raise result.ex
2563 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
2564 
 
2565 
 
3376 rajveer 2566 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 2567 
  def __init__(self, handler):
3376 rajveer 2568 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 2569 
    self._processMap["createTransaction"] = Processor.process_createTransaction
2570 
    self._processMap["getTransaction"] = Processor.process_getTransaction
2571 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 2572 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 2573 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
2574 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 2575 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 2576 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
999 varun.gupt 2577 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 2578 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 2579 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
2580 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 2581 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
2582 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
2583 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
2584 
    self._processMap["createOrder"] = Processor.process_createOrder
2585 
    self._processMap["getOrder"] = Processor.process_getOrder
2586 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 2587 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 2588 
    self._processMap["getAlerts"] = Processor.process_getAlerts
2589 
    self._processMap["setAlert"] = Processor.process_setAlert
2590 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
2591 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
2592 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
2593 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 2594 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 2595 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 2596 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
2597 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
2598 
    self._processMap["billOrder"] = Processor.process_billOrder
2599 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
2600 
    self._processMap["addJacketNumber"] = Processor.process_addJacketNumber
759 chandransh 2601 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 2602 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 2603 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 2604 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 2605 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 2606 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 2607 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
2608 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
2609 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 2610 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 2611 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 2612 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 2613 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
2614 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 2615 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 2616 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 2617 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 2618 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 2619 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 2620 
    self._processMap["changeItem"] = Processor.process_changeItem
2621 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 2622 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
94 ashish 2623 
 
2624 
  def process(self, iprot, oprot):
2625 
    (name, type, seqid) = iprot.readMessageBegin()
2626 
    if name not in self._processMap:
2627 
      iprot.skip(TType.STRUCT)
2628 
      iprot.readMessageEnd()
2629 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2630 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2631 
      x.write(oprot)
2632 
      oprot.writeMessageEnd()
2633 
      oprot.trans.flush()
2634 
      return
2635 
    else:
2636 
      self._processMap[name](self, seqid, iprot, oprot)
2637 
    return True
2638 
 
2639 
  def process_createTransaction(self, seqid, iprot, oprot):
2640 
    args = createTransaction_args()
2641 
    args.read(iprot)
2642 
    iprot.readMessageEnd()
2643 
    result = createTransaction_result()
2644 
    try:
132 ashish 2645 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 2646 
    except TransactionServiceException, ex:
2647 
      result.ex = ex
2648 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
2649 
    result.write(oprot)
2650 
    oprot.writeMessageEnd()
2651 
    oprot.trans.flush()
2652 
 
2653 
  def process_getTransaction(self, seqid, iprot, oprot):
2654 
    args = getTransaction_args()
2655 
    args.read(iprot)
2656 
    iprot.readMessageEnd()
2657 
    result = getTransaction_result()
2658 
    try:
2659 
      result.success = self._handler.getTransaction(args.id)
2660 
    except TransactionServiceException, ex:
2661 
      result.ex = ex
2662 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
2663 
    result.write(oprot)
2664 
    oprot.writeMessageEnd()
2665 
    oprot.trans.flush()
2666 
 
2667 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
2668 
    args = getTransactionsForCustomer_args()
2669 
    args.read(iprot)
2670 
    iprot.readMessageEnd()
2671 
    result = getTransactionsForCustomer_result()
2672 
    try:
2673 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
2674 
    except TransactionServiceException, ex:
2675 
      result.ex = ex
2676 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
2677 
    result.write(oprot)
2678 
    oprot.writeMessageEnd()
2679 
    oprot.trans.flush()
2680 
 
132 ashish 2681 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
2682 
    args = getTransactionsForShoppingCartId_args()
2683 
    args.read(iprot)
2684 
    iprot.readMessageEnd()
2685 
    result = getTransactionsForShoppingCartId_result()
2686 
    try:
2687 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
2688 
    except TransactionServiceException, ex:
2689 
      result.ex = ex
2690 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
2691 
    result.write(oprot)
2692 
    oprot.writeMessageEnd()
2693 
    oprot.trans.flush()
2694 
 
94 ashish 2695 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
2696 
    args = getTransactionStatus_args()
2697 
    args.read(iprot)
2698 
    iprot.readMessageEnd()
2699 
    result = getTransactionStatus_result()
2700 
    try:
2701 
      result.success = self._handler.getTransactionStatus(args.transactionId)
2702 
    except TransactionServiceException, ex:
2703 
      result.ex = ex
2704 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
2705 
    result.write(oprot)
2706 
    oprot.writeMessageEnd()
2707 
    oprot.trans.flush()
2708 
 
2709 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
2710 
    args = changeTransactionStatus_args()
2711 
    args.read(iprot)
2712 
    iprot.readMessageEnd()
2713 
    result = changeTransactionStatus_result()
2714 
    try:
2715 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
2716 
    except TransactionServiceException, ex:
2717 
      result.ex = ex
2718 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
2719 
    result.write(oprot)
2720 
    oprot.writeMessageEnd()
2721 
    oprot.trans.flush()
2722 
 
1398 varun.gupt 2723 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
2724 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 2725 
    args.read(iprot)
2726 
    iprot.readMessageEnd()
1398 varun.gupt 2727 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 2728 
    try:
1398 varun.gupt 2729 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 2730 
    except TransactionServiceException, ex:
2731 
      result.ex = ex
1398 varun.gupt 2732 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 2733 
    result.write(oprot)
2734 
    oprot.writeMessageEnd()
2735 
    oprot.trans.flush()
2736 
 
483 rajveer 2737 
  def process_getAllOrders(self, seqid, iprot, oprot):
2738 
    args = getAllOrders_args()
94 ashish 2739 
    args.read(iprot)
2740 
    iprot.readMessageEnd()
483 rajveer 2741 
    result = getAllOrders_result()
94 ashish 2742 
    try:
483 rajveer 2743 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 2744 
    except TransactionServiceException, ex:
2745 
      result.ex = ex
483 rajveer 2746 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 2747 
    result.write(oprot)
2748 
    oprot.writeMessageEnd()
2749 
    oprot.trans.flush()
2750 
 
999 varun.gupt 2751 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
2752 
    args = getOrdersByBillingDate_args()
2753 
    args.read(iprot)
2754 
    iprot.readMessageEnd()
2755 
    result = getOrdersByBillingDate_result()
2756 
    try:
2757 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
2758 
    except TransactionServiceException, ex:
2759 
      result.ex = ex
2760 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
2761 
    result.write(oprot)
2762 
    oprot.writeMessageEnd()
2763 
    oprot.trans.flush()
2764 
 
3427 chandransh 2765 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
2766 
    args = getOrdersByShippingDate_args()
2767 
    args.read(iprot)
2768 
    iprot.readMessageEnd()
2769 
    result = getOrdersByShippingDate_result()
2770 
    try:
3451 chandransh 2771 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 2772 
    except TransactionServiceException, ex:
2773 
      result.ex = ex
2774 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
2775 
    result.write(oprot)
2776 
    oprot.writeMessageEnd()
2777 
    oprot.trans.flush()
2778 
 
1382 varun.gupt 2779 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
2780 
    args = getReturnableOrdersForCustomer_args()
2781 
    args.read(iprot)
2782 
    iprot.readMessageEnd()
2783 
    result = getReturnableOrdersForCustomer_result()
2784 
    try:
2785 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
2786 
    except TransactionServiceException, ex:
2787 
      result.ex = ex
2788 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
2789 
    result.write(oprot)
2790 
    oprot.writeMessageEnd()
2791 
    oprot.trans.flush()
2792 
 
2793 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
2794 
    args = getCancellableOrdersForCustomer_args()
2795 
    args.read(iprot)
2796 
    iprot.readMessageEnd()
2797 
    result = getCancellableOrdersForCustomer_result()
2798 
    try:
2799 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
2800 
    except TransactionServiceException, ex:
2801 
      result.ex = ex
2802 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
2803 
    result.write(oprot)
2804 
    oprot.writeMessageEnd()
2805 
    oprot.trans.flush()
2806 
 
483 rajveer 2807 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
2808 
    args = changeOrderStatus_args()
94 ashish 2809 
    args.read(iprot)
2810 
    iprot.readMessageEnd()
483 rajveer 2811 
    result = changeOrderStatus_result()
94 ashish 2812 
    try:
483 rajveer 2813 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 2814 
    except TransactionServiceException, ex:
2815 
      result.ex = ex
483 rajveer 2816 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 2817 
    result.write(oprot)
2818 
    oprot.writeMessageEnd()
2819 
    oprot.trans.flush()
2820 
 
483 rajveer 2821 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
2822 
    args = getOrdersForTransaction_args()
94 ashish 2823 
    args.read(iprot)
2824 
    iprot.readMessageEnd()
483 rajveer 2825 
    result = getOrdersForTransaction_result()
94 ashish 2826 
    try:
1528 ankur.sing 2827 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 2828 
    except TransactionServiceException, ex:
2829 
      result.ex = ex
483 rajveer 2830 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 2831 
    result.write(oprot)
2832 
    oprot.writeMessageEnd()
2833 
    oprot.trans.flush()
2834 
 
483 rajveer 2835 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
2836 
    args = getOrdersForCustomer_args()
94 ashish 2837 
    args.read(iprot)
2838 
    iprot.readMessageEnd()
483 rajveer 2839 
    result = getOrdersForCustomer_result()
94 ashish 2840 
    try:
3014 chandransh 2841 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 2842 
    except TransactionServiceException, ex:
2843 
      result.ex = ex
483 rajveer 2844 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 2845 
    result.write(oprot)
2846 
    oprot.writeMessageEnd()
2847 
    oprot.trans.flush()
2848 
 
483 rajveer 2849 
  def process_createOrder(self, seqid, iprot, oprot):
2850 
    args = createOrder_args()
94 ashish 2851 
    args.read(iprot)
2852 
    iprot.readMessageEnd()
483 rajveer 2853 
    result = createOrder_result()
94 ashish 2854 
    try:
483 rajveer 2855 
      result.success = self._handler.createOrder(args.order)
94 ashish 2856 
    except TransactionServiceException, ex:
2857 
      result.ex = ex
483 rajveer 2858 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 2859 
    result.write(oprot)
2860 
    oprot.writeMessageEnd()
2861 
    oprot.trans.flush()
2862 
 
483 rajveer 2863 
  def process_getOrder(self, seqid, iprot, oprot):
2864 
    args = getOrder_args()
94 ashish 2865 
    args.read(iprot)
2866 
    iprot.readMessageEnd()
483 rajveer 2867 
    result = getOrder_result()
94 ashish 2868 
    try:
483 rajveer 2869 
      result.success = self._handler.getOrder(args.id)
94 ashish 2870 
    except TransactionServiceException, ex:
2871 
      result.ex = ex
483 rajveer 2872 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 2873 
    result.write(oprot)
2874 
    oprot.writeMessageEnd()
2875 
    oprot.trans.flush()
2876 
 
483 rajveer 2877 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
2878 
    args = getLineItemsForOrder_args()
94 ashish 2879 
    args.read(iprot)
2880 
    iprot.readMessageEnd()
483 rajveer 2881 
    result = getLineItemsForOrder_result()
94 ashish 2882 
    try:
483 rajveer 2883 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 2884 
    except TransactionServiceException, ex:
2885 
      result.ex = ex
483 rajveer 2886 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 2887 
    result.write(oprot)
2888 
    oprot.writeMessageEnd()
2889 
    oprot.trans.flush()
2890 
 
1528 ankur.sing 2891 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
2892 
    args = getOrderForCustomer_args()
2893 
    args.read(iprot)
2894 
    iprot.readMessageEnd()
2895 
    result = getOrderForCustomer_result()
2896 
    try:
2897 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
2898 
    except TransactionServiceException, ex:
2899 
      result.ex = ex
2900 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
2901 
    result.write(oprot)
2902 
    oprot.writeMessageEnd()
2903 
    oprot.trans.flush()
2904 
 
3064 chandransh 2905 
  def process_getAlerts(self, seqid, iprot, oprot):
2906 
    args = getAlerts_args()
2907 
    args.read(iprot)
2908 
    iprot.readMessageEnd()
2909 
    result = getAlerts_result()
2910 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
2911 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
2912 
    result.write(oprot)
2913 
    oprot.writeMessageEnd()
2914 
    oprot.trans.flush()
2915 
 
2916 
  def process_setAlert(self, seqid, iprot, oprot):
2917 
    args = setAlert_args()
2918 
    args.read(iprot)
2919 
    iprot.readMessageEnd()
2920 
    result = setAlert_result()
2921 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
2922 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
2923 
    result.write(oprot)
2924 
    oprot.writeMessageEnd()
2925 
    oprot.trans.flush()
2926 
 
2927 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
2928 
    args = getValidOrderCount_args()
2929 
    args.read(iprot)
2930 
    iprot.readMessageEnd()
2931 
    result = getValidOrderCount_result()
2932 
    result.success = self._handler.getValidOrderCount()
2933 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
2934 
    result.write(oprot)
2935 
    oprot.writeMessageEnd()
2936 
    oprot.trans.flush()
2937 
 
2938 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
2939 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2940 
    args.read(iprot)
2941 
    iprot.readMessageEnd()
2942 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2943 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
2944 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
2945 
    result.write(oprot)
2946 
    oprot.writeMessageEnd()
2947 
    oprot.trans.flush()
2948 
 
2949 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
2950 
    args = getValidOrdersAmountRange_args()
2951 
    args.read(iprot)
2952 
    iprot.readMessageEnd()
2953 
    result = getValidOrdersAmountRange_result()
2954 
    result.success = self._handler.getValidOrdersAmountRange()
2955 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
2956 
    result.write(oprot)
2957 
    oprot.writeMessageEnd()
2958 
    oprot.trans.flush()
2959 
 
2960 
  def process_getValidOrders(self, seqid, iprot, oprot):
2961 
    args = getValidOrders_args()
2962 
    args.read(iprot)
2963 
    iprot.readMessageEnd()
2964 
    result = getValidOrders_result()
2965 
    result.success = self._handler.getValidOrders(args.limit)
2966 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
2967 
    result.write(oprot)
2968 
    oprot.writeMessageEnd()
2969 
    oprot.trans.flush()
2970 
 
1220 chandransh 2971 
  def process_batchOrders(self, seqid, iprot, oprot):
2972 
    args = batchOrders_args()
2973 
    args.read(iprot)
2974 
    iprot.readMessageEnd()
2975 
    result = batchOrders_result()
2976 
    try:
2977 
      result.success = self._handler.batchOrders(args.warehouseId)
2978 
    except TransactionServiceException, ex:
2979 
      result.ex = ex
2980 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
2981 
    result.write(oprot)
2982 
    oprot.writeMessageEnd()
2983 
    oprot.trans.flush()
2984 
 
1208 chandransh 2985 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
2986 
    args = markOrderAsOutOfStock_args()
2987 
    args.read(iprot)
2988 
    iprot.readMessageEnd()
2989 
    result = markOrderAsOutOfStock_result()
2990 
    try:
2991 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
2992 
    except TransactionServiceException, ex:
2993 
      result.ex = ex
2994 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
2995 
    result.write(oprot)
2996 
    oprot.writeMessageEnd()
2997 
    oprot.trans.flush()
2998 
 
3064 chandransh 2999 
  def process_verifyOrder(self, seqid, iprot, oprot):
3000 
    args = verifyOrder_args()
759 chandransh 3001 
    args.read(iprot)
3002 
    iprot.readMessageEnd()
3064 chandransh 3003 
    result = verifyOrder_result()
759 chandransh 3004 
    try:
3064 chandransh 3005 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 3006 
    except TransactionServiceException, ex:
3007 
      result.ex = ex
3064 chandransh 3008 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 3009 
    result.write(oprot)
3010 
    oprot.writeMessageEnd()
3011 
    oprot.trans.flush()
3012 
 
3064 chandransh 3013 
  def process_acceptOrder(self, seqid, iprot, oprot):
3014 
    args = acceptOrder_args()
1113 chandransh 3015 
    args.read(iprot)
3016 
    iprot.readMessageEnd()
3064 chandransh 3017 
    result = acceptOrder_result()
1113 chandransh 3018 
    try:
3064 chandransh 3019 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 3020 
    except TransactionServiceException, ex:
3021 
      result.ex = ex
3064 chandransh 3022 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 3023 
    result.write(oprot)
3024 
    oprot.writeMessageEnd()
3025 
    oprot.trans.flush()
3026 
 
3064 chandransh 3027 
  def process_billOrder(self, seqid, iprot, oprot):
3028 
    args = billOrder_args()
1132 chandransh 3029 
    args.read(iprot)
3030 
    iprot.readMessageEnd()
3064 chandransh 3031 
    result = billOrder_result()
1132 chandransh 3032 
    try:
3064 chandransh 3033 
      result.success = self._handler.billOrder(args.orderId)
1132 chandransh 3034 
    except TransactionServiceException, ex:
3035 
      result.ex = ex
3064 chandransh 3036 
    oprot.writeMessageBegin("billOrder", TMessageType.REPLY, seqid)
1132 chandransh 3037 
    result.write(oprot)
3038 
    oprot.writeMessageEnd()
3039 
    oprot.trans.flush()
3040 
 
3064 chandransh 3041 
  def process_addBillingDetails(self, seqid, iprot, oprot):
3042 
    args = addBillingDetails_args()
1135 chandransh 3043 
    args.read(iprot)
3044 
    iprot.readMessageEnd()
3064 chandransh 3045 
    result = addBillingDetails_result()
1135 chandransh 3046 
    try:
3064 chandransh 3047 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.billed_by)
1135 chandransh 3048 
    except TransactionServiceException, ex:
3049 
      result.ex = ex
3064 chandransh 3050 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 3051 
    result.write(oprot)
3052 
    oprot.writeMessageEnd()
3053 
    oprot.trans.flush()
3054 
 
3064 chandransh 3055 
  def process_addJacketNumber(self, seqid, iprot, oprot):
3056 
    args = addJacketNumber_args()
1246 chandransh 3057 
    args.read(iprot)
3058 
    iprot.readMessageEnd()
3064 chandransh 3059 
    result = addJacketNumber_result()
1246 chandransh 3060 
    try:
3064 chandransh 3061 
      result.success = self._handler.addJacketNumber(args.orderId, args.jacketNumber, args.imeiNumber, args.itemNumber, args.billedBy, args.billingType)
1246 chandransh 3062 
    except TransactionServiceException, ex:
3063 
      result.ex = ex
3064 chandransh 3064 
    oprot.writeMessageBegin("addJacketNumber", TMessageType.REPLY, seqid)
1246 chandransh 3065 
    result.write(oprot)
3066 
    oprot.writeMessageEnd()
3067 
    oprot.trans.flush()
3068 
 
3064 chandransh 3069 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
3070 
    args = markOrdersAsManifested_args()
1408 ankur.sing 3071 
    args.read(iprot)
3072 
    iprot.readMessageEnd()
3064 chandransh 3073 
    result = markOrdersAsManifested_result()
3074 
    try:
3075 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
3076 
    except TransactionServiceException, ex:
3077 
      result.ex = ex
3078 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 3079 
    result.write(oprot)
3080 
    oprot.writeMessageEnd()
3081 
    oprot.trans.flush()
3082 
 
3064 chandransh 3083 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
3084 
    args = markOrdersAsPickedUp_args()
304 ashish 3085 
    args.read(iprot)
3086 
    iprot.readMessageEnd()
3064 chandransh 3087 
    result = markOrdersAsPickedUp_result()
3088 
    try:
3089 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3090 
    except TransactionServiceException, ex:
3091 
      result.ex = ex
3092 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 3093 
    result.write(oprot)
3094 
    oprot.writeMessageEnd()
3095 
    oprot.trans.flush()
94 ashish 3096 
 
3064 chandransh 3097 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
3098 
    args = markOrdersAsDelivered_args()
304 ashish 3099 
    args.read(iprot)
3100 
    iprot.readMessageEnd()
3064 chandransh 3101 
    result = markOrdersAsDelivered_result()
3102 
    try:
3103 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
3104 
    except TransactionServiceException, ex:
3105 
      result.ex = ex
3106 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 3107 
    result.write(oprot)
3108 
    oprot.writeMessageEnd()
3109 
    oprot.trans.flush()
3110 
 
3064 chandransh 3111 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
3112 
    args = markOrdersAsFailed_args()
1596 ankur.sing 3113 
    args.read(iprot)
3114 
    iprot.readMessageEnd()
3064 chandransh 3115 
    result = markOrdersAsFailed_result()
3116 
    try:
3117 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
3118 
    except TransactionServiceException, ex:
3119 
      result.ex = ex
3120 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 3121 
    result.write(oprot)
3122 
    oprot.writeMessageEnd()
3123 
    oprot.trans.flush()
304 ashish 3124 
 
3064 chandransh 3125 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
3126 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 3127 
    args.read(iprot)
3128 
    iprot.readMessageEnd()
3064 chandransh 3129 
    result = updateNonDeliveryReason_result()
3130 
    try:
3131 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3132 
    except TransactionServiceException, ex:
3133 
      result.ex = ex
3134 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 3135 
    result.write(oprot)
3136 
    oprot.writeMessageEnd()
3137 
    oprot.trans.flush()
1596 ankur.sing 3138 
 
3064 chandransh 3139 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
3140 
    args = getUndeliveredOrders_args()
1627 ankur.sing 3141 
    args.read(iprot)
3142 
    iprot.readMessageEnd()
3064 chandransh 3143 
    result = getUndeliveredOrders_result()
3144 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
3145 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 3146 
    result.write(oprot)
3147 
    oprot.writeMessageEnd()
3148 
    oprot.trans.flush()
3149 
 
2536 chandransh 3150 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
3151 
    args = toggleDOAFlag_args()
3152 
    args.read(iprot)
3153 
    iprot.readMessageEnd()
3154 
    result = toggleDOAFlag_result()
3155 
    try:
3156 
      result.success = self._handler.toggleDOAFlag(args.orderId)
3157 
    except TransactionServiceException, ex:
3158 
      result.ex = ex
3159 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
3160 
    result.write(oprot)
3161 
    oprot.writeMessageEnd()
3162 
    oprot.trans.flush()
1886 ankur.sing 3163 
 
2536 chandransh 3164 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
3165 
    args = requestPickupNumber_args()
3166 
    args.read(iprot)
3167 
    iprot.readMessageEnd()
3168 
    result = requestPickupNumber_result()
3169 
    try:
3170 
      result.success = self._handler.requestPickupNumber(args.orderId)
3171 
    except TransactionServiceException, ex:
3172 
      result.ex = ex
3173 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
3174 
    result.write(oprot)
3175 
    oprot.writeMessageEnd()
3176 
    oprot.trans.flush()
3177 
 
3178 
  def process_authorizePickup(self, seqid, iprot, oprot):
3179 
    args = authorizePickup_args()
3180 
    args.read(iprot)
3181 
    iprot.readMessageEnd()
3182 
    result = authorizePickup_result()
3183 
    try:
3184 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
3185 
    except TransactionServiceException, ex:
3186 
      result.ex = ex
3187 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
3188 
    result.write(oprot)
3189 
    oprot.writeMessageEnd()
3190 
    oprot.trans.flush()
3191 
 
2764 chandransh 3192 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
3193 
    args = markDoasAsPickedUp_args()
3194 
    args.read(iprot)
3195 
    iprot.readMessageEnd()
3196 
    result = markDoasAsPickedUp_result()
3197 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
3198 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
3199 
    result.write(oprot)
3200 
    oprot.writeMessageEnd()
3201 
    oprot.trans.flush()
3202 
 
2616 chandransh 3203 
  def process_receiveReturn(self, seqid, iprot, oprot):
3204 
    args = receiveReturn_args()
2591 chandransh 3205 
    args.read(iprot)
3206 
    iprot.readMessageEnd()
2616 chandransh 3207 
    result = receiveReturn_result()
2591 chandransh 3208 
    try:
2616 chandransh 3209 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 3210 
    except TransactionServiceException, ex:
3211 
      result.ex = ex
2616 chandransh 3212 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 3213 
    result.write(oprot)
3214 
    oprot.writeMessageEnd()
3215 
    oprot.trans.flush()
2536 chandransh 3216 
 
2591 chandransh 3217 
  def process_validateDoa(self, seqid, iprot, oprot):
3218 
    args = validateDoa_args()
3219 
    args.read(iprot)
3220 
    iprot.readMessageEnd()
3221 
    result = validateDoa_result()
3222 
    try:
3223 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
3224 
    except TransactionServiceException, ex:
3225 
      result.ex = ex
3226 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
3227 
    result.write(oprot)
3228 
    oprot.writeMessageEnd()
3229 
    oprot.trans.flush()
3230 
 
2616 chandransh 3231 
  def process_reshipOrder(self, seqid, iprot, oprot):
3232 
    args = reshipOrder_args()
3233 
    args.read(iprot)
3234 
    iprot.readMessageEnd()
3235 
    result = reshipOrder_result()
3236 
    try:
3237 
      result.success = self._handler.reshipOrder(args.orderId)
3238 
    except TransactionServiceException, ex:
3239 
      result.ex = ex
3240 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
3241 
    result.write(oprot)
3242 
    oprot.writeMessageEnd()
3243 
    oprot.trans.flush()
2591 chandransh 3244 
 
2616 chandransh 3245 
  def process_refundOrder(self, seqid, iprot, oprot):
3246 
    args = refundOrder_args()
3247 
    args.read(iprot)
3248 
    iprot.readMessageEnd()
3249 
    result = refundOrder_result()
3250 
    try:
3226 chandransh 3251 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 3252 
    except TransactionServiceException, ex:
3253 
      result.ex = ex
3254 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
3255 
    result.write(oprot)
3256 
    oprot.writeMessageEnd()
3257 
    oprot.trans.flush()
3258 
 
2690 chandransh 3259 
  def process_getReturnOrders(self, seqid, iprot, oprot):
3260 
    args = getReturnOrders_args()
3261 
    args.read(iprot)
3262 
    iprot.readMessageEnd()
3263 
    result = getReturnOrders_result()
3264 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
3265 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
3266 
    result.write(oprot)
3267 
    oprot.writeMessageEnd()
3268 
    oprot.trans.flush()
2616 chandransh 3269 
 
2700 chandransh 3270 
  def process_getReturnOrder(self, seqid, iprot, oprot):
3271 
    args = getReturnOrder_args()
3272 
    args.read(iprot)
3273 
    iprot.readMessageEnd()
3274 
    result = getReturnOrder_result()
3275 
    try:
3276 
      result.success = self._handler.getReturnOrder(args.id)
3277 
    except TransactionServiceException, ex:
3278 
      result.ex = ex
3279 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
3280 
    result.write(oprot)
3281 
    oprot.writeMessageEnd()
3282 
    oprot.trans.flush()
3283 
 
2690 chandransh 3284 
  def process_processReturn(self, seqid, iprot, oprot):
3285 
    args = processReturn_args()
3286 
    args.read(iprot)
3287 
    iprot.readMessageEnd()
3288 
    result = processReturn_result()
3289 
    try:
3290 
      self._handler.processReturn(args.returnOrderId)
3291 
    except TransactionServiceException, ex:
3292 
      result.ex = ex
3293 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
3294 
    result.write(oprot)
3295 
    oprot.writeMessageEnd()
3296 
    oprot.trans.flush()
3297 
 
2819 chandransh 3298 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
3299 
    args = createPurchaseOrder_args()
3300 
    args.read(iprot)
3301 
    iprot.readMessageEnd()
3302 
    result = createPurchaseOrder_result()
3303 
    try:
3304 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
3305 
    except TransactionServiceException, ex:
3306 
      result.ex = ex
3307 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
3308 
    result.write(oprot)
3309 
    oprot.writeMessageEnd()
3310 
    oprot.trans.flush()
2690 chandransh 3311 
 
3451 chandransh 3312 
  def process_updateWeight(self, seqid, iprot, oprot):
3313 
    args = updateWeight_args()
3314 
    args.read(iprot)
3315 
    iprot.readMessageEnd()
3316 
    result = updateWeight_result()
3317 
    try:
3318 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
3319 
    except TransactionServiceException, ex:
3320 
      result.ex = ex
3321 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
3322 
    result.write(oprot)
3323 
    oprot.writeMessageEnd()
3324 
    oprot.trans.flush()
2819 chandransh 3325 
 
3469 chandransh 3326 
  def process_changeItem(self, seqid, iprot, oprot):
3327 
    args = changeItem_args()
3328 
    args.read(iprot)
3329 
    iprot.readMessageEnd()
3330 
    result = changeItem_result()
3331 
    try:
3332 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
3333 
    except TransactionServiceException, ex:
3334 
      result.ex = ex
3335 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
3336 
    result.write(oprot)
3337 
    oprot.writeMessageEnd()
3338 
    oprot.trans.flush()
3451 chandransh 3339 
 
3469 chandransh 3340 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
3341 
    args = shiftToWarehouse_args()
3342 
    args.read(iprot)
3343 
    iprot.readMessageEnd()
3344 
    result = shiftToWarehouse_result()
3345 
    try:
3346 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
3347 
    except TransactionServiceException, ex:
3348 
      result.ex = ex
3349 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
3350 
    result.write(oprot)
3351 
    oprot.writeMessageEnd()
3352 
    oprot.trans.flush()
3353 
 
3553 chandransh 3354 
  def process_addDelayReason(self, seqid, iprot, oprot):
3355 
    args = addDelayReason_args()
3356 
    args.read(iprot)
3357 
    iprot.readMessageEnd()
3358 
    result = addDelayReason_result()
3359 
    try:
3360 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason)
3361 
    except TransactionServiceException, ex:
3362 
      result.ex = ex
3363 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
3364 
    result.write(oprot)
3365 
    oprot.writeMessageEnd()
3366 
    oprot.trans.flush()
3469 chandransh 3367 
 
3553 chandransh 3368 
 
94 ashish 3369 
# HELPER FUNCTIONS AND STRUCTURES
3370 
 
3371 
class createTransaction_args:
3372 
  """
3373 
  Attributes:
3374 
   - transaction
3375 
  """
3376 
 
3377 
  thrift_spec = (
3378 
    None, # 0
3379 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
3380 
  )
3381 
 
3382 
  def __init__(self, transaction=None,):
3383 
    self.transaction = transaction
3384 
 
3385 
  def read(self, iprot):
3386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3388 
      return
3389 
    iprot.readStructBegin()
3390 
    while True:
3391 
      (fname, ftype, fid) = iprot.readFieldBegin()
3392 
      if ftype == TType.STOP:
3393 
        break
3394 
      if fid == 1:
3395 
        if ftype == TType.STRUCT:
3396 
          self.transaction = Transaction()
3397 
          self.transaction.read(iprot)
3398 
        else:
3399 
          iprot.skip(ftype)
3400 
      else:
3401 
        iprot.skip(ftype)
3402 
      iprot.readFieldEnd()
3403 
    iprot.readStructEnd()
3404 
 
3405 
  def write(self, oprot):
3406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3408 
      return
3409 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 3410 
    if self.transaction is not None:
94 ashish 3411 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
3412 
      self.transaction.write(oprot)
3413 
      oprot.writeFieldEnd()
3414 
    oprot.writeFieldStop()
3415 
    oprot.writeStructEnd()
3416 
 
3431 rajveer 3417 
  def validate(self):
3418 
    return
3419 
 
3420 
 
94 ashish 3421 
  def __repr__(self):
3422 
    L = ['%s=%r' % (key, value)
3423 
      for key, value in self.__dict__.iteritems()]
3424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3425 
 
3426 
  def __eq__(self, other):
3427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3428 
 
3429 
  def __ne__(self, other):
3430 
    return not (self == other)
3431 
 
3432 
class createTransaction_result:
3433 
  """
3434 
  Attributes:
132 ashish 3435 
   - success
94 ashish 3436 
   - ex
3437 
  """
3438 
 
3439 
  thrift_spec = (
132 ashish 3440 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 3441 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3442 
  )
3443 
 
132 ashish 3444 
  def __init__(self, success=None, ex=None,):
3445 
    self.success = success
94 ashish 3446 
    self.ex = ex
3447 
 
3448 
  def read(self, iprot):
3449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3451 
      return
3452 
    iprot.readStructBegin()
3453 
    while True:
3454 
      (fname, ftype, fid) = iprot.readFieldBegin()
3455 
      if ftype == TType.STOP:
3456 
        break
132 ashish 3457 
      if fid == 0:
3458 
        if ftype == TType.I64:
3459 
          self.success = iprot.readI64();
3460 
        else:
3461 
          iprot.skip(ftype)
3462 
      elif fid == 1:
94 ashish 3463 
        if ftype == TType.STRUCT:
3464 
          self.ex = TransactionServiceException()
3465 
          self.ex.read(iprot)
3466 
        else:
3467 
          iprot.skip(ftype)
3468 
      else:
3469 
        iprot.skip(ftype)
3470 
      iprot.readFieldEnd()
3471 
    iprot.readStructEnd()
3472 
 
3473 
  def write(self, oprot):
3474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3476 
      return
3477 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 3478 
    if self.success is not None:
132 ashish 3479 
      oprot.writeFieldBegin('success', TType.I64, 0)
3480 
      oprot.writeI64(self.success)
3481 
      oprot.writeFieldEnd()
3431 rajveer 3482 
    if self.ex is not None:
94 ashish 3483 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3484 
      self.ex.write(oprot)
3485 
      oprot.writeFieldEnd()
3486 
    oprot.writeFieldStop()
3487 
    oprot.writeStructEnd()
3488 
 
3431 rajveer 3489 
  def validate(self):
3490 
    return
3491 
 
3492 
 
94 ashish 3493 
  def __repr__(self):
3494 
    L = ['%s=%r' % (key, value)
3495 
      for key, value in self.__dict__.iteritems()]
3496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3497 
 
3498 
  def __eq__(self, other):
3499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3500 
 
3501 
  def __ne__(self, other):
3502 
    return not (self == other)
3503 
 
3504 
class getTransaction_args:
3505 
  """
3506 
  Attributes:
3507 
   - id
3508 
  """
3509 
 
3510 
  thrift_spec = (
3511 
    None, # 0
3512 
    (1, TType.I64, 'id', None, None, ), # 1
3513 
  )
3514 
 
3515 
  def __init__(self, id=None,):
3516 
    self.id = id
3517 
 
3518 
  def read(self, iprot):
3519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3521 
      return
3522 
    iprot.readStructBegin()
3523 
    while True:
3524 
      (fname, ftype, fid) = iprot.readFieldBegin()
3525 
      if ftype == TType.STOP:
3526 
        break
3527 
      if fid == 1:
3528 
        if ftype == TType.I64:
3529 
          self.id = iprot.readI64();
3530 
        else:
3531 
          iprot.skip(ftype)
3532 
      else:
3533 
        iprot.skip(ftype)
3534 
      iprot.readFieldEnd()
3535 
    iprot.readStructEnd()
3536 
 
3537 
  def write(self, oprot):
3538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3540 
      return
3541 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 3542 
    if self.id is not None:
94 ashish 3543 
      oprot.writeFieldBegin('id', TType.I64, 1)
3544 
      oprot.writeI64(self.id)
3545 
      oprot.writeFieldEnd()
3546 
    oprot.writeFieldStop()
3547 
    oprot.writeStructEnd()
3548 
 
3431 rajveer 3549 
  def validate(self):
3550 
    return
3551 
 
3552 
 
94 ashish 3553 
  def __repr__(self):
3554 
    L = ['%s=%r' % (key, value)
3555 
      for key, value in self.__dict__.iteritems()]
3556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3557 
 
3558 
  def __eq__(self, other):
3559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3560 
 
3561 
  def __ne__(self, other):
3562 
    return not (self == other)
3563 
 
3564 
class getTransaction_result:
3565 
  """
3566 
  Attributes:
3567 
   - success
3568 
   - ex
3569 
  """
3570 
 
3571 
  thrift_spec = (
3572 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
3573 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3574 
  )
3575 
 
3576 
  def __init__(self, success=None, ex=None,):
3577 
    self.success = success
3578 
    self.ex = ex
3579 
 
3580 
  def read(self, iprot):
3581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3583 
      return
3584 
    iprot.readStructBegin()
3585 
    while True:
3586 
      (fname, ftype, fid) = iprot.readFieldBegin()
3587 
      if ftype == TType.STOP:
3588 
        break
3589 
      if fid == 0:
3590 
        if ftype == TType.STRUCT:
3591 
          self.success = Transaction()
3592 
          self.success.read(iprot)
3593 
        else:
3594 
          iprot.skip(ftype)
3595 
      elif fid == 1:
3596 
        if ftype == TType.STRUCT:
3597 
          self.ex = TransactionServiceException()
3598 
          self.ex.read(iprot)
3599 
        else:
3600 
          iprot.skip(ftype)
3601 
      else:
3602 
        iprot.skip(ftype)
3603 
      iprot.readFieldEnd()
3604 
    iprot.readStructEnd()
3605 
 
3606 
  def write(self, oprot):
3607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3609 
      return
3610 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 3611 
    if self.success is not None:
94 ashish 3612 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3613 
      self.success.write(oprot)
3614 
      oprot.writeFieldEnd()
3431 rajveer 3615 
    if self.ex is not None:
94 ashish 3616 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3617 
      self.ex.write(oprot)
3618 
      oprot.writeFieldEnd()
3619 
    oprot.writeFieldStop()
3620 
    oprot.writeStructEnd()
3621 
 
3431 rajveer 3622 
  def validate(self):
3623 
    return
3624 
 
3625 
 
94 ashish 3626 
  def __repr__(self):
3627 
    L = ['%s=%r' % (key, value)
3628 
      for key, value in self.__dict__.iteritems()]
3629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3630 
 
3631 
  def __eq__(self, other):
3632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3633 
 
3634 
  def __ne__(self, other):
3635 
    return not (self == other)
3636 
 
3637 
class getTransactionsForCustomer_args:
3638 
  """
3639 
  Attributes:
3640 
   - customerId
3641 
   - from_date
3642 
   - to_date
3643 
   - status
3644 
  """
3645 
 
3646 
  thrift_spec = (
3647 
    None, # 0
3648 
    (1, TType.I64, 'customerId', None, None, ), # 1
3649 
    (2, TType.I64, 'from_date', None, None, ), # 2
3650 
    (3, TType.I64, 'to_date', None, None, ), # 3
3651 
    (4, TType.I32, 'status', None, None, ), # 4
3652 
  )
3653 
 
3654 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
3655 
    self.customerId = customerId
3656 
    self.from_date = from_date
3657 
    self.to_date = to_date
3658 
    self.status = status
3659 
 
3660 
  def read(self, iprot):
3661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3663 
      return
3664 
    iprot.readStructBegin()
3665 
    while True:
3666 
      (fname, ftype, fid) = iprot.readFieldBegin()
3667 
      if ftype == TType.STOP:
3668 
        break
3669 
      if fid == 1:
3670 
        if ftype == TType.I64:
3671 
          self.customerId = iprot.readI64();
3672 
        else:
3673 
          iprot.skip(ftype)
3674 
      elif fid == 2:
3675 
        if ftype == TType.I64:
3676 
          self.from_date = iprot.readI64();
3677 
        else:
3678 
          iprot.skip(ftype)
3679 
      elif fid == 3:
3680 
        if ftype == TType.I64:
3681 
          self.to_date = iprot.readI64();
3682 
        else:
3683 
          iprot.skip(ftype)
3684 
      elif fid == 4:
3685 
        if ftype == TType.I32:
3686 
          self.status = iprot.readI32();
3687 
        else:
3688 
          iprot.skip(ftype)
3689 
      else:
3690 
        iprot.skip(ftype)
3691 
      iprot.readFieldEnd()
3692 
    iprot.readStructEnd()
3693 
 
3694 
  def write(self, oprot):
3695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3697 
      return
3698 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 3699 
    if self.customerId is not None:
94 ashish 3700 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
3701 
      oprot.writeI64(self.customerId)
3702 
      oprot.writeFieldEnd()
3431 rajveer 3703 
    if self.from_date is not None:
94 ashish 3704 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
3705 
      oprot.writeI64(self.from_date)
3706 
      oprot.writeFieldEnd()
3431 rajveer 3707 
    if self.to_date is not None:
94 ashish 3708 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
3709 
      oprot.writeI64(self.to_date)
3710 
      oprot.writeFieldEnd()
3431 rajveer 3711 
    if self.status is not None:
94 ashish 3712 
      oprot.writeFieldBegin('status', TType.I32, 4)
3713 
      oprot.writeI32(self.status)
3714 
      oprot.writeFieldEnd()
3715 
    oprot.writeFieldStop()
3716 
    oprot.writeStructEnd()
3717 
 
3431 rajveer 3718 
  def validate(self):
3719 
    return
3720 
 
3721 
 
94 ashish 3722 
  def __repr__(self):
3723 
    L = ['%s=%r' % (key, value)
3724 
      for key, value in self.__dict__.iteritems()]
3725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3726 
 
3727 
  def __eq__(self, other):
3728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3729 
 
3730 
  def __ne__(self, other):
3731 
    return not (self == other)
3732 
 
3733 
class getTransactionsForCustomer_result:
3734 
  """
3735 
  Attributes:
3736 
   - success
3737 
   - ex
3738 
  """
3739 
 
3740 
  thrift_spec = (
3741 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
3742 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3743 
  )
3744 
 
3745 
  def __init__(self, success=None, ex=None,):
3746 
    self.success = success
3747 
    self.ex = ex
3748 
 
3749 
  def read(self, iprot):
3750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3752 
      return
3753 
    iprot.readStructBegin()
3754 
    while True:
3755 
      (fname, ftype, fid) = iprot.readFieldBegin()
3756 
      if ftype == TType.STOP:
3757 
        break
3758 
      if fid == 0:
3759 
        if ftype == TType.LIST:
3760 
          self.success = []
685 chandransh 3761 
          (_etype17, _size14) = iprot.readListBegin()
3762 
          for _i18 in xrange(_size14):
3763 
            _elem19 = Transaction()
3764 
            _elem19.read(iprot)
3765 
            self.success.append(_elem19)
94 ashish 3766 
          iprot.readListEnd()
3767 
        else:
3768 
          iprot.skip(ftype)
3769 
      elif fid == 1:
3770 
        if ftype == TType.STRUCT:
3771 
          self.ex = TransactionServiceException()
3772 
          self.ex.read(iprot)
3773 
        else:
3774 
          iprot.skip(ftype)
3775 
      else:
3776 
        iprot.skip(ftype)
3777 
      iprot.readFieldEnd()
3778 
    iprot.readStructEnd()
3779 
 
3780 
  def write(self, oprot):
3781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3783 
      return
3784 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 3785 
    if self.success is not None:
94 ashish 3786 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3787 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 3788 
      for iter20 in self.success:
3789 
        iter20.write(oprot)
94 ashish 3790 
      oprot.writeListEnd()
3791 
      oprot.writeFieldEnd()
3431 rajveer 3792 
    if self.ex is not None:
94 ashish 3793 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3794 
      self.ex.write(oprot)
3795 
      oprot.writeFieldEnd()
3796 
    oprot.writeFieldStop()
3797 
    oprot.writeStructEnd()
3798 
 
3431 rajveer 3799 
  def validate(self):
3800 
    return
3801 
 
3802 
 
94 ashish 3803 
  def __repr__(self):
3804 
    L = ['%s=%r' % (key, value)
3805 
      for key, value in self.__dict__.iteritems()]
3806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3807 
 
3808 
  def __eq__(self, other):
3809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3810 
 
3811 
  def __ne__(self, other):
3812 
    return not (self == other)
3813 
 
132 ashish 3814 
class getTransactionsForShoppingCartId_args:
3815 
  """
3816 
  Attributes:
3817 
   - shoppingCartId
3818 
  """
3819 
 
3820 
  thrift_spec = (
3821 
    None, # 0
3822 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
3823 
  )
3824 
 
3825 
  def __init__(self, shoppingCartId=None,):
3826 
    self.shoppingCartId = shoppingCartId
3827 
 
3828 
  def read(self, iprot):
3829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3831 
      return
3832 
    iprot.readStructBegin()
3833 
    while True:
3834 
      (fname, ftype, fid) = iprot.readFieldBegin()
3835 
      if ftype == TType.STOP:
3836 
        break
3837 
      if fid == 1:
3838 
        if ftype == TType.I64:
3839 
          self.shoppingCartId = iprot.readI64();
3840 
        else:
3841 
          iprot.skip(ftype)
3842 
      else:
3843 
        iprot.skip(ftype)
3844 
      iprot.readFieldEnd()
3845 
    iprot.readStructEnd()
3846 
 
3847 
  def write(self, oprot):
3848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3850 
      return
3851 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 3852 
    if self.shoppingCartId is not None:
132 ashish 3853 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
3854 
      oprot.writeI64(self.shoppingCartId)
3855 
      oprot.writeFieldEnd()
3856 
    oprot.writeFieldStop()
3857 
    oprot.writeStructEnd()
3858 
 
3431 rajveer 3859 
  def validate(self):
3860 
    return
3861 
 
3862 
 
132 ashish 3863 
  def __repr__(self):
3864 
    L = ['%s=%r' % (key, value)
3865 
      for key, value in self.__dict__.iteritems()]
3866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3867 
 
3868 
  def __eq__(self, other):
3869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3870 
 
3871 
  def __ne__(self, other):
3872 
    return not (self == other)
3873 
 
3874 
class getTransactionsForShoppingCartId_result:
3875 
  """
3876 
  Attributes:
3877 
   - success
3878 
   - ex
3879 
  """
3880 
 
3881 
  thrift_spec = (
3882 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
3883 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3884 
  )
3885 
 
3886 
  def __init__(self, success=None, ex=None,):
3887 
    self.success = success
3888 
    self.ex = ex
3889 
 
3890 
  def read(self, iprot):
3891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3893 
      return
3894 
    iprot.readStructBegin()
3895 
    while True:
3896 
      (fname, ftype, fid) = iprot.readFieldBegin()
3897 
      if ftype == TType.STOP:
3898 
        break
3899 
      if fid == 0:
3900 
        if ftype == TType.LIST:
3901 
          self.success = []
685 chandransh 3902 
          (_etype24, _size21) = iprot.readListBegin()
3903 
          for _i25 in xrange(_size21):
3904 
            _elem26 = Transaction()
3905 
            _elem26.read(iprot)
3906 
            self.success.append(_elem26)
132 ashish 3907 
          iprot.readListEnd()
3908 
        else:
3909 
          iprot.skip(ftype)
3910 
      elif fid == 1:
3911 
        if ftype == TType.STRUCT:
3912 
          self.ex = TransactionServiceException()
3913 
          self.ex.read(iprot)
3914 
        else:
3915 
          iprot.skip(ftype)
3916 
      else:
3917 
        iprot.skip(ftype)
3918 
      iprot.readFieldEnd()
3919 
    iprot.readStructEnd()
3920 
 
3921 
  def write(self, oprot):
3922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3924 
      return
3925 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 3926 
    if self.success is not None:
132 ashish 3927 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3928 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 3929 
      for iter27 in self.success:
3930 
        iter27.write(oprot)
132 ashish 3931 
      oprot.writeListEnd()
3932 
      oprot.writeFieldEnd()
3431 rajveer 3933 
    if self.ex is not None:
132 ashish 3934 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3935 
      self.ex.write(oprot)
3936 
      oprot.writeFieldEnd()
3937 
    oprot.writeFieldStop()
3938 
    oprot.writeStructEnd()
3939 
 
3431 rajveer 3940 
  def validate(self):
3941 
    return
3942 
 
3943 
 
132 ashish 3944 
  def __repr__(self):
3945 
    L = ['%s=%r' % (key, value)
3946 
      for key, value in self.__dict__.iteritems()]
3947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3948 
 
3949 
  def __eq__(self, other):
3950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3951 
 
3952 
  def __ne__(self, other):
3953 
    return not (self == other)
3954 
 
94 ashish 3955 
class getTransactionStatus_args:
3956 
  """
3957 
  Attributes:
3958 
   - transactionId
3959 
  """
3960 
 
3961 
  thrift_spec = (
3962 
    None, # 0
3963 
    (1, TType.I64, 'transactionId', None, None, ), # 1
3964 
  )
3965 
 
3966 
  def __init__(self, transactionId=None,):
3967 
    self.transactionId = transactionId
3968 
 
3969 
  def read(self, iprot):
3970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3972 
      return
3973 
    iprot.readStructBegin()
3974 
    while True:
3975 
      (fname, ftype, fid) = iprot.readFieldBegin()
3976 
      if ftype == TType.STOP:
3977 
        break
3978 
      if fid == 1:
3979 
        if ftype == TType.I64:
3980 
          self.transactionId = iprot.readI64();
3981 
        else:
3982 
          iprot.skip(ftype)
3983 
      else:
3984 
        iprot.skip(ftype)
3985 
      iprot.readFieldEnd()
3986 
    iprot.readStructEnd()
3987 
 
3988 
  def write(self, oprot):
3989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3991 
      return
3992 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 3993 
    if self.transactionId is not None:
94 ashish 3994 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
3995 
      oprot.writeI64(self.transactionId)
3996 
      oprot.writeFieldEnd()
3997 
    oprot.writeFieldStop()
3998 
    oprot.writeStructEnd()
3999 
 
3431 rajveer 4000 
  def validate(self):
4001 
    return
4002 
 
4003 
 
94 ashish 4004 
  def __repr__(self):
4005 
    L = ['%s=%r' % (key, value)
4006 
      for key, value in self.__dict__.iteritems()]
4007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4008 
 
4009 
  def __eq__(self, other):
4010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4011 
 
4012 
  def __ne__(self, other):
4013 
    return not (self == other)
4014 
 
4015 
class getTransactionStatus_result:
4016 
  """
4017 
  Attributes:
4018 
   - success
4019 
   - ex
4020 
  """
4021 
 
4022 
  thrift_spec = (
4023 
    (0, TType.I32, 'success', None, None, ), # 0
4024 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4025 
  )
4026 
 
4027 
  def __init__(self, success=None, ex=None,):
4028 
    self.success = success
4029 
    self.ex = ex
4030 
 
4031 
  def read(self, iprot):
4032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4034 
      return
4035 
    iprot.readStructBegin()
4036 
    while True:
4037 
      (fname, ftype, fid) = iprot.readFieldBegin()
4038 
      if ftype == TType.STOP:
4039 
        break
4040 
      if fid == 0:
4041 
        if ftype == TType.I32:
4042 
          self.success = iprot.readI32();
4043 
        else:
4044 
          iprot.skip(ftype)
4045 
      elif fid == 1:
4046 
        if ftype == TType.STRUCT:
4047 
          self.ex = TransactionServiceException()
4048 
          self.ex.read(iprot)
4049 
        else:
4050 
          iprot.skip(ftype)
4051 
      else:
4052 
        iprot.skip(ftype)
4053 
      iprot.readFieldEnd()
4054 
    iprot.readStructEnd()
4055 
 
4056 
  def write(self, oprot):
4057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4059 
      return
4060 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 4061 
    if self.success is not None:
94 ashish 4062 
      oprot.writeFieldBegin('success', TType.I32, 0)
4063 
      oprot.writeI32(self.success)
4064 
      oprot.writeFieldEnd()
3431 rajveer 4065 
    if self.ex is not None:
94 ashish 4066 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4067 
      self.ex.write(oprot)
4068 
      oprot.writeFieldEnd()
4069 
    oprot.writeFieldStop()
4070 
    oprot.writeStructEnd()
4071 
 
3431 rajveer 4072 
  def validate(self):
4073 
    return
4074 
 
4075 
 
94 ashish 4076 
  def __repr__(self):
4077 
    L = ['%s=%r' % (key, value)
4078 
      for key, value in self.__dict__.iteritems()]
4079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4080 
 
4081 
  def __eq__(self, other):
4082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4083 
 
4084 
  def __ne__(self, other):
4085 
    return not (self == other)
4086 
 
4087 
class changeTransactionStatus_args:
4088 
  """
4089 
  Attributes:
4090 
   - transactionId
4091 
   - status
4092 
   - description
4093 
  """
4094 
 
4095 
  thrift_spec = (
4096 
    None, # 0
4097 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4098 
    (2, TType.I32, 'status', None, None, ), # 2
4099 
    (3, TType.STRING, 'description', None, None, ), # 3
4100 
  )
4101 
 
4102 
  def __init__(self, transactionId=None, status=None, description=None,):
4103 
    self.transactionId = transactionId
4104 
    self.status = status
4105 
    self.description = description
4106 
 
4107 
  def read(self, iprot):
4108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4110 
      return
4111 
    iprot.readStructBegin()
4112 
    while True:
4113 
      (fname, ftype, fid) = iprot.readFieldBegin()
4114 
      if ftype == TType.STOP:
4115 
        break
4116 
      if fid == 1:
4117 
        if ftype == TType.I64:
4118 
          self.transactionId = iprot.readI64();
4119 
        else:
4120 
          iprot.skip(ftype)
4121 
      elif fid == 2:
4122 
        if ftype == TType.I32:
4123 
          self.status = iprot.readI32();
4124 
        else:
4125 
          iprot.skip(ftype)
4126 
      elif fid == 3:
4127 
        if ftype == TType.STRING:
4128 
          self.description = iprot.readString();
4129 
        else:
4130 
          iprot.skip(ftype)
4131 
      else:
4132 
        iprot.skip(ftype)
4133 
      iprot.readFieldEnd()
4134 
    iprot.readStructEnd()
4135 
 
4136 
  def write(self, oprot):
4137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4139 
      return
4140 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 4141 
    if self.transactionId is not None:
94 ashish 4142 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4143 
      oprot.writeI64(self.transactionId)
4144 
      oprot.writeFieldEnd()
3431 rajveer 4145 
    if self.status is not None:
94 ashish 4146 
      oprot.writeFieldBegin('status', TType.I32, 2)
4147 
      oprot.writeI32(self.status)
4148 
      oprot.writeFieldEnd()
3431 rajveer 4149 
    if self.description is not None:
94 ashish 4150 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4151 
      oprot.writeString(self.description)
4152 
      oprot.writeFieldEnd()
4153 
    oprot.writeFieldStop()
4154 
    oprot.writeStructEnd()
4155 
 
3431 rajveer 4156 
  def validate(self):
4157 
    return
4158 
 
4159 
 
94 ashish 4160 
  def __repr__(self):
4161 
    L = ['%s=%r' % (key, value)
4162 
      for key, value in self.__dict__.iteritems()]
4163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4164 
 
4165 
  def __eq__(self, other):
4166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4167 
 
4168 
  def __ne__(self, other):
4169 
    return not (self == other)
4170 
 
4171 
class changeTransactionStatus_result:
4172 
  """
4173 
  Attributes:
4174 
   - success
4175 
   - ex
4176 
  """
4177 
 
4178 
  thrift_spec = (
4179 
    (0, TType.BOOL, 'success', None, None, ), # 0
4180 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4181 
  )
4182 
 
4183 
  def __init__(self, success=None, ex=None,):
4184 
    self.success = success
4185 
    self.ex = ex
4186 
 
4187 
  def read(self, iprot):
4188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4190 
      return
4191 
    iprot.readStructBegin()
4192 
    while True:
4193 
      (fname, ftype, fid) = iprot.readFieldBegin()
4194 
      if ftype == TType.STOP:
4195 
        break
4196 
      if fid == 0:
4197 
        if ftype == TType.BOOL:
4198 
          self.success = iprot.readBool();
4199 
        else:
4200 
          iprot.skip(ftype)
4201 
      elif fid == 1:
4202 
        if ftype == TType.STRUCT:
4203 
          self.ex = TransactionServiceException()
4204 
          self.ex.read(iprot)
4205 
        else:
4206 
          iprot.skip(ftype)
4207 
      else:
4208 
        iprot.skip(ftype)
4209 
      iprot.readFieldEnd()
4210 
    iprot.readStructEnd()
4211 
 
4212 
  def write(self, oprot):
4213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4215 
      return
4216 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 4217 
    if self.success is not None:
94 ashish 4218 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4219 
      oprot.writeBool(self.success)
4220 
      oprot.writeFieldEnd()
3431 rajveer 4221 
    if self.ex is not None:
94 ashish 4222 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4223 
      self.ex.write(oprot)
4224 
      oprot.writeFieldEnd()
4225 
    oprot.writeFieldStop()
4226 
    oprot.writeStructEnd()
4227 
 
3431 rajveer 4228 
  def validate(self):
4229 
    return
4230 
 
4231 
 
94 ashish 4232 
  def __repr__(self):
4233 
    L = ['%s=%r' % (key, value)
4234 
      for key, value in self.__dict__.iteritems()]
4235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4236 
 
4237 
  def __eq__(self, other):
4238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4239 
 
4240 
  def __ne__(self, other):
4241 
    return not (self == other)
4242 
 
1398 varun.gupt 4243 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 4244 
  """
4245 
  Attributes:
4246 
   - transactionId
4247 
  """
4248 
 
4249 
  thrift_spec = (
4250 
    None, # 0
4251 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4252 
  )
4253 
 
4254 
  def __init__(self, transactionId=None,):
4255 
    self.transactionId = transactionId
4256 
 
4257 
  def read(self, iprot):
4258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4260 
      return
4261 
    iprot.readStructBegin()
4262 
    while True:
4263 
      (fname, ftype, fid) = iprot.readFieldBegin()
4264 
      if ftype == TType.STOP:
4265 
        break
4266 
      if fid == 1:
4267 
        if ftype == TType.I64:
4268 
          self.transactionId = iprot.readI64();
4269 
        else:
4270 
          iprot.skip(ftype)
4271 
      else:
4272 
        iprot.skip(ftype)
4273 
      iprot.readFieldEnd()
4274 
    iprot.readStructEnd()
4275 
 
4276 
  def write(self, oprot):
4277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4279 
      return
1398 varun.gupt 4280 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 4281 
    if self.transactionId is not None:
1382 varun.gupt 4282 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4283 
      oprot.writeI64(self.transactionId)
4284 
      oprot.writeFieldEnd()
4285 
    oprot.writeFieldStop()
4286 
    oprot.writeStructEnd()
4287 
 
3431 rajveer 4288 
  def validate(self):
4289 
    return
4290 
 
4291 
 
1382 varun.gupt 4292 
  def __repr__(self):
4293 
    L = ['%s=%r' % (key, value)
4294 
      for key, value in self.__dict__.iteritems()]
4295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4296 
 
4297 
  def __eq__(self, other):
4298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4299 
 
4300 
  def __ne__(self, other):
4301 
    return not (self == other)
4302 
 
1398 varun.gupt 4303 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 4304 
  """
4305 
  Attributes:
4306 
   - success
4307 
   - ex
4308 
  """
4309 
 
4310 
  thrift_spec = (
4311 
    (0, TType.BOOL, 'success', None, None, ), # 0
4312 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4313 
  )
4314 
 
4315 
  def __init__(self, success=None, ex=None,):
4316 
    self.success = success
4317 
    self.ex = ex
4318 
 
4319 
  def read(self, iprot):
4320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4322 
      return
4323 
    iprot.readStructBegin()
4324 
    while True:
4325 
      (fname, ftype, fid) = iprot.readFieldBegin()
4326 
      if ftype == TType.STOP:
4327 
        break
4328 
      if fid == 0:
4329 
        if ftype == TType.BOOL:
4330 
          self.success = iprot.readBool();
4331 
        else:
4332 
          iprot.skip(ftype)
4333 
      elif fid == 1:
4334 
        if ftype == TType.STRUCT:
4335 
          self.ex = TransactionServiceException()
4336 
          self.ex.read(iprot)
4337 
        else:
4338 
          iprot.skip(ftype)
4339 
      else:
4340 
        iprot.skip(ftype)
4341 
      iprot.readFieldEnd()
4342 
    iprot.readStructEnd()
4343 
 
4344 
  def write(self, oprot):
4345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4347 
      return
1398 varun.gupt 4348 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 4349 
    if self.success is not None:
1382 varun.gupt 4350 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4351 
      oprot.writeBool(self.success)
4352 
      oprot.writeFieldEnd()
3431 rajveer 4353 
    if self.ex is not None:
1382 varun.gupt 4354 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4355 
      self.ex.write(oprot)
4356 
      oprot.writeFieldEnd()
4357 
    oprot.writeFieldStop()
4358 
    oprot.writeStructEnd()
4359 
 
3431 rajveer 4360 
  def validate(self):
4361 
    return
4362 
 
4363 
 
1382 varun.gupt 4364 
  def __repr__(self):
4365 
    L = ['%s=%r' % (key, value)
4366 
      for key, value in self.__dict__.iteritems()]
4367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4368 
 
4369 
  def __eq__(self, other):
4370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4371 
 
4372 
  def __ne__(self, other):
4373 
    return not (self == other)
4374 
 
483 rajveer 4375 
class getAllOrders_args:
94 ashish 4376 
  """
4377 
  Attributes:
483 rajveer 4378 
   - status
4379 
   - from_date
4380 
   - to_date
4381 
   - warehouse_id
94 ashish 4382 
  """
4383 
 
4384 
  thrift_spec = (
4385 
    None, # 0
483 rajveer 4386 
    (1, TType.I32, 'status', None, None, ), # 1
4387 
    (2, TType.I64, 'from_date', None, None, ), # 2
4388 
    (3, TType.I64, 'to_date', None, None, ), # 3
4389 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 4390 
  )
4391 
 
483 rajveer 4392 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
4393 
    self.status = status
4394 
    self.from_date = from_date
4395 
    self.to_date = to_date
4396 
    self.warehouse_id = warehouse_id
94 ashish 4397 
 
4398 
  def read(self, iprot):
4399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4401 
      return
4402 
    iprot.readStructBegin()
4403 
    while True:
4404 
      (fname, ftype, fid) = iprot.readFieldBegin()
4405 
      if ftype == TType.STOP:
4406 
        break
4407 
      if fid == 1:
483 rajveer 4408 
        if ftype == TType.I32:
4409 
          self.status = iprot.readI32();
94 ashish 4410 
        else:
4411 
          iprot.skip(ftype)
483 rajveer 4412 
      elif fid == 2:
4413 
        if ftype == TType.I64:
4414 
          self.from_date = iprot.readI64();
94 ashish 4415 
        else:
4416 
          iprot.skip(ftype)
483 rajveer 4417 
      elif fid == 3:
4418 
        if ftype == TType.I64:
4419 
          self.to_date = iprot.readI64();
94 ashish 4420 
        else:
4421 
          iprot.skip(ftype)
483 rajveer 4422 
      elif fid == 4:
94 ashish 4423 
        if ftype == TType.I64:
483 rajveer 4424 
          self.warehouse_id = iprot.readI64();
94 ashish 4425 
        else:
4426 
          iprot.skip(ftype)
4427 
      else:
4428 
        iprot.skip(ftype)
4429 
      iprot.readFieldEnd()
4430 
    iprot.readStructEnd()
4431 
 
4432 
  def write(self, oprot):
4433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4435 
      return
483 rajveer 4436 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 4437 
    if self.status is not None:
483 rajveer 4438 
      oprot.writeFieldBegin('status', TType.I32, 1)
4439 
      oprot.writeI32(self.status)
94 ashish 4440 
      oprot.writeFieldEnd()
3431 rajveer 4441 
    if self.from_date is not None:
483 rajveer 4442 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4443 
      oprot.writeI64(self.from_date)
94 ashish 4444 
      oprot.writeFieldEnd()
3431 rajveer 4445 
    if self.to_date is not None:
483 rajveer 4446 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4447 
      oprot.writeI64(self.to_date)
94 ashish 4448 
      oprot.writeFieldEnd()
3431 rajveer 4449 
    if self.warehouse_id is not None:
483 rajveer 4450 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
4451 
      oprot.writeI64(self.warehouse_id)
94 ashish 4452 
      oprot.writeFieldEnd()
4453 
    oprot.writeFieldStop()
4454 
    oprot.writeStructEnd()
4455 
 
3431 rajveer 4456 
  def validate(self):
4457 
    return
4458 
 
4459 
 
94 ashish 4460 
  def __repr__(self):
4461 
    L = ['%s=%r' % (key, value)
4462 
      for key, value in self.__dict__.iteritems()]
4463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4464 
 
4465 
  def __eq__(self, other):
4466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4467 
 
4468 
  def __ne__(self, other):
4469 
    return not (self == other)
4470 
 
483 rajveer 4471 
class getAllOrders_result:
94 ashish 4472 
  """
4473 
  Attributes:
4474 
   - success
4475 
   - ex
4476 
  """
4477 
 
4478 
  thrift_spec = (
483 rajveer 4479 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 4480 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4481 
  )
4482 
 
4483 
  def __init__(self, success=None, ex=None,):
4484 
    self.success = success
4485 
    self.ex = ex
4486 
 
4487 
  def read(self, iprot):
4488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4490 
      return
4491 
    iprot.readStructBegin()
4492 
    while True:
4493 
      (fname, ftype, fid) = iprot.readFieldBegin()
4494 
      if ftype == TType.STOP:
4495 
        break
4496 
      if fid == 0:
483 rajveer 4497 
        if ftype == TType.LIST:
4498 
          self.success = []
685 chandransh 4499 
          (_etype31, _size28) = iprot.readListBegin()
4500 
          for _i32 in xrange(_size28):
4501 
            _elem33 = Order()
4502 
            _elem33.read(iprot)
4503 
            self.success.append(_elem33)
483 rajveer 4504 
          iprot.readListEnd()
94 ashish 4505 
        else:
4506 
          iprot.skip(ftype)
4507 
      elif fid == 1:
4508 
        if ftype == TType.STRUCT:
4509 
          self.ex = TransactionServiceException()
4510 
          self.ex.read(iprot)
4511 
        else:
4512 
          iprot.skip(ftype)
4513 
      else:
4514 
        iprot.skip(ftype)
4515 
      iprot.readFieldEnd()
4516 
    iprot.readStructEnd()
4517 
 
4518 
  def write(self, oprot):
4519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4521 
      return
483 rajveer 4522 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 4523 
    if self.success is not None:
483 rajveer 4524 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4525 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4526 
      for iter34 in self.success:
4527 
        iter34.write(oprot)
483 rajveer 4528 
      oprot.writeListEnd()
94 ashish 4529 
      oprot.writeFieldEnd()
3431 rajveer 4530 
    if self.ex is not None:
94 ashish 4531 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4532 
      self.ex.write(oprot)
4533 
      oprot.writeFieldEnd()
4534 
    oprot.writeFieldStop()
4535 
    oprot.writeStructEnd()
4536 
 
3431 rajveer 4537 
  def validate(self):
4538 
    return
4539 
 
4540 
 
94 ashish 4541 
  def __repr__(self):
4542 
    L = ['%s=%r' % (key, value)
4543 
      for key, value in self.__dict__.iteritems()]
4544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4545 
 
4546 
  def __eq__(self, other):
4547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4548 
 
4549 
  def __ne__(self, other):
4550 
    return not (self == other)
4551 
 
999 varun.gupt 4552 
class getOrdersByBillingDate_args:
4553 
  """
4554 
  Attributes:
4555 
   - status
4556 
   - start_billing_date
4557 
   - end_billing_date
4558 
   - warehouse_id
4559 
  """
4560 
 
4561 
  thrift_spec = (
4562 
    None, # 0
4563 
    (1, TType.I32, 'status', None, None, ), # 1
4564 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
4565 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
4566 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
4567 
  )
4568 
 
4569 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
4570 
    self.status = status
4571 
    self.start_billing_date = start_billing_date
4572 
    self.end_billing_date = end_billing_date
4573 
    self.warehouse_id = warehouse_id
4574 
 
4575 
  def read(self, iprot):
4576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4578 
      return
4579 
    iprot.readStructBegin()
4580 
    while True:
4581 
      (fname, ftype, fid) = iprot.readFieldBegin()
4582 
      if ftype == TType.STOP:
4583 
        break
4584 
      if fid == 1:
4585 
        if ftype == TType.I32:
4586 
          self.status = iprot.readI32();
4587 
        else:
4588 
          iprot.skip(ftype)
4589 
      elif fid == 2:
4590 
        if ftype == TType.I64:
4591 
          self.start_billing_date = iprot.readI64();
4592 
        else:
4593 
          iprot.skip(ftype)
4594 
      elif fid == 3:
4595 
        if ftype == TType.I64:
4596 
          self.end_billing_date = iprot.readI64();
4597 
        else:
4598 
          iprot.skip(ftype)
4599 
      elif fid == 4:
4600 
        if ftype == TType.I64:
4601 
          self.warehouse_id = iprot.readI64();
4602 
        else:
4603 
          iprot.skip(ftype)
4604 
      else:
4605 
        iprot.skip(ftype)
4606 
      iprot.readFieldEnd()
4607 
    iprot.readStructEnd()
4608 
 
4609 
  def write(self, oprot):
4610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4612 
      return
4613 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 4614 
    if self.status is not None:
999 varun.gupt 4615 
      oprot.writeFieldBegin('status', TType.I32, 1)
4616 
      oprot.writeI32(self.status)
4617 
      oprot.writeFieldEnd()
3431 rajveer 4618 
    if self.start_billing_date is not None:
999 varun.gupt 4619 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
4620 
      oprot.writeI64(self.start_billing_date)
4621 
      oprot.writeFieldEnd()
3431 rajveer 4622 
    if self.end_billing_date is not None:
999 varun.gupt 4623 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
4624 
      oprot.writeI64(self.end_billing_date)
4625 
      oprot.writeFieldEnd()
3431 rajveer 4626 
    if self.warehouse_id is not None:
999 varun.gupt 4627 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
4628 
      oprot.writeI64(self.warehouse_id)
4629 
      oprot.writeFieldEnd()
4630 
    oprot.writeFieldStop()
4631 
    oprot.writeStructEnd()
4632 
 
3431 rajveer 4633 
  def validate(self):
4634 
    return
4635 
 
4636 
 
999 varun.gupt 4637 
  def __repr__(self):
4638 
    L = ['%s=%r' % (key, value)
4639 
      for key, value in self.__dict__.iteritems()]
4640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4641 
 
4642 
  def __eq__(self, other):
4643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4644 
 
4645 
  def __ne__(self, other):
4646 
    return not (self == other)
4647 
 
4648 
class getOrdersByBillingDate_result:
4649 
  """
4650 
  Attributes:
4651 
   - success
4652 
   - ex
4653 
  """
4654 
 
4655 
  thrift_spec = (
4656 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
4657 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4658 
  )
4659 
 
4660 
  def __init__(self, success=None, ex=None,):
4661 
    self.success = success
4662 
    self.ex = ex
4663 
 
4664 
  def read(self, iprot):
4665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4667 
      return
4668 
    iprot.readStructBegin()
4669 
    while True:
4670 
      (fname, ftype, fid) = iprot.readFieldBegin()
4671 
      if ftype == TType.STOP:
4672 
        break
4673 
      if fid == 0:
4674 
        if ftype == TType.LIST:
4675 
          self.success = []
4676 
          (_etype38, _size35) = iprot.readListBegin()
4677 
          for _i39 in xrange(_size35):
4678 
            _elem40 = Order()
4679 
            _elem40.read(iprot)
4680 
            self.success.append(_elem40)
4681 
          iprot.readListEnd()
4682 
        else:
4683 
          iprot.skip(ftype)
4684 
      elif fid == 1:
4685 
        if ftype == TType.STRUCT:
4686 
          self.ex = TransactionServiceException()
4687 
          self.ex.read(iprot)
4688 
        else:
4689 
          iprot.skip(ftype)
4690 
      else:
4691 
        iprot.skip(ftype)
4692 
      iprot.readFieldEnd()
4693 
    iprot.readStructEnd()
4694 
 
4695 
  def write(self, oprot):
4696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4698 
      return
4699 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 4700 
    if self.success is not None:
999 varun.gupt 4701 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4702 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4703 
      for iter41 in self.success:
4704 
        iter41.write(oprot)
4705 
      oprot.writeListEnd()
4706 
      oprot.writeFieldEnd()
3431 rajveer 4707 
    if self.ex is not None:
999 varun.gupt 4708 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4709 
      self.ex.write(oprot)
4710 
      oprot.writeFieldEnd()
4711 
    oprot.writeFieldStop()
4712 
    oprot.writeStructEnd()
4713 
 
3431 rajveer 4714 
  def validate(self):
4715 
    return
4716 
 
4717 
 
999 varun.gupt 4718 
  def __repr__(self):
4719 
    L = ['%s=%r' % (key, value)
4720 
      for key, value in self.__dict__.iteritems()]
4721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4722 
 
4723 
  def __eq__(self, other):
4724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4725 
 
4726 
  def __ne__(self, other):
4727 
    return not (self == other)
4728 
 
3427 chandransh 4729 
class getOrdersByShippingDate_args:
4730 
  """
4731 
  Attributes:
4732 
   - fromShippingDate
4733 
   - toShippingDate
4734 
   - providerId
4735 
   - warehouseId
3451 chandransh 4736 
   - cod
3427 chandransh 4737 
  """
4738 
 
4739 
  thrift_spec = (
4740 
    None, # 0
4741 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
4742 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
4743 
    (3, TType.I64, 'providerId', None, None, ), # 3
4744 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 4745 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 4746 
  )
4747 
 
3451 chandransh 4748 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 4749 
    self.fromShippingDate = fromShippingDate
4750 
    self.toShippingDate = toShippingDate
4751 
    self.providerId = providerId
4752 
    self.warehouseId = warehouseId
3451 chandransh 4753 
    self.cod = cod
3427 chandransh 4754 
 
4755 
  def read(self, iprot):
4756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4758 
      return
4759 
    iprot.readStructBegin()
4760 
    while True:
4761 
      (fname, ftype, fid) = iprot.readFieldBegin()
4762 
      if ftype == TType.STOP:
4763 
        break
4764 
      if fid == 1:
4765 
        if ftype == TType.I64:
4766 
          self.fromShippingDate = iprot.readI64();
4767 
        else:
4768 
          iprot.skip(ftype)
4769 
      elif fid == 2:
4770 
        if ftype == TType.I64:
4771 
          self.toShippingDate = iprot.readI64();
4772 
        else:
4773 
          iprot.skip(ftype)
4774 
      elif fid == 3:
4775 
        if ftype == TType.I64:
4776 
          self.providerId = iprot.readI64();
4777 
        else:
4778 
          iprot.skip(ftype)
4779 
      elif fid == 4:
4780 
        if ftype == TType.I64:
4781 
          self.warehouseId = iprot.readI64();
4782 
        else:
4783 
          iprot.skip(ftype)
3451 chandransh 4784 
      elif fid == 5:
4785 
        if ftype == TType.BOOL:
4786 
          self.cod = iprot.readBool();
4787 
        else:
4788 
          iprot.skip(ftype)
3427 chandransh 4789 
      else:
4790 
        iprot.skip(ftype)
4791 
      iprot.readFieldEnd()
4792 
    iprot.readStructEnd()
4793 
 
4794 
  def write(self, oprot):
4795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4797 
      return
4798 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 4799 
    if self.fromShippingDate is not None:
3427 chandransh 4800 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
4801 
      oprot.writeI64(self.fromShippingDate)
4802 
      oprot.writeFieldEnd()
3431 rajveer 4803 
    if self.toShippingDate is not None:
3427 chandransh 4804 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
4805 
      oprot.writeI64(self.toShippingDate)
4806 
      oprot.writeFieldEnd()
3431 rajveer 4807 
    if self.providerId is not None:
3427 chandransh 4808 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
4809 
      oprot.writeI64(self.providerId)
4810 
      oprot.writeFieldEnd()
3431 rajveer 4811 
    if self.warehouseId is not None:
3427 chandransh 4812 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
4813 
      oprot.writeI64(self.warehouseId)
4814 
      oprot.writeFieldEnd()
3451 chandransh 4815 
    if self.cod is not None:
4816 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
4817 
      oprot.writeBool(self.cod)
4818 
      oprot.writeFieldEnd()
3427 chandransh 4819 
    oprot.writeFieldStop()
4820 
    oprot.writeStructEnd()
4821 
 
3431 rajveer 4822 
  def validate(self):
4823 
    return
4824 
 
4825 
 
3427 chandransh 4826 
  def __repr__(self):
4827 
    L = ['%s=%r' % (key, value)
4828 
      for key, value in self.__dict__.iteritems()]
4829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4830 
 
4831 
  def __eq__(self, other):
4832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4833 
 
4834 
  def __ne__(self, other):
4835 
    return not (self == other)
4836 
 
4837 
class getOrdersByShippingDate_result:
4838 
  """
4839 
  Attributes:
4840 
   - success
4841 
   - ex
4842 
  """
4843 
 
4844 
  thrift_spec = (
4845 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
4846 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4847 
  )
4848 
 
4849 
  def __init__(self, success=None, ex=None,):
4850 
    self.success = success
4851 
    self.ex = ex
4852 
 
4853 
  def read(self, iprot):
4854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4856 
      return
4857 
    iprot.readStructBegin()
4858 
    while True:
4859 
      (fname, ftype, fid) = iprot.readFieldBegin()
4860 
      if ftype == TType.STOP:
4861 
        break
4862 
      if fid == 0:
4863 
        if ftype == TType.LIST:
4864 
          self.success = []
4865 
          (_etype45, _size42) = iprot.readListBegin()
4866 
          for _i46 in xrange(_size42):
4867 
            _elem47 = Order()
4868 
            _elem47.read(iprot)
4869 
            self.success.append(_elem47)
4870 
          iprot.readListEnd()
4871 
        else:
4872 
          iprot.skip(ftype)
4873 
      elif fid == 1:
4874 
        if ftype == TType.STRUCT:
4875 
          self.ex = TransactionServiceException()
4876 
          self.ex.read(iprot)
4877 
        else:
4878 
          iprot.skip(ftype)
4879 
      else:
4880 
        iprot.skip(ftype)
4881 
      iprot.readFieldEnd()
4882 
    iprot.readStructEnd()
4883 
 
4884 
  def write(self, oprot):
4885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4887 
      return
4888 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 4889 
    if self.success is not None:
3427 chandransh 4890 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4891 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4892 
      for iter48 in self.success:
4893 
        iter48.write(oprot)
4894 
      oprot.writeListEnd()
4895 
      oprot.writeFieldEnd()
3431 rajveer 4896 
    if self.ex is not None:
3427 chandransh 4897 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4898 
      self.ex.write(oprot)
4899 
      oprot.writeFieldEnd()
4900 
    oprot.writeFieldStop()
4901 
    oprot.writeStructEnd()
4902 
 
3431 rajveer 4903 
  def validate(self):
4904 
    return
4905 
 
4906 
 
3427 chandransh 4907 
  def __repr__(self):
4908 
    L = ['%s=%r' % (key, value)
4909 
      for key, value in self.__dict__.iteritems()]
4910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4911 
 
4912 
  def __eq__(self, other):
4913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4914 
 
4915 
  def __ne__(self, other):
4916 
    return not (self == other)
4917 
 
1382 varun.gupt 4918 
class getReturnableOrdersForCustomer_args:
4919 
  """
4920 
  Attributes:
4921 
   - customer_id
4922 
   - limit
4923 
  """
4924 
 
4925 
  thrift_spec = (
4926 
    None, # 0
4927 
    (1, TType.I64, 'customer_id', None, None, ), # 1
4928 
    (2, TType.I64, 'limit', None, None, ), # 2
4929 
  )
4930 
 
4931 
  def __init__(self, customer_id=None, limit=None,):
4932 
    self.customer_id = customer_id
4933 
    self.limit = limit
4934 
 
4935 
  def read(self, iprot):
4936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4938 
      return
4939 
    iprot.readStructBegin()
4940 
    while True:
4941 
      (fname, ftype, fid) = iprot.readFieldBegin()
4942 
      if ftype == TType.STOP:
4943 
        break
4944 
      if fid == 1:
4945 
        if ftype == TType.I64:
4946 
          self.customer_id = iprot.readI64();
4947 
        else:
4948 
          iprot.skip(ftype)
4949 
      elif fid == 2:
4950 
        if ftype == TType.I64:
4951 
          self.limit = iprot.readI64();
4952 
        else:
4953 
          iprot.skip(ftype)
4954 
      else:
4955 
        iprot.skip(ftype)
4956 
      iprot.readFieldEnd()
4957 
    iprot.readStructEnd()
4958 
 
4959 
  def write(self, oprot):
4960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4962 
      return
4963 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 4964 
    if self.customer_id is not None:
1382 varun.gupt 4965 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
4966 
      oprot.writeI64(self.customer_id)
4967 
      oprot.writeFieldEnd()
3431 rajveer 4968 
    if self.limit is not None:
1382 varun.gupt 4969 
      oprot.writeFieldBegin('limit', TType.I64, 2)
4970 
      oprot.writeI64(self.limit)
4971 
      oprot.writeFieldEnd()
4972 
    oprot.writeFieldStop()
4973 
    oprot.writeStructEnd()
4974 
 
3431 rajveer 4975 
  def validate(self):
4976 
    return
4977 
 
4978 
 
1382 varun.gupt 4979 
  def __repr__(self):
4980 
    L = ['%s=%r' % (key, value)
4981 
      for key, value in self.__dict__.iteritems()]
4982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4983 
 
4984 
  def __eq__(self, other):
4985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4986 
 
4987 
  def __ne__(self, other):
4988 
    return not (self == other)
4989 
 
4990 
class getReturnableOrdersForCustomer_result:
4991 
  """
4992 
  Attributes:
4993 
   - success
4994 
   - ex
4995 
  """
4996 
 
4997 
  thrift_spec = (
4998 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
4999 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5000 
  )
5001 
 
5002 
  def __init__(self, success=None, ex=None,):
5003 
    self.success = success
5004 
    self.ex = ex
5005 
 
5006 
  def read(self, iprot):
5007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5009 
      return
5010 
    iprot.readStructBegin()
5011 
    while True:
5012 
      (fname, ftype, fid) = iprot.readFieldBegin()
5013 
      if ftype == TType.STOP:
5014 
        break
5015 
      if fid == 0:
5016 
        if ftype == TType.LIST:
5017 
          self.success = []
3427 chandransh 5018 
          (_etype52, _size49) = iprot.readListBegin()
5019 
          for _i53 in xrange(_size49):
5020 
            _elem54 = iprot.readI64();
5021 
            self.success.append(_elem54)
1382 varun.gupt 5022 
          iprot.readListEnd()
5023 
        else:
5024 
          iprot.skip(ftype)
5025 
      elif fid == 1:
5026 
        if ftype == TType.STRUCT:
5027 
          self.ex = TransactionServiceException()
5028 
          self.ex.read(iprot)
5029 
        else:
5030 
          iprot.skip(ftype)
5031 
      else:
5032 
        iprot.skip(ftype)
5033 
      iprot.readFieldEnd()
5034 
    iprot.readStructEnd()
5035 
 
5036 
  def write(self, oprot):
5037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5039 
      return
5040 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 5041 
    if self.success is not None:
1382 varun.gupt 5042 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5043 
      oprot.writeListBegin(TType.I64, len(self.success))
3427 chandransh 5044 
      for iter55 in self.success:
5045 
        oprot.writeI64(iter55)
1382 varun.gupt 5046 
      oprot.writeListEnd()
5047 
      oprot.writeFieldEnd()
3431 rajveer 5048 
    if self.ex is not None:
1382 varun.gupt 5049 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5050 
      self.ex.write(oprot)
5051 
      oprot.writeFieldEnd()
5052 
    oprot.writeFieldStop()
5053 
    oprot.writeStructEnd()
5054 
 
3431 rajveer 5055 
  def validate(self):
5056 
    return
5057 
 
5058 
 
1382 varun.gupt 5059 
  def __repr__(self):
5060 
    L = ['%s=%r' % (key, value)
5061 
      for key, value in self.__dict__.iteritems()]
5062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5063 
 
5064 
  def __eq__(self, other):
5065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5066 
 
5067 
  def __ne__(self, other):
5068 
    return not (self == other)
5069 
 
5070 
class getCancellableOrdersForCustomer_args:
5071 
  """
5072 
  Attributes:
5073 
   - customer_id
5074 
   - limit
5075 
  """
5076 
 
5077 
  thrift_spec = (
5078 
    None, # 0
5079 
    (1, TType.I64, 'customer_id', None, None, ), # 1
5080 
    (2, TType.I64, 'limit', None, None, ), # 2
5081 
  )
5082 
 
5083 
  def __init__(self, customer_id=None, limit=None,):
5084 
    self.customer_id = customer_id
5085 
    self.limit = limit
5086 
 
5087 
  def read(self, iprot):
5088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5090 
      return
5091 
    iprot.readStructBegin()
5092 
    while True:
5093 
      (fname, ftype, fid) = iprot.readFieldBegin()
5094 
      if ftype == TType.STOP:
5095 
        break
5096 
      if fid == 1:
5097 
        if ftype == TType.I64:
5098 
          self.customer_id = iprot.readI64();
5099 
        else:
5100 
          iprot.skip(ftype)
5101 
      elif fid == 2:
5102 
        if ftype == TType.I64:
5103 
          self.limit = iprot.readI64();
5104 
        else:
5105 
          iprot.skip(ftype)
5106 
      else:
5107 
        iprot.skip(ftype)
5108 
      iprot.readFieldEnd()
5109 
    iprot.readStructEnd()
5110 
 
5111 
  def write(self, oprot):
5112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5114 
      return
5115 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 5116 
    if self.customer_id is not None:
1382 varun.gupt 5117 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
5118 
      oprot.writeI64(self.customer_id)
5119 
      oprot.writeFieldEnd()
3431 rajveer 5120 
    if self.limit is not None:
1382 varun.gupt 5121 
      oprot.writeFieldBegin('limit', TType.I64, 2)
5122 
      oprot.writeI64(self.limit)
5123 
      oprot.writeFieldEnd()
5124 
    oprot.writeFieldStop()
5125 
    oprot.writeStructEnd()
5126 
 
3431 rajveer 5127 
  def validate(self):
5128 
    return
5129 
 
5130 
 
1382 varun.gupt 5131 
  def __repr__(self):
5132 
    L = ['%s=%r' % (key, value)
5133 
      for key, value in self.__dict__.iteritems()]
5134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5135 
 
5136 
  def __eq__(self, other):
5137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5138 
 
5139 
  def __ne__(self, other):
5140 
    return not (self == other)
5141 
 
5142 
class getCancellableOrdersForCustomer_result:
5143 
  """
5144 
  Attributes:
5145 
   - success
5146 
   - ex
5147 
  """
5148 
 
5149 
  thrift_spec = (
5150 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
5151 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5152 
  )
5153 
 
5154 
  def __init__(self, success=None, ex=None,):
5155 
    self.success = success
5156 
    self.ex = ex
5157 
 
5158 
  def read(self, iprot):
5159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5161 
      return
5162 
    iprot.readStructBegin()
5163 
    while True:
5164 
      (fname, ftype, fid) = iprot.readFieldBegin()
5165 
      if ftype == TType.STOP:
5166 
        break
5167 
      if fid == 0:
5168 
        if ftype == TType.LIST:
5169 
          self.success = []
3427 chandransh 5170 
          (_etype59, _size56) = iprot.readListBegin()
5171 
          for _i60 in xrange(_size56):
5172 
            _elem61 = iprot.readI64();
5173 
            self.success.append(_elem61)
1382 varun.gupt 5174 
          iprot.readListEnd()
5175 
        else:
5176 
          iprot.skip(ftype)
5177 
      elif fid == 1:
5178 
        if ftype == TType.STRUCT:
5179 
          self.ex = TransactionServiceException()
5180 
          self.ex.read(iprot)
5181 
        else:
5182 
          iprot.skip(ftype)
5183 
      else:
5184 
        iprot.skip(ftype)
5185 
      iprot.readFieldEnd()
5186 
    iprot.readStructEnd()
5187 
 
5188 
  def write(self, oprot):
5189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5191 
      return
5192 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 5193 
    if self.success is not None:
1382 varun.gupt 5194 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5195 
      oprot.writeListBegin(TType.I64, len(self.success))
3427 chandransh 5196 
      for iter62 in self.success:
5197 
        oprot.writeI64(iter62)
1382 varun.gupt 5198 
      oprot.writeListEnd()
5199 
      oprot.writeFieldEnd()
3431 rajveer 5200 
    if self.ex is not None:
1382 varun.gupt 5201 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5202 
      self.ex.write(oprot)
5203 
      oprot.writeFieldEnd()
5204 
    oprot.writeFieldStop()
5205 
    oprot.writeStructEnd()
5206 
 
3431 rajveer 5207 
  def validate(self):
5208 
    return
5209 
 
5210 
 
1382 varun.gupt 5211 
  def __repr__(self):
5212 
    L = ['%s=%r' % (key, value)
5213 
      for key, value in self.__dict__.iteritems()]
5214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5215 
 
5216 
  def __eq__(self, other):
5217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5218 
 
5219 
  def __ne__(self, other):
5220 
    return not (self == other)
5221 
 
483 rajveer 5222 
class changeOrderStatus_args:
94 ashish 5223 
  """
5224 
  Attributes:
483 rajveer 5225 
   - orderId
5226 
   - status
5227 
   - description
94 ashish 5228 
  """
5229 
 
5230 
  thrift_spec = (
5231 
    None, # 0
483 rajveer 5232 
    (1, TType.I64, 'orderId', None, None, ), # 1
5233 
    (2, TType.I32, 'status', None, None, ), # 2
5234 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 5235 
  )
5236 
 
483 rajveer 5237 
  def __init__(self, orderId=None, status=None, description=None,):
5238 
    self.orderId = orderId
5239 
    self.status = status
5240 
    self.description = description
94 ashish 5241 
 
5242 
  def read(self, iprot):
5243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5245 
      return
5246 
    iprot.readStructBegin()
5247 
    while True:
5248 
      (fname, ftype, fid) = iprot.readFieldBegin()
5249 
      if ftype == TType.STOP:
5250 
        break
5251 
      if fid == 1:
5252 
        if ftype == TType.I64:
483 rajveer 5253 
          self.orderId = iprot.readI64();
94 ashish 5254 
        else:
5255 
          iprot.skip(ftype)
5256 
      elif fid == 2:
483 rajveer 5257 
        if ftype == TType.I32:
5258 
          self.status = iprot.readI32();
94 ashish 5259 
        else:
5260 
          iprot.skip(ftype)
483 rajveer 5261 
      elif fid == 3:
5262 
        if ftype == TType.STRING:
5263 
          self.description = iprot.readString();
5264 
        else:
5265 
          iprot.skip(ftype)
94 ashish 5266 
      else:
5267 
        iprot.skip(ftype)
5268 
      iprot.readFieldEnd()
5269 
    iprot.readStructEnd()
5270 
 
5271 
  def write(self, oprot):
5272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5274 
      return
483 rajveer 5275 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 5276 
    if self.orderId is not None:
483 rajveer 5277 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5278 
      oprot.writeI64(self.orderId)
94 ashish 5279 
      oprot.writeFieldEnd()
3431 rajveer 5280 
    if self.status is not None:
483 rajveer 5281 
      oprot.writeFieldBegin('status', TType.I32, 2)
5282 
      oprot.writeI32(self.status)
94 ashish 5283 
      oprot.writeFieldEnd()
3431 rajveer 5284 
    if self.description is not None:
483 rajveer 5285 
      oprot.writeFieldBegin('description', TType.STRING, 3)
5286 
      oprot.writeString(self.description)
5287 
      oprot.writeFieldEnd()
94 ashish 5288 
    oprot.writeFieldStop()
5289 
    oprot.writeStructEnd()
5290 
 
3431 rajveer 5291 
  def validate(self):
5292 
    return
5293 
 
5294 
 
94 ashish 5295 
  def __repr__(self):
5296 
    L = ['%s=%r' % (key, value)
5297 
      for key, value in self.__dict__.iteritems()]
5298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5299 
 
5300 
  def __eq__(self, other):
5301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5302 
 
5303 
  def __ne__(self, other):
5304 
    return not (self == other)
5305 
 
483 rajveer 5306 
class changeOrderStatus_result:
94 ashish 5307 
  """
5308 
  Attributes:
5309 
   - success
5310 
   - ex
5311 
  """
5312 
 
5313 
  thrift_spec = (
5314 
    (0, TType.BOOL, 'success', None, None, ), # 0
5315 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5316 
  )
5317 
 
5318 
  def __init__(self, success=None, ex=None,):
5319 
    self.success = success
5320 
    self.ex = ex
5321 
 
5322 
  def read(self, iprot):
5323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5325 
      return
5326 
    iprot.readStructBegin()
5327 
    while True:
5328 
      (fname, ftype, fid) = iprot.readFieldBegin()
5329 
      if ftype == TType.STOP:
5330 
        break
5331 
      if fid == 0:
5332 
        if ftype == TType.BOOL:
5333 
          self.success = iprot.readBool();
5334 
        else:
5335 
          iprot.skip(ftype)
5336 
      elif fid == 1:
5337 
        if ftype == TType.STRUCT:
5338 
          self.ex = TransactionServiceException()
5339 
          self.ex.read(iprot)
5340 
        else:
5341 
          iprot.skip(ftype)
5342 
      else:
5343 
        iprot.skip(ftype)
5344 
      iprot.readFieldEnd()
5345 
    iprot.readStructEnd()
5346 
 
5347 
  def write(self, oprot):
5348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5350 
      return
483 rajveer 5351 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 5352 
    if self.success is not None:
94 ashish 5353 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5354 
      oprot.writeBool(self.success)
5355 
      oprot.writeFieldEnd()
3431 rajveer 5356 
    if self.ex is not None:
94 ashish 5357 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5358 
      self.ex.write(oprot)
5359 
      oprot.writeFieldEnd()
5360 
    oprot.writeFieldStop()
5361 
    oprot.writeStructEnd()
5362 
 
3431 rajveer 5363 
  def validate(self):
5364 
    return
5365 
 
5366 
 
94 ashish 5367 
  def __repr__(self):
5368 
    L = ['%s=%r' % (key, value)
5369 
      for key, value in self.__dict__.iteritems()]
5370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5371 
 
5372 
  def __eq__(self, other):
5373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5374 
 
5375 
  def __ne__(self, other):
5376 
    return not (self == other)
5377 
 
3064 chandransh 5378 
class getOrdersForTransaction_args:
494 rajveer 5379 
  """
5380 
  Attributes:
3064 chandransh 5381 
   - transactionId
5382 
   - customerId
494 rajveer 5383 
  """
5384 
 
5385 
  thrift_spec = (
5386 
    None, # 0
3064 chandransh 5387 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5388 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 5389 
  )
5390 
 
3064 chandransh 5391 
  def __init__(self, transactionId=None, customerId=None,):
5392 
    self.transactionId = transactionId
5393 
    self.customerId = customerId
494 rajveer 5394 
 
5395 
  def read(self, iprot):
5396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5398 
      return
5399 
    iprot.readStructBegin()
5400 
    while True:
5401 
      (fname, ftype, fid) = iprot.readFieldBegin()
5402 
      if ftype == TType.STOP:
5403 
        break
5404 
      if fid == 1:
5405 
        if ftype == TType.I64:
3064 chandransh 5406 
          self.transactionId = iprot.readI64();
494 rajveer 5407 
        else:
5408 
          iprot.skip(ftype)
5409 
      elif fid == 2:
3064 chandransh 5410 
        if ftype == TType.I64:
5411 
          self.customerId = iprot.readI64();
494 rajveer 5412 
        else:
5413 
          iprot.skip(ftype)
5414 
      else:
5415 
        iprot.skip(ftype)
5416 
      iprot.readFieldEnd()
5417 
    iprot.readStructEnd()
5418 
 
5419 
  def write(self, oprot):
5420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5422 
      return
3064 chandransh 5423 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 5424 
    if self.transactionId is not None:
3064 chandransh 5425 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5426 
      oprot.writeI64(self.transactionId)
494 rajveer 5427 
      oprot.writeFieldEnd()
3431 rajveer 5428 
    if self.customerId is not None:
3064 chandransh 5429 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
5430 
      oprot.writeI64(self.customerId)
494 rajveer 5431 
      oprot.writeFieldEnd()
5432 
    oprot.writeFieldStop()
5433 
    oprot.writeStructEnd()
5434 
 
3431 rajveer 5435 
  def validate(self):
5436 
    return
5437 
 
5438 
 
494 rajveer 5439 
  def __repr__(self):
5440 
    L = ['%s=%r' % (key, value)
5441 
      for key, value in self.__dict__.iteritems()]
5442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5443 
 
5444 
  def __eq__(self, other):
5445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5446 
 
5447 
  def __ne__(self, other):
5448 
    return not (self == other)
5449 
 
3064 chandransh 5450 
class getOrdersForTransaction_result:
494 rajveer 5451 
  """
5452 
  Attributes:
5453 
   - success
5454 
   - ex
5455 
  """
5456 
 
5457 
  thrift_spec = (
3064 chandransh 5458 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 5459 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5460 
  )
5461 
 
5462 
  def __init__(self, success=None, ex=None,):
5463 
    self.success = success
5464 
    self.ex = ex
5465 
 
5466 
  def read(self, iprot):
5467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5469 
      return
5470 
    iprot.readStructBegin()
5471 
    while True:
5472 
      (fname, ftype, fid) = iprot.readFieldBegin()
5473 
      if ftype == TType.STOP:
5474 
        break
5475 
      if fid == 0:
3064 chandransh 5476 
        if ftype == TType.LIST:
5477 
          self.success = []
3427 chandransh 5478 
          (_etype66, _size63) = iprot.readListBegin()
5479 
          for _i67 in xrange(_size63):
5480 
            _elem68 = Order()
5481 
            _elem68.read(iprot)
5482 
            self.success.append(_elem68)
3064 chandransh 5483 
          iprot.readListEnd()
494 rajveer 5484 
        else:
5485 
          iprot.skip(ftype)
5486 
      elif fid == 1:
5487 
        if ftype == TType.STRUCT:
5488 
          self.ex = TransactionServiceException()
5489 
          self.ex.read(iprot)
5490 
        else:
5491 
          iprot.skip(ftype)
5492 
      else:
5493 
        iprot.skip(ftype)
5494 
      iprot.readFieldEnd()
5495 
    iprot.readStructEnd()
5496 
 
5497 
  def write(self, oprot):
5498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5500 
      return
3064 chandransh 5501 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 5502 
    if self.success is not None:
3064 chandransh 5503 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5504 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3427 chandransh 5505 
      for iter69 in self.success:
5506 
        iter69.write(oprot)
3064 chandransh 5507 
      oprot.writeListEnd()
494 rajveer 5508 
      oprot.writeFieldEnd()
3431 rajveer 5509 
    if self.ex is not None:
494 rajveer 5510 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5511 
      self.ex.write(oprot)
5512 
      oprot.writeFieldEnd()
5513 
    oprot.writeFieldStop()
5514 
    oprot.writeStructEnd()
5515 
 
3431 rajveer 5516 
  def validate(self):
5517 
    return
5518 
 
5519 
 
494 rajveer 5520 
  def __repr__(self):
5521 
    L = ['%s=%r' % (key, value)
5522 
      for key, value in self.__dict__.iteritems()]
5523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5524 
 
5525 
  def __eq__(self, other):
5526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5527 
 
5528 
  def __ne__(self, other):
5529 
    return not (self == other)
5530 
 
3064 chandransh 5531 
class getOrdersForCustomer_args:
1149 chandransh 5532 
  """
5533 
  Attributes:
3064 chandransh 5534 
   - customerId
5535 
   - from_date
5536 
   - to_date
5537 
   - statuses
1149 chandransh 5538 
  """
5539 
 
5540 
  thrift_spec = (
5541 
    None, # 0
3064 chandransh 5542 
    (1, TType.I64, 'customerId', None, None, ), # 1
5543 
    (2, TType.I64, 'from_date', None, None, ), # 2
5544 
    (3, TType.I64, 'to_date', None, None, ), # 3
5545 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 5546 
  )
5547 
 
3064 chandransh 5548 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
5549 
    self.customerId = customerId
5550 
    self.from_date = from_date
5551 
    self.to_date = to_date
5552 
    self.statuses = statuses
1149 chandransh 5553 
 
5554 
  def read(self, iprot):
5555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5557 
      return
5558 
    iprot.readStructBegin()
5559 
    while True:
5560 
      (fname, ftype, fid) = iprot.readFieldBegin()
5561 
      if ftype == TType.STOP:
5562 
        break
5563 
      if fid == 1:
5564 
        if ftype == TType.I64:
3064 chandransh 5565 
          self.customerId = iprot.readI64();
1149 chandransh 5566 
        else:
5567 
          iprot.skip(ftype)
5568 
      elif fid == 2:
5569 
        if ftype == TType.I64:
3064 chandransh 5570 
          self.from_date = iprot.readI64();
1149 chandransh 5571 
        else:
5572 
          iprot.skip(ftype)
2783 chandransh 5573 
      elif fid == 3:
5574 
        if ftype == TType.I64:
3064 chandransh 5575 
          self.to_date = iprot.readI64();
2783 chandransh 5576 
        else:
5577 
          iprot.skip(ftype)
5578 
      elif fid == 4:
3064 chandransh 5579 
        if ftype == TType.LIST:
5580 
          self.statuses = []
3427 chandransh 5581 
          (_etype73, _size70) = iprot.readListBegin()
5582 
          for _i74 in xrange(_size70):
5583 
            _elem75 = iprot.readI32();
5584 
            self.statuses.append(_elem75)
3064 chandransh 5585 
          iprot.readListEnd()
2783 chandransh 5586 
        else:
5587 
          iprot.skip(ftype)
1149 chandransh 5588 
      else:
5589 
        iprot.skip(ftype)
5590 
      iprot.readFieldEnd()
5591 
    iprot.readStructEnd()
5592 
 
5593 
  def write(self, oprot):
5594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5596 
      return
3064 chandransh 5597 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 5598 
    if self.customerId is not None:
3064 chandransh 5599 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5600 
      oprot.writeI64(self.customerId)
1149 chandransh 5601 
      oprot.writeFieldEnd()
3431 rajveer 5602 
    if self.from_date is not None:
3064 chandransh 5603 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5604 
      oprot.writeI64(self.from_date)
1149 chandransh 5605 
      oprot.writeFieldEnd()
3431 rajveer 5606 
    if self.to_date is not None:
3064 chandransh 5607 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5608 
      oprot.writeI64(self.to_date)
2783 chandransh 5609 
      oprot.writeFieldEnd()
3431 rajveer 5610 
    if self.statuses is not None:
3064 chandransh 5611 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
5612 
      oprot.writeListBegin(TType.I32, len(self.statuses))
3427 chandransh 5613 
      for iter76 in self.statuses:
5614 
        oprot.writeI32(iter76)
3064 chandransh 5615 
      oprot.writeListEnd()
2783 chandransh 5616 
      oprot.writeFieldEnd()
1149 chandransh 5617 
    oprot.writeFieldStop()
5618 
    oprot.writeStructEnd()
5619 
 
3431 rajveer 5620 
  def validate(self):
5621 
    return
5622 
 
5623 
 
1149 chandransh 5624 
  def __repr__(self):
5625 
    L = ['%s=%r' % (key, value)
5626 
      for key, value in self.__dict__.iteritems()]
5627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5628 
 
5629 
  def __eq__(self, other):
5630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5631 
 
5632 
  def __ne__(self, other):
5633 
    return not (self == other)
5634 
 
3064 chandransh 5635 
class getOrdersForCustomer_result:
1149 chandransh 5636 
  """
5637 
  Attributes:
5638 
   - success
5639 
   - ex
5640 
  """
5641 
 
5642 
  thrift_spec = (
3064 chandransh 5643 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 5644 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5645 
  )
5646 
 
5647 
  def __init__(self, success=None, ex=None,):
5648 
    self.success = success
5649 
    self.ex = ex
5650 
 
5651 
  def read(self, iprot):
5652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5654 
      return
5655 
    iprot.readStructBegin()
5656 
    while True:
5657 
      (fname, ftype, fid) = iprot.readFieldBegin()
5658 
      if ftype == TType.STOP:
5659 
        break
5660 
      if fid == 0:
3064 chandransh 5661 
        if ftype == TType.LIST:
5662 
          self.success = []
3427 chandransh 5663 
          (_etype80, _size77) = iprot.readListBegin()
5664 
          for _i81 in xrange(_size77):
5665 
            _elem82 = Order()
5666 
            _elem82.read(iprot)
5667 
            self.success.append(_elem82)
3064 chandransh 5668 
          iprot.readListEnd()
1149 chandransh 5669 
        else:
5670 
          iprot.skip(ftype)
5671 
      elif fid == 1:
5672 
        if ftype == TType.STRUCT:
5673 
          self.ex = TransactionServiceException()
5674 
          self.ex.read(iprot)
5675 
        else:
5676 
          iprot.skip(ftype)
5677 
      else:
5678 
        iprot.skip(ftype)
5679 
      iprot.readFieldEnd()
5680 
    iprot.readStructEnd()
5681 
 
5682 
  def write(self, oprot):
5683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5685 
      return
3064 chandransh 5686 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 5687 
    if self.success is not None:
3064 chandransh 5688 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5689 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3427 chandransh 5690 
      for iter83 in self.success:
5691 
        iter83.write(oprot)
3064 chandransh 5692 
      oprot.writeListEnd()
1149 chandransh 5693 
      oprot.writeFieldEnd()
3431 rajveer 5694 
    if self.ex is not None:
1149 chandransh 5695 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5696 
      self.ex.write(oprot)
5697 
      oprot.writeFieldEnd()
5698 
    oprot.writeFieldStop()
5699 
    oprot.writeStructEnd()
5700 
 
3431 rajveer 5701 
  def validate(self):
5702 
    return
5703 
 
5704 
 
1149 chandransh 5705 
  def __repr__(self):
5706 
    L = ['%s=%r' % (key, value)
5707 
      for key, value in self.__dict__.iteritems()]
5708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5709 
 
5710 
  def __eq__(self, other):
5711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5712 
 
5713 
  def __ne__(self, other):
5714 
    return not (self == other)
5715 
 
3064 chandransh 5716 
class createOrder_args:
921 rajveer 5717 
  """
5718 
  Attributes:
3064 chandransh 5719 
   - order
921 rajveer 5720 
  """
5721 
 
5722 
  thrift_spec = (
5723 
    None, # 0
3064 chandransh 5724 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 5725 
  )
5726 
 
3064 chandransh 5727 
  def __init__(self, order=None,):
5728 
    self.order = order
921 rajveer 5729 
 
5730 
  def read(self, iprot):
5731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5733 
      return
5734 
    iprot.readStructBegin()
5735 
    while True:
5736 
      (fname, ftype, fid) = iprot.readFieldBegin()
5737 
      if ftype == TType.STOP:
5738 
        break
5739 
      if fid == 1:
3064 chandransh 5740 
        if ftype == TType.STRUCT:
5741 
          self.order = Order()
5742 
          self.order.read(iprot)
921 rajveer 5743 
        else:
5744 
          iprot.skip(ftype)
5745 
      else:
5746 
        iprot.skip(ftype)
5747 
      iprot.readFieldEnd()
5748 
    iprot.readStructEnd()
5749 
 
5750 
  def write(self, oprot):
5751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5753 
      return
3064 chandransh 5754 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 5755 
    if self.order is not None:
3064 chandransh 5756 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
5757 
      self.order.write(oprot)
921 rajveer 5758 
      oprot.writeFieldEnd()
5759 
    oprot.writeFieldStop()
5760 
    oprot.writeStructEnd()
5761 
 
3431 rajveer 5762 
  def validate(self):
5763 
    return
5764 
 
5765 
 
921 rajveer 5766 
  def __repr__(self):
5767 
    L = ['%s=%r' % (key, value)
5768 
      for key, value in self.__dict__.iteritems()]
5769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5770 
 
5771 
  def __eq__(self, other):
5772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5773 
 
5774 
  def __ne__(self, other):
5775 
    return not (self == other)
5776 
 
3064 chandransh 5777 
class createOrder_result:
921 rajveer 5778 
  """
5779 
  Attributes:
5780 
   - success
5781 
   - ex
5782 
  """
5783 
 
5784 
  thrift_spec = (
3064 chandransh 5785 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 5786 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5787 
  )
5788 
 
5789 
  def __init__(self, success=None, ex=None,):
5790 
    self.success = success
5791 
    self.ex = ex
5792 
 
5793 
  def read(self, iprot):
5794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5796 
      return
5797 
    iprot.readStructBegin()
5798 
    while True:
5799 
      (fname, ftype, fid) = iprot.readFieldBegin()
5800 
      if ftype == TType.STOP:
5801 
        break
5802 
      if fid == 0:
3064 chandransh 5803 
        if ftype == TType.I64:
5804 
          self.success = iprot.readI64();
921 rajveer 5805 
        else:
5806 
          iprot.skip(ftype)
5807 
      elif fid == 1:
5808 
        if ftype == TType.STRUCT:
5809 
          self.ex = TransactionServiceException()
5810 
          self.ex.read(iprot)
5811 
        else:
5812 
          iprot.skip(ftype)
5813 
      else:
5814 
        iprot.skip(ftype)
5815 
      iprot.readFieldEnd()
5816 
    iprot.readStructEnd()
5817 
 
5818 
  def write(self, oprot):
5819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5821 
      return
3064 chandransh 5822 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 5823 
    if self.success is not None:
3064 chandransh 5824 
      oprot.writeFieldBegin('success', TType.I64, 0)
5825 
      oprot.writeI64(self.success)
921 rajveer 5826 
      oprot.writeFieldEnd()
3431 rajveer 5827 
    if self.ex is not None:
921 rajveer 5828 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5829 
      self.ex.write(oprot)
5830 
      oprot.writeFieldEnd()
5831 
    oprot.writeFieldStop()
5832 
    oprot.writeStructEnd()
5833 
 
3431 rajveer 5834 
  def validate(self):
5835 
    return
5836 
 
5837 
 
921 rajveer 5838 
  def __repr__(self):
5839 
    L = ['%s=%r' % (key, value)
5840 
      for key, value in self.__dict__.iteritems()]
5841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5842 
 
5843 
  def __eq__(self, other):
5844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5845 
 
5846 
  def __ne__(self, other):
5847 
    return not (self == other)
5848 
 
3064 chandransh 5849 
class getOrder_args:
921 rajveer 5850 
  """
5851 
  Attributes:
3064 chandransh 5852 
   - id
921 rajveer 5853 
  """
5854 
 
5855 
  thrift_spec = (
5856 
    None, # 0
3064 chandransh 5857 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 5858 
  )
5859 
 
3064 chandransh 5860 
  def __init__(self, id=None,):
5861 
    self.id = id
921 rajveer 5862 
 
5863 
  def read(self, iprot):
5864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5866 
      return
5867 
    iprot.readStructBegin()
5868 
    while True:
5869 
      (fname, ftype, fid) = iprot.readFieldBegin()
5870 
      if ftype == TType.STOP:
5871 
        break
5872 
      if fid == 1:
5873 
        if ftype == TType.I64:
3064 chandransh 5874 
          self.id = iprot.readI64();
921 rajveer 5875 
        else:
5876 
          iprot.skip(ftype)
5877 
      else:
5878 
        iprot.skip(ftype)
5879 
      iprot.readFieldEnd()
5880 
    iprot.readStructEnd()
5881 
 
5882 
  def write(self, oprot):
5883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5885 
      return
3064 chandransh 5886 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 5887 
    if self.id is not None:
3064 chandransh 5888 
      oprot.writeFieldBegin('id', TType.I64, 1)
5889 
      oprot.writeI64(self.id)
921 rajveer 5890 
      oprot.writeFieldEnd()
5891 
    oprot.writeFieldStop()
5892 
    oprot.writeStructEnd()
5893 
 
3431 rajveer 5894 
  def validate(self):
5895 
    return
5896 
 
5897 
 
921 rajveer 5898 
  def __repr__(self):
5899 
    L = ['%s=%r' % (key, value)
5900 
      for key, value in self.__dict__.iteritems()]
5901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5902 
 
5903 
  def __eq__(self, other):
5904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5905 
 
5906 
  def __ne__(self, other):
5907 
    return not (self == other)
5908 
 
3064 chandransh 5909 
class getOrder_result:
921 rajveer 5910 
  """
5911 
  Attributes:
5912 
   - success
5913 
   - ex
5914 
  """
5915 
 
5916 
  thrift_spec = (
3064 chandransh 5917 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 5918 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5919 
  )
5920 
 
5921 
  def __init__(self, success=None, ex=None,):
5922 
    self.success = success
5923 
    self.ex = ex
5924 
 
5925 
  def read(self, iprot):
5926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5928 
      return
5929 
    iprot.readStructBegin()
5930 
    while True:
5931 
      (fname, ftype, fid) = iprot.readFieldBegin()
5932 
      if ftype == TType.STOP:
5933 
        break
5934 
      if fid == 0:
3064 chandransh 5935 
        if ftype == TType.STRUCT:
5936 
          self.success = Order()
5937 
          self.success.read(iprot)
921 rajveer 5938 
        else:
5939 
          iprot.skip(ftype)
5940 
      elif fid == 1:
5941 
        if ftype == TType.STRUCT:
5942 
          self.ex = TransactionServiceException()
5943 
          self.ex.read(iprot)
5944 
        else:
5945 
          iprot.skip(ftype)
5946 
      else:
5947 
        iprot.skip(ftype)
5948 
      iprot.readFieldEnd()
5949 
    iprot.readStructEnd()
5950 
 
5951 
  def write(self, oprot):
5952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5954 
      return
3064 chandransh 5955 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 5956 
    if self.success is not None:
3064 chandransh 5957 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5958 
      self.success.write(oprot)
921 rajveer 5959 
      oprot.writeFieldEnd()
3431 rajveer 5960 
    if self.ex is not None:
921 rajveer 5961 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5962 
      self.ex.write(oprot)
5963 
      oprot.writeFieldEnd()
5964 
    oprot.writeFieldStop()
5965 
    oprot.writeStructEnd()
5966 
 
3431 rajveer 5967 
  def validate(self):
5968 
    return
5969 
 
5970 
 
921 rajveer 5971 
  def __repr__(self):
5972 
    L = ['%s=%r' % (key, value)
5973 
      for key, value in self.__dict__.iteritems()]
5974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5975 
 
5976 
  def __eq__(self, other):
5977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5978 
 
5979 
  def __ne__(self, other):
5980 
    return not (self == other)
5981 
 
3064 chandransh 5982 
class getLineItemsForOrder_args:
94 ashish 5983 
  """
5984 
  Attributes:
3064 chandransh 5985 
   - orderId
94 ashish 5986 
  """
5987 
 
5988 
  thrift_spec = (
5989 
    None, # 0
3064 chandransh 5990 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 5991 
  )
5992 
 
3064 chandransh 5993 
  def __init__(self, orderId=None,):
5994 
    self.orderId = orderId
94 ashish 5995 
 
5996 
  def read(self, iprot):
5997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5999 
      return
6000 
    iprot.readStructBegin()
6001 
    while True:
6002 
      (fname, ftype, fid) = iprot.readFieldBegin()
6003 
      if ftype == TType.STOP:
6004 
        break
6005 
      if fid == 1:
6006 
        if ftype == TType.I64:
3064 chandransh 6007 
          self.orderId = iprot.readI64();
94 ashish 6008 
        else:
6009 
          iprot.skip(ftype)
6010 
      else:
6011 
        iprot.skip(ftype)
6012 
      iprot.readFieldEnd()
6013 
    iprot.readStructEnd()
6014 
 
6015 
  def write(self, oprot):
6016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6018 
      return
3064 chandransh 6019 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 6020 
    if self.orderId is not None:
3064 chandransh 6021 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6022 
      oprot.writeI64(self.orderId)
94 ashish 6023 
      oprot.writeFieldEnd()
6024 
    oprot.writeFieldStop()
6025 
    oprot.writeStructEnd()
6026 
 
3431 rajveer 6027 
  def validate(self):
6028 
    return
6029 
 
6030 
 
94 ashish 6031 
  def __repr__(self):
6032 
    L = ['%s=%r' % (key, value)
6033 
      for key, value in self.__dict__.iteritems()]
6034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6035 
 
6036 
  def __eq__(self, other):
6037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6038 
 
6039 
  def __ne__(self, other):
6040 
    return not (self == other)
6041 
 
3064 chandransh 6042 
class getLineItemsForOrder_result:
94 ashish 6043 
  """
6044 
  Attributes:
6045 
   - success
6046 
   - ex
6047 
  """
6048 
 
6049 
  thrift_spec = (
3064 chandransh 6050 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 6051 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6052 
  )
6053 
 
6054 
  def __init__(self, success=None, ex=None,):
6055 
    self.success = success
6056 
    self.ex = ex
6057 
 
6058 
  def read(self, iprot):
6059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6061 
      return
6062 
    iprot.readStructBegin()
6063 
    while True:
6064 
      (fname, ftype, fid) = iprot.readFieldBegin()
6065 
      if ftype == TType.STOP:
6066 
        break
6067 
      if fid == 0:
483 rajveer 6068 
        if ftype == TType.LIST:
6069 
          self.success = []
3427 chandransh 6070 
          (_etype87, _size84) = iprot.readListBegin()
6071 
          for _i88 in xrange(_size84):
6072 
            _elem89 = LineItem()
6073 
            _elem89.read(iprot)
6074 
            self.success.append(_elem89)
483 rajveer 6075 
          iprot.readListEnd()
94 ashish 6076 
        else:
6077 
          iprot.skip(ftype)
6078 
      elif fid == 1:
6079 
        if ftype == TType.STRUCT:
6080 
          self.ex = TransactionServiceException()
6081 
          self.ex.read(iprot)
6082 
        else:
6083 
          iprot.skip(ftype)
6084 
      else:
6085 
        iprot.skip(ftype)
6086 
      iprot.readFieldEnd()
6087 
    iprot.readStructEnd()
6088 
 
6089 
  def write(self, oprot):
6090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6092 
      return
3064 chandransh 6093 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 6094 
    if self.success is not None:
483 rajveer 6095 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6096 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3427 chandransh 6097 
      for iter90 in self.success:
6098 
        iter90.write(oprot)
483 rajveer 6099 
      oprot.writeListEnd()
94 ashish 6100 
      oprot.writeFieldEnd()
3431 rajveer 6101 
    if self.ex is not None:
94 ashish 6102 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6103 
      self.ex.write(oprot)
6104 
      oprot.writeFieldEnd()
6105 
    oprot.writeFieldStop()
6106 
    oprot.writeStructEnd()
6107 
 
3431 rajveer 6108 
  def validate(self):
6109 
    return
6110 
 
6111 
 
94 ashish 6112 
  def __repr__(self):
6113 
    L = ['%s=%r' % (key, value)
6114 
      for key, value in self.__dict__.iteritems()]
6115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6116 
 
6117 
  def __eq__(self, other):
6118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6119 
 
6120 
  def __ne__(self, other):
6121 
    return not (self == other)
6122 
 
3064 chandransh 6123 
class getOrderForCustomer_args:
94 ashish 6124 
  """
6125 
  Attributes:
3064 chandransh 6126 
   - orderId
483 rajveer 6127 
   - customerId
94 ashish 6128 
  """
6129 
 
6130 
  thrift_spec = (
6131 
    None, # 0
3064 chandransh 6132 
    (1, TType.I64, 'orderId', None, None, ), # 1
6133 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 6134 
  )
6135 
 
3064 chandransh 6136 
  def __init__(self, orderId=None, customerId=None,):
6137 
    self.orderId = orderId
483 rajveer 6138 
    self.customerId = customerId
94 ashish 6139 
 
6140 
  def read(self, iprot):
6141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6143 
      return
6144 
    iprot.readStructBegin()
6145 
    while True:
6146 
      (fname, ftype, fid) = iprot.readFieldBegin()
6147 
      if ftype == TType.STOP:
6148 
        break
6149 
      if fid == 1:
6150 
        if ftype == TType.I64:
3064 chandransh 6151 
          self.orderId = iprot.readI64();
94 ashish 6152 
        else:
6153 
          iprot.skip(ftype)
6154 
      elif fid == 2:
6155 
        if ftype == TType.I64:
3064 chandransh 6156 
          self.customerId = iprot.readI64();
94 ashish 6157 
        else:
6158 
          iprot.skip(ftype)
6159 
      else:
6160 
        iprot.skip(ftype)
6161 
      iprot.readFieldEnd()
6162 
    iprot.readStructEnd()
6163 
 
6164 
  def write(self, oprot):
6165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6167 
      return
3064 chandransh 6168 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 6169 
    if self.orderId is not None:
3064 chandransh 6170 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6171 
      oprot.writeI64(self.orderId)
6172 
      oprot.writeFieldEnd()
3431 rajveer 6173 
    if self.customerId is not None:
3064 chandransh 6174 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 6175 
      oprot.writeI64(self.customerId)
94 ashish 6176 
      oprot.writeFieldEnd()
6177 
    oprot.writeFieldStop()
6178 
    oprot.writeStructEnd()
6179 
 
3431 rajveer 6180 
  def validate(self):
6181 
    return
6182 
 
6183 
 
94 ashish 6184 
  def __repr__(self):
6185 
    L = ['%s=%r' % (key, value)
6186 
      for key, value in self.__dict__.iteritems()]
6187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6188 
 
6189 
  def __eq__(self, other):
6190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6191 
 
6192 
  def __ne__(self, other):
6193 
    return not (self == other)
6194 
 
3064 chandransh 6195 
class getOrderForCustomer_result:
94 ashish 6196 
  """
6197 
  Attributes:
6198 
   - success
6199 
   - ex
6200 
  """
6201 
 
6202 
  thrift_spec = (
3064 chandransh 6203 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 6204 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6205 
  )
6206 
 
6207 
  def __init__(self, success=None, ex=None,):
6208 
    self.success = success
6209 
    self.ex = ex
6210 
 
6211 
  def read(self, iprot):
6212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6214 
      return
6215 
    iprot.readStructBegin()
6216 
    while True:
6217 
      (fname, ftype, fid) = iprot.readFieldBegin()
6218 
      if ftype == TType.STOP:
6219 
        break
6220 
      if fid == 0:
3064 chandransh 6221 
        if ftype == TType.STRUCT:
6222 
          self.success = Order()
6223 
          self.success.read(iprot)
94 ashish 6224 
        else:
6225 
          iprot.skip(ftype)
6226 
      elif fid == 1:
6227 
        if ftype == TType.STRUCT:
6228 
          self.ex = TransactionServiceException()
6229 
          self.ex.read(iprot)
6230 
        else:
6231 
          iprot.skip(ftype)
6232 
      else:
6233 
        iprot.skip(ftype)
6234 
      iprot.readFieldEnd()
6235 
    iprot.readStructEnd()
6236 
 
6237 
  def write(self, oprot):
6238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6240 
      return
3064 chandransh 6241 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 6242 
    if self.success is not None:
3064 chandransh 6243 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6244 
      self.success.write(oprot)
94 ashish 6245 
      oprot.writeFieldEnd()
3431 rajveer 6246 
    if self.ex is not None:
94 ashish 6247 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6248 
      self.ex.write(oprot)
6249 
      oprot.writeFieldEnd()
6250 
    oprot.writeFieldStop()
6251 
    oprot.writeStructEnd()
6252 
 
3431 rajveer 6253 
  def validate(self):
6254 
    return
6255 
 
6256 
 
94 ashish 6257 
  def __repr__(self):
6258 
    L = ['%s=%r' % (key, value)
6259 
      for key, value in self.__dict__.iteritems()]
6260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6261 
 
6262 
  def __eq__(self, other):
6263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6264 
 
6265 
  def __ne__(self, other):
6266 
    return not (self == other)
6267 
 
3064 chandransh 6268 
class getAlerts_args:
94 ashish 6269 
  """
6270 
  Attributes:
3064 chandransh 6271 
   - orderId
6272 
   - valid
94 ashish 6273 
  """
6274 
 
6275 
  thrift_spec = (
6276 
    None, # 0
3064 chandransh 6277 
    (1, TType.I64, 'orderId', None, None, ), # 1
6278 
    (2, TType.BOOL, 'valid', None, None, ), # 2
94 ashish 6279 
  )
6280 
 
3064 chandransh 6281 
  def __init__(self, orderId=None, valid=None,):
6282 
    self.orderId = orderId
6283 
    self.valid = valid
94 ashish 6284 
 
6285 
  def read(self, iprot):
6286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6288 
      return
6289 
    iprot.readStructBegin()
6290 
    while True:
6291 
      (fname, ftype, fid) = iprot.readFieldBegin()
6292 
      if ftype == TType.STOP:
6293 
        break
6294 
      if fid == 1:
3064 chandransh 6295 
        if ftype == TType.I64:
6296 
          self.orderId = iprot.readI64();
94 ashish 6297 
        else:
6298 
          iprot.skip(ftype)
3064 chandransh 6299 
      elif fid == 2:
6300 
        if ftype == TType.BOOL:
6301 
          self.valid = iprot.readBool();
6302 
        else:
6303 
          iprot.skip(ftype)
94 ashish 6304 
      else:
6305 
        iprot.skip(ftype)
6306 
      iprot.readFieldEnd()
6307 
    iprot.readStructEnd()
6308 
 
6309 
  def write(self, oprot):
6310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6312 
      return
3064 chandransh 6313 
    oprot.writeStructBegin('getAlerts_args')
3431 rajveer 6314 
    if self.orderId is not None:
3064 chandransh 6315 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6316 
      oprot.writeI64(self.orderId)
94 ashish 6317 
      oprot.writeFieldEnd()
3431 rajveer 6318 
    if self.valid is not None:
3064 chandransh 6319 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
6320 
      oprot.writeBool(self.valid)
6321 
      oprot.writeFieldEnd()
94 ashish 6322 
    oprot.writeFieldStop()
6323 
    oprot.writeStructEnd()
6324 
 
3431 rajveer 6325 
  def validate(self):
6326 
    return
6327 
 
6328 
 
94 ashish 6329 
  def __repr__(self):
6330 
    L = ['%s=%r' % (key, value)
6331 
      for key, value in self.__dict__.iteritems()]
6332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6333 
 
6334 
  def __eq__(self, other):
6335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6336 
 
6337 
  def __ne__(self, other):
6338 
    return not (self == other)
6339 
 
3064 chandransh 6340 
class getAlerts_result:
94 ashish 6341 
  """
6342 
  Attributes:
6343 
   - success
6344 
  """
6345 
 
6346 
  thrift_spec = (
3064 chandransh 6347 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 6348 
  )
6349 
 
3064 chandransh 6350 
  def __init__(self, success=None,):
94 ashish 6351 
    self.success = success
6352 
 
6353 
  def read(self, iprot):
6354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6356 
      return
6357 
    iprot.readStructBegin()
6358 
    while True:
6359 
      (fname, ftype, fid) = iprot.readFieldBegin()
6360 
      if ftype == TType.STOP:
6361 
        break
6362 
      if fid == 0:
3064 chandransh 6363 
        if ftype == TType.LIST:
6364 
          self.success = []
3427 chandransh 6365 
          (_etype94, _size91) = iprot.readListBegin()
6366 
          for _i95 in xrange(_size91):
6367 
            _elem96 = Alert()
6368 
            _elem96.read(iprot)
6369 
            self.success.append(_elem96)
3064 chandransh 6370 
          iprot.readListEnd()
94 ashish 6371 
        else:
6372 
          iprot.skip(ftype)
6373 
      else:
6374 
        iprot.skip(ftype)
6375 
      iprot.readFieldEnd()
6376 
    iprot.readStructEnd()
6377 
 
6378 
  def write(self, oprot):
6379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6381 
      return
3064 chandransh 6382 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 6383 
    if self.success is not None:
3064 chandransh 6384 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6385 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3427 chandransh 6386 
      for iter97 in self.success:
6387 
        iter97.write(oprot)
3064 chandransh 6388 
      oprot.writeListEnd()
94 ashish 6389 
      oprot.writeFieldEnd()
6390 
    oprot.writeFieldStop()
6391 
    oprot.writeStructEnd()
6392 
 
3431 rajveer 6393 
  def validate(self):
6394 
    return
6395 
 
6396 
 
94 ashish 6397 
  def __repr__(self):
6398 
    L = ['%s=%r' % (key, value)
6399 
      for key, value in self.__dict__.iteritems()]
6400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6401 
 
6402 
  def __eq__(self, other):
6403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6404 
 
6405 
  def __ne__(self, other):
6406 
    return not (self == other)
6407 
 
3064 chandransh 6408 
class setAlert_args:
94 ashish 6409 
  """
6410 
  Attributes:
3064 chandransh 6411 
   - orderId
6412 
   - unset
6413 
   - type
6414 
   - comment
94 ashish 6415 
  """
6416 
 
6417 
  thrift_spec = (
6418 
    None, # 0
3064 chandransh 6419 
    (1, TType.I64, 'orderId', None, None, ), # 1
6420 
    (2, TType.BOOL, 'unset', None, None, ), # 2
6421 
    (3, TType.I64, 'type', None, None, ), # 3
6422 
    (4, TType.STRING, 'comment', None, None, ), # 4
94 ashish 6423 
  )
6424 
 
3064 chandransh 6425 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
6426 
    self.orderId = orderId
6427 
    self.unset = unset
6428 
    self.type = type
6429 
    self.comment = comment
94 ashish 6430 
 
6431 
  def read(self, iprot):
6432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6434 
      return
6435 
    iprot.readStructBegin()
6436 
    while True:
6437 
      (fname, ftype, fid) = iprot.readFieldBegin()
6438 
      if ftype == TType.STOP:
6439 
        break
6440 
      if fid == 1:
6441 
        if ftype == TType.I64:
3064 chandransh 6442 
          self.orderId = iprot.readI64();
94 ashish 6443 
        else:
6444 
          iprot.skip(ftype)
3064 chandransh 6445 
      elif fid == 2:
6446 
        if ftype == TType.BOOL:
6447 
          self.unset = iprot.readBool();
6448 
        else:
6449 
          iprot.skip(ftype)
6450 
      elif fid == 3:
6451 
        if ftype == TType.I64:
6452 
          self.type = iprot.readI64();
6453 
        else:
6454 
          iprot.skip(ftype)
6455 
      elif fid == 4:
6456 
        if ftype == TType.STRING:
6457 
          self.comment = iprot.readString();
6458 
        else:
6459 
          iprot.skip(ftype)
94 ashish 6460 
      else:
6461 
        iprot.skip(ftype)
6462 
      iprot.readFieldEnd()
6463 
    iprot.readStructEnd()
6464 
 
6465 
  def write(self, oprot):
6466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6468 
      return
3064 chandransh 6469 
    oprot.writeStructBegin('setAlert_args')
3431 rajveer 6470 
    if self.orderId is not None:
3064 chandransh 6471 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6472 
      oprot.writeI64(self.orderId)
94 ashish 6473 
      oprot.writeFieldEnd()
3431 rajveer 6474 
    if self.unset is not None:
3064 chandransh 6475 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
6476 
      oprot.writeBool(self.unset)
6477 
      oprot.writeFieldEnd()
3431 rajveer 6478 
    if self.type is not None:
3064 chandransh 6479 
      oprot.writeFieldBegin('type', TType.I64, 3)
6480 
      oprot.writeI64(self.type)
6481 
      oprot.writeFieldEnd()
3431 rajveer 6482 
    if self.comment is not None:
3064 chandransh 6483 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
6484 
      oprot.writeString(self.comment)
6485 
      oprot.writeFieldEnd()
94 ashish 6486 
    oprot.writeFieldStop()
6487 
    oprot.writeStructEnd()
6488 
 
3431 rajveer 6489 
  def validate(self):
6490 
    return
6491 
 
6492 
 
94 ashish 6493 
  def __repr__(self):
6494 
    L = ['%s=%r' % (key, value)
6495 
      for key, value in self.__dict__.iteritems()]
6496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6497 
 
6498 
  def __eq__(self, other):
6499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6500 
 
6501 
  def __ne__(self, other):
6502 
    return not (self == other)
6503 
 
3064 chandransh 6504 
class setAlert_result:
6505 
 
6506 
  thrift_spec = (
6507 
  )
6508 
 
6509 
  def read(self, iprot):
6510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6512 
      return
6513 
    iprot.readStructBegin()
6514 
    while True:
6515 
      (fname, ftype, fid) = iprot.readFieldBegin()
6516 
      if ftype == TType.STOP:
6517 
        break
6518 
      else:
6519 
        iprot.skip(ftype)
6520 
      iprot.readFieldEnd()
6521 
    iprot.readStructEnd()
6522 
 
6523 
  def write(self, oprot):
6524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6526 
      return
6527 
    oprot.writeStructBegin('setAlert_result')
6528 
    oprot.writeFieldStop()
6529 
    oprot.writeStructEnd()
6530 
 
3431 rajveer 6531 
  def validate(self):
6532 
    return
6533 
 
6534 
 
3064 chandransh 6535 
  def __repr__(self):
6536 
    L = ['%s=%r' % (key, value)
6537 
      for key, value in self.__dict__.iteritems()]
6538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6539 
 
6540 
  def __eq__(self, other):
6541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6542 
 
6543 
  def __ne__(self, other):
6544 
    return not (self == other)
6545 
 
6546 
class getValidOrderCount_args:
6547 
 
6548 
  thrift_spec = (
6549 
  )
6550 
 
6551 
  def read(self, iprot):
6552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6554 
      return
6555 
    iprot.readStructBegin()
6556 
    while True:
6557 
      (fname, ftype, fid) = iprot.readFieldBegin()
6558 
      if ftype == TType.STOP:
6559 
        break
6560 
      else:
6561 
        iprot.skip(ftype)
6562 
      iprot.readFieldEnd()
6563 
    iprot.readStructEnd()
6564 
 
6565 
  def write(self, oprot):
6566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6568 
      return
6569 
    oprot.writeStructBegin('getValidOrderCount_args')
6570 
    oprot.writeFieldStop()
6571 
    oprot.writeStructEnd()
6572 
 
3431 rajveer 6573 
  def validate(self):
6574 
    return
6575 
 
6576 
 
3064 chandransh 6577 
  def __repr__(self):
6578 
    L = ['%s=%r' % (key, value)
6579 
      for key, value in self.__dict__.iteritems()]
6580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6581 
 
6582 
  def __eq__(self, other):
6583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6584 
 
6585 
  def __ne__(self, other):
6586 
    return not (self == other)
6587 
 
6588 
class getValidOrderCount_result:
94 ashish 6589 
  """
6590 
  Attributes:
6591 
   - success
6592 
  """
6593 
 
6594 
  thrift_spec = (
3064 chandransh 6595 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6596 
  )
6597 
 
3064 chandransh 6598 
  def __init__(self, success=None,):
94 ashish 6599 
    self.success = success
6600 
 
6601 
  def read(self, iprot):
6602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6604 
      return
6605 
    iprot.readStructBegin()
6606 
    while True:
6607 
      (fname, ftype, fid) = iprot.readFieldBegin()
6608 
      if ftype == TType.STOP:
6609 
        break
6610 
      if fid == 0:
3064 chandransh 6611 
        if ftype == TType.I64:
6612 
          self.success = iprot.readI64();
94 ashish 6613 
        else:
6614 
          iprot.skip(ftype)
6615 
      else:
6616 
        iprot.skip(ftype)
6617 
      iprot.readFieldEnd()
6618 
    iprot.readStructEnd()
6619 
 
6620 
  def write(self, oprot):
6621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6623 
      return
3064 chandransh 6624 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 6625 
    if self.success is not None:
3064 chandransh 6626 
      oprot.writeFieldBegin('success', TType.I64, 0)
6627 
      oprot.writeI64(self.success)
94 ashish 6628 
      oprot.writeFieldEnd()
6629 
    oprot.writeFieldStop()
6630 
    oprot.writeStructEnd()
6631 
 
3431 rajveer 6632 
  def validate(self):
6633 
    return
6634 
 
6635 
 
94 ashish 6636 
  def __repr__(self):
6637 
    L = ['%s=%r' % (key, value)
6638 
      for key, value in self.__dict__.iteritems()]
6639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6640 
 
6641 
  def __eq__(self, other):
6642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6643 
 
6644 
  def __ne__(self, other):
6645 
    return not (self == other)
6646 
 
3064 chandransh 6647 
class getNoOfCustomersWithSuccessfulTransaction_args:
6648 
 
6649 
  thrift_spec = (
6650 
  )
6651 
 
6652 
  def read(self, iprot):
6653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6655 
      return
6656 
    iprot.readStructBegin()
6657 
    while True:
6658 
      (fname, ftype, fid) = iprot.readFieldBegin()
6659 
      if ftype == TType.STOP:
6660 
        break
6661 
      else:
6662 
        iprot.skip(ftype)
6663 
      iprot.readFieldEnd()
6664 
    iprot.readStructEnd()
6665 
 
6666 
  def write(self, oprot):
6667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6669 
      return
6670 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
6671 
    oprot.writeFieldStop()
6672 
    oprot.writeStructEnd()
6673 
 
3431 rajveer 6674 
  def validate(self):
6675 
    return
6676 
 
6677 
 
3064 chandransh 6678 
  def __repr__(self):
6679 
    L = ['%s=%r' % (key, value)
6680 
      for key, value in self.__dict__.iteritems()]
6681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6682 
 
6683 
  def __eq__(self, other):
6684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6685 
 
6686 
  def __ne__(self, other):
6687 
    return not (self == other)
6688 
 
6689 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 6690 
  """
6691 
  Attributes:
3064 chandransh 6692 
   - success
94 ashish 6693 
  """
6694 
 
6695 
  thrift_spec = (
3064 chandransh 6696 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6697 
  )
6698 
 
3064 chandransh 6699 
  def __init__(self, success=None,):
6700 
    self.success = success
94 ashish 6701 
 
6702 
  def read(self, iprot):
6703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6705 
      return
6706 
    iprot.readStructBegin()
6707 
    while True:
6708 
      (fname, ftype, fid) = iprot.readFieldBegin()
6709 
      if ftype == TType.STOP:
6710 
        break
3064 chandransh 6711 
      if fid == 0:
94 ashish 6712 
        if ftype == TType.I64:
3064 chandransh 6713 
          self.success = iprot.readI64();
94 ashish 6714 
        else:
6715 
          iprot.skip(ftype)
6716 
      else:
6717 
        iprot.skip(ftype)
6718 
      iprot.readFieldEnd()
6719 
    iprot.readStructEnd()
6720 
 
6721 
  def write(self, oprot):
6722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6724 
      return
3064 chandransh 6725 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 6726 
    if self.success is not None:
3064 chandransh 6727 
      oprot.writeFieldBegin('success', TType.I64, 0)
6728 
      oprot.writeI64(self.success)
94 ashish 6729 
      oprot.writeFieldEnd()
6730 
    oprot.writeFieldStop()
6731 
    oprot.writeStructEnd()
6732 
 
3431 rajveer 6733 
  def validate(self):
6734 
    return
6735 
 
6736 
 
94 ashish 6737 
  def __repr__(self):
6738 
    L = ['%s=%r' % (key, value)
6739 
      for key, value in self.__dict__.iteritems()]
6740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6741 
 
6742 
  def __eq__(self, other):
6743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6744 
 
6745 
  def __ne__(self, other):
6746 
    return not (self == other)
6747 
 
3064 chandransh 6748 
class getValidOrdersAmountRange_args:
6749 
 
6750 
  thrift_spec = (
6751 
  )
6752 
 
6753 
  def read(self, iprot):
6754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6756 
      return
6757 
    iprot.readStructBegin()
6758 
    while True:
6759 
      (fname, ftype, fid) = iprot.readFieldBegin()
6760 
      if ftype == TType.STOP:
6761 
        break
6762 
      else:
6763 
        iprot.skip(ftype)
6764 
      iprot.readFieldEnd()
6765 
    iprot.readStructEnd()
6766 
 
6767 
  def write(self, oprot):
6768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6770 
      return
6771 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
6772 
    oprot.writeFieldStop()
6773 
    oprot.writeStructEnd()
6774 
 
3431 rajveer 6775 
  def validate(self):
6776 
    return
6777 
 
6778 
 
3064 chandransh 6779 
  def __repr__(self):
6780 
    L = ['%s=%r' % (key, value)
6781 
      for key, value in self.__dict__.iteritems()]
6782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6783 
 
6784 
  def __eq__(self, other):
6785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6786 
 
6787 
  def __ne__(self, other):
6788 
    return not (self == other)
6789 
 
6790 
class getValidOrdersAmountRange_result:
94 ashish 6791 
  """
6792 
  Attributes:
6793 
   - success
6794 
  """
6795 
 
6796 
  thrift_spec = (
3064 chandransh 6797 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 6798 
  )
6799 
 
3064 chandransh 6800 
  def __init__(self, success=None,):
94 ashish 6801 
    self.success = success
6802 
 
6803 
  def read(self, iprot):
6804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6806 
      return
6807 
    iprot.readStructBegin()
6808 
    while True:
6809 
      (fname, ftype, fid) = iprot.readFieldBegin()
6810 
      if ftype == TType.STOP:
6811 
        break
6812 
      if fid == 0:
483 rajveer 6813 
        if ftype == TType.LIST:
6814 
          self.success = []
3427 chandransh 6815 
          (_etype101, _size98) = iprot.readListBegin()
6816 
          for _i102 in xrange(_size98):
6817 
            _elem103 = iprot.readDouble();
6818 
            self.success.append(_elem103)
483 rajveer 6819 
          iprot.readListEnd()
94 ashish 6820 
        else:
6821 
          iprot.skip(ftype)
6822 
      else:
6823 
        iprot.skip(ftype)
6824 
      iprot.readFieldEnd()
6825 
    iprot.readStructEnd()
6826 
 
6827 
  def write(self, oprot):
6828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6830 
      return
3064 chandransh 6831 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 6832 
    if self.success is not None:
483 rajveer 6833 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 6834 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
3427 chandransh 6835 
      for iter104 in self.success:
6836 
        oprot.writeDouble(iter104)
483 rajveer 6837 
      oprot.writeListEnd()
94 ashish 6838 
      oprot.writeFieldEnd()
6839 
    oprot.writeFieldStop()
6840 
    oprot.writeStructEnd()
6841 
 
3431 rajveer 6842 
  def validate(self):
6843 
    return
6844 
 
6845 
 
94 ashish 6846 
  def __repr__(self):
6847 
    L = ['%s=%r' % (key, value)
6848 
      for key, value in self.__dict__.iteritems()]
6849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6850 
 
6851 
  def __eq__(self, other):
6852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6853 
 
6854 
  def __ne__(self, other):
6855 
    return not (self == other)
6856 
 
3064 chandransh 6857 
class getValidOrders_args:
1528 ankur.sing 6858 
  """
6859 
  Attributes:
3064 chandransh 6860 
   - limit
1528 ankur.sing 6861 
  """
6862 
 
6863 
  thrift_spec = (
6864 
    None, # 0
3064 chandransh 6865 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 6866 
  )
6867 
 
3064 chandransh 6868 
  def __init__(self, limit=None,):
6869 
    self.limit = limit
1528 ankur.sing 6870 
 
6871 
  def read(self, iprot):
6872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6874 
      return
6875 
    iprot.readStructBegin()
6876 
    while True:
6877 
      (fname, ftype, fid) = iprot.readFieldBegin()
6878 
      if ftype == TType.STOP:
6879 
        break
6880 
      if fid == 1:
6881 
        if ftype == TType.I64:
3064 chandransh 6882 
          self.limit = iprot.readI64();
1528 ankur.sing 6883 
        else:
6884 
          iprot.skip(ftype)
6885 
      else:
6886 
        iprot.skip(ftype)
6887 
      iprot.readFieldEnd()
6888 
    iprot.readStructEnd()
6889 
 
6890 
  def write(self, oprot):
6891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6893 
      return
3064 chandransh 6894 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 6895 
    if self.limit is not None:
3064 chandransh 6896 
      oprot.writeFieldBegin('limit', TType.I64, 1)
6897 
      oprot.writeI64(self.limit)
1528 ankur.sing 6898 
      oprot.writeFieldEnd()
6899 
    oprot.writeFieldStop()
6900 
    oprot.writeStructEnd()
6901 
 
3431 rajveer 6902 
  def validate(self):
6903 
    return
6904 
 
6905 
 
1528 ankur.sing 6906 
  def __repr__(self):
6907 
    L = ['%s=%r' % (key, value)
6908 
      for key, value in self.__dict__.iteritems()]
6909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6910 
 
6911 
  def __eq__(self, other):
6912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6913 
 
6914 
  def __ne__(self, other):
6915 
    return not (self == other)
6916 
 
3064 chandransh 6917 
class getValidOrders_result:
1528 ankur.sing 6918 
  """
6919 
  Attributes:
6920 
   - success
6921 
  """
6922 
 
6923 
  thrift_spec = (
3064 chandransh 6924 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 6925 
  )
6926 
 
3064 chandransh 6927 
  def __init__(self, success=None,):
1528 ankur.sing 6928 
    self.success = success
6929 
 
6930 
  def read(self, iprot):
6931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6933 
      return
6934 
    iprot.readStructBegin()
6935 
    while True:
6936 
      (fname, ftype, fid) = iprot.readFieldBegin()
6937 
      if ftype == TType.STOP:
6938 
        break
6939 
      if fid == 0:
3064 chandransh 6940 
        if ftype == TType.LIST:
6941 
          self.success = []
3427 chandransh 6942 
          (_etype108, _size105) = iprot.readListBegin()
6943 
          for _i109 in xrange(_size105):
6944 
            _elem110 = Order()
6945 
            _elem110.read(iprot)
6946 
            self.success.append(_elem110)
3064 chandransh 6947 
          iprot.readListEnd()
1528 ankur.sing 6948 
        else:
6949 
          iprot.skip(ftype)
6950 
      else:
6951 
        iprot.skip(ftype)
6952 
      iprot.readFieldEnd()
6953 
    iprot.readStructEnd()
6954 
 
6955 
  def write(self, oprot):
6956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6958 
      return
3064 chandransh 6959 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 6960 
    if self.success is not None:
3064 chandransh 6961 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6962 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3427 chandransh 6963 
      for iter111 in self.success:
6964 
        iter111.write(oprot)
3064 chandransh 6965 
      oprot.writeListEnd()
1528 ankur.sing 6966 
      oprot.writeFieldEnd()
6967 
    oprot.writeFieldStop()
6968 
    oprot.writeStructEnd()
6969 
 
3431 rajveer 6970 
  def validate(self):
6971 
    return
6972 
 
6973 
 
1528 ankur.sing 6974 
  def __repr__(self):
6975 
    L = ['%s=%r' % (key, value)
6976 
      for key, value in self.__dict__.iteritems()]
6977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6978 
 
6979 
  def __eq__(self, other):
6980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6981 
 
6982 
  def __ne__(self, other):
6983 
    return not (self == other)
6984 
 
1220 chandransh 6985 
class batchOrders_args:
6986 
  """
6987 
  Attributes:
6988 
   - warehouseId
6989 
  """
6990 
 
6991 
  thrift_spec = (
6992 
    None, # 0
6993 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
6994 
  )
6995 
 
6996 
  def __init__(self, warehouseId=None,):
6997 
    self.warehouseId = warehouseId
6998 
 
6999 
  def read(self, iprot):
7000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7002 
      return
7003 
    iprot.readStructBegin()
7004 
    while True:
7005 
      (fname, ftype, fid) = iprot.readFieldBegin()
7006 
      if ftype == TType.STOP:
7007 
        break
7008 
      if fid == 1:
7009 
        if ftype == TType.I64:
7010 
          self.warehouseId = iprot.readI64();
7011 
        else:
7012 
          iprot.skip(ftype)
7013 
      else:
7014 
        iprot.skip(ftype)
7015 
      iprot.readFieldEnd()
7016 
    iprot.readStructEnd()
7017 
 
7018 
  def write(self, oprot):
7019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7021 
      return
7022 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 7023 
    if self.warehouseId is not None:
1220 chandransh 7024 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
7025 
      oprot.writeI64(self.warehouseId)
7026 
      oprot.writeFieldEnd()
7027 
    oprot.writeFieldStop()
7028 
    oprot.writeStructEnd()
7029 
 
3431 rajveer 7030 
  def validate(self):
7031 
    return
7032 
 
7033 
 
1220 chandransh 7034 
  def __repr__(self):
7035 
    L = ['%s=%r' % (key, value)
7036 
      for key, value in self.__dict__.iteritems()]
7037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7038 
 
7039 
  def __eq__(self, other):
7040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7041 
 
7042 
  def __ne__(self, other):
7043 
    return not (self == other)
7044 
 
7045 
class batchOrders_result:
7046 
  """
7047 
  Attributes:
7048 
   - success
7049 
   - ex
7050 
  """
7051 
 
7052 
  thrift_spec = (
7053 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7054 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7055 
  )
7056 
 
7057 
  def __init__(self, success=None, ex=None,):
7058 
    self.success = success
7059 
    self.ex = ex
7060 
 
7061 
  def read(self, iprot):
7062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7064 
      return
7065 
    iprot.readStructBegin()
7066 
    while True:
7067 
      (fname, ftype, fid) = iprot.readFieldBegin()
7068 
      if ftype == TType.STOP:
7069 
        break
7070 
      if fid == 0:
7071 
        if ftype == TType.LIST:
7072 
          self.success = []
3427 chandransh 7073 
          (_etype115, _size112) = iprot.readListBegin()
7074 
          for _i116 in xrange(_size112):
7075 
            _elem117 = Order()
7076 
            _elem117.read(iprot)
7077 
            self.success.append(_elem117)
1220 chandransh 7078 
          iprot.readListEnd()
7079 
        else:
7080 
          iprot.skip(ftype)
7081 
      elif fid == 1:
7082 
        if ftype == TType.STRUCT:
7083 
          self.ex = TransactionServiceException()
7084 
          self.ex.read(iprot)
7085 
        else:
7086 
          iprot.skip(ftype)
7087 
      else:
7088 
        iprot.skip(ftype)
7089 
      iprot.readFieldEnd()
7090 
    iprot.readStructEnd()
7091 
 
7092 
  def write(self, oprot):
7093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7095 
      return
7096 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 7097 
    if self.success is not None:
1220 chandransh 7098 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7099 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3427 chandransh 7100 
      for iter118 in self.success:
7101 
        iter118.write(oprot)
1220 chandransh 7102 
      oprot.writeListEnd()
7103 
      oprot.writeFieldEnd()
3431 rajveer 7104 
    if self.ex is not None:
1220 chandransh 7105 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7106 
      self.ex.write(oprot)
7107 
      oprot.writeFieldEnd()
7108 
    oprot.writeFieldStop()
7109 
    oprot.writeStructEnd()
7110 
 
3431 rajveer 7111 
  def validate(self):
7112 
    return
7113 
 
7114 
 
1220 chandransh 7115 
  def __repr__(self):
7116 
    L = ['%s=%r' % (key, value)
7117 
      for key, value in self.__dict__.iteritems()]
7118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7119 
 
7120 
  def __eq__(self, other):
7121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7122 
 
7123 
  def __ne__(self, other):
7124 
    return not (self == other)
7125 
 
1208 chandransh 7126 
class markOrderAsOutOfStock_args:
7127 
  """
7128 
  Attributes:
7129 
   - orderId
7130 
  """
7131 
 
7132 
  thrift_spec = (
7133 
    None, # 0
7134 
    (1, TType.I64, 'orderId', None, None, ), # 1
7135 
  )
7136 
 
7137 
  def __init__(self, orderId=None,):
7138 
    self.orderId = orderId
7139 
 
7140 
  def read(self, iprot):
7141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7143 
      return
7144 
    iprot.readStructBegin()
7145 
    while True:
7146 
      (fname, ftype, fid) = iprot.readFieldBegin()
7147 
      if ftype == TType.STOP:
7148 
        break
7149 
      if fid == 1:
7150 
        if ftype == TType.I64:
7151 
          self.orderId = iprot.readI64();
7152 
        else:
7153 
          iprot.skip(ftype)
7154 
      else:
7155 
        iprot.skip(ftype)
7156 
      iprot.readFieldEnd()
7157 
    iprot.readStructEnd()
7158 
 
7159 
  def write(self, oprot):
7160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7162 
      return
7163 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 7164 
    if self.orderId is not None:
1208 chandransh 7165 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7166 
      oprot.writeI64(self.orderId)
7167 
      oprot.writeFieldEnd()
7168 
    oprot.writeFieldStop()
7169 
    oprot.writeStructEnd()
7170 
 
3431 rajveer 7171 
  def validate(self):
7172 
    return
7173 
 
7174 
 
1208 chandransh 7175 
  def __repr__(self):
7176 
    L = ['%s=%r' % (key, value)
7177 
      for key, value in self.__dict__.iteritems()]
7178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7179 
 
7180 
  def __eq__(self, other):
7181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7182 
 
7183 
  def __ne__(self, other):
7184 
    return not (self == other)
7185 
 
7186 
class markOrderAsOutOfStock_result:
7187 
  """
7188 
  Attributes:
7189 
   - success
7190 
   - ex
7191 
  """
7192 
 
7193 
  thrift_spec = (
7194 
    (0, TType.BOOL, 'success', None, None, ), # 0
7195 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7196 
  )
7197 
 
7198 
  def __init__(self, success=None, ex=None,):
7199 
    self.success = success
7200 
    self.ex = ex
7201 
 
7202 
  def read(self, iprot):
7203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7205 
      return
7206 
    iprot.readStructBegin()
7207 
    while True:
7208 
      (fname, ftype, fid) = iprot.readFieldBegin()
7209 
      if ftype == TType.STOP:
7210 
        break
7211 
      if fid == 0:
7212 
        if ftype == TType.BOOL:
7213 
          self.success = iprot.readBool();
7214 
        else:
7215 
          iprot.skip(ftype)
7216 
      elif fid == 1:
7217 
        if ftype == TType.STRUCT:
7218 
          self.ex = TransactionServiceException()
7219 
          self.ex.read(iprot)
7220 
        else:
7221 
          iprot.skip(ftype)
7222 
      else:
7223 
        iprot.skip(ftype)
7224 
      iprot.readFieldEnd()
7225 
    iprot.readStructEnd()
7226 
 
7227 
  def write(self, oprot):
7228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7230 
      return
7231 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 7232 
    if self.success is not None:
1208 chandransh 7233 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7234 
      oprot.writeBool(self.success)
7235 
      oprot.writeFieldEnd()
3431 rajveer 7236 
    if self.ex is not None:
1208 chandransh 7237 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7238 
      self.ex.write(oprot)
7239 
      oprot.writeFieldEnd()
7240 
    oprot.writeFieldStop()
7241 
    oprot.writeStructEnd()
7242 
 
3431 rajveer 7243 
  def validate(self):
7244 
    return
7245 
 
7246 
 
1208 chandransh 7247 
  def __repr__(self):
7248 
    L = ['%s=%r' % (key, value)
7249 
      for key, value in self.__dict__.iteritems()]
7250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7251 
 
7252 
  def __eq__(self, other):
7253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7254 
 
7255 
  def __ne__(self, other):
7256 
    return not (self == other)
7257 
 
3064 chandransh 7258 
class verifyOrder_args:
759 chandransh 7259 
  """
7260 
  Attributes:
3064 chandransh 7261 
   - orderId
759 chandransh 7262 
  """
7263 
 
7264 
  thrift_spec = (
7265 
    None, # 0
3064 chandransh 7266 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 7267 
  )
7268 
 
3064 chandransh 7269 
  def __init__(self, orderId=None,):
7270 
    self.orderId = orderId
759 chandransh 7271 
 
7272 
  def read(self, iprot):
7273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7275 
      return
7276 
    iprot.readStructBegin()
7277 
    while True:
7278 
      (fname, ftype, fid) = iprot.readFieldBegin()
7279 
      if ftype == TType.STOP:
7280 
        break
7281 
      if fid == 1:
7282 
        if ftype == TType.I64:
3064 chandransh 7283 
          self.orderId = iprot.readI64();
759 chandransh 7284 
        else:
7285 
          iprot.skip(ftype)
7286 
      else:
7287 
        iprot.skip(ftype)
7288 
      iprot.readFieldEnd()
7289 
    iprot.readStructEnd()
7290 
 
7291 
  def write(self, oprot):
7292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7294 
      return
3064 chandransh 7295 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 7296 
    if self.orderId is not None:
3064 chandransh 7297 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7298 
      oprot.writeI64(self.orderId)
759 chandransh 7299 
      oprot.writeFieldEnd()
7300 
    oprot.writeFieldStop()
7301 
    oprot.writeStructEnd()
7302 
 
3431 rajveer 7303 
  def validate(self):
7304 
    return
7305 
 
7306 
 
759 chandransh 7307 
  def __repr__(self):
7308 
    L = ['%s=%r' % (key, value)
7309 
      for key, value in self.__dict__.iteritems()]
7310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7311 
 
7312 
  def __eq__(self, other):
7313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7314 
 
7315 
  def __ne__(self, other):
7316 
    return not (self == other)
7317 
 
3064 chandransh 7318 
class verifyOrder_result:
759 chandransh 7319 
  """
7320 
  Attributes:
7321 
   - success
7322 
   - ex
7323 
  """
7324 
 
7325 
  thrift_spec = (
7326 
    (0, TType.BOOL, 'success', None, None, ), # 0
7327 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7328 
  )
7329 
 
7330 
  def __init__(self, success=None, ex=None,):
7331 
    self.success = success
7332 
    self.ex = ex
7333 
 
7334 
  def read(self, iprot):
7335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7337 
      return
7338 
    iprot.readStructBegin()
7339 
    while True:
7340 
      (fname, ftype, fid) = iprot.readFieldBegin()
7341 
      if ftype == TType.STOP:
7342 
        break
7343 
      if fid == 0:
7344 
        if ftype == TType.BOOL:
7345 
          self.success = iprot.readBool();
7346 
        else:
7347 
          iprot.skip(ftype)
7348 
      elif fid == 1:
7349 
        if ftype == TType.STRUCT:
7350 
          self.ex = TransactionServiceException()
7351 
          self.ex.read(iprot)
7352 
        else:
7353 
          iprot.skip(ftype)
7354 
      else:
7355 
        iprot.skip(ftype)
7356 
      iprot.readFieldEnd()
7357 
    iprot.readStructEnd()
7358 
 
7359 
  def write(self, oprot):
7360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7362 
      return
3064 chandransh 7363 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 7364 
    if self.success is not None:
759 chandransh 7365 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7366 
      oprot.writeBool(self.success)
7367 
      oprot.writeFieldEnd()
3431 rajveer 7368 
    if self.ex is not None:
759 chandransh 7369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7370 
      self.ex.write(oprot)
7371 
      oprot.writeFieldEnd()
7372 
    oprot.writeFieldStop()
7373 
    oprot.writeStructEnd()
7374 
 
3431 rajveer 7375 
  def validate(self):
7376 
    return
7377 
 
7378 
 
759 chandransh 7379 
  def __repr__(self):
7380 
    L = ['%s=%r' % (key, value)
7381 
      for key, value in self.__dict__.iteritems()]
7382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7383 
 
7384 
  def __eq__(self, other):
7385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7386 
 
7387 
  def __ne__(self, other):
7388 
    return not (self == other)
7389 
 
3064 chandransh 7390 
class acceptOrder_args:
1113 chandransh 7391 
  """
7392 
  Attributes:
3064 chandransh 7393 
   - orderId
1113 chandransh 7394 
  """
7395 
 
7396 
  thrift_spec = (
7397 
    None, # 0
3064 chandransh 7398 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 7399 
  )
7400 
 
3064 chandransh 7401 
  def __init__(self, orderId=None,):
7402 
    self.orderId = orderId
1113 chandransh 7403 
 
7404 
  def read(self, iprot):
7405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7407 
      return
7408 
    iprot.readStructBegin()
7409 
    while True:
7410 
      (fname, ftype, fid) = iprot.readFieldBegin()
7411 
      if ftype == TType.STOP:
7412 
        break
7413 
      if fid == 1:
7414 
        if ftype == TType.I64:
3064 chandransh 7415 
          self.orderId = iprot.readI64();
1113 chandransh 7416 
        else:
7417 
          iprot.skip(ftype)
7418 
      else:
7419 
        iprot.skip(ftype)
7420 
      iprot.readFieldEnd()
7421 
    iprot.readStructEnd()
7422 
 
7423 
  def write(self, oprot):
7424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7426 
      return
3064 chandransh 7427 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 7428 
    if self.orderId is not None:
3064 chandransh 7429 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7430 
      oprot.writeI64(self.orderId)
1113 chandransh 7431 
      oprot.writeFieldEnd()
7432 
    oprot.writeFieldStop()
7433 
    oprot.writeStructEnd()
7434 
 
3431 rajveer 7435 
  def validate(self):
7436 
    return
7437 
 
7438 
 
1113 chandransh 7439 
  def __repr__(self):
7440 
    L = ['%s=%r' % (key, value)
7441 
      for key, value in self.__dict__.iteritems()]
7442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7443 
 
7444 
  def __eq__(self, other):
7445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7446 
 
7447 
  def __ne__(self, other):
7448 
    return not (self == other)
7449 
 
3064 chandransh 7450 
class acceptOrder_result:
1113 chandransh 7451 
  """
7452 
  Attributes:
7453 
   - success
7454 
   - ex
7455 
  """
7456 
 
7457 
  thrift_spec = (
3064 chandransh 7458 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 7459 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7460 
  )
7461 
 
7462 
  def __init__(self, success=None, ex=None,):
7463 
    self.success = success
7464 
    self.ex = ex
7465 
 
7466 
  def read(self, iprot):
7467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7469 
      return
7470 
    iprot.readStructBegin()
7471 
    while True:
7472 
      (fname, ftype, fid) = iprot.readFieldBegin()
7473 
      if ftype == TType.STOP:
7474 
        break
7475 
      if fid == 0:
3064 chandransh 7476 
        if ftype == TType.BOOL:
7477 
          self.success = iprot.readBool();
1113 chandransh 7478 
        else:
7479 
          iprot.skip(ftype)
7480 
      elif fid == 1:
7481 
        if ftype == TType.STRUCT:
7482 
          self.ex = TransactionServiceException()
7483 
          self.ex.read(iprot)
7484 
        else:
7485 
          iprot.skip(ftype)
7486 
      else:
7487 
        iprot.skip(ftype)
7488 
      iprot.readFieldEnd()
7489 
    iprot.readStructEnd()
7490 
 
7491 
  def write(self, oprot):
7492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7494 
      return
3064 chandransh 7495 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 7496 
    if self.success is not None:
3064 chandransh 7497 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7498 
      oprot.writeBool(self.success)
1113 chandransh 7499 
      oprot.writeFieldEnd()
3431 rajveer 7500 
    if self.ex is not None:
1113 chandransh 7501 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7502 
      self.ex.write(oprot)
7503 
      oprot.writeFieldEnd()
7504 
    oprot.writeFieldStop()
7505 
    oprot.writeStructEnd()
7506 
 
3431 rajveer 7507 
  def validate(self):
7508 
    return
7509 
 
7510 
 
1113 chandransh 7511 
  def __repr__(self):
7512 
    L = ['%s=%r' % (key, value)
7513 
      for key, value in self.__dict__.iteritems()]
7514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7515 
 
7516 
  def __eq__(self, other):
7517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7518 
 
7519 
  def __ne__(self, other):
7520 
    return not (self == other)
7521 
 
3064 chandransh 7522 
class billOrder_args:
1132 chandransh 7523 
  """
7524 
  Attributes:
3064 chandransh 7525 
   - orderId
1132 chandransh 7526 
  """
7527 
 
7528 
  thrift_spec = (
7529 
    None, # 0
3064 chandransh 7530 
    (1, TType.I64, 'orderId', None, None, ), # 1
1132 chandransh 7531 
  )
7532 
 
3064 chandransh 7533 
  def __init__(self, orderId=None,):
7534 
    self.orderId = orderId
1132 chandransh 7535 
 
7536 
  def read(self, iprot):
7537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7539 
      return
7540 
    iprot.readStructBegin()
7541 
    while True:
7542 
      (fname, ftype, fid) = iprot.readFieldBegin()
7543 
      if ftype == TType.STOP:
7544 
        break
7545 
      if fid == 1:
7546 
        if ftype == TType.I64:
3064 chandransh 7547 
          self.orderId = iprot.readI64();
1132 chandransh 7548 
        else:
7549 
          iprot.skip(ftype)
7550 
      else:
7551 
        iprot.skip(ftype)
7552 
      iprot.readFieldEnd()
7553 
    iprot.readStructEnd()
7554 
 
7555 
  def write(self, oprot):
7556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7558 
      return
3064 chandransh 7559 
    oprot.writeStructBegin('billOrder_args')
3431 rajveer 7560 
    if self.orderId is not None:
3064 chandransh 7561 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7562 
      oprot.writeI64(self.orderId)
1132 chandransh 7563 
      oprot.writeFieldEnd()
7564 
    oprot.writeFieldStop()
7565 
    oprot.writeStructEnd()
7566 
 
3431 rajveer 7567 
  def validate(self):
7568 
    return
7569 
 
7570 
 
1132 chandransh 7571 
  def __repr__(self):
7572 
    L = ['%s=%r' % (key, value)
7573 
      for key, value in self.__dict__.iteritems()]
7574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7575 
 
7576 
  def __eq__(self, other):
7577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7578 
 
7579 
  def __ne__(self, other):
7580 
    return not (self == other)
7581 
 
3064 chandransh 7582 
class billOrder_result:
1132 chandransh 7583 
  """
7584 
  Attributes:
3064 chandransh 7585 
   - success
1132 chandransh 7586 
   - ex
7587 
  """
7588 
 
7589 
  thrift_spec = (
3064 chandransh 7590 
    (0, TType.BOOL, 'success', None, None, ), # 0
1132 chandransh 7591 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7592 
  )
7593 
 
3064 chandransh 7594 
  def __init__(self, success=None, ex=None,):
7595 
    self.success = success
1132 chandransh 7596 
    self.ex = ex
7597 
 
7598 
  def read(self, iprot):
7599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7601 
      return
7602 
    iprot.readStructBegin()
7603 
    while True:
7604 
      (fname, ftype, fid) = iprot.readFieldBegin()
7605 
      if ftype == TType.STOP:
7606 
        break
3064 chandransh 7607 
      if fid == 0:
7608 
        if ftype == TType.BOOL:
7609 
          self.success = iprot.readBool();
7610 
        else:
7611 
          iprot.skip(ftype)
7612 
      elif fid == 1:
1132 chandransh 7613 
        if ftype == TType.STRUCT:
7614 
          self.ex = TransactionServiceException()
7615 
          self.ex.read(iprot)
7616 
        else:
7617 
          iprot.skip(ftype)
7618 
      else:
7619 
        iprot.skip(ftype)
7620 
      iprot.readFieldEnd()
7621 
    iprot.readStructEnd()
7622 
 
7623 
  def write(self, oprot):
7624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7626 
      return
3064 chandransh 7627 
    oprot.writeStructBegin('billOrder_result')
3431 rajveer 7628 
    if self.success is not None:
3064 chandransh 7629 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7630 
      oprot.writeBool(self.success)
7631 
      oprot.writeFieldEnd()
3431 rajveer 7632 
    if self.ex is not None:
1132 chandransh 7633 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7634 
      self.ex.write(oprot)
7635 
      oprot.writeFieldEnd()
7636 
    oprot.writeFieldStop()
7637 
    oprot.writeStructEnd()
7638 
 
3431 rajveer 7639 
  def validate(self):
7640 
    return
7641 
 
7642 
 
1132 chandransh 7643 
  def __repr__(self):
7644 
    L = ['%s=%r' % (key, value)
7645 
      for key, value in self.__dict__.iteritems()]
7646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7647 
 
7648 
  def __eq__(self, other):
7649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7650 
 
7651 
  def __ne__(self, other):
7652 
    return not (self == other)
7653 
 
3064 chandransh 7654 
class addBillingDetails_args:
1135 chandransh 7655 
  """
7656 
  Attributes:
3064 chandransh 7657 
   - orderId
7658 
   - invoice_number
7659 
   - billed_by
1135 chandransh 7660 
  """
7661 
 
7662 
  thrift_spec = (
7663 
    None, # 0
3064 chandransh 7664 
    (1, TType.I64, 'orderId', None, None, ), # 1
7665 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
7666 
    (3, TType.STRING, 'billed_by', None, None, ), # 3
1135 chandransh 7667 
  )
7668 
 
3064 chandransh 7669 
  def __init__(self, orderId=None, invoice_number=None, billed_by=None,):
7670 
    self.orderId = orderId
7671 
    self.invoice_number = invoice_number
7672 
    self.billed_by = billed_by
1135 chandransh 7673 
 
7674 
  def read(self, iprot):
7675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7677 
      return
7678 
    iprot.readStructBegin()
7679 
    while True:
7680 
      (fname, ftype, fid) = iprot.readFieldBegin()
7681 
      if ftype == TType.STOP:
7682 
        break
7683 
      if fid == 1:
7684 
        if ftype == TType.I64:
3064 chandransh 7685 
          self.orderId = iprot.readI64();
1135 chandransh 7686 
        else:
7687 
          iprot.skip(ftype)
7688 
      elif fid == 2:
3064 chandransh 7689 
        if ftype == TType.STRING:
7690 
          self.invoice_number = iprot.readString();
1135 chandransh 7691 
        else:
7692 
          iprot.skip(ftype)
3064 chandransh 7693 
      elif fid == 3:
7694 
        if ftype == TType.STRING:
7695 
          self.billed_by = iprot.readString();
7696 
        else:
7697 
          iprot.skip(ftype)
1135 chandransh 7698 
      else:
7699 
        iprot.skip(ftype)
7700 
      iprot.readFieldEnd()
7701 
    iprot.readStructEnd()
7702 
 
7703 
  def write(self, oprot):
7704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7706 
      return
3064 chandransh 7707 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 7708 
    if self.orderId is not None:
3064 chandransh 7709 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7710 
      oprot.writeI64(self.orderId)
1135 chandransh 7711 
      oprot.writeFieldEnd()
3431 rajveer 7712 
    if self.invoice_number is not None:
3064 chandransh 7713 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
7714 
      oprot.writeString(self.invoice_number)
1135 chandransh 7715 
      oprot.writeFieldEnd()
3431 rajveer 7716 
    if self.billed_by is not None:
3064 chandransh 7717 
      oprot.writeFieldBegin('billed_by', TType.STRING, 3)
7718 
      oprot.writeString(self.billed_by)
7719 
      oprot.writeFieldEnd()
1135 chandransh 7720 
    oprot.writeFieldStop()
7721 
    oprot.writeStructEnd()
7722 
 
3431 rajveer 7723 
  def validate(self):
7724 
    return
7725 
 
7726 
 
1135 chandransh 7727 
  def __repr__(self):
7728 
    L = ['%s=%r' % (key, value)
7729 
      for key, value in self.__dict__.iteritems()]
7730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7731 
 
7732 
  def __eq__(self, other):
7733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7734 
 
7735 
  def __ne__(self, other):
7736 
    return not (self == other)
7737 
 
3064 chandransh 7738 
class addBillingDetails_result:
1135 chandransh 7739 
  """
7740 
  Attributes:
3064 chandransh 7741 
   - success
1135 chandransh 7742 
   - ex
7743 
  """
7744 
 
7745 
  thrift_spec = (
3064 chandransh 7746 
    (0, TType.BOOL, 'success', None, None, ), # 0
1135 chandransh 7747 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7748 
  )
7749 
 
3064 chandransh 7750 
  def __init__(self, success=None, ex=None,):
7751 
    self.success = success
1135 chandransh 7752 
    self.ex = ex
7753 
 
7754 
  def read(self, iprot):
7755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7757 
      return
7758 
    iprot.readStructBegin()
7759 
    while True:
7760 
      (fname, ftype, fid) = iprot.readFieldBegin()
7761 
      if ftype == TType.STOP:
7762 
        break
3064 chandransh 7763 
      if fid == 0:
7764 
        if ftype == TType.BOOL:
7765 
          self.success = iprot.readBool();
7766 
        else:
7767 
          iprot.skip(ftype)
7768 
      elif fid == 1:
1135 chandransh 7769 
        if ftype == TType.STRUCT:
7770 
          self.ex = TransactionServiceException()
7771 
          self.ex.read(iprot)
7772 
        else:
7773 
          iprot.skip(ftype)
7774 
      else:
7775 
        iprot.skip(ftype)
7776 
      iprot.readFieldEnd()
7777 
    iprot.readStructEnd()
7778 
 
7779 
  def write(self, oprot):
7780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7782 
      return
3064 chandransh 7783 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 7784 
    if self.success is not None:
3064 chandransh 7785 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7786 
      oprot.writeBool(self.success)
7787 
      oprot.writeFieldEnd()
3431 rajveer 7788 
    if self.ex is not None:
1135 chandransh 7789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7790 
      self.ex.write(oprot)
7791 
      oprot.writeFieldEnd()
7792 
    oprot.writeFieldStop()
7793 
    oprot.writeStructEnd()
7794 
 
3431 rajveer 7795 
  def validate(self):
7796 
    return
7797 
 
7798 
 
1135 chandransh 7799 
  def __repr__(self):
7800 
    L = ['%s=%r' % (key, value)
7801 
      for key, value in self.__dict__.iteritems()]
7802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7803 
 
7804 
  def __eq__(self, other):
7805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7806 
 
7807 
  def __ne__(self, other):
7808 
    return not (self == other)
7809 
 
3064 chandransh 7810 
class addJacketNumber_args:
1246 chandransh 7811 
  """
7812 
  Attributes:
3064 chandransh 7813 
   - orderId
7814 
   - jacketNumber
7815 
   - imeiNumber
7816 
   - itemNumber
7817 
   - billedBy
7818 
   - billingType
1246 chandransh 7819 
  """
7820 
 
7821 
  thrift_spec = (
7822 
    None, # 0
3064 chandransh 7823 
    (1, TType.I64, 'orderId', None, None, ), # 1
7824 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
7825 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
7826 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
7827 
    (5, TType.STRING, 'billedBy', None, None, ), # 5
7828 
    (6, TType.I64, 'billingType', None, None, ), # 6
1246 chandransh 7829 
  )
7830 
 
3064 chandransh 7831 
  def __init__(self, orderId=None, jacketNumber=None, imeiNumber=None, itemNumber=None, billedBy=None, billingType=None,):
7832 
    self.orderId = orderId
7833 
    self.jacketNumber = jacketNumber
7834 
    self.imeiNumber = imeiNumber
7835 
    self.itemNumber = itemNumber
7836 
    self.billedBy = billedBy
7837 
    self.billingType = billingType
1246 chandransh 7838 
 
7839 
  def read(self, iprot):
7840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7842 
      return
7843 
    iprot.readStructBegin()
7844 
    while True:
7845 
      (fname, ftype, fid) = iprot.readFieldBegin()
7846 
      if ftype == TType.STOP:
7847 
        break
7848 
      if fid == 1:
7849 
        if ftype == TType.I64:
3064 chandransh 7850 
          self.orderId = iprot.readI64();
1246 chandransh 7851 
        else:
7852 
          iprot.skip(ftype)
7853 
      elif fid == 2:
3064 chandransh 7854 
        if ftype == TType.I64:
7855 
          self.jacketNumber = iprot.readI64();
1246 chandransh 7856 
        else:
7857 
          iprot.skip(ftype)
3064 chandransh 7858 
      elif fid == 3:
7859 
        if ftype == TType.I64:
7860 
          self.imeiNumber = iprot.readI64();
7861 
        else:
7862 
          iprot.skip(ftype)
7863 
      elif fid == 4:
7864 
        if ftype == TType.STRING:
7865 
          self.itemNumber = iprot.readString();
7866 
        else:
7867 
          iprot.skip(ftype)
7868 
      elif fid == 5:
7869 
        if ftype == TType.STRING:
7870 
          self.billedBy = iprot.readString();
7871 
        else:
7872 
          iprot.skip(ftype)
7873 
      elif fid == 6:
7874 
        if ftype == TType.I64:
7875 
          self.billingType = iprot.readI64();
7876 
        else:
7877 
          iprot.skip(ftype)
1246 chandransh 7878 
      else:
7879 
        iprot.skip(ftype)
7880 
      iprot.readFieldEnd()
7881 
    iprot.readStructEnd()
7882 
 
7883 
  def write(self, oprot):
7884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7886 
      return
3064 chandransh 7887 
    oprot.writeStructBegin('addJacketNumber_args')
3431 rajveer 7888 
    if self.orderId is not None:
3064 chandransh 7889 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7890 
      oprot.writeI64(self.orderId)
1246 chandransh 7891 
      oprot.writeFieldEnd()
3431 rajveer 7892 
    if self.jacketNumber is not None:
3064 chandransh 7893 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
7894 
      oprot.writeI64(self.jacketNumber)
1246 chandransh 7895 
      oprot.writeFieldEnd()
3431 rajveer 7896 
    if self.imeiNumber is not None:
3064 chandransh 7897 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
7898 
      oprot.writeI64(self.imeiNumber)
7899 
      oprot.writeFieldEnd()
3431 rajveer 7900 
    if self.itemNumber is not None:
3064 chandransh 7901 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
7902 
      oprot.writeString(self.itemNumber)
7903 
      oprot.writeFieldEnd()
3431 rajveer 7904 
    if self.billedBy is not None:
3064 chandransh 7905 
      oprot.writeFieldBegin('billedBy', TType.STRING, 5)
7906 
      oprot.writeString(self.billedBy)
7907 
      oprot.writeFieldEnd()
3431 rajveer 7908 
    if self.billingType is not None:
3064 chandransh 7909 
      oprot.writeFieldBegin('billingType', TType.I64, 6)
7910 
      oprot.writeI64(self.billingType)
7911 
      oprot.writeFieldEnd()
1246 chandransh 7912 
    oprot.writeFieldStop()
7913 
    oprot.writeStructEnd()
7914 
 
3431 rajveer 7915 
  def validate(self):
7916 
    return
7917 
 
7918 
 
1246 chandransh 7919 
  def __repr__(self):
7920 
    L = ['%s=%r' % (key, value)
7921 
      for key, value in self.__dict__.iteritems()]
7922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7923 
 
7924 
  def __eq__(self, other):
7925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7926 
 
7927 
  def __ne__(self, other):
7928 
    return not (self == other)
7929 
 
3064 chandransh 7930 
class addJacketNumber_result:
1246 chandransh 7931 
  """
7932 
  Attributes:
3064 chandransh 7933 
   - success
1246 chandransh 7934 
   - ex
7935 
  """
7936 
 
7937 
  thrift_spec = (
3064 chandransh 7938 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 7939 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7940 
  )
7941 
 
3064 chandransh 7942 
  def __init__(self, success=None, ex=None,):
7943 
    self.success = success
1246 chandransh 7944 
    self.ex = ex
7945 
 
7946 
  def read(self, iprot):
7947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7949 
      return
7950 
    iprot.readStructBegin()
7951 
    while True:
7952 
      (fname, ftype, fid) = iprot.readFieldBegin()
7953 
      if ftype == TType.STOP:
7954 
        break
3064 chandransh 7955 
      if fid == 0:
7956 
        if ftype == TType.BOOL:
7957 
          self.success = iprot.readBool();
7958 
        else:
7959 
          iprot.skip(ftype)
7960 
      elif fid == 1:
1246 chandransh 7961 
        if ftype == TType.STRUCT:
7962 
          self.ex = TransactionServiceException()
7963 
          self.ex.read(iprot)
7964 
        else:
7965 
          iprot.skip(ftype)
7966 
      else:
7967 
        iprot.skip(ftype)
7968 
      iprot.readFieldEnd()
7969 
    iprot.readStructEnd()
7970 
 
7971 
  def write(self, oprot):
7972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7974 
      return
3064 chandransh 7975 
    oprot.writeStructBegin('addJacketNumber_result')
3431 rajveer 7976 
    if self.success is not None:
3064 chandransh 7977 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7978 
      oprot.writeBool(self.success)
7979 
      oprot.writeFieldEnd()
3431 rajveer 7980 
    if self.ex is not None:
1246 chandransh 7981 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7982 
      self.ex.write(oprot)
7983 
      oprot.writeFieldEnd()
7984 
    oprot.writeFieldStop()
7985 
    oprot.writeStructEnd()
7986 
 
3431 rajveer 7987 
  def validate(self):
7988 
    return
7989 
 
7990 
 
1246 chandransh 7991 
  def __repr__(self):
7992 
    L = ['%s=%r' % (key, value)
7993 
      for key, value in self.__dict__.iteritems()]
7994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7995 
 
7996 
  def __eq__(self, other):
7997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7998 
 
7999 
  def __ne__(self, other):
8000 
    return not (self == other)
8001 
 
3064 chandransh 8002 
class markOrdersAsManifested_args:
1408 ankur.sing 8003 
  """
8004 
  Attributes:
3064 chandransh 8005 
   - warehouseId
1408 ankur.sing 8006 
   - providerId
3064 chandransh 8007 
   - cod
1408 ankur.sing 8008 
  """
8009 
 
8010 
  thrift_spec = (
8011 
    None, # 0
3064 chandransh 8012 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8013 
    (2, TType.I64, 'providerId', None, None, ), # 2
8014 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 8015 
  )
8016 
 
3064 chandransh 8017 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
8018 
    self.warehouseId = warehouseId
1408 ankur.sing 8019 
    self.providerId = providerId
3064 chandransh 8020 
    self.cod = cod
1408 ankur.sing 8021 
 
8022 
  def read(self, iprot):
8023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8025 
      return
8026 
    iprot.readStructBegin()
8027 
    while True:
8028 
      (fname, ftype, fid) = iprot.readFieldBegin()
8029 
      if ftype == TType.STOP:
8030 
        break
8031 
      if fid == 1:
8032 
        if ftype == TType.I64:
3064 chandransh 8033 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 8034 
        else:
8035 
          iprot.skip(ftype)
8036 
      elif fid == 2:
8037 
        if ftype == TType.I64:
3064 chandransh 8038 
          self.providerId = iprot.readI64();
1408 ankur.sing 8039 
        else:
8040 
          iprot.skip(ftype)
3064 chandransh 8041 
      elif fid == 3:
8042 
        if ftype == TType.BOOL:
8043 
          self.cod = iprot.readBool();
8044 
        else:
8045 
          iprot.skip(ftype)
1408 ankur.sing 8046 
      else:
8047 
        iprot.skip(ftype)
8048 
      iprot.readFieldEnd()
8049 
    iprot.readStructEnd()
8050 
 
8051 
  def write(self, oprot):
8052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8054 
      return
3064 chandransh 8055 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 8056 
    if self.warehouseId is not None:
3064 chandransh 8057 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8058 
      oprot.writeI64(self.warehouseId)
8059 
      oprot.writeFieldEnd()
3431 rajveer 8060 
    if self.providerId is not None:
3064 chandransh 8061 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 8062 
      oprot.writeI64(self.providerId)
8063 
      oprot.writeFieldEnd()
3431 rajveer 8064 
    if self.cod is not None:
3064 chandransh 8065 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
8066 
      oprot.writeBool(self.cod)
1408 ankur.sing 8067 
      oprot.writeFieldEnd()
8068 
    oprot.writeFieldStop()
8069 
    oprot.writeStructEnd()
8070 
 
3431 rajveer 8071 
  def validate(self):
8072 
    return
8073 
 
8074 
 
1408 ankur.sing 8075 
  def __repr__(self):
8076 
    L = ['%s=%r' % (key, value)
8077 
      for key, value in self.__dict__.iteritems()]
8078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8079 
 
8080 
  def __eq__(self, other):
8081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8082 
 
8083 
  def __ne__(self, other):
8084 
    return not (self == other)
8085 
 
3064 chandransh 8086 
class markOrdersAsManifested_result:
1408 ankur.sing 8087 
  """
8088 
  Attributes:
8089 
   - success
3064 chandransh 8090 
   - ex
1408 ankur.sing 8091 
  """
8092 
 
8093 
  thrift_spec = (
3064 chandransh 8094 
    (0, TType.BOOL, 'success', None, None, ), # 0
8095 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 8096 
  )
8097 
 
3064 chandransh 8098 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 8099 
    self.success = success
3064 chandransh 8100 
    self.ex = ex
1408 ankur.sing 8101 
 
8102 
  def read(self, iprot):
8103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8105 
      return
8106 
    iprot.readStructBegin()
8107 
    while True:
8108 
      (fname, ftype, fid) = iprot.readFieldBegin()
8109 
      if ftype == TType.STOP:
8110 
        break
8111 
      if fid == 0:
3064 chandransh 8112 
        if ftype == TType.BOOL:
8113 
          self.success = iprot.readBool();
1408 ankur.sing 8114 
        else:
8115 
          iprot.skip(ftype)
3064 chandransh 8116 
      elif fid == 1:
8117 
        if ftype == TType.STRUCT:
8118 
          self.ex = TransactionServiceException()
8119 
          self.ex.read(iprot)
8120 
        else:
8121 
          iprot.skip(ftype)
1408 ankur.sing 8122 
      else:
8123 
        iprot.skip(ftype)
8124 
      iprot.readFieldEnd()
8125 
    iprot.readStructEnd()
8126 
 
8127 
  def write(self, oprot):
8128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8130 
      return
3064 chandransh 8131 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 8132 
    if self.success is not None:
3064 chandransh 8133 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8134 
      oprot.writeBool(self.success)
1408 ankur.sing 8135 
      oprot.writeFieldEnd()
3431 rajveer 8136 
    if self.ex is not None:
3064 chandransh 8137 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8138 
      self.ex.write(oprot)
8139 
      oprot.writeFieldEnd()
1408 ankur.sing 8140 
    oprot.writeFieldStop()
8141 
    oprot.writeStructEnd()
8142 
 
3431 rajveer 8143 
  def validate(self):
8144 
    return
8145 
 
8146 
 
1408 ankur.sing 8147 
  def __repr__(self):
8148 
    L = ['%s=%r' % (key, value)
8149 
      for key, value in self.__dict__.iteritems()]
8150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8151 
 
8152 
  def __eq__(self, other):
8153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8154 
 
8155 
  def __ne__(self, other):
8156 
    return not (self == other)
8157 
 
3064 chandransh 8158 
class markOrdersAsPickedUp_args:
304 ashish 8159 
  """
8160 
  Attributes:
3064 chandransh 8161 
   - providerId
8162 
   - pickupDetails
304 ashish 8163 
  """
94 ashish 8164 
 
304 ashish 8165 
  thrift_spec = (
8166 
    None, # 0
3064 chandransh 8167 
    (1, TType.I64, 'providerId', None, None, ), # 1
8168 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 8169 
  )
8170 
 
3064 chandransh 8171 
  def __init__(self, providerId=None, pickupDetails=None,):
8172 
    self.providerId = providerId
8173 
    self.pickupDetails = pickupDetails
304 ashish 8174 
 
8175 
  def read(self, iprot):
8176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8178 
      return
8179 
    iprot.readStructBegin()
8180 
    while True:
8181 
      (fname, ftype, fid) = iprot.readFieldBegin()
8182 
      if ftype == TType.STOP:
8183 
        break
8184 
      if fid == 1:
8185 
        if ftype == TType.I64:
3064 chandransh 8186 
          self.providerId = iprot.readI64();
304 ashish 8187 
        else:
8188 
          iprot.skip(ftype)
8189 
      elif fid == 2:
3064 chandransh 8190 
        if ftype == TType.MAP:
8191 
          self.pickupDetails = {}
3427 chandransh 8192 
          (_ktype120, _vtype121, _size119 ) = iprot.readMapBegin()
8193 
          for _i123 in xrange(_size119):
8194 
            _key124 = iprot.readString();
8195 
            _val125 = iprot.readString();
8196 
            self.pickupDetails[_key124] = _val125
3064 chandransh 8197 
          iprot.readMapEnd()
304 ashish 8198 
        else:
8199 
          iprot.skip(ftype)
8200 
      else:
8201 
        iprot.skip(ftype)
8202 
      iprot.readFieldEnd()
8203 
    iprot.readStructEnd()
8204 
 
8205 
  def write(self, oprot):
8206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8208 
      return
3064 chandransh 8209 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 8210 
    if self.providerId is not None:
3064 chandransh 8211 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
8212 
      oprot.writeI64(self.providerId)
304 ashish 8213 
      oprot.writeFieldEnd()
3431 rajveer 8214 
    if self.pickupDetails is not None:
3064 chandransh 8215 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
8216 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
3427 chandransh 8217 
      for kiter126,viter127 in self.pickupDetails.items():
8218 
        oprot.writeString(kiter126)
8219 
        oprot.writeString(viter127)
3064 chandransh 8220 
      oprot.writeMapEnd()
304 ashish 8221 
      oprot.writeFieldEnd()
8222 
    oprot.writeFieldStop()
8223 
    oprot.writeStructEnd()
8224 
 
3431 rajveer 8225 
  def validate(self):
8226 
    return
8227 
 
8228 
 
304 ashish 8229 
  def __repr__(self):
8230 
    L = ['%s=%r' % (key, value)
8231 
      for key, value in self.__dict__.iteritems()]
8232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8233 
 
8234 
  def __eq__(self, other):
8235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8236 
 
8237 
  def __ne__(self, other):
8238 
    return not (self == other)
8239 
 
3064 chandransh 8240 
class markOrdersAsPickedUp_result:
304 ashish 8241 
  """
8242 
  Attributes:
8243 
   - success
3064 chandransh 8244 
   - ex
304 ashish 8245 
  """
8246 
 
8247 
  thrift_spec = (
3064 chandransh 8248 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8249 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 8250 
  )
8251 
 
3064 chandransh 8252 
  def __init__(self, success=None, ex=None,):
304 ashish 8253 
    self.success = success
3064 chandransh 8254 
    self.ex = ex
304 ashish 8255 
 
8256 
  def read(self, iprot):
8257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8259 
      return
8260 
    iprot.readStructBegin()
8261 
    while True:
8262 
      (fname, ftype, fid) = iprot.readFieldBegin()
8263 
      if ftype == TType.STOP:
8264 
        break
8265 
      if fid == 0:
8266 
        if ftype == TType.LIST:
8267 
          self.success = []
3427 chandransh 8268 
          (_etype131, _size128) = iprot.readListBegin()
8269 
          for _i132 in xrange(_size128):
8270 
            _elem133 = Order()
8271 
            _elem133.read(iprot)
8272 
            self.success.append(_elem133)
304 ashish 8273 
          iprot.readListEnd()
8274 
        else:
8275 
          iprot.skip(ftype)
3064 chandransh 8276 
      elif fid == 1:
8277 
        if ftype == TType.STRUCT:
8278 
          self.ex = TransactionServiceException()
8279 
          self.ex.read(iprot)
8280 
        else:
8281 
          iprot.skip(ftype)
304 ashish 8282 
      else:
8283 
        iprot.skip(ftype)
8284 
      iprot.readFieldEnd()
8285 
    iprot.readStructEnd()
8286 
 
8287 
  def write(self, oprot):
8288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8290 
      return
3064 chandransh 8291 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 8292 
    if self.success is not None:
304 ashish 8293 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8294 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3427 chandransh 8295 
      for iter134 in self.success:
8296 
        iter134.write(oprot)
304 ashish 8297 
      oprot.writeListEnd()
8298 
      oprot.writeFieldEnd()
3431 rajveer 8299 
    if self.ex is not None:
3064 chandransh 8300 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8301 
      self.ex.write(oprot)
8302 
      oprot.writeFieldEnd()
304 ashish 8303 
    oprot.writeFieldStop()
8304 
    oprot.writeStructEnd()
8305 
 
3431 rajveer 8306 
  def validate(self):
8307 
    return
8308 
 
8309 
 
304 ashish 8310 
  def __repr__(self):
8311 
    L = ['%s=%r' % (key, value)
8312 
      for key, value in self.__dict__.iteritems()]
8313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8314 
 
8315 
  def __eq__(self, other):
8316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8317 
 
8318 
  def __ne__(self, other):
8319 
    return not (self == other)
8320 
 
3064 chandransh 8321 
class markOrdersAsDelivered_args:
304 ashish 8322 
  """
8323 
  Attributes:
3064 chandransh 8324 
   - providerId
8325 
   - deliveredOrders
304 ashish 8326 
  """
8327 
 
8328 
  thrift_spec = (
8329 
    None, # 0
3064 chandransh 8330 
    (1, TType.I64, 'providerId', None, None, ), # 1
8331 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 8332 
  )
8333 
 
3064 chandransh 8334 
  def __init__(self, providerId=None, deliveredOrders=None,):
8335 
    self.providerId = providerId
8336 
    self.deliveredOrders = deliveredOrders
304 ashish 8337 
 
8338 
  def read(self, iprot):
8339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8341 
      return
8342 
    iprot.readStructBegin()
8343 
    while True:
8344 
      (fname, ftype, fid) = iprot.readFieldBegin()
8345 
      if ftype == TType.STOP:
8346 
        break
8347 
      if fid == 1:
8348 
        if ftype == TType.I64:
3064 chandransh 8349 
          self.providerId = iprot.readI64();
304 ashish 8350 
        else:
8351 
          iprot.skip(ftype)
8352 
      elif fid == 2:
3064 chandransh 8353 
        if ftype == TType.MAP:
8354 
          self.deliveredOrders = {}
3427 chandransh 8355 
          (_ktype136, _vtype137, _size135 ) = iprot.readMapBegin()
8356 
          for _i139 in xrange(_size135):
8357 
            _key140 = iprot.readString();
8358 
            _val141 = iprot.readString();
8359 
            self.deliveredOrders[_key140] = _val141
3064 chandransh 8360 
          iprot.readMapEnd()
304 ashish 8361 
        else:
8362 
          iprot.skip(ftype)
8363 
      else:
8364 
        iprot.skip(ftype)
8365 
      iprot.readFieldEnd()
8366 
    iprot.readStructEnd()
8367 
 
8368 
  def write(self, oprot):
8369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8371 
      return
3064 chandransh 8372 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 8373 
    if self.providerId is not None:
3064 chandransh 8374 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
8375 
      oprot.writeI64(self.providerId)
304 ashish 8376 
      oprot.writeFieldEnd()
3431 rajveer 8377 
    if self.deliveredOrders is not None:
3064 chandransh 8378 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
8379 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
3427 chandransh 8380 
      for kiter142,viter143 in self.deliveredOrders.items():
8381 
        oprot.writeString(kiter142)
8382 
        oprot.writeString(viter143)
3064 chandransh 8383 
      oprot.writeMapEnd()
304 ashish 8384 
      oprot.writeFieldEnd()
8385 
    oprot.writeFieldStop()
8386 
    oprot.writeStructEnd()
8387 
 
3431 rajveer 8388 
  def validate(self):
8389 
    return
8390 
 
8391 
 
304 ashish 8392 
  def __repr__(self):
8393 
    L = ['%s=%r' % (key, value)
8394 
      for key, value in self.__dict__.iteritems()]
8395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8396 
 
8397 
  def __eq__(self, other):
8398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8399 
 
8400 
  def __ne__(self, other):
8401 
    return not (self == other)
8402 
 
3064 chandransh 8403 
class markOrdersAsDelivered_result:
8404 
  """
8405 
  Attributes:
8406 
   - ex
8407 
  """
304 ashish 8408 
 
8409 
  thrift_spec = (
3064 chandransh 8410 
    None, # 0
8411 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 8412 
  )
8413 
 
3064 chandransh 8414 
  def __init__(self, ex=None,):
8415 
    self.ex = ex
304 ashish 8416 
 
1596 ankur.sing 8417 
  def read(self, iprot):
8418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8420 
      return
8421 
    iprot.readStructBegin()
8422 
    while True:
8423 
      (fname, ftype, fid) = iprot.readFieldBegin()
8424 
      if ftype == TType.STOP:
8425 
        break
3064 chandransh 8426 
      if fid == 1:
8427 
        if ftype == TType.STRUCT:
8428 
          self.ex = TransactionServiceException()
8429 
          self.ex.read(iprot)
8430 
        else:
8431 
          iprot.skip(ftype)
1596 ankur.sing 8432 
      else:
8433 
        iprot.skip(ftype)
8434 
      iprot.readFieldEnd()
8435 
    iprot.readStructEnd()
8436 
 
8437 
  def write(self, oprot):
8438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8440 
      return
3064 chandransh 8441 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 8442 
    if self.ex is not None:
3064 chandransh 8443 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8444 
      self.ex.write(oprot)
8445 
      oprot.writeFieldEnd()
1596 ankur.sing 8446 
    oprot.writeFieldStop()
8447 
    oprot.writeStructEnd()
8448 
 
3431 rajveer 8449 
  def validate(self):
8450 
    return
8451 
 
8452 
 
1596 ankur.sing 8453 
  def __repr__(self):
8454 
    L = ['%s=%r' % (key, value)
8455 
      for key, value in self.__dict__.iteritems()]
8456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8457 
 
8458 
  def __eq__(self, other):
8459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8460 
 
8461 
  def __ne__(self, other):
8462 
    return not (self == other)
8463 
 
3064 chandransh 8464 
class markOrdersAsFailed_args:
1596 ankur.sing 8465 
  """
8466 
  Attributes:
3064 chandransh 8467 
   - providerId
8468 
   - returnedOrders
1596 ankur.sing 8469 
  """
8470 
 
8471 
  thrift_spec = (
3064 chandransh 8472 
    None, # 0
8473 
    (1, TType.I64, 'providerId', None, None, ), # 1
8474 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 8475 
  )
8476 
 
3064 chandransh 8477 
  def __init__(self, providerId=None, returnedOrders=None,):
8478 
    self.providerId = providerId
8479 
    self.returnedOrders = returnedOrders
1596 ankur.sing 8480 
 
8481 
  def read(self, iprot):
8482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8484 
      return
8485 
    iprot.readStructBegin()
8486 
    while True:
8487 
      (fname, ftype, fid) = iprot.readFieldBegin()
8488 
      if ftype == TType.STOP:
8489 
        break
3064 chandransh 8490 
      if fid == 1:
1596 ankur.sing 8491 
        if ftype == TType.I64:
3064 chandransh 8492 
          self.providerId = iprot.readI64();
1596 ankur.sing 8493 
        else:
8494 
          iprot.skip(ftype)
3064 chandransh 8495 
      elif fid == 2:
8496 
        if ftype == TType.MAP:
8497 
          self.returnedOrders = {}
3427 chandransh 8498 
          (_ktype145, _vtype146, _size144 ) = iprot.readMapBegin()
8499 
          for _i148 in xrange(_size144):
8500 
            _key149 = iprot.readString();
8501 
            _val150 = iprot.readString();
8502 
            self.returnedOrders[_key149] = _val150
3064 chandransh 8503 
          iprot.readMapEnd()
8504 
        else:
8505 
          iprot.skip(ftype)
1596 ankur.sing 8506 
      else:
8507 
        iprot.skip(ftype)
8508 
      iprot.readFieldEnd()
8509 
    iprot.readStructEnd()
8510 
 
8511 
  def write(self, oprot):
8512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8514 
      return
3064 chandransh 8515 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 8516 
    if self.providerId is not None:
3064 chandransh 8517 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
8518 
      oprot.writeI64(self.providerId)
1596 ankur.sing 8519 
      oprot.writeFieldEnd()
3431 rajveer 8520 
    if self.returnedOrders is not None:
3064 chandransh 8521 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
8522 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
3427 chandransh 8523 
      for kiter151,viter152 in self.returnedOrders.items():
8524 
        oprot.writeString(kiter151)
8525 
        oprot.writeString(viter152)
3064 chandransh 8526 
      oprot.writeMapEnd()
8527 
      oprot.writeFieldEnd()
1596 ankur.sing 8528 
    oprot.writeFieldStop()
8529 
    oprot.writeStructEnd()
8530 
 
3431 rajveer 8531 
  def validate(self):
8532 
    return
8533 
 
8534 
 
1596 ankur.sing 8535 
  def __repr__(self):
8536 
    L = ['%s=%r' % (key, value)
8537 
      for key, value in self.__dict__.iteritems()]
8538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8539 
 
8540 
  def __eq__(self, other):
8541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8542 
 
8543 
  def __ne__(self, other):
8544 
    return not (self == other)
8545 
 
3064 chandransh 8546 
class markOrdersAsFailed_result:
8547 
  """
8548 
  Attributes:
8549 
   - ex
8550 
  """
1596 ankur.sing 8551 
 
1627 ankur.sing 8552 
  thrift_spec = (
3064 chandransh 8553 
    None, # 0
8554 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 8555 
  )
8556 
 
3064 chandransh 8557 
  def __init__(self, ex=None,):
8558 
    self.ex = ex
8559 
 
1627 ankur.sing 8560 
  def read(self, iprot):
8561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8563 
      return
8564 
    iprot.readStructBegin()
8565 
    while True:
8566 
      (fname, ftype, fid) = iprot.readFieldBegin()
8567 
      if ftype == TType.STOP:
8568 
        break
3064 chandransh 8569 
      if fid == 1:
8570 
        if ftype == TType.STRUCT:
8571 
          self.ex = TransactionServiceException()
8572 
          self.ex.read(iprot)
8573 
        else:
8574 
          iprot.skip(ftype)
1627 ankur.sing 8575 
      else:
8576 
        iprot.skip(ftype)
8577 
      iprot.readFieldEnd()
8578 
    iprot.readStructEnd()
8579 
 
8580 
  def write(self, oprot):
8581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8583 
      return
3064 chandransh 8584 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 8585 
    if self.ex is not None:
3064 chandransh 8586 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8587 
      self.ex.write(oprot)
8588 
      oprot.writeFieldEnd()
1627 ankur.sing 8589 
    oprot.writeFieldStop()
8590 
    oprot.writeStructEnd()
8591 
 
3431 rajveer 8592 
  def validate(self):
8593 
    return
8594 
 
8595 
 
1627 ankur.sing 8596 
  def __repr__(self):
8597 
    L = ['%s=%r' % (key, value)
8598 
      for key, value in self.__dict__.iteritems()]
8599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8600 
 
8601 
  def __eq__(self, other):
8602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8603 
 
8604 
  def __ne__(self, other):
8605 
    return not (self == other)
8606 
 
3064 chandransh 8607 
class updateNonDeliveryReason_args:
1627 ankur.sing 8608 
  """
8609 
  Attributes:
3064 chandransh 8610 
   - providerId
8611 
   - undeliveredOrders
1627 ankur.sing 8612 
  """
8613 
 
8614 
  thrift_spec = (
3064 chandransh 8615 
    None, # 0
8616 
    (1, TType.I64, 'providerId', None, None, ), # 1
8617 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 8618 
  )
8619 
 
3064 chandransh 8620 
  def __init__(self, providerId=None, undeliveredOrders=None,):
8621 
    self.providerId = providerId
8622 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 8623 
 
8624 
  def read(self, iprot):
8625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8627 
      return
8628 
    iprot.readStructBegin()
8629 
    while True:
8630 
      (fname, ftype, fid) = iprot.readFieldBegin()
8631 
      if ftype == TType.STOP:
8632 
        break
3064 chandransh 8633 
      if fid == 1:
1627 ankur.sing 8634 
        if ftype == TType.I64:
3064 chandransh 8635 
          self.providerId = iprot.readI64();
1627 ankur.sing 8636 
        else:
8637 
          iprot.skip(ftype)
3064 chandransh 8638 
      elif fid == 2:
8639 
        if ftype == TType.MAP:
8640 
          self.undeliveredOrders = {}
3427 chandransh 8641 
          (_ktype154, _vtype155, _size153 ) = iprot.readMapBegin()
8642 
          for _i157 in xrange(_size153):
8643 
            _key158 = iprot.readString();
8644 
            _val159 = iprot.readString();
8645 
            self.undeliveredOrders[_key158] = _val159
3064 chandransh 8646 
          iprot.readMapEnd()
8647 
        else:
8648 
          iprot.skip(ftype)
1627 ankur.sing 8649 
      else:
8650 
        iprot.skip(ftype)
8651 
      iprot.readFieldEnd()
8652 
    iprot.readStructEnd()
8653 
 
8654 
  def write(self, oprot):
8655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8657 
      return
3064 chandransh 8658 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 8659 
    if self.providerId is not None:
3064 chandransh 8660 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
8661 
      oprot.writeI64(self.providerId)
1627 ankur.sing 8662 
      oprot.writeFieldEnd()
3431 rajveer 8663 
    if self.undeliveredOrders is not None:
3064 chandransh 8664 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
8665 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
3427 chandransh 8666 
      for kiter160,viter161 in self.undeliveredOrders.items():
8667 
        oprot.writeString(kiter160)
8668 
        oprot.writeString(viter161)
3064 chandransh 8669 
      oprot.writeMapEnd()
8670 
      oprot.writeFieldEnd()
1627 ankur.sing 8671 
    oprot.writeFieldStop()
8672 
    oprot.writeStructEnd()
8673 
 
3431 rajveer 8674 
  def validate(self):
8675 
    return
8676 
 
8677 
 
1627 ankur.sing 8678 
  def __repr__(self):
8679 
    L = ['%s=%r' % (key, value)
8680 
      for key, value in self.__dict__.iteritems()]
8681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8682 
 
8683 
  def __eq__(self, other):
8684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8685 
 
8686 
  def __ne__(self, other):
8687 
    return not (self == other)
8688 
 
3064 chandransh 8689 
class updateNonDeliveryReason_result:
1627 ankur.sing 8690 
  """
8691 
  Attributes:
3064 chandransh 8692 
   - ex
1627 ankur.sing 8693 
  """
8694 
 
8695 
  thrift_spec = (
3064 chandransh 8696 
    None, # 0
8697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 8698 
  )
8699 
 
3064 chandransh 8700 
  def __init__(self, ex=None,):
8701 
    self.ex = ex
1627 ankur.sing 8702 
 
8703 
  def read(self, iprot):
8704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8706 
      return
8707 
    iprot.readStructBegin()
8708 
    while True:
8709 
      (fname, ftype, fid) = iprot.readFieldBegin()
8710 
      if ftype == TType.STOP:
8711 
        break
3064 chandransh 8712 
      if fid == 1:
8713 
        if ftype == TType.STRUCT:
8714 
          self.ex = TransactionServiceException()
8715 
          self.ex.read(iprot)
1627 ankur.sing 8716 
        else:
8717 
          iprot.skip(ftype)
8718 
      else:
8719 
        iprot.skip(ftype)
8720 
      iprot.readFieldEnd()
8721 
    iprot.readStructEnd()
8722 
 
8723 
  def write(self, oprot):
8724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8726 
      return
3064 chandransh 8727 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 8728 
    if self.ex is not None:
3064 chandransh 8729 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8730 
      self.ex.write(oprot)
1627 ankur.sing 8731 
      oprot.writeFieldEnd()
8732 
    oprot.writeFieldStop()
8733 
    oprot.writeStructEnd()
8734 
 
3431 rajveer 8735 
  def validate(self):
8736 
    return
8737 
 
8738 
 
1627 ankur.sing 8739 
  def __repr__(self):
8740 
    L = ['%s=%r' % (key, value)
8741 
      for key, value in self.__dict__.iteritems()]
8742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8743 
 
8744 
  def __eq__(self, other):
8745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8746 
 
8747 
  def __ne__(self, other):
8748 
    return not (self == other)
8749 
 
3064 chandransh 8750 
class getUndeliveredOrders_args:
1886 ankur.sing 8751 
  """
8752 
  Attributes:
3064 chandransh 8753 
   - providerId
8754 
   - warehouseId
1886 ankur.sing 8755 
  """
1627 ankur.sing 8756 
 
1886 ankur.sing 8757 
  thrift_spec = (
8758 
    None, # 0
3064 chandransh 8759 
    (1, TType.I64, 'providerId', None, None, ), # 1
8760 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 8761 
  )
8762 
 
3064 chandransh 8763 
  def __init__(self, providerId=None, warehouseId=None,):
8764 
    self.providerId = providerId
8765 
    self.warehouseId = warehouseId
1886 ankur.sing 8766 
 
8767 
  def read(self, iprot):
8768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8770 
      return
8771 
    iprot.readStructBegin()
8772 
    while True:
8773 
      (fname, ftype, fid) = iprot.readFieldBegin()
8774 
      if ftype == TType.STOP:
8775 
        break
8776 
      if fid == 1:
8777 
        if ftype == TType.I64:
3064 chandransh 8778 
          self.providerId = iprot.readI64();
1886 ankur.sing 8779 
        else:
8780 
          iprot.skip(ftype)
3064 chandransh 8781 
      elif fid == 2:
8782 
        if ftype == TType.I64:
8783 
          self.warehouseId = iprot.readI64();
8784 
        else:
8785 
          iprot.skip(ftype)
1886 ankur.sing 8786 
      else:
8787 
        iprot.skip(ftype)
8788 
      iprot.readFieldEnd()
8789 
    iprot.readStructEnd()
8790 
 
8791 
  def write(self, oprot):
8792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8794 
      return
3064 chandransh 8795 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 8796 
    if self.providerId is not None:
3064 chandransh 8797 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
8798 
      oprot.writeI64(self.providerId)
1886 ankur.sing 8799 
      oprot.writeFieldEnd()
3431 rajveer 8800 
    if self.warehouseId is not None:
3064 chandransh 8801 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8802 
      oprot.writeI64(self.warehouseId)
8803 
      oprot.writeFieldEnd()
1886 ankur.sing 8804 
    oprot.writeFieldStop()
8805 
    oprot.writeStructEnd()
8806 
 
3431 rajveer 8807 
  def validate(self):
8808 
    return
8809 
 
8810 
 
1886 ankur.sing 8811 
  def __repr__(self):
8812 
    L = ['%s=%r' % (key, value)
8813 
      for key, value in self.__dict__.iteritems()]
8814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8815 
 
8816 
  def __eq__(self, other):
8817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8818 
 
8819 
  def __ne__(self, other):
8820 
    return not (self == other)
8821 
 
3064 chandransh 8822 
class getUndeliveredOrders_result:
1886 ankur.sing 8823 
  """
8824 
  Attributes:
8825 
   - success
8826 
  """
8827 
 
8828 
  thrift_spec = (
8829 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8830 
  )
8831 
 
8832 
  def __init__(self, success=None,):
8833 
    self.success = success
8834 
 
8835 
  def read(self, iprot):
8836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8838 
      return
8839 
    iprot.readStructBegin()
8840 
    while True:
8841 
      (fname, ftype, fid) = iprot.readFieldBegin()
8842 
      if ftype == TType.STOP:
8843 
        break
8844 
      if fid == 0:
8845 
        if ftype == TType.LIST:
8846 
          self.success = []
3427 chandransh 8847 
          (_etype165, _size162) = iprot.readListBegin()
8848 
          for _i166 in xrange(_size162):
8849 
            _elem167 = Order()
8850 
            _elem167.read(iprot)
8851 
            self.success.append(_elem167)
1886 ankur.sing 8852 
          iprot.readListEnd()
8853 
        else:
8854 
          iprot.skip(ftype)
8855 
      else:
8856 
        iprot.skip(ftype)
8857 
      iprot.readFieldEnd()
8858 
    iprot.readStructEnd()
8859 
 
8860 
  def write(self, oprot):
8861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8863 
      return
3064 chandransh 8864 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 8865 
    if self.success is not None:
1886 ankur.sing 8866 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8867 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3427 chandransh 8868 
      for iter168 in self.success:
8869 
        iter168.write(oprot)
1886 ankur.sing 8870 
      oprot.writeListEnd()
8871 
      oprot.writeFieldEnd()
8872 
    oprot.writeFieldStop()
8873 
    oprot.writeStructEnd()
8874 
 
3431 rajveer 8875 
  def validate(self):
8876 
    return
8877 
 
8878 
 
1886 ankur.sing 8879 
  def __repr__(self):
8880 
    L = ['%s=%r' % (key, value)
8881 
      for key, value in self.__dict__.iteritems()]
8882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8883 
 
8884 
  def __eq__(self, other):
8885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8886 
 
8887 
  def __ne__(self, other):
8888 
    return not (self == other)
8889 
 
2536 chandransh 8890 
class toggleDOAFlag_args:
8891 
  """
8892 
  Attributes:
8893 
   - orderId
8894 
  """
1886 ankur.sing 8895 
 
2536 chandransh 8896 
  thrift_spec = (
8897 
    None, # 0
8898 
    (1, TType.I64, 'orderId', None, None, ), # 1
8899 
  )
8900 
 
8901 
  def __init__(self, orderId=None,):
8902 
    self.orderId = orderId
8903 
 
8904 
  def read(self, iprot):
8905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8907 
      return
8908 
    iprot.readStructBegin()
8909 
    while True:
8910 
      (fname, ftype, fid) = iprot.readFieldBegin()
8911 
      if ftype == TType.STOP:
8912 
        break
8913 
      if fid == 1:
8914 
        if ftype == TType.I64:
8915 
          self.orderId = iprot.readI64();
8916 
        else:
8917 
          iprot.skip(ftype)
8918 
      else:
8919 
        iprot.skip(ftype)
8920 
      iprot.readFieldEnd()
8921 
    iprot.readStructEnd()
8922 
 
8923 
  def write(self, oprot):
8924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8926 
      return
8927 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 8928 
    if self.orderId is not None:
2536 chandransh 8929 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8930 
      oprot.writeI64(self.orderId)
8931 
      oprot.writeFieldEnd()
8932 
    oprot.writeFieldStop()
8933 
    oprot.writeStructEnd()
8934 
 
3431 rajveer 8935 
  def validate(self):
8936 
    return
8937 
 
8938 
 
2536 chandransh 8939 
  def __repr__(self):
8940 
    L = ['%s=%r' % (key, value)
8941 
      for key, value in self.__dict__.iteritems()]
8942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8943 
 
8944 
  def __eq__(self, other):
8945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8946 
 
8947 
  def __ne__(self, other):
8948 
    return not (self == other)
8949 
 
8950 
class toggleDOAFlag_result:
8951 
  """
8952 
  Attributes:
8953 
   - success
8954 
   - ex
8955 
  """
8956 
 
8957 
  thrift_spec = (
8958 
    (0, TType.BOOL, 'success', None, None, ), # 0
8959 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8960 
  )
8961 
 
8962 
  def __init__(self, success=None, ex=None,):
8963 
    self.success = success
8964 
    self.ex = ex
8965 
 
8966 
  def read(self, iprot):
8967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8969 
      return
8970 
    iprot.readStructBegin()
8971 
    while True:
8972 
      (fname, ftype, fid) = iprot.readFieldBegin()
8973 
      if ftype == TType.STOP:
8974 
        break
8975 
      if fid == 0:
8976 
        if ftype == TType.BOOL:
8977 
          self.success = iprot.readBool();
8978 
        else:
8979 
          iprot.skip(ftype)
8980 
      elif fid == 1:
8981 
        if ftype == TType.STRUCT:
8982 
          self.ex = TransactionServiceException()
8983 
          self.ex.read(iprot)
8984 
        else:
8985 
          iprot.skip(ftype)
8986 
      else:
8987 
        iprot.skip(ftype)
8988 
      iprot.readFieldEnd()
8989 
    iprot.readStructEnd()
8990 
 
8991 
  def write(self, oprot):
8992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8994 
      return
8995 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 8996 
    if self.success is not None:
2536 chandransh 8997 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8998 
      oprot.writeBool(self.success)
8999 
      oprot.writeFieldEnd()
3431 rajveer 9000 
    if self.ex is not None:
2536 chandransh 9001 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9002 
      self.ex.write(oprot)
9003 
      oprot.writeFieldEnd()
9004 
    oprot.writeFieldStop()
9005 
    oprot.writeStructEnd()
9006 
 
3431 rajveer 9007 
  def validate(self):
9008 
    return
9009 
 
9010 
 
2536 chandransh 9011 
  def __repr__(self):
9012 
    L = ['%s=%r' % (key, value)
9013 
      for key, value in self.__dict__.iteritems()]
9014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9015 
 
9016 
  def __eq__(self, other):
9017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9018 
 
9019 
  def __ne__(self, other):
9020 
    return not (self == other)
9021 
 
9022 
class requestPickupNumber_args:
9023 
  """
9024 
  Attributes:
9025 
   - orderId
9026 
  """
9027 
 
9028 
  thrift_spec = (
9029 
    None, # 0
9030 
    (1, TType.I64, 'orderId', None, None, ), # 1
9031 
  )
9032 
 
9033 
  def __init__(self, orderId=None,):
9034 
    self.orderId = orderId
9035 
 
9036 
  def read(self, iprot):
9037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9039 
      return
9040 
    iprot.readStructBegin()
9041 
    while True:
9042 
      (fname, ftype, fid) = iprot.readFieldBegin()
9043 
      if ftype == TType.STOP:
9044 
        break
9045 
      if fid == 1:
9046 
        if ftype == TType.I64:
9047 
          self.orderId = iprot.readI64();
9048 
        else:
9049 
          iprot.skip(ftype)
9050 
      else:
9051 
        iprot.skip(ftype)
9052 
      iprot.readFieldEnd()
9053 
    iprot.readStructEnd()
9054 
 
9055 
  def write(self, oprot):
9056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9058 
      return
9059 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 9060 
    if self.orderId is not None:
2536 chandransh 9061 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9062 
      oprot.writeI64(self.orderId)
9063 
      oprot.writeFieldEnd()
9064 
    oprot.writeFieldStop()
9065 
    oprot.writeStructEnd()
9066 
 
3431 rajveer 9067 
  def validate(self):
9068 
    return
9069 
 
9070 
 
2536 chandransh 9071 
  def __repr__(self):
9072 
    L = ['%s=%r' % (key, value)
9073 
      for key, value in self.__dict__.iteritems()]
9074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9075 
 
9076 
  def __eq__(self, other):
9077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9078 
 
9079 
  def __ne__(self, other):
9080 
    return not (self == other)
9081 
 
9082 
class requestPickupNumber_result:
9083 
  """
9084 
  Attributes:
9085 
   - success
9086 
   - ex
9087 
  """
9088 
 
9089 
  thrift_spec = (
9090 
    (0, TType.BOOL, 'success', None, None, ), # 0
9091 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9092 
  )
9093 
 
9094 
  def __init__(self, success=None, ex=None,):
9095 
    self.success = success
9096 
    self.ex = ex
9097 
 
9098 
  def read(self, iprot):
9099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9101 
      return
9102 
    iprot.readStructBegin()
9103 
    while True:
9104 
      (fname, ftype, fid) = iprot.readFieldBegin()
9105 
      if ftype == TType.STOP:
9106 
        break
9107 
      if fid == 0:
9108 
        if ftype == TType.BOOL:
9109 
          self.success = iprot.readBool();
9110 
        else:
9111 
          iprot.skip(ftype)
9112 
      elif fid == 1:
9113 
        if ftype == TType.STRUCT:
9114 
          self.ex = TransactionServiceException()
9115 
          self.ex.read(iprot)
9116 
        else:
9117 
          iprot.skip(ftype)
9118 
      else:
9119 
        iprot.skip(ftype)
9120 
      iprot.readFieldEnd()
9121 
    iprot.readStructEnd()
9122 
 
9123 
  def write(self, oprot):
9124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9126 
      return
9127 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 9128 
    if self.success is not None:
2536 chandransh 9129 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9130 
      oprot.writeBool(self.success)
9131 
      oprot.writeFieldEnd()
3431 rajveer 9132 
    if self.ex is not None:
2536 chandransh 9133 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9134 
      self.ex.write(oprot)
9135 
      oprot.writeFieldEnd()
9136 
    oprot.writeFieldStop()
9137 
    oprot.writeStructEnd()
9138 
 
3431 rajveer 9139 
  def validate(self):
9140 
    return
9141 
 
9142 
 
2536 chandransh 9143 
  def __repr__(self):
9144 
    L = ['%s=%r' % (key, value)
9145 
      for key, value in self.__dict__.iteritems()]
9146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9147 
 
9148 
  def __eq__(self, other):
9149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9150 
 
9151 
  def __ne__(self, other):
9152 
    return not (self == other)
9153 
 
9154 
class authorizePickup_args:
9155 
  """
9156 
  Attributes:
9157 
   - orderId
9158 
   - pickupNumber
9159 
  """
9160 
 
9161 
  thrift_spec = (
9162 
    None, # 0
9163 
    (1, TType.I64, 'orderId', None, None, ), # 1
9164 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
9165 
  )
9166 
 
9167 
  def __init__(self, orderId=None, pickupNumber=None,):
9168 
    self.orderId = orderId
9169 
    self.pickupNumber = pickupNumber
9170 
 
9171 
  def read(self, iprot):
9172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9174 
      return
9175 
    iprot.readStructBegin()
9176 
    while True:
9177 
      (fname, ftype, fid) = iprot.readFieldBegin()
9178 
      if ftype == TType.STOP:
9179 
        break
9180 
      if fid == 1:
9181 
        if ftype == TType.I64:
9182 
          self.orderId = iprot.readI64();
9183 
        else:
9184 
          iprot.skip(ftype)
9185 
      elif fid == 2:
9186 
        if ftype == TType.STRING:
9187 
          self.pickupNumber = iprot.readString();
9188 
        else:
9189 
          iprot.skip(ftype)
9190 
      else:
9191 
        iprot.skip(ftype)
9192 
      iprot.readFieldEnd()
9193 
    iprot.readStructEnd()
9194 
 
9195 
  def write(self, oprot):
9196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9198 
      return
9199 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 9200 
    if self.orderId is not None:
2536 chandransh 9201 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9202 
      oprot.writeI64(self.orderId)
9203 
      oprot.writeFieldEnd()
3431 rajveer 9204 
    if self.pickupNumber is not None:
2536 chandransh 9205 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
9206 
      oprot.writeString(self.pickupNumber)
9207 
      oprot.writeFieldEnd()
9208 
    oprot.writeFieldStop()
9209 
    oprot.writeStructEnd()
9210 
 
3431 rajveer 9211 
  def validate(self):
9212 
    return
9213 
 
9214 
 
2536 chandransh 9215 
  def __repr__(self):
9216 
    L = ['%s=%r' % (key, value)
9217 
      for key, value in self.__dict__.iteritems()]
9218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9219 
 
9220 
  def __eq__(self, other):
9221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9222 
 
9223 
  def __ne__(self, other):
9224 
    return not (self == other)
9225 
 
9226 
class authorizePickup_result:
9227 
  """
9228 
  Attributes:
9229 
   - success
9230 
   - ex
9231 
  """
9232 
 
9233 
  thrift_spec = (
9234 
    (0, TType.BOOL, 'success', None, None, ), # 0
9235 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9236 
  )
9237 
 
9238 
  def __init__(self, success=None, ex=None,):
9239 
    self.success = success
9240 
    self.ex = ex
9241 
 
9242 
  def read(self, iprot):
9243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9245 
      return
9246 
    iprot.readStructBegin()
9247 
    while True:
9248 
      (fname, ftype, fid) = iprot.readFieldBegin()
9249 
      if ftype == TType.STOP:
9250 
        break
9251 
      if fid == 0:
9252 
        if ftype == TType.BOOL:
9253 
          self.success = iprot.readBool();
9254 
        else:
9255 
          iprot.skip(ftype)
9256 
      elif fid == 1:
9257 
        if ftype == TType.STRUCT:
9258 
          self.ex = TransactionServiceException()
9259 
          self.ex.read(iprot)
9260 
        else:
9261 
          iprot.skip(ftype)
9262 
      else:
9263 
        iprot.skip(ftype)
9264 
      iprot.readFieldEnd()
9265 
    iprot.readStructEnd()
9266 
 
9267 
  def write(self, oprot):
9268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9270 
      return
9271 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 9272 
    if self.success is not None:
2536 chandransh 9273 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9274 
      oprot.writeBool(self.success)
9275 
      oprot.writeFieldEnd()
3431 rajveer 9276 
    if self.ex is not None:
2536 chandransh 9277 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9278 
      self.ex.write(oprot)
9279 
      oprot.writeFieldEnd()
9280 
    oprot.writeFieldStop()
9281 
    oprot.writeStructEnd()
9282 
 
3431 rajveer 9283 
  def validate(self):
9284 
    return
9285 
 
9286 
 
2536 chandransh 9287 
  def __repr__(self):
9288 
    L = ['%s=%r' % (key, value)
9289 
      for key, value in self.__dict__.iteritems()]
9290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9291 
 
9292 
  def __eq__(self, other):
9293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9294 
 
9295 
  def __ne__(self, other):
9296 
    return not (self == other)
9297 
 
2764 chandransh 9298 
class markDoasAsPickedUp_args:
9299 
  """
9300 
  Attributes:
9301 
   - providerId
9302 
   - pickupDetails
9303 
  """
9304 
 
9305 
  thrift_spec = (
9306 
    None, # 0
9307 
    (1, TType.I64, 'providerId', None, None, ), # 1
9308 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
9309 
  )
9310 
 
9311 
  def __init__(self, providerId=None, pickupDetails=None,):
9312 
    self.providerId = providerId
9313 
    self.pickupDetails = pickupDetails
9314 
 
9315 
  def read(self, iprot):
9316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9318 
      return
9319 
    iprot.readStructBegin()
9320 
    while True:
9321 
      (fname, ftype, fid) = iprot.readFieldBegin()
9322 
      if ftype == TType.STOP:
9323 
        break
9324 
      if fid == 1:
9325 
        if ftype == TType.I64:
9326 
          self.providerId = iprot.readI64();
9327 
        else:
9328 
          iprot.skip(ftype)
9329 
      elif fid == 2:
9330 
        if ftype == TType.MAP:
9331 
          self.pickupDetails = {}
3427 chandransh 9332 
          (_ktype170, _vtype171, _size169 ) = iprot.readMapBegin()
9333 
          for _i173 in xrange(_size169):
9334 
            _key174 = iprot.readString();
9335 
            _val175 = iprot.readString();
9336 
            self.pickupDetails[_key174] = _val175
2764 chandransh 9337 
          iprot.readMapEnd()
9338 
        else:
9339 
          iprot.skip(ftype)
9340 
      else:
9341 
        iprot.skip(ftype)
9342 
      iprot.readFieldEnd()
9343 
    iprot.readStructEnd()
9344 
 
9345 
  def write(self, oprot):
9346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9348 
      return
9349 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 9350 
    if self.providerId is not None:
2764 chandransh 9351 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9352 
      oprot.writeI64(self.providerId)
9353 
      oprot.writeFieldEnd()
3431 rajveer 9354 
    if self.pickupDetails is not None:
2764 chandransh 9355 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
9356 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
3427 chandransh 9357 
      for kiter176,viter177 in self.pickupDetails.items():
9358 
        oprot.writeString(kiter176)
9359 
        oprot.writeString(viter177)
2764 chandransh 9360 
      oprot.writeMapEnd()
9361 
      oprot.writeFieldEnd()
9362 
    oprot.writeFieldStop()
9363 
    oprot.writeStructEnd()
9364 
 
3431 rajveer 9365 
  def validate(self):
9366 
    return
9367 
 
9368 
 
2764 chandransh 9369 
  def __repr__(self):
9370 
    L = ['%s=%r' % (key, value)
9371 
      for key, value in self.__dict__.iteritems()]
9372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9373 
 
9374 
  def __eq__(self, other):
9375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9376 
 
9377 
  def __ne__(self, other):
9378 
    return not (self == other)
9379 
 
9380 
class markDoasAsPickedUp_result:
9381 
  """
9382 
  Attributes:
9383 
   - success
9384 
  """
9385 
 
9386 
  thrift_spec = (
9387 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9388 
  )
9389 
 
9390 
  def __init__(self, success=None,):
9391 
    self.success = success
9392 
 
9393 
  def read(self, iprot):
9394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9396 
      return
9397 
    iprot.readStructBegin()
9398 
    while True:
9399 
      (fname, ftype, fid) = iprot.readFieldBegin()
9400 
      if ftype == TType.STOP:
9401 
        break
9402 
      if fid == 0:
9403 
        if ftype == TType.LIST:
9404 
          self.success = []
3427 chandransh 9405 
          (_etype181, _size178) = iprot.readListBegin()
9406 
          for _i182 in xrange(_size178):
9407 
            _elem183 = Order()
9408 
            _elem183.read(iprot)
9409 
            self.success.append(_elem183)
2764 chandransh 9410 
          iprot.readListEnd()
9411 
        else:
9412 
          iprot.skip(ftype)
9413 
      else:
9414 
        iprot.skip(ftype)
9415 
      iprot.readFieldEnd()
9416 
    iprot.readStructEnd()
9417 
 
9418 
  def write(self, oprot):
9419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9421 
      return
9422 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 9423 
    if self.success is not None:
2764 chandransh 9424 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9425 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3427 chandransh 9426 
      for iter184 in self.success:
9427 
        iter184.write(oprot)
2764 chandransh 9428 
      oprot.writeListEnd()
9429 
      oprot.writeFieldEnd()
9430 
    oprot.writeFieldStop()
9431 
    oprot.writeStructEnd()
9432 
 
3431 rajveer 9433 
  def validate(self):
9434 
    return
9435 
 
9436 
 
2764 chandransh 9437 
  def __repr__(self):
9438 
    L = ['%s=%r' % (key, value)
9439 
      for key, value in self.__dict__.iteritems()]
9440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9441 
 
9442 
  def __eq__(self, other):
9443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9444 
 
9445 
  def __ne__(self, other):
9446 
    return not (self == other)
9447 
 
2616 chandransh 9448 
class receiveReturn_args:
2591 chandransh 9449 
  """
9450 
  Attributes:
9451 
   - orderId
9452 
  """
2536 chandransh 9453 
 
2591 chandransh 9454 
  thrift_spec = (
9455 
    None, # 0
9456 
    (1, TType.I64, 'orderId', None, None, ), # 1
9457 
  )
9458 
 
9459 
  def __init__(self, orderId=None,):
9460 
    self.orderId = orderId
9461 
 
9462 
  def read(self, iprot):
9463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9465 
      return
9466 
    iprot.readStructBegin()
9467 
    while True:
9468 
      (fname, ftype, fid) = iprot.readFieldBegin()
9469 
      if ftype == TType.STOP:
9470 
        break
9471 
      if fid == 1:
9472 
        if ftype == TType.I64:
9473 
          self.orderId = iprot.readI64();
9474 
        else:
9475 
          iprot.skip(ftype)
9476 
      else:
9477 
        iprot.skip(ftype)
9478 
      iprot.readFieldEnd()
9479 
    iprot.readStructEnd()
9480 
 
9481 
  def write(self, oprot):
9482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9484 
      return
2616 chandransh 9485 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 9486 
    if self.orderId is not None:
2591 chandransh 9487 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9488 
      oprot.writeI64(self.orderId)
9489 
      oprot.writeFieldEnd()
9490 
    oprot.writeFieldStop()
9491 
    oprot.writeStructEnd()
9492 
 
3431 rajveer 9493 
  def validate(self):
9494 
    return
9495 
 
9496 
 
2591 chandransh 9497 
  def __repr__(self):
9498 
    L = ['%s=%r' % (key, value)
9499 
      for key, value in self.__dict__.iteritems()]
9500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9501 
 
9502 
  def __eq__(self, other):
9503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9504 
 
9505 
  def __ne__(self, other):
9506 
    return not (self == other)
9507 
 
2616 chandransh 9508 
class receiveReturn_result:
2591 chandransh 9509 
  """
9510 
  Attributes:
9511 
   - success
9512 
   - ex
9513 
  """
9514 
 
9515 
  thrift_spec = (
9516 
    (0, TType.BOOL, 'success', None, None, ), # 0
9517 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9518 
  )
9519 
 
9520 
  def __init__(self, success=None, ex=None,):
9521 
    self.success = success
9522 
    self.ex = ex
9523 
 
9524 
  def read(self, iprot):
9525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9527 
      return
9528 
    iprot.readStructBegin()
9529 
    while True:
9530 
      (fname, ftype, fid) = iprot.readFieldBegin()
9531 
      if ftype == TType.STOP:
9532 
        break
9533 
      if fid == 0:
9534 
        if ftype == TType.BOOL:
9535 
          self.success = iprot.readBool();
9536 
        else:
9537 
          iprot.skip(ftype)
9538 
      elif fid == 1:
9539 
        if ftype == TType.STRUCT:
9540 
          self.ex = TransactionServiceException()
9541 
          self.ex.read(iprot)
9542 
        else:
9543 
          iprot.skip(ftype)
9544 
      else:
9545 
        iprot.skip(ftype)
9546 
      iprot.readFieldEnd()
9547 
    iprot.readStructEnd()
9548 
 
9549 
  def write(self, oprot):
9550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9552 
      return
2616 chandransh 9553 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 9554 
    if self.success is not None:
2591 chandransh 9555 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9556 
      oprot.writeBool(self.success)
9557 
      oprot.writeFieldEnd()
3431 rajveer 9558 
    if self.ex is not None:
2591 chandransh 9559 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9560 
      self.ex.write(oprot)
9561 
      oprot.writeFieldEnd()
9562 
    oprot.writeFieldStop()
9563 
    oprot.writeStructEnd()
9564 
 
3431 rajveer 9565 
  def validate(self):
9566 
    return
9567 
 
9568 
 
2591 chandransh 9569 
  def __repr__(self):
9570 
    L = ['%s=%r' % (key, value)
9571 
      for key, value in self.__dict__.iteritems()]
9572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9573 
 
9574 
  def __eq__(self, other):
9575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9576 
 
9577 
  def __ne__(self, other):
9578 
    return not (self == other)
9579 
 
9580 
class validateDoa_args:
9581 
  """
9582 
  Attributes:
9583 
   - orderId
9584 
   - isValid
9585 
  """
9586 
 
9587 
  thrift_spec = (
9588 
    None, # 0
9589 
    (1, TType.I64, 'orderId', None, None, ), # 1
9590 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
9591 
  )
9592 
 
9593 
  def __init__(self, orderId=None, isValid=None,):
9594 
    self.orderId = orderId
9595 
    self.isValid = isValid
9596 
 
9597 
  def read(self, iprot):
9598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9600 
      return
9601 
    iprot.readStructBegin()
9602 
    while True:
9603 
      (fname, ftype, fid) = iprot.readFieldBegin()
9604 
      if ftype == TType.STOP:
9605 
        break
9606 
      if fid == 1:
9607 
        if ftype == TType.I64:
9608 
          self.orderId = iprot.readI64();
9609 
        else:
9610 
          iprot.skip(ftype)
9611 
      elif fid == 2:
9612 
        if ftype == TType.BOOL:
9613 
          self.isValid = iprot.readBool();
9614 
        else:
9615 
          iprot.skip(ftype)
9616 
      else:
9617 
        iprot.skip(ftype)
9618 
      iprot.readFieldEnd()
9619 
    iprot.readStructEnd()
9620 
 
9621 
  def write(self, oprot):
9622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9624 
      return
9625 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 9626 
    if self.orderId is not None:
2591 chandransh 9627 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9628 
      oprot.writeI64(self.orderId)
9629 
      oprot.writeFieldEnd()
3431 rajveer 9630 
    if self.isValid is not None:
2591 chandransh 9631 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
9632 
      oprot.writeBool(self.isValid)
9633 
      oprot.writeFieldEnd()
9634 
    oprot.writeFieldStop()
9635 
    oprot.writeStructEnd()
9636 
 
3431 rajveer 9637 
  def validate(self):
9638 
    return
9639 
 
9640 
 
2591 chandransh 9641 
  def __repr__(self):
9642 
    L = ['%s=%r' % (key, value)
9643 
      for key, value in self.__dict__.iteritems()]
9644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9645 
 
9646 
  def __eq__(self, other):
9647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9648 
 
9649 
  def __ne__(self, other):
9650 
    return not (self == other)
9651 
 
9652 
class validateDoa_result:
9653 
  """
9654 
  Attributes:
9655 
   - success
9656 
   - ex
9657 
  """
9658 
 
9659 
  thrift_spec = (
9660 
    (0, TType.BOOL, 'success', None, None, ), # 0
9661 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9662 
  )
9663 
 
9664 
  def __init__(self, success=None, ex=None,):
9665 
    self.success = success
9666 
    self.ex = ex
9667 
 
9668 
  def read(self, iprot):
9669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9671 
      return
9672 
    iprot.readStructBegin()
9673 
    while True:
9674 
      (fname, ftype, fid) = iprot.readFieldBegin()
9675 
      if ftype == TType.STOP:
9676 
        break
9677 
      if fid == 0:
9678 
        if ftype == TType.BOOL:
9679 
          self.success = iprot.readBool();
9680 
        else:
9681 
          iprot.skip(ftype)
9682 
      elif fid == 1:
9683 
        if ftype == TType.STRUCT:
9684 
          self.ex = TransactionServiceException()
9685 
          self.ex.read(iprot)
9686 
        else:
9687 
          iprot.skip(ftype)
9688 
      else:
9689 
        iprot.skip(ftype)
9690 
      iprot.readFieldEnd()
9691 
    iprot.readStructEnd()
9692 
 
9693 
  def write(self, oprot):
9694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9696 
      return
9697 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 9698 
    if self.success is not None:
2591 chandransh 9699 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9700 
      oprot.writeBool(self.success)
9701 
      oprot.writeFieldEnd()
3431 rajveer 9702 
    if self.ex is not None:
2591 chandransh 9703 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9704 
      self.ex.write(oprot)
9705 
      oprot.writeFieldEnd()
9706 
    oprot.writeFieldStop()
9707 
    oprot.writeStructEnd()
9708 
 
3431 rajveer 9709 
  def validate(self):
9710 
    return
9711 
 
9712 
 
2591 chandransh 9713 
  def __repr__(self):
9714 
    L = ['%s=%r' % (key, value)
9715 
      for key, value in self.__dict__.iteritems()]
9716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9717 
 
9718 
  def __eq__(self, other):
9719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9720 
 
9721 
  def __ne__(self, other):
9722 
    return not (self == other)
9723 
 
2616 chandransh 9724 
class reshipOrder_args:
9725 
  """
9726 
  Attributes:
9727 
   - orderId
9728 
  """
2591 chandransh 9729 
 
2616 chandransh 9730 
  thrift_spec = (
9731 
    None, # 0
9732 
    (1, TType.I64, 'orderId', None, None, ), # 1
9733 
  )
9734 
 
9735 
  def __init__(self, orderId=None,):
9736 
    self.orderId = orderId
9737 
 
9738 
  def read(self, iprot):
9739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9741 
      return
9742 
    iprot.readStructBegin()
9743 
    while True:
9744 
      (fname, ftype, fid) = iprot.readFieldBegin()
9745 
      if ftype == TType.STOP:
9746 
        break
9747 
      if fid == 1:
9748 
        if ftype == TType.I64:
9749 
          self.orderId = iprot.readI64();
9750 
        else:
9751 
          iprot.skip(ftype)
9752 
      else:
9753 
        iprot.skip(ftype)
9754 
      iprot.readFieldEnd()
9755 
    iprot.readStructEnd()
9756 
 
9757 
  def write(self, oprot):
9758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9760 
      return
9761 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 9762 
    if self.orderId is not None:
2616 chandransh 9763 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9764 
      oprot.writeI64(self.orderId)
9765 
      oprot.writeFieldEnd()
9766 
    oprot.writeFieldStop()
9767 
    oprot.writeStructEnd()
9768 
 
3431 rajveer 9769 
  def validate(self):
9770 
    return
9771 
 
9772 
 
2616 chandransh 9773 
  def __repr__(self):
9774 
    L = ['%s=%r' % (key, value)
9775 
      for key, value in self.__dict__.iteritems()]
9776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9777 
 
9778 
  def __eq__(self, other):
9779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9780 
 
9781 
  def __ne__(self, other):
9782 
    return not (self == other)
9783 
 
9784 
class reshipOrder_result:
9785 
  """
9786 
  Attributes:
9787 
   - success
9788 
   - ex
9789 
  """
9790 
 
9791 
  thrift_spec = (
9792 
    (0, TType.I64, 'success', None, None, ), # 0
9793 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9794 
  )
9795 
 
9796 
  def __init__(self, success=None, ex=None,):
9797 
    self.success = success
9798 
    self.ex = ex
9799 
 
9800 
  def read(self, iprot):
9801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9803 
      return
9804 
    iprot.readStructBegin()
9805 
    while True:
9806 
      (fname, ftype, fid) = iprot.readFieldBegin()
9807 
      if ftype == TType.STOP:
9808 
        break
9809 
      if fid == 0:
9810 
        if ftype == TType.I64:
9811 
          self.success = iprot.readI64();
9812 
        else:
9813 
          iprot.skip(ftype)
9814 
      elif fid == 1:
9815 
        if ftype == TType.STRUCT:
9816 
          self.ex = TransactionServiceException()
9817 
          self.ex.read(iprot)
9818 
        else:
9819 
          iprot.skip(ftype)
9820 
      else:
9821 
        iprot.skip(ftype)
9822 
      iprot.readFieldEnd()
9823 
    iprot.readStructEnd()
9824 
 
9825 
  def write(self, oprot):
9826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9828 
      return
9829 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 9830 
    if self.success is not None:
2616 chandransh 9831 
      oprot.writeFieldBegin('success', TType.I64, 0)
9832 
      oprot.writeI64(self.success)
9833 
      oprot.writeFieldEnd()
3431 rajveer 9834 
    if self.ex is not None:
2616 chandransh 9835 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9836 
      self.ex.write(oprot)
9837 
      oprot.writeFieldEnd()
9838 
    oprot.writeFieldStop()
9839 
    oprot.writeStructEnd()
9840 
 
3431 rajveer 9841 
  def validate(self):
9842 
    return
9843 
 
9844 
 
2616 chandransh 9845 
  def __repr__(self):
9846 
    L = ['%s=%r' % (key, value)
9847 
      for key, value in self.__dict__.iteritems()]
9848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9849 
 
9850 
  def __eq__(self, other):
9851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9852 
 
9853 
  def __ne__(self, other):
9854 
    return not (self == other)
9855 
 
9856 
class refundOrder_args:
9857 
  """
9858 
  Attributes:
9859 
   - orderId
3226 chandransh 9860 
   - refundedBy
9861 
   - reason
2616 chandransh 9862 
  """
9863 
 
9864 
  thrift_spec = (
9865 
    None, # 0
9866 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 9867 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
9868 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 9869 
  )
9870 
 
3226 chandransh 9871 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 9872 
    self.orderId = orderId
3226 chandransh 9873 
    self.refundedBy = refundedBy
9874 
    self.reason = reason
2616 chandransh 9875 
 
9876 
  def read(self, iprot):
9877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9879 
      return
9880 
    iprot.readStructBegin()
9881 
    while True:
9882 
      (fname, ftype, fid) = iprot.readFieldBegin()
9883 
      if ftype == TType.STOP:
9884 
        break
9885 
      if fid == 1:
9886 
        if ftype == TType.I64:
9887 
          self.orderId = iprot.readI64();
9888 
        else:
9889 
          iprot.skip(ftype)
3226 chandransh 9890 
      elif fid == 2:
9891 
        if ftype == TType.STRING:
9892 
          self.refundedBy = iprot.readString();
9893 
        else:
9894 
          iprot.skip(ftype)
9895 
      elif fid == 3:
9896 
        if ftype == TType.STRING:
9897 
          self.reason = iprot.readString();
9898 
        else:
9899 
          iprot.skip(ftype)
2616 chandransh 9900 
      else:
9901 
        iprot.skip(ftype)
9902 
      iprot.readFieldEnd()
9903 
    iprot.readStructEnd()
9904 
 
9905 
  def write(self, oprot):
9906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9908 
      return
9909 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 9910 
    if self.orderId is not None:
2616 chandransh 9911 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9912 
      oprot.writeI64(self.orderId)
9913 
      oprot.writeFieldEnd()
3431 rajveer 9914 
    if self.refundedBy is not None:
3226 chandransh 9915 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
9916 
      oprot.writeString(self.refundedBy)
9917 
      oprot.writeFieldEnd()
3431 rajveer 9918 
    if self.reason is not None:
3226 chandransh 9919 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
9920 
      oprot.writeString(self.reason)
9921 
      oprot.writeFieldEnd()
2616 chandransh 9922 
    oprot.writeFieldStop()
9923 
    oprot.writeStructEnd()
9924 
 
3431 rajveer 9925 
  def validate(self):
9926 
    return
9927 
 
9928 
 
2616 chandransh 9929 
  def __repr__(self):
9930 
    L = ['%s=%r' % (key, value)
9931 
      for key, value in self.__dict__.iteritems()]
9932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9933 
 
9934 
  def __eq__(self, other):
9935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9936 
 
9937 
  def __ne__(self, other):
9938 
    return not (self == other)
9939 
 
9940 
class refundOrder_result:
9941 
  """
9942 
  Attributes:
9943 
   - success
9944 
   - ex
9945 
  """
9946 
 
9947 
  thrift_spec = (
9948 
    (0, TType.BOOL, 'success', None, None, ), # 0
9949 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9950 
  )
9951 
 
9952 
  def __init__(self, success=None, ex=None,):
9953 
    self.success = success
9954 
    self.ex = ex
9955 
 
9956 
  def read(self, iprot):
9957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9959 
      return
9960 
    iprot.readStructBegin()
9961 
    while True:
9962 
      (fname, ftype, fid) = iprot.readFieldBegin()
9963 
      if ftype == TType.STOP:
9964 
        break
9965 
      if fid == 0:
9966 
        if ftype == TType.BOOL:
9967 
          self.success = iprot.readBool();
9968 
        else:
9969 
          iprot.skip(ftype)
9970 
      elif fid == 1:
9971 
        if ftype == TType.STRUCT:
9972 
          self.ex = TransactionServiceException()
9973 
          self.ex.read(iprot)
9974 
        else:
9975 
          iprot.skip(ftype)
9976 
      else:
9977 
        iprot.skip(ftype)
9978 
      iprot.readFieldEnd()
9979 
    iprot.readStructEnd()
9980 
 
9981 
  def write(self, oprot):
9982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9984 
      return
9985 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 9986 
    if self.success is not None:
2616 chandransh 9987 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9988 
      oprot.writeBool(self.success)
9989 
      oprot.writeFieldEnd()
3431 rajveer 9990 
    if self.ex is not None:
2616 chandransh 9991 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9992 
      self.ex.write(oprot)
9993 
      oprot.writeFieldEnd()
9994 
    oprot.writeFieldStop()
9995 
    oprot.writeStructEnd()
9996 
 
3431 rajveer 9997 
  def validate(self):
9998 
    return
9999 
 
10000 
 
2616 chandransh 10001 
  def __repr__(self):
10002 
    L = ['%s=%r' % (key, value)
10003 
      for key, value in self.__dict__.iteritems()]
10004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10005 
 
10006 
  def __eq__(self, other):
10007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10008 
 
10009 
  def __ne__(self, other):
10010 
    return not (self == other)
10011 
 
2690 chandransh 10012 
class getReturnOrders_args:
10013 
  """
10014 
  Attributes:
10015 
   - warehouseId
10016 
   - fromDate
10017 
   - toDate
10018 
  """
2616 chandransh 10019 
 
2690 chandransh 10020 
  thrift_spec = (
10021 
    None, # 0
10022 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10023 
    (2, TType.I64, 'fromDate', None, None, ), # 2
10024 
    (3, TType.I64, 'toDate', None, None, ), # 3
10025 
  )
10026 
 
10027 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
10028 
    self.warehouseId = warehouseId
10029 
    self.fromDate = fromDate
10030 
    self.toDate = toDate
10031 
 
10032 
  def read(self, iprot):
10033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10035 
      return
10036 
    iprot.readStructBegin()
10037 
    while True:
10038 
      (fname, ftype, fid) = iprot.readFieldBegin()
10039 
      if ftype == TType.STOP:
10040 
        break
10041 
      if fid == 1:
10042 
        if ftype == TType.I64:
10043 
          self.warehouseId = iprot.readI64();
10044 
        else:
10045 
          iprot.skip(ftype)
10046 
      elif fid == 2:
10047 
        if ftype == TType.I64:
10048 
          self.fromDate = iprot.readI64();
10049 
        else:
10050 
          iprot.skip(ftype)
10051 
      elif fid == 3:
10052 
        if ftype == TType.I64:
10053 
          self.toDate = iprot.readI64();
10054 
        else:
10055 
          iprot.skip(ftype)
10056 
      else:
10057 
        iprot.skip(ftype)
10058 
      iprot.readFieldEnd()
10059 
    iprot.readStructEnd()
10060 
 
10061 
  def write(self, oprot):
10062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10064 
      return
10065 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 10066 
    if self.warehouseId is not None:
2690 chandransh 10067 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10068 
      oprot.writeI64(self.warehouseId)
10069 
      oprot.writeFieldEnd()
3431 rajveer 10070 
    if self.fromDate is not None:
2690 chandransh 10071 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
10072 
      oprot.writeI64(self.fromDate)
10073 
      oprot.writeFieldEnd()
3431 rajveer 10074 
    if self.toDate is not None:
2690 chandransh 10075 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
10076 
      oprot.writeI64(self.toDate)
10077 
      oprot.writeFieldEnd()
10078 
    oprot.writeFieldStop()
10079 
    oprot.writeStructEnd()
10080 
 
3431 rajveer 10081 
  def validate(self):
10082 
    return
10083 
 
10084 
 
2690 chandransh 10085 
  def __repr__(self):
10086 
    L = ['%s=%r' % (key, value)
10087 
      for key, value in self.__dict__.iteritems()]
10088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10089 
 
10090 
  def __eq__(self, other):
10091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10092 
 
10093 
  def __ne__(self, other):
10094 
    return not (self == other)
10095 
 
10096 
class getReturnOrders_result:
10097 
  """
10098 
  Attributes:
10099 
   - success
10100 
  """
10101 
 
10102 
  thrift_spec = (
10103 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
10104 
  )
10105 
 
10106 
  def __init__(self, success=None,):
10107 
    self.success = success
10108 
 
10109 
  def read(self, iprot):
10110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10112 
      return
10113 
    iprot.readStructBegin()
10114 
    while True:
10115 
      (fname, ftype, fid) = iprot.readFieldBegin()
10116 
      if ftype == TType.STOP:
10117 
        break
10118 
      if fid == 0:
10119 
        if ftype == TType.LIST:
10120 
          self.success = []
3427 chandransh 10121 
          (_etype188, _size185) = iprot.readListBegin()
10122 
          for _i189 in xrange(_size185):
10123 
            _elem190 = ReturnOrder()
10124 
            _elem190.read(iprot)
10125 
            self.success.append(_elem190)
2690 chandransh 10126 
          iprot.readListEnd()
10127 
        else:
10128 
          iprot.skip(ftype)
10129 
      else:
10130 
        iprot.skip(ftype)
10131 
      iprot.readFieldEnd()
10132 
    iprot.readStructEnd()
10133 
 
10134 
  def write(self, oprot):
10135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10137 
      return
10138 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 10139 
    if self.success is not None:
2690 chandransh 10140 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10141 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3427 chandransh 10142 
      for iter191 in self.success:
10143 
        iter191.write(oprot)
2690 chandransh 10144 
      oprot.writeListEnd()
10145 
      oprot.writeFieldEnd()
10146 
    oprot.writeFieldStop()
10147 
    oprot.writeStructEnd()
10148 
 
3431 rajveer 10149 
  def validate(self):
10150 
    return
10151 
 
10152 
 
2690 chandransh 10153 
  def __repr__(self):
10154 
    L = ['%s=%r' % (key, value)
10155 
      for key, value in self.__dict__.iteritems()]
10156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10157 
 
10158 
  def __eq__(self, other):
10159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10160 
 
10161 
  def __ne__(self, other):
10162 
    return not (self == other)
10163 
 
2700 chandransh 10164 
class getReturnOrder_args:
10165 
  """
10166 
  Attributes:
10167 
   - id
10168 
  """
10169 
 
10170 
  thrift_spec = (
10171 
    None, # 0
10172 
    (1, TType.I64, 'id', None, None, ), # 1
10173 
  )
10174 
 
10175 
  def __init__(self, id=None,):
10176 
    self.id = id
10177 
 
10178 
  def read(self, iprot):
10179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10181 
      return
10182 
    iprot.readStructBegin()
10183 
    while True:
10184 
      (fname, ftype, fid) = iprot.readFieldBegin()
10185 
      if ftype == TType.STOP:
10186 
        break
10187 
      if fid == 1:
10188 
        if ftype == TType.I64:
10189 
          self.id = iprot.readI64();
10190 
        else:
10191 
          iprot.skip(ftype)
10192 
      else:
10193 
        iprot.skip(ftype)
10194 
      iprot.readFieldEnd()
10195 
    iprot.readStructEnd()
10196 
 
10197 
  def write(self, oprot):
10198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10200 
      return
10201 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 10202 
    if self.id is not None:
2700 chandransh 10203 
      oprot.writeFieldBegin('id', TType.I64, 1)
10204 
      oprot.writeI64(self.id)
10205 
      oprot.writeFieldEnd()
10206 
    oprot.writeFieldStop()
10207 
    oprot.writeStructEnd()
10208 
 
3431 rajveer 10209 
  def validate(self):
10210 
    return
10211 
 
10212 
 
2700 chandransh 10213 
  def __repr__(self):
10214 
    L = ['%s=%r' % (key, value)
10215 
      for key, value in self.__dict__.iteritems()]
10216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10217 
 
10218 
  def __eq__(self, other):
10219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10220 
 
10221 
  def __ne__(self, other):
10222 
    return not (self == other)
10223 
 
10224 
class getReturnOrder_result:
10225 
  """
10226 
  Attributes:
10227 
   - success
10228 
   - ex
10229 
  """
10230 
 
10231 
  thrift_spec = (
10232 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
10233 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10234 
  )
10235 
 
10236 
  def __init__(self, success=None, ex=None,):
10237 
    self.success = success
10238 
    self.ex = ex
10239 
 
10240 
  def read(self, iprot):
10241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10243 
      return
10244 
    iprot.readStructBegin()
10245 
    while True:
10246 
      (fname, ftype, fid) = iprot.readFieldBegin()
10247 
      if ftype == TType.STOP:
10248 
        break
10249 
      if fid == 0:
10250 
        if ftype == TType.STRUCT:
10251 
          self.success = ReturnOrder()
10252 
          self.success.read(iprot)
10253 
        else:
10254 
          iprot.skip(ftype)
10255 
      elif fid == 1:
10256 
        if ftype == TType.STRUCT:
10257 
          self.ex = TransactionServiceException()
10258 
          self.ex.read(iprot)
10259 
        else:
10260 
          iprot.skip(ftype)
10261 
      else:
10262 
        iprot.skip(ftype)
10263 
      iprot.readFieldEnd()
10264 
    iprot.readStructEnd()
10265 
 
10266 
  def write(self, oprot):
10267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10269 
      return
10270 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 10271 
    if self.success is not None:
2700 chandransh 10272 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10273 
      self.success.write(oprot)
10274 
      oprot.writeFieldEnd()
3431 rajveer 10275 
    if self.ex is not None:
2700 chandransh 10276 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10277 
      self.ex.write(oprot)
10278 
      oprot.writeFieldEnd()
10279 
    oprot.writeFieldStop()
10280 
    oprot.writeStructEnd()
10281 
 
3431 rajveer 10282 
  def validate(self):
10283 
    return
10284 
 
10285 
 
2700 chandransh 10286 
  def __repr__(self):
10287 
    L = ['%s=%r' % (key, value)
10288 
      for key, value in self.__dict__.iteritems()]
10289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10290 
 
10291 
  def __eq__(self, other):
10292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10293 
 
10294 
  def __ne__(self, other):
10295 
    return not (self == other)
10296 
 
2690 chandransh 10297 
class processReturn_args:
10298 
  """
10299 
  Attributes:
10300 
   - returnOrderId
10301 
  """
10302 
 
10303 
  thrift_spec = (
10304 
    None, # 0
10305 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
10306 
  )
10307 
 
10308 
  def __init__(self, returnOrderId=None,):
10309 
    self.returnOrderId = returnOrderId
10310 
 
10311 
  def read(self, iprot):
10312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10314 
      return
10315 
    iprot.readStructBegin()
10316 
    while True:
10317 
      (fname, ftype, fid) = iprot.readFieldBegin()
10318 
      if ftype == TType.STOP:
10319 
        break
10320 
      if fid == 1:
10321 
        if ftype == TType.I64:
10322 
          self.returnOrderId = iprot.readI64();
10323 
        else:
10324 
          iprot.skip(ftype)
10325 
      else:
10326 
        iprot.skip(ftype)
10327 
      iprot.readFieldEnd()
10328 
    iprot.readStructEnd()
10329 
 
10330 
  def write(self, oprot):
10331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10333 
      return
10334 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 10335 
    if self.returnOrderId is not None:
2690 chandransh 10336 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
10337 
      oprot.writeI64(self.returnOrderId)
10338 
      oprot.writeFieldEnd()
10339 
    oprot.writeFieldStop()
10340 
    oprot.writeStructEnd()
10341 
 
3431 rajveer 10342 
  def validate(self):
10343 
    return
10344 
 
10345 
 
2690 chandransh 10346 
  def __repr__(self):
10347 
    L = ['%s=%r' % (key, value)
10348 
      for key, value in self.__dict__.iteritems()]
10349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10350 
 
10351 
  def __eq__(self, other):
10352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10353 
 
10354 
  def __ne__(self, other):
10355 
    return not (self == other)
10356 
 
10357 
class processReturn_result:
10358 
  """
10359 
  Attributes:
10360 
   - ex
10361 
  """
10362 
 
10363 
  thrift_spec = (
10364 
    None, # 0
10365 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10366 
  )
10367 
 
10368 
  def __init__(self, ex=None,):
10369 
    self.ex = ex
10370 
 
10371 
  def read(self, iprot):
10372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10374 
      return
10375 
    iprot.readStructBegin()
10376 
    while True:
10377 
      (fname, ftype, fid) = iprot.readFieldBegin()
10378 
      if ftype == TType.STOP:
10379 
        break
10380 
      if fid == 1:
10381 
        if ftype == TType.STRUCT:
10382 
          self.ex = TransactionServiceException()
10383 
          self.ex.read(iprot)
10384 
        else:
10385 
          iprot.skip(ftype)
10386 
      else:
10387 
        iprot.skip(ftype)
10388 
      iprot.readFieldEnd()
10389 
    iprot.readStructEnd()
10390 
 
10391 
  def write(self, oprot):
10392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10394 
      return
10395 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 10396 
    if self.ex is not None:
2690 chandransh 10397 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10398 
      self.ex.write(oprot)
10399 
      oprot.writeFieldEnd()
10400 
    oprot.writeFieldStop()
10401 
    oprot.writeStructEnd()
10402 
 
3431 rajveer 10403 
  def validate(self):
10404 
    return
10405 
 
10406 
 
2690 chandransh 10407 
  def __repr__(self):
10408 
    L = ['%s=%r' % (key, value)
10409 
      for key, value in self.__dict__.iteritems()]
10410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10411 
 
10412 
  def __eq__(self, other):
10413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10414 
 
10415 
  def __ne__(self, other):
10416 
    return not (self == other)
10417 
 
2819 chandransh 10418 
class createPurchaseOrder_args:
10419 
  """
10420 
  Attributes:
10421 
   - warehouseId
10422 
  """
2690 chandransh 10423 
 
2819 chandransh 10424 
  thrift_spec = (
10425 
    None, # 0
10426 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10427 
  )
10428 
 
10429 
  def __init__(self, warehouseId=None,):
10430 
    self.warehouseId = warehouseId
10431 
 
10432 
  def read(self, iprot):
10433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10435 
      return
10436 
    iprot.readStructBegin()
10437 
    while True:
10438 
      (fname, ftype, fid) = iprot.readFieldBegin()
10439 
      if ftype == TType.STOP:
10440 
        break
10441 
      if fid == 1:
10442 
        if ftype == TType.I64:
10443 
          self.warehouseId = iprot.readI64();
10444 
        else:
10445 
          iprot.skip(ftype)
10446 
      else:
10447 
        iprot.skip(ftype)
10448 
      iprot.readFieldEnd()
10449 
    iprot.readStructEnd()
10450 
 
10451 
  def write(self, oprot):
10452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10454 
      return
10455 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 10456 
    if self.warehouseId is not None:
2819 chandransh 10457 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10458 
      oprot.writeI64(self.warehouseId)
10459 
      oprot.writeFieldEnd()
10460 
    oprot.writeFieldStop()
10461 
    oprot.writeStructEnd()
10462 
 
3431 rajveer 10463 
  def validate(self):
10464 
    return
10465 
 
10466 
 
2819 chandransh 10467 
  def __repr__(self):
10468 
    L = ['%s=%r' % (key, value)
10469 
      for key, value in self.__dict__.iteritems()]
10470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10471 
 
10472 
  def __eq__(self, other):
10473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10474 
 
10475 
  def __ne__(self, other):
10476 
    return not (self == other)
10477 
 
10478 
class createPurchaseOrder_result:
10479 
  """
10480 
  Attributes:
10481 
   - success
10482 
   - ex
10483 
  """
10484 
 
10485 
  thrift_spec = (
10486 
    (0, TType.I64, 'success', None, None, ), # 0
10487 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10488 
  )
10489 
 
10490 
  def __init__(self, success=None, ex=None,):
10491 
    self.success = success
10492 
    self.ex = ex
10493 
 
10494 
  def read(self, iprot):
10495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10497 
      return
10498 
    iprot.readStructBegin()
10499 
    while True:
10500 
      (fname, ftype, fid) = iprot.readFieldBegin()
10501 
      if ftype == TType.STOP:
10502 
        break
10503 
      if fid == 0:
10504 
        if ftype == TType.I64:
10505 
          self.success = iprot.readI64();
10506 
        else:
10507 
          iprot.skip(ftype)
10508 
      elif fid == 1:
10509 
        if ftype == TType.STRUCT:
10510 
          self.ex = TransactionServiceException()
10511 
          self.ex.read(iprot)
10512 
        else:
10513 
          iprot.skip(ftype)
10514 
      else:
10515 
        iprot.skip(ftype)
10516 
      iprot.readFieldEnd()
10517 
    iprot.readStructEnd()
10518 
 
10519 
  def write(self, oprot):
10520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10522 
      return
10523 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 10524 
    if self.success is not None:
2819 chandransh 10525 
      oprot.writeFieldBegin('success', TType.I64, 0)
10526 
      oprot.writeI64(self.success)
10527 
      oprot.writeFieldEnd()
3431 rajveer 10528 
    if self.ex is not None:
2819 chandransh 10529 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10530 
      self.ex.write(oprot)
10531 
      oprot.writeFieldEnd()
10532 
    oprot.writeFieldStop()
10533 
    oprot.writeStructEnd()
10534 
 
3431 rajveer 10535 
  def validate(self):
10536 
    return
10537 
 
10538 
 
2819 chandransh 10539 
  def __repr__(self):
10540 
    L = ['%s=%r' % (key, value)
10541 
      for key, value in self.__dict__.iteritems()]
10542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10543 
 
10544 
  def __eq__(self, other):
10545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10546 
 
10547 
  def __ne__(self, other):
10548 
    return not (self == other)
3451 chandransh 10549 
 
10550 
class updateWeight_args:
10551 
  """
10552 
  Attributes:
10553 
   - orderId
10554 
   - weight
10555 
  """
10556 
 
10557 
  thrift_spec = (
10558 
    None, # 0
10559 
    (1, TType.I64, 'orderId', None, None, ), # 1
10560 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
10561 
  )
10562 
 
10563 
  def __init__(self, orderId=None, weight=None,):
10564 
    self.orderId = orderId
10565 
    self.weight = weight
10566 
 
10567 
  def read(self, iprot):
10568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10570 
      return
10571 
    iprot.readStructBegin()
10572 
    while True:
10573 
      (fname, ftype, fid) = iprot.readFieldBegin()
10574 
      if ftype == TType.STOP:
10575 
        break
10576 
      if fid == 1:
10577 
        if ftype == TType.I64:
10578 
          self.orderId = iprot.readI64();
10579 
        else:
10580 
          iprot.skip(ftype)
10581 
      elif fid == 2:
10582 
        if ftype == TType.DOUBLE:
10583 
          self.weight = iprot.readDouble();
10584 
        else:
10585 
          iprot.skip(ftype)
10586 
      else:
10587 
        iprot.skip(ftype)
10588 
      iprot.readFieldEnd()
10589 
    iprot.readStructEnd()
10590 
 
10591 
  def write(self, oprot):
10592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10594 
      return
10595 
    oprot.writeStructBegin('updateWeight_args')
10596 
    if self.orderId is not None:
10597 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10598 
      oprot.writeI64(self.orderId)
10599 
      oprot.writeFieldEnd()
10600 
    if self.weight is not None:
10601 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
10602 
      oprot.writeDouble(self.weight)
10603 
      oprot.writeFieldEnd()
10604 
    oprot.writeFieldStop()
10605 
    oprot.writeStructEnd()
10606 
 
10607 
  def validate(self):
10608 
    return
10609 
 
10610 
 
10611 
  def __repr__(self):
10612 
    L = ['%s=%r' % (key, value)
10613 
      for key, value in self.__dict__.iteritems()]
10614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10615 
 
10616 
  def __eq__(self, other):
10617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10618 
 
10619 
  def __ne__(self, other):
10620 
    return not (self == other)
10621 
 
10622 
class updateWeight_result:
10623 
  """
10624 
  Attributes:
10625 
   - success
10626 
   - ex
10627 
  """
10628 
 
10629 
  thrift_spec = (
10630 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
10631 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10632 
  )
10633 
 
10634 
  def __init__(self, success=None, ex=None,):
10635 
    self.success = success
10636 
    self.ex = ex
10637 
 
10638 
  def read(self, iprot):
10639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10641 
      return
10642 
    iprot.readStructBegin()
10643 
    while True:
10644 
      (fname, ftype, fid) = iprot.readFieldBegin()
10645 
      if ftype == TType.STOP:
10646 
        break
10647 
      if fid == 0:
10648 
        if ftype == TType.STRUCT:
10649 
          self.success = Order()
10650 
          self.success.read(iprot)
10651 
        else:
10652 
          iprot.skip(ftype)
10653 
      elif fid == 1:
10654 
        if ftype == TType.STRUCT:
10655 
          self.ex = TransactionServiceException()
10656 
          self.ex.read(iprot)
10657 
        else:
10658 
          iprot.skip(ftype)
10659 
      else:
10660 
        iprot.skip(ftype)
10661 
      iprot.readFieldEnd()
10662 
    iprot.readStructEnd()
10663 
 
10664 
  def write(self, oprot):
10665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10667 
      return
10668 
    oprot.writeStructBegin('updateWeight_result')
10669 
    if self.success is not None:
10670 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10671 
      self.success.write(oprot)
10672 
      oprot.writeFieldEnd()
10673 
    if self.ex is not None:
10674 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10675 
      self.ex.write(oprot)
10676 
      oprot.writeFieldEnd()
10677 
    oprot.writeFieldStop()
10678 
    oprot.writeStructEnd()
10679 
 
10680 
  def validate(self):
10681 
    return
10682 
 
10683 
 
10684 
  def __repr__(self):
10685 
    L = ['%s=%r' % (key, value)
10686 
      for key, value in self.__dict__.iteritems()]
10687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10688 
 
10689 
  def __eq__(self, other):
10690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10691 
 
10692 
  def __ne__(self, other):
10693 
    return not (self == other)
3469 chandransh 10694 
 
10695 
class changeItem_args:
10696 
  """
10697 
  Attributes:
10698 
   - orderId
10699 
   - itemId
10700 
  """
10701 
 
10702 
  thrift_spec = (
10703 
    None, # 0
10704 
    (1, TType.I64, 'orderId', None, None, ), # 1
10705 
    (2, TType.I64, 'itemId', None, None, ), # 2
10706 
  )
10707 
 
10708 
  def __init__(self, orderId=None, itemId=None,):
10709 
    self.orderId = orderId
10710 
    self.itemId = itemId
10711 
 
10712 
  def read(self, iprot):
10713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10715 
      return
10716 
    iprot.readStructBegin()
10717 
    while True:
10718 
      (fname, ftype, fid) = iprot.readFieldBegin()
10719 
      if ftype == TType.STOP:
10720 
        break
10721 
      if fid == 1:
10722 
        if ftype == TType.I64:
10723 
          self.orderId = iprot.readI64();
10724 
        else:
10725 
          iprot.skip(ftype)
10726 
      elif fid == 2:
10727 
        if ftype == TType.I64:
10728 
          self.itemId = iprot.readI64();
10729 
        else:
10730 
          iprot.skip(ftype)
10731 
      else:
10732 
        iprot.skip(ftype)
10733 
      iprot.readFieldEnd()
10734 
    iprot.readStructEnd()
10735 
 
10736 
  def write(self, oprot):
10737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10739 
      return
10740 
    oprot.writeStructBegin('changeItem_args')
10741 
    if self.orderId is not None:
10742 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10743 
      oprot.writeI64(self.orderId)
10744 
      oprot.writeFieldEnd()
10745 
    if self.itemId is not None:
10746 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10747 
      oprot.writeI64(self.itemId)
10748 
      oprot.writeFieldEnd()
10749 
    oprot.writeFieldStop()
10750 
    oprot.writeStructEnd()
10751 
 
10752 
  def validate(self):
10753 
    return
10754 
 
10755 
 
10756 
  def __repr__(self):
10757 
    L = ['%s=%r' % (key, value)
10758 
      for key, value in self.__dict__.iteritems()]
10759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10760 
 
10761 
  def __eq__(self, other):
10762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10763 
 
10764 
  def __ne__(self, other):
10765 
    return not (self == other)
10766 
 
10767 
class changeItem_result:
10768 
  """
10769 
  Attributes:
10770 
   - success
10771 
   - ex
10772 
  """
10773 
 
10774 
  thrift_spec = (
10775 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
10776 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10777 
  )
10778 
 
10779 
  def __init__(self, success=None, ex=None,):
10780 
    self.success = success
10781 
    self.ex = ex
10782 
 
10783 
  def read(self, iprot):
10784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10786 
      return
10787 
    iprot.readStructBegin()
10788 
    while True:
10789 
      (fname, ftype, fid) = iprot.readFieldBegin()
10790 
      if ftype == TType.STOP:
10791 
        break
10792 
      if fid == 0:
10793 
        if ftype == TType.STRUCT:
10794 
          self.success = Order()
10795 
          self.success.read(iprot)
10796 
        else:
10797 
          iprot.skip(ftype)
10798 
      elif fid == 1:
10799 
        if ftype == TType.STRUCT:
10800 
          self.ex = TransactionServiceException()
10801 
          self.ex.read(iprot)
10802 
        else:
10803 
          iprot.skip(ftype)
10804 
      else:
10805 
        iprot.skip(ftype)
10806 
      iprot.readFieldEnd()
10807 
    iprot.readStructEnd()
10808 
 
10809 
  def write(self, oprot):
10810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10812 
      return
10813 
    oprot.writeStructBegin('changeItem_result')
10814 
    if self.success is not None:
10815 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10816 
      self.success.write(oprot)
10817 
      oprot.writeFieldEnd()
10818 
    if self.ex is not None:
10819 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10820 
      self.ex.write(oprot)
10821 
      oprot.writeFieldEnd()
10822 
    oprot.writeFieldStop()
10823 
    oprot.writeStructEnd()
10824 
 
10825 
  def validate(self):
10826 
    return
10827 
 
10828 
 
10829 
  def __repr__(self):
10830 
    L = ['%s=%r' % (key, value)
10831 
      for key, value in self.__dict__.iteritems()]
10832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10833 
 
10834 
  def __eq__(self, other):
10835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10836 
 
10837 
  def __ne__(self, other):
10838 
    return not (self == other)
10839 
 
10840 
class shiftToWarehouse_args:
10841 
  """
10842 
  Attributes:
10843 
   - orderId
10844 
   - warehouseId
10845 
  """
10846 
 
10847 
  thrift_spec = (
10848 
    None, # 0
10849 
    (1, TType.I64, 'orderId', None, None, ), # 1
10850 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10851 
  )
10852 
 
10853 
  def __init__(self, orderId=None, warehouseId=None,):
10854 
    self.orderId = orderId
10855 
    self.warehouseId = warehouseId
10856 
 
10857 
  def read(self, iprot):
10858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10860 
      return
10861 
    iprot.readStructBegin()
10862 
    while True:
10863 
      (fname, ftype, fid) = iprot.readFieldBegin()
10864 
      if ftype == TType.STOP:
10865 
        break
10866 
      if fid == 1:
10867 
        if ftype == TType.I64:
10868 
          self.orderId = iprot.readI64();
10869 
        else:
10870 
          iprot.skip(ftype)
10871 
      elif fid == 2:
10872 
        if ftype == TType.I64:
10873 
          self.warehouseId = iprot.readI64();
10874 
        else:
10875 
          iprot.skip(ftype)
10876 
      else:
10877 
        iprot.skip(ftype)
10878 
      iprot.readFieldEnd()
10879 
    iprot.readStructEnd()
10880 
 
10881 
  def write(self, oprot):
10882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10884 
      return
10885 
    oprot.writeStructBegin('shiftToWarehouse_args')
10886 
    if self.orderId is not None:
10887 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10888 
      oprot.writeI64(self.orderId)
10889 
      oprot.writeFieldEnd()
10890 
    if self.warehouseId is not None:
10891 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10892 
      oprot.writeI64(self.warehouseId)
10893 
      oprot.writeFieldEnd()
10894 
    oprot.writeFieldStop()
10895 
    oprot.writeStructEnd()
10896 
 
10897 
  def validate(self):
10898 
    return
10899 
 
10900 
 
10901 
  def __repr__(self):
10902 
    L = ['%s=%r' % (key, value)
10903 
      for key, value in self.__dict__.iteritems()]
10904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10905 
 
10906 
  def __eq__(self, other):
10907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10908 
 
10909 
  def __ne__(self, other):
10910 
    return not (self == other)
10911 
 
10912 
class shiftToWarehouse_result:
10913 
  """
10914 
  Attributes:
10915 
   - success
10916 
   - ex
10917 
  """
10918 
 
10919 
  thrift_spec = (
10920 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
10921 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10922 
  )
10923 
 
10924 
  def __init__(self, success=None, ex=None,):
10925 
    self.success = success
10926 
    self.ex = ex
10927 
 
10928 
  def read(self, iprot):
10929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10931 
      return
10932 
    iprot.readStructBegin()
10933 
    while True:
10934 
      (fname, ftype, fid) = iprot.readFieldBegin()
10935 
      if ftype == TType.STOP:
10936 
        break
10937 
      if fid == 0:
10938 
        if ftype == TType.STRUCT:
10939 
          self.success = Order()
10940 
          self.success.read(iprot)
10941 
        else:
10942 
          iprot.skip(ftype)
10943 
      elif fid == 1:
10944 
        if ftype == TType.STRUCT:
10945 
          self.ex = TransactionServiceException()
10946 
          self.ex.read(iprot)
10947 
        else:
10948 
          iprot.skip(ftype)
10949 
      else:
10950 
        iprot.skip(ftype)
10951 
      iprot.readFieldEnd()
10952 
    iprot.readStructEnd()
10953 
 
10954 
  def write(self, oprot):
10955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10957 
      return
10958 
    oprot.writeStructBegin('shiftToWarehouse_result')
10959 
    if self.success is not None:
10960 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10961 
      self.success.write(oprot)
10962 
      oprot.writeFieldEnd()
10963 
    if self.ex is not None:
10964 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10965 
      self.ex.write(oprot)
10966 
      oprot.writeFieldEnd()
10967 
    oprot.writeFieldStop()
10968 
    oprot.writeStructEnd()
10969 
 
10970 
  def validate(self):
10971 
    return
10972 
 
10973 
 
10974 
  def __repr__(self):
10975 
    L = ['%s=%r' % (key, value)
10976 
      for key, value in self.__dict__.iteritems()]
10977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10978 
 
10979 
  def __eq__(self, other):
10980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10981 
 
10982 
  def __ne__(self, other):
10983 
    return not (self == other)
3553 chandransh 10984 
 
10985 
class addDelayReason_args:
10986 
  """
10987 
  Attributes:
10988 
   - orderId
10989 
   - delayReason
10990 
  """
10991 
 
10992 
  thrift_spec = (
10993 
    None, # 0
10994 
    (1, TType.I64, 'orderId', None, None, ), # 1
10995 
    (2, TType.I32, 'delayReason', None, None, ), # 2
10996 
  )
10997 
 
10998 
  def __init__(self, orderId=None, delayReason=None,):
10999 
    self.orderId = orderId
11000 
    self.delayReason = delayReason
11001 
 
11002 
  def read(self, iprot):
11003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11005 
      return
11006 
    iprot.readStructBegin()
11007 
    while True:
11008 
      (fname, ftype, fid) = iprot.readFieldBegin()
11009 
      if ftype == TType.STOP:
11010 
        break
11011 
      if fid == 1:
11012 
        if ftype == TType.I64:
11013 
          self.orderId = iprot.readI64();
11014 
        else:
11015 
          iprot.skip(ftype)
11016 
      elif fid == 2:
11017 
        if ftype == TType.I32:
11018 
          self.delayReason = iprot.readI32();
11019 
        else:
11020 
          iprot.skip(ftype)
11021 
      else:
11022 
        iprot.skip(ftype)
11023 
      iprot.readFieldEnd()
11024 
    iprot.readStructEnd()
11025 
 
11026 
  def write(self, oprot):
11027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11029 
      return
11030 
    oprot.writeStructBegin('addDelayReason_args')
11031 
    if self.orderId is not None:
11032 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11033 
      oprot.writeI64(self.orderId)
11034 
      oprot.writeFieldEnd()
11035 
    if self.delayReason is not None:
11036 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
11037 
      oprot.writeI32(self.delayReason)
11038 
      oprot.writeFieldEnd()
11039 
    oprot.writeFieldStop()
11040 
    oprot.writeStructEnd()
11041 
 
11042 
  def validate(self):
11043 
    return
11044 
 
11045 
 
11046 
  def __repr__(self):
11047 
    L = ['%s=%r' % (key, value)
11048 
      for key, value in self.__dict__.iteritems()]
11049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11050 
 
11051 
  def __eq__(self, other):
11052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11053 
 
11054 
  def __ne__(self, other):
11055 
    return not (self == other)
11056 
 
11057 
class addDelayReason_result:
11058 
  """
11059 
  Attributes:
11060 
   - success
11061 
   - ex
11062 
  """
11063 
 
11064 
  thrift_spec = (
11065 
    (0, TType.BOOL, 'success', None, None, ), # 0
11066 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11067 
  )
11068 
 
11069 
  def __init__(self, success=None, ex=None,):
11070 
    self.success = success
11071 
    self.ex = ex
11072 
 
11073 
  def read(self, iprot):
11074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11076 
      return
11077 
    iprot.readStructBegin()
11078 
    while True:
11079 
      (fname, ftype, fid) = iprot.readFieldBegin()
11080 
      if ftype == TType.STOP:
11081 
        break
11082 
      if fid == 0:
11083 
        if ftype == TType.BOOL:
11084 
          self.success = iprot.readBool();
11085 
        else:
11086 
          iprot.skip(ftype)
11087 
      elif fid == 1:
11088 
        if ftype == TType.STRUCT:
11089 
          self.ex = TransactionServiceException()
11090 
          self.ex.read(iprot)
11091 
        else:
11092 
          iprot.skip(ftype)
11093 
      else:
11094 
        iprot.skip(ftype)
11095 
      iprot.readFieldEnd()
11096 
    iprot.readStructEnd()
11097 
 
11098 
  def write(self, oprot):
11099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11101 
      return
11102 
    oprot.writeStructBegin('addDelayReason_result')
11103 
    if self.success is not None:
11104 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11105 
      oprot.writeBool(self.success)
11106 
      oprot.writeFieldEnd()
11107 
    if self.ex is not None:
11108 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11109 
      self.ex.write(oprot)
11110 
      oprot.writeFieldEnd()
11111 
    oprot.writeFieldStop()
11112 
    oprot.writeStructEnd()
11113 
 
11114 
  def validate(self):
11115 
    return
11116 
 
11117 
 
11118 
  def __repr__(self):
11119 
    L = ['%s=%r' % (key, value)
11120 
      for key, value in self.__dict__.iteritems()]
11121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11122 
 
11123 
  def __eq__(self, other):
11124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11125 
 
11126 
  def __ne__(self, other):
11127 
    return not (self == other)