Subversion Repositories SmartDukaan

Rev

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