Subversion Repositories SmartDukaan

Rev

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