Subversion Repositories SmartDukaan

Rev

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