Subversion Repositories SmartDukaan

Rev

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