Subversion Repositories SmartDukaan

Rev

Rev 4258 | Rev 4264 | 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 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
3064 chandransh 219 
  def getAlerts(self, orderId, valid):
220 
    """
221 
    Parameters:
222 
     - orderId
223 
     - valid
224 
    """
225 
    pass
226 
 
227 
  def setAlert(self, orderId, unset, type, comment):
228 
    """
229 
    Parameters:
230 
     - orderId
231 
     - unset
232 
     - type
233 
     - comment
234 
    """
235 
    pass
236 
 
237 
  def getValidOrderCount(self, ):
238 
    """
239 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
240 
    """
241 
    pass
242 
 
243 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
244 
    """
245 
    Returns the number of distinct customers who have done successful transactions
246 
    """
247 
    pass
248 
 
249 
  def getValidOrdersAmountRange(self, ):
250 
    """
251 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
252 
    List contains two values, first minimum amount and second maximum amount.
253 
    """
254 
    pass
255 
 
256 
  def getValidOrders(self, limit):
257 
    """
258 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
259 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 260 
 
3064 chandransh 261 
    Parameters:
262 
     - limit
263 
    """
264 
    pass
265 
 
1220 chandransh 266 
  def batchOrders(self, warehouseId):
267 
    """
268 
    Create a batch of all the pending orders for the given warehouse.
269 
    The returned list is orderd by created_timestamp.
270 
    If there are no pending orders, an empty list is returned.
3431 rajveer 271 
 
1220 chandransh 272 
    Parameters:
273 
     - warehouseId
274 
    """
275 
    pass
276 
 
1208 chandransh 277 
  def markOrderAsOutOfStock(self, orderId):
278 
    """
279 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 280 
 
1208 chandransh 281 
    Parameters:
282 
     - orderId
283 
    """
284 
    pass
285 
 
3064 chandransh 286 
  def verifyOrder(self, orderId):
759 chandransh 287 
    """
3064 chandransh 288 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
289 
    timestamp. It is intended to be used for COD orders but can be harmlessly
290 
    used for all other orders as well.
291 
    Throws an exception if no such order exists.
3431 rajveer 292 
 
759 chandransh 293 
    Parameters:
3064 chandransh 294 
     - orderId
295 
    """
296 
    pass
297 
 
298 
  def acceptOrder(self, orderId):
299 
    """
300 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
301 
    given order is not a COD order, it also captures the payment if the same has
302 
    not been captured.
303 
    Throws an exception if no such order exists.
3431 rajveer 304 
 
3064 chandransh 305 
    Parameters:
306 
     - orderId
307 
    """
308 
    pass
309 
 
310 
  def billOrder(self, orderId):
311 
    """
312 
    Parameters:
313 
     - orderId
314 
    """
315 
    pass
316 
 
317 
  def addBillingDetails(self, orderId, invoice_number, billed_by):
318 
    """
319 
    Add billing details such as the bill number and the biller to the Order.
320 
    Should be used when the bill is issued by a 3rd party and we've to feed
321 
    the information into our system.
3431 rajveer 322 
 
3064 chandransh 323 
    Parameters:
324 
     - orderId
325 
     - invoice_number
326 
     - billed_by
327 
    """
328 
    pass
329 
 
330 
  def addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
331 
    """
332 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
333 
    the IMEI no. if a -1 is supplied.
334 
    Also, it generates an invoice number for the order, marks the order as
335 
    BILLED and sets the billing timestamp.
336 
    It should be used when we are billing the orders ourselves.
3431 rajveer 337 
 
3064 chandransh 338 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 339 
 
3064 chandransh 340 
    Parameters:
341 
     - orderId
342 
     - jacketNumber
343 
     - imeiNumber
344 
     - itemNumber
345 
     - billedBy
346 
     - billingType
347 
    """
348 
    pass
349 
 
350 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
351 
    """
352 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
353 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 354 
 
3064 chandransh 355 
    Parameters:
759 chandransh 356 
     - warehouseId
357 
     - providerId
3064 chandransh 358 
     - cod
759 chandransh 359 
    """
360 
    pass
361 
 
1113 chandransh 362 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
363 
    """
364 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
365 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
366 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 367 
 
1113 chandransh 368 
    Parameters:
369 
     - providerId
370 
     - pickupDetails
371 
    """
372 
    pass
373 
 
1132 chandransh 374 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
375 
    """
376 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
377 
    the name of the receiver.
378 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 379 
 
1132 chandransh 380 
    Parameters:
381 
     - providerId
382 
     - deliveredOrders
383 
    """
384 
    pass
385 
 
1135 chandransh 386 
  def markOrdersAsFailed(self, providerId, returnedOrders):
387 
    """
388 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
389 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 390 
 
1135 chandransh 391 
    Parameters:
392 
     - providerId
393 
     - returnedOrders
394 
    """
395 
    pass
396 
 
1246 chandransh 397 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
398 
    """
399 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 400 
 
1246 chandransh 401 
    Parameters:
402 
     - providerId
403 
     - undeliveredOrders
404 
    """
405 
    pass
406 
 
1408 ankur.sing 407 
  def getUndeliveredOrders(self, providerId, warehouseId):
408 
    """
409 
    Returns the list of orders whose delivery time has passed but have not been
410 
    delivered yet for the given provider and warehouse. To get a complete list of
411 
    undelivered orders, pass them as -1.
412 
    Returns an empty list if no such orders exist.
3431 rajveer 413 
 
1408 ankur.sing 414 
    Parameters:
415 
     - providerId
416 
     - warehouseId
417 
    """
418 
    pass
419 
 
2536 chandransh 420 
  def toggleDOAFlag(self, orderId):
421 
    """
422 
    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.
423 
    Returns the final flag status.
424 
    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 425 
 
2536 chandransh 426 
    Parameters:
427 
     - orderId
428 
    """
429 
    pass
1886 ankur.sing 430 
 
2536 chandransh 431 
  def requestPickupNumber(self, orderId):
432 
    """
433 
    Sends out an email to the account manager of the original courier provider used to ship the order.
434 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
435 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
436 
    For any other status, it returns false.
437 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 438 
 
2536 chandransh 439 
    Parameters:
440 
     - orderId
441 
    """
442 
    pass
443 
 
444 
  def authorizePickup(self, orderId, pickupNumber):
445 
    """
446 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
447 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
448 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
449 
    	3. Returns true
2591 chandransh 450 
    If the order is in any other status, it returns false.
2536 chandransh 451 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 452 
 
2536 chandransh 453 
    Parameters:
454 
     - orderId
455 
     - pickupNumber
456 
    """
457 
    pass
458 
 
2764 chandransh 459 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
460 
    """
461 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
462 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 463 
 
2764 chandransh 464 
    Parameters:
465 
     - providerId
466 
     - pickupDetails
467 
    """
468 
    pass
469 
 
2616 chandransh 470 
  def receiveReturn(self, orderId):
2591 chandransh 471 
    """
2599 chandransh 472 
    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 473 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 474 
    If the order is in any other state, it returns false.
475 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 476 
 
2591 chandransh 477 
    Parameters:
478 
     - orderId
479 
    """
480 
    pass
2536 chandransh 481 
 
2591 chandransh 482 
  def validateDoa(self, orderId, isValid):
483 
    """
2599 chandransh 484 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 485 
    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 486 
    If the order is in any other state, it returns false.
487 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 488 
 
2591 chandransh 489 
    Parameters:
490 
     - orderId
491 
     - isValid
492 
    """
493 
    pass
494 
 
2616 chandransh 495 
  def reshipOrder(self, orderId):
496 
    """
497 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
498 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
499 
    	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.
500 
 
501 
    If the order is in DOA_CERT_VALID state, it does the following:
502 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
503 
    	2. Creates a return order for the warehouse executive to return the DOA material.
504 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 505 
 
2616 chandransh 506 
    Returns the id of the newly created order.
3431 rajveer 507 
 
2616 chandransh 508 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 509 
 
2616 chandransh 510 
    Parameters:
511 
     - orderId
512 
    """
513 
    pass
2591 chandransh 514 
 
3226 chandransh 515 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 516 
    """
517 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
518 
    	1. Creates a refund request for batch processing.
519 
    	2. Creates a return order for the warehouse executive to return the shipped material.
520 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 521 
 
2616 chandransh 522 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
523 
    	1. Creates a refund request for batch processing.
3226 chandransh 524 
    	2. Cancels the reservation of the item in the warehouse.
525 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 526 
 
3226 chandransh 527 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
528 
    	1. Cancels the reservation of the item in the warehouse.
529 
    	2. Marks the current order as CANCELED.
530 
 
531 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
532 
 
2616 chandransh 533 
    Returns True if it is successful, False otherwise.
3431 rajveer 534 
 
2616 chandransh 535 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 536 
 
2616 chandransh 537 
    Parameters:
538 
     - orderId
3226 chandransh 539 
     - refundedBy
540 
     - reason
2616 chandransh 541 
    """
542 
    pass
543 
 
2690 chandransh 544 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
545 
    """
546 
    Get all return orders created between the from and to dates for the given warehouse.
547 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 548 
 
2690 chandransh 549 
    Parameters:
550 
     - warehouseId
551 
     - fromDate
552 
     - toDate
553 
    """
554 
    pass
2616 chandransh 555 
 
2700 chandransh 556 
  def getReturnOrder(self, id):
557 
    """
558 
    Returns the ReturnOrder corresponding to the given id.
559 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 560 
 
2700 chandransh 561 
    Parameters:
562 
     - id
563 
    """
564 
    pass
565 
 
2690 chandransh 566 
  def processReturn(self, returnOrderId):
567 
    """
568 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 569 
 
2690 chandransh 570 
    Parameters:
571 
     - returnOrderId
572 
    """
573 
    pass
574 
 
2819 chandransh 575 
  def createPurchaseOrder(self, warehouseId):
576 
    """
577 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 578 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 579 
 
2819 chandransh 580 
    Parameters:
581 
     - warehouseId
582 
    """
583 
    pass
2690 chandransh 584 
 
3451 chandransh 585 
  def updateWeight(self, orderId, weight):
586 
    """
587 
    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 588 
 
3451 chandransh 589 
    Parameters:
590 
     - orderId
591 
     - weight
592 
    """
593 
    pass
594 
 
3469 chandransh 595 
  def changeItem(self, orderId, itemId):
596 
    """
597 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
598 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 599 
 
3469 chandransh 600 
    Parameters:
601 
     - orderId
602 
     - itemId
603 
    """
604 
    pass
605 
 
606 
  def shiftToWarehouse(self, orderId, warehouseId):
607 
    """
608 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
609 
 
610 
    Parameters:
611 
     - orderId
612 
     - warehouseId
613 
    """
614 
    pass
615 
 
3986 chandransh 616 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 617 
    """
618 
    Adds the given delay reason to the given order.
3986 chandransh 619 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 620 
    Raises an exception if no order with the given id can be found.
3469 chandransh 621 
 
3553 chandransh 622 
    Parameters:
623 
     - orderId
624 
     - delayReason
3986 chandransh 625 
     - furtherDelay
3553 chandransh 626 
    """
627 
    pass
628 
 
3956 chandransh 629 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
630 
    """
631 
    Marks the COD orders with given AWB nos. as having been processed.
632 
    Updates the captured amount for the corresponding payment.
3553 chandransh 633 
 
3956 chandransh 634 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
635 
    1. There is no order corresponding to an AWB number.
636 
    2. The captured amount for a payment exceeds the total payment.
637 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
638 
 
639 
    Parameters:
640 
     - collectedAmountMap
641 
     - xferBy
642 
     - xferTxnId
643 
     - xferDate
644 
    """
645 
    pass
646 
 
4008 mandeep.dh 647 
  def getTransactionsRequiringExtraProcessing(self, category):
648 
    """
4065 mandeep.dh 649 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 650 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 651 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 652 
 
4008 mandeep.dh 653 
    Parameters:
654 
     - category
655 
    """
656 
    pass
657 
 
658 
  def markTransactionAsProcessed(self, transactionId, category):
659 
    """
660 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 661 
    It essentially deletes the transaction id record for a particular
662 
    processing type category (if present) from DB.
663 
    This is currently used by CRM application.
4008 mandeep.dh 664 
 
665 
    Parameters:
666 
     - transactionId
667 
     - category
668 
    """
669 
    pass
670 
 
4018 chandransh 671 
  def getItemWiseRiskyOrdersCount(self, ):
672 
    """
673 
    Returns a map containing the number of risky orders keyed by item id. A risky order
674 
    is defined as one whose shipping date is about to expire.
675 
    """
676 
    pass
4008 mandeep.dh 677 
 
4247 rajveer 678 
  def markOrderCancellationRequestReceived(self, orderId):
679 
    """
680 
    Mark order as cancellation request received. If customer sends request of cancellation of
681 
    a particular order, this method will be called. It will just change status of the order
682 
    depending on its current status. It also records the previous status, so that we can move
683 
    back to that status if cancellation request is denied.
4018 chandransh 684 
 
4247 rajveer 685 
    Parameters:
686 
     - orderId
687 
    """
688 
    pass
689 
 
690 
  def markOrderCancellationRequestConfirmed(self, orderId):
691 
    """
692 
    If we decide to to cancel order, CRM will call this method to move the status of order to
693 
    cancellation request confirmed. After this OM will be able to cancel the order.
694 
 
695 
    Parameters:
696 
     - orderId
697 
    """
698 
    pass
699 
 
700 
  def markOrderCancellationRequestDenied(self, orderId):
701 
    """
702 
    If we decide to not to cancel order, we will move the order ro previous status.
703 
 
704 
    Parameters:
705 
     - orderId
706 
    """
707 
    pass
708 
 
4258 rajveer 709 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 710 
    """
4258 rajveer 711 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
712 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 713 
 
714 
    Parameters:
4258 rajveer 715 
     - transactionId
4247 rajveer 716 
    """
717 
    pass
718 
 
4259 anupam.sin 719 
  def refundTransaction(self, transactionId, refundedBy, reason):
720 
    """
721 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
722 
    need to be cancelled
4247 rajveer 723 
 
4259 anupam.sin 724 
    Parameters:
725 
     - transactionId
726 
     - refundedBy
727 
     - reason
728 
    """
729 
    pass
730 
 
731 
 
3376 rajveer 732 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 733 
  def __init__(self, iprot, oprot=None):
3376 rajveer 734 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 735 
 
736 
  def createTransaction(self, transaction):
737 
    """
738 
    Parameters:
739 
     - transaction
740 
    """
741 
    self.send_createTransaction(transaction)
132 ashish 742 
    return self.recv_createTransaction()
94 ashish 743 
 
744 
  def send_createTransaction(self, transaction):
745 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
746 
    args = createTransaction_args()
747 
    args.transaction = transaction
748 
    args.write(self._oprot)
749 
    self._oprot.writeMessageEnd()
750 
    self._oprot.trans.flush()
751 
 
752 
  def recv_createTransaction(self, ):
753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
754 
    if mtype == TMessageType.EXCEPTION:
755 
      x = TApplicationException()
756 
      x.read(self._iprot)
757 
      self._iprot.readMessageEnd()
758 
      raise x
759 
    result = createTransaction_result()
760 
    result.read(self._iprot)
761 
    self._iprot.readMessageEnd()
3431 rajveer 762 
    if result.success is not None:
132 ashish 763 
      return result.success
3431 rajveer 764 
    if result.ex is not None:
94 ashish 765 
      raise result.ex
132 ashish 766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 767 
 
768 
  def getTransaction(self, id):
769 
    """
770 
    Parameters:
771 
     - id
772 
    """
773 
    self.send_getTransaction(id)
774 
    return self.recv_getTransaction()
775 
 
776 
  def send_getTransaction(self, id):
777 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
778 
    args = getTransaction_args()
779 
    args.id = id
780 
    args.write(self._oprot)
781 
    self._oprot.writeMessageEnd()
782 
    self._oprot.trans.flush()
783 
 
784 
  def recv_getTransaction(self, ):
785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
786 
    if mtype == TMessageType.EXCEPTION:
787 
      x = TApplicationException()
788 
      x.read(self._iprot)
789 
      self._iprot.readMessageEnd()
790 
      raise x
791 
    result = getTransaction_result()
792 
    result.read(self._iprot)
793 
    self._iprot.readMessageEnd()
3431 rajveer 794 
    if result.success is not None:
94 ashish 795 
      return result.success
3431 rajveer 796 
    if result.ex is not None:
94 ashish 797 
      raise result.ex
798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
799 
 
800 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
801 
    """
802 
    Parameters:
803 
     - customerId
804 
     - from_date
805 
     - to_date
806 
     - status
807 
    """
808 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
809 
    return self.recv_getTransactionsForCustomer()
810 
 
811 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
812 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
813 
    args = getTransactionsForCustomer_args()
814 
    args.customerId = customerId
815 
    args.from_date = from_date
816 
    args.to_date = to_date
817 
    args.status = status
818 
    args.write(self._oprot)
819 
    self._oprot.writeMessageEnd()
820 
    self._oprot.trans.flush()
821 
 
822 
  def recv_getTransactionsForCustomer(self, ):
823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
824 
    if mtype == TMessageType.EXCEPTION:
825 
      x = TApplicationException()
826 
      x.read(self._iprot)
827 
      self._iprot.readMessageEnd()
828 
      raise x
829 
    result = getTransactionsForCustomer_result()
830 
    result.read(self._iprot)
831 
    self._iprot.readMessageEnd()
3431 rajveer 832 
    if result.success is not None:
94 ashish 833 
      return result.success
3431 rajveer 834 
    if result.ex is not None:
94 ashish 835 
      raise result.ex
836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
837 
 
132 ashish 838 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
839 
    """
840 
    Parameters:
841 
     - shoppingCartId
842 
    """
843 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
844 
    return self.recv_getTransactionsForShoppingCartId()
845 
 
846 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
847 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
848 
    args = getTransactionsForShoppingCartId_args()
849 
    args.shoppingCartId = shoppingCartId
850 
    args.write(self._oprot)
851 
    self._oprot.writeMessageEnd()
852 
    self._oprot.trans.flush()
853 
 
854 
  def recv_getTransactionsForShoppingCartId(self, ):
855 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
856 
    if mtype == TMessageType.EXCEPTION:
857 
      x = TApplicationException()
858 
      x.read(self._iprot)
859 
      self._iprot.readMessageEnd()
860 
      raise x
861 
    result = getTransactionsForShoppingCartId_result()
862 
    result.read(self._iprot)
863 
    self._iprot.readMessageEnd()
3431 rajveer 864 
    if result.success is not None:
132 ashish 865 
      return result.success
3431 rajveer 866 
    if result.ex is not None:
132 ashish 867 
      raise result.ex
868 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
869 
 
94 ashish 870 
  def getTransactionStatus(self, transactionId):
871 
    """
872 
    Parameters:
873 
     - transactionId
874 
    """
875 
    self.send_getTransactionStatus(transactionId)
876 
    return self.recv_getTransactionStatus()
877 
 
878 
  def send_getTransactionStatus(self, transactionId):
879 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
880 
    args = getTransactionStatus_args()
881 
    args.transactionId = transactionId
882 
    args.write(self._oprot)
883 
    self._oprot.writeMessageEnd()
884 
    self._oprot.trans.flush()
885 
 
886 
  def recv_getTransactionStatus(self, ):
887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
888 
    if mtype == TMessageType.EXCEPTION:
889 
      x = TApplicationException()
890 
      x.read(self._iprot)
891 
      self._iprot.readMessageEnd()
892 
      raise x
893 
    result = getTransactionStatus_result()
894 
    result.read(self._iprot)
895 
    self._iprot.readMessageEnd()
3431 rajveer 896 
    if result.success is not None:
94 ashish 897 
      return result.success
3431 rajveer 898 
    if result.ex is not None:
94 ashish 899 
      raise result.ex
900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
901 
 
902 
  def changeTransactionStatus(self, transactionId, status, description):
903 
    """
904 
    Parameters:
905 
     - transactionId
906 
     - status
907 
     - description
908 
    """
909 
    self.send_changeTransactionStatus(transactionId, status, description)
910 
    return self.recv_changeTransactionStatus()
911 
 
912 
  def send_changeTransactionStatus(self, transactionId, status, description):
913 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
914 
    args = changeTransactionStatus_args()
915 
    args.transactionId = transactionId
916 
    args.status = status
917 
    args.description = description
918 
    args.write(self._oprot)
919 
    self._oprot.writeMessageEnd()
920 
    self._oprot.trans.flush()
921 
 
922 
  def recv_changeTransactionStatus(self, ):
923 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
924 
    if mtype == TMessageType.EXCEPTION:
925 
      x = TApplicationException()
926 
      x.read(self._iprot)
927 
      self._iprot.readMessageEnd()
928 
      raise x
929 
    result = changeTransactionStatus_result()
930 
    result.read(self._iprot)
931 
    self._iprot.readMessageEnd()
3431 rajveer 932 
    if result.success is not None:
94 ashish 933 
      return result.success
3431 rajveer 934 
    if result.ex is not None:
94 ashish 935 
      raise result.ex
936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
937 
 
1398 varun.gupt 938 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 939 
    """
940 
    Parameters:
941 
     - transactionId
942 
    """
1398 varun.gupt 943 
    self.send_enqueueTransactionInfoEmail(transactionId)
944 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 945 
 
1398 varun.gupt 946 
  def send_enqueueTransactionInfoEmail(self, transactionId):
947 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
948 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 949 
    args.transactionId = transactionId
950 
    args.write(self._oprot)
951 
    self._oprot.writeMessageEnd()
952 
    self._oprot.trans.flush()
953 
 
1398 varun.gupt 954 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
956 
    if mtype == TMessageType.EXCEPTION:
957 
      x = TApplicationException()
958 
      x.read(self._iprot)
959 
      self._iprot.readMessageEnd()
960 
      raise x
1398 varun.gupt 961 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 962 
    result.read(self._iprot)
963 
    self._iprot.readMessageEnd()
3431 rajveer 964 
    if result.success is not None:
1382 varun.gupt 965 
      return result.success
3431 rajveer 966 
    if result.ex is not None:
1382 varun.gupt 967 
      raise result.ex
1398 varun.gupt 968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 969 
 
483 rajveer 970 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 971 
    """
972 
    Parameters:
483 rajveer 973 
     - status
974 
     - from_date
975 
     - to_date
976 
     - warehouse_id
94 ashish 977 
    """
483 rajveer 978 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
979 
    return self.recv_getAllOrders()
94 ashish 980 
 
483 rajveer 981 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
982 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
983 
    args = getAllOrders_args()
984 
    args.status = status
985 
    args.from_date = from_date
986 
    args.to_date = to_date
987 
    args.warehouse_id = warehouse_id
94 ashish 988 
    args.write(self._oprot)
989 
    self._oprot.writeMessageEnd()
990 
    self._oprot.trans.flush()
991 
 
483 rajveer 992 
  def recv_getAllOrders(self, ):
94 ashish 993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
994 
    if mtype == TMessageType.EXCEPTION:
995 
      x = TApplicationException()
996 
      x.read(self._iprot)
997 
      self._iprot.readMessageEnd()
998 
      raise x
483 rajveer 999 
    result = getAllOrders_result()
94 ashish 1000 
    result.read(self._iprot)
1001 
    self._iprot.readMessageEnd()
3431 rajveer 1002 
    if result.success is not None:
94 ashish 1003 
      return result.success
3431 rajveer 1004 
    if result.ex is not None:
94 ashish 1005 
      raise result.ex
483 rajveer 1006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1007 
 
4133 chandransh 1008 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1009 
    """
1010 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1011 
    Pass the status as null and the limit as 0 to ignore them.
1012 
 
1013 
    Parameters:
1014 
     - statuses
1015 
     - offset
1016 
     - limit
1017 
     - warehouse_id
1018 
    """
1019 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1020 
    return self.recv_getOrdersInBatch()
1021 
 
1022 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1023 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1024 
    args = getOrdersInBatch_args()
1025 
    args.statuses = statuses
1026 
    args.offset = offset
1027 
    args.limit = limit
1028 
    args.warehouse_id = warehouse_id
1029 
    args.write(self._oprot)
1030 
    self._oprot.writeMessageEnd()
1031 
    self._oprot.trans.flush()
1032 
 
1033 
  def recv_getOrdersInBatch(self, ):
1034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1035 
    if mtype == TMessageType.EXCEPTION:
1036 
      x = TApplicationException()
1037 
      x.read(self._iprot)
1038 
      self._iprot.readMessageEnd()
1039 
      raise x
1040 
    result = getOrdersInBatch_result()
1041 
    result.read(self._iprot)
1042 
    self._iprot.readMessageEnd()
1043 
    if result.success is not None:
1044 
      return result.success
1045 
    if result.ex is not None:
1046 
      raise result.ex
1047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1048 
 
1049 
  def getOrderCount(self, statuses, warehouseId):
1050 
    """
1051 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1052 
 
1053 
    Parameters:
1054 
     - statuses
1055 
     - warehouseId
1056 
    """
1057 
    self.send_getOrderCount(statuses, warehouseId)
1058 
    return self.recv_getOrderCount()
1059 
 
1060 
  def send_getOrderCount(self, statuses, warehouseId):
1061 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1062 
    args = getOrderCount_args()
1063 
    args.statuses = statuses
1064 
    args.warehouseId = warehouseId
1065 
    args.write(self._oprot)
1066 
    self._oprot.writeMessageEnd()
1067 
    self._oprot.trans.flush()
1068 
 
1069 
  def recv_getOrderCount(self, ):
1070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1071 
    if mtype == TMessageType.EXCEPTION:
1072 
      x = TApplicationException()
1073 
      x.read(self._iprot)
1074 
      self._iprot.readMessageEnd()
1075 
      raise x
1076 
    result = getOrderCount_result()
1077 
    result.read(self._iprot)
1078 
    self._iprot.readMessageEnd()
1079 
    if result.success is not None:
1080 
      return result.success
1081 
    if result.ex is not None:
1082 
      raise result.ex
1083 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1084 
 
999 varun.gupt 1085 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1086 
    """
1132 chandransh 1087 
    Returns orders within a range of their billing dates
3431 rajveer 1088 
 
999 varun.gupt 1089 
    Parameters:
1090 
     - status
1091 
     - start_billing_date
1092 
     - end_billing_date
1093 
     - warehouse_id
1094 
    """
1095 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1096 
    return self.recv_getOrdersByBillingDate()
1097 
 
1098 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1099 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1100 
    args = getOrdersByBillingDate_args()
1101 
    args.status = status
1102 
    args.start_billing_date = start_billing_date
1103 
    args.end_billing_date = end_billing_date
1104 
    args.warehouse_id = warehouse_id
1105 
    args.write(self._oprot)
1106 
    self._oprot.writeMessageEnd()
1107 
    self._oprot.trans.flush()
1108 
 
1109 
  def recv_getOrdersByBillingDate(self, ):
1110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1111 
    if mtype == TMessageType.EXCEPTION:
1112 
      x = TApplicationException()
1113 
      x.read(self._iprot)
1114 
      self._iprot.readMessageEnd()
1115 
      raise x
1116 
    result = getOrdersByBillingDate_result()
1117 
    result.read(self._iprot)
1118 
    self._iprot.readMessageEnd()
3431 rajveer 1119 
    if result.success is not None:
999 varun.gupt 1120 
      return result.success
3431 rajveer 1121 
    if result.ex is not None:
999 varun.gupt 1122 
      raise result.ex
1123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1124 
 
3451 chandransh 1125 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1126 
    """
1127 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1128 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1129 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1130 
 
3427 chandransh 1131 
    Parameters:
1132 
     - fromShippingDate
1133 
     - toShippingDate
1134 
     - providerId
1135 
     - warehouseId
3451 chandransh 1136 
     - cod
3427 chandransh 1137 
    """
3451 chandransh 1138 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1139 
    return self.recv_getOrdersByShippingDate()
1140 
 
3451 chandransh 1141 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1142 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1143 
    args = getOrdersByShippingDate_args()
1144 
    args.fromShippingDate = fromShippingDate
1145 
    args.toShippingDate = toShippingDate
1146 
    args.providerId = providerId
1147 
    args.warehouseId = warehouseId
3451 chandransh 1148 
    args.cod = cod
3427 chandransh 1149 
    args.write(self._oprot)
1150 
    self._oprot.writeMessageEnd()
1151 
    self._oprot.trans.flush()
1152 
 
1153 
  def recv_getOrdersByShippingDate(self, ):
1154 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1155 
    if mtype == TMessageType.EXCEPTION:
1156 
      x = TApplicationException()
1157 
      x.read(self._iprot)
1158 
      self._iprot.readMessageEnd()
1159 
      raise x
1160 
    result = getOrdersByShippingDate_result()
1161 
    result.read(self._iprot)
1162 
    self._iprot.readMessageEnd()
3431 rajveer 1163 
    if result.success is not None:
3427 chandransh 1164 
      return result.success
3431 rajveer 1165 
    if result.ex is not None:
3427 chandransh 1166 
      raise result.ex
1167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1168 
 
1382 varun.gupt 1169 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1170 
    """
1171 
    Returns order ids for orders which can be returned
3431 rajveer 1172 
 
1382 varun.gupt 1173 
    Parameters:
1174 
     - customer_id
1175 
     - limit
1176 
    """
1177 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1178 
    return self.recv_getReturnableOrdersForCustomer()
1179 
 
1180 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1181 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1182 
    args = getReturnableOrdersForCustomer_args()
1183 
    args.customer_id = customer_id
1184 
    args.limit = limit
1185 
    args.write(self._oprot)
1186 
    self._oprot.writeMessageEnd()
1187 
    self._oprot.trans.flush()
1188 
 
1189 
  def recv_getReturnableOrdersForCustomer(self, ):
1190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1191 
    if mtype == TMessageType.EXCEPTION:
1192 
      x = TApplicationException()
1193 
      x.read(self._iprot)
1194 
      self._iprot.readMessageEnd()
1195 
      raise x
1196 
    result = getReturnableOrdersForCustomer_result()
1197 
    result.read(self._iprot)
1198 
    self._iprot.readMessageEnd()
3431 rajveer 1199 
    if result.success is not None:
1382 varun.gupt 1200 
      return result.success
3431 rajveer 1201 
    if result.ex is not None:
1382 varun.gupt 1202 
      raise result.ex
1203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1204 
 
1205 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1206 
    """
1207 
    Returns order ids for orders which can be cancelled
3431 rajveer 1208 
 
1382 varun.gupt 1209 
    Parameters:
1210 
     - customer_id
1211 
     - limit
1212 
    """
1213 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1214 
    return self.recv_getCancellableOrdersForCustomer()
1215 
 
1216 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1217 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1218 
    args = getCancellableOrdersForCustomer_args()
1219 
    args.customer_id = customer_id
1220 
    args.limit = limit
1221 
    args.write(self._oprot)
1222 
    self._oprot.writeMessageEnd()
1223 
    self._oprot.trans.flush()
1224 
 
1225 
  def recv_getCancellableOrdersForCustomer(self, ):
1226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1227 
    if mtype == TMessageType.EXCEPTION:
1228 
      x = TApplicationException()
1229 
      x.read(self._iprot)
1230 
      self._iprot.readMessageEnd()
1231 
      raise x
1232 
    result = getCancellableOrdersForCustomer_result()
1233 
    result.read(self._iprot)
1234 
    self._iprot.readMessageEnd()
3431 rajveer 1235 
    if result.success is not None:
1382 varun.gupt 1236 
      return result.success
3431 rajveer 1237 
    if result.ex is not None:
1382 varun.gupt 1238 
      raise result.ex
1239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1240 
 
483 rajveer 1241 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1242 
    """
1243 
    Parameters:
483 rajveer 1244 
     - orderId
1245 
     - status
1246 
     - description
94 ashish 1247 
    """
483 rajveer 1248 
    self.send_changeOrderStatus(orderId, status, description)
1249 
    return self.recv_changeOrderStatus()
94 ashish 1250 
 
483 rajveer 1251 
  def send_changeOrderStatus(self, orderId, status, description):
1252 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1253 
    args = changeOrderStatus_args()
1254 
    args.orderId = orderId
1255 
    args.status = status
1256 
    args.description = description
94 ashish 1257 
    args.write(self._oprot)
1258 
    self._oprot.writeMessageEnd()
1259 
    self._oprot.trans.flush()
1260 
 
483 rajveer 1261 
  def recv_changeOrderStatus(self, ):
94 ashish 1262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1263 
    if mtype == TMessageType.EXCEPTION:
1264 
      x = TApplicationException()
1265 
      x.read(self._iprot)
1266 
      self._iprot.readMessageEnd()
1267 
      raise x
483 rajveer 1268 
    result = changeOrderStatus_result()
94 ashish 1269 
    result.read(self._iprot)
1270 
    self._iprot.readMessageEnd()
3431 rajveer 1271 
    if result.success is not None:
94 ashish 1272 
      return result.success
3431 rajveer 1273 
    if result.ex is not None:
94 ashish 1274 
      raise result.ex
483 rajveer 1275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1276 
 
1528 ankur.sing 1277 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1278 
    """
1528 ankur.sing 1279 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1280 
    only user who owns the transaction can view its order details.
3431 rajveer 1281 
 
94 ashish 1282 
    Parameters:
1283 
     - transactionId
1528 ankur.sing 1284 
     - customerId
94 ashish 1285 
    """
1528 ankur.sing 1286 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1287 
    return self.recv_getOrdersForTransaction()
94 ashish 1288 
 
1528 ankur.sing 1289 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1290 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1291 
    args = getOrdersForTransaction_args()
94 ashish 1292 
    args.transactionId = transactionId
1528 ankur.sing 1293 
    args.customerId = customerId
94 ashish 1294 
    args.write(self._oprot)
1295 
    self._oprot.writeMessageEnd()
1296 
    self._oprot.trans.flush()
1297 
 
483 rajveer 1298 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1300 
    if mtype == TMessageType.EXCEPTION:
1301 
      x = TApplicationException()
1302 
      x.read(self._iprot)
1303 
      self._iprot.readMessageEnd()
1304 
      raise x
483 rajveer 1305 
    result = getOrdersForTransaction_result()
94 ashish 1306 
    result.read(self._iprot)
1307 
    self._iprot.readMessageEnd()
3431 rajveer 1308 
    if result.success is not None:
94 ashish 1309 
      return result.success
3431 rajveer 1310 
    if result.ex is not None:
94 ashish 1311 
      raise result.ex
483 rajveer 1312 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1313 
 
3014 chandransh 1314 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1315 
    """
3014 chandransh 1316 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1317 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1318 
 
94 ashish 1319 
    Parameters:
483 rajveer 1320 
     - customerId
1321 
     - from_date
1322 
     - to_date
3014 chandransh 1323 
     - statuses
94 ashish 1324 
    """
3014 chandransh 1325 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1326 
    return self.recv_getOrdersForCustomer()
94 ashish 1327 
 
3014 chandransh 1328 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1329 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1330 
    args = getOrdersForCustomer_args()
1331 
    args.customerId = customerId
1332 
    args.from_date = from_date
1333 
    args.to_date = to_date
3014 chandransh 1334 
    args.statuses = statuses
94 ashish 1335 
    args.write(self._oprot)
1336 
    self._oprot.writeMessageEnd()
1337 
    self._oprot.trans.flush()
1338 
 
483 rajveer 1339 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1341 
    if mtype == TMessageType.EXCEPTION:
1342 
      x = TApplicationException()
1343 
      x.read(self._iprot)
1344 
      self._iprot.readMessageEnd()
1345 
      raise x
483 rajveer 1346 
    result = getOrdersForCustomer_result()
94 ashish 1347 
    result.read(self._iprot)
1348 
    self._iprot.readMessageEnd()
3431 rajveer 1349 
    if result.success is not None:
94 ashish 1350 
      return result.success
3431 rajveer 1351 
    if result.ex is not None:
94 ashish 1352 
      raise result.ex
483 rajveer 1353 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1354 
 
483 rajveer 1355 
  def createOrder(self, order):
94 ashish 1356 
    """
1357 
    Parameters:
483 rajveer 1358 
     - order
94 ashish 1359 
    """
483 rajveer 1360 
    self.send_createOrder(order)
1361 
    return self.recv_createOrder()
94 ashish 1362 
 
483 rajveer 1363 
  def send_createOrder(self, order):
1364 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1365 
    args = createOrder_args()
1366 
    args.order = order
94 ashish 1367 
    args.write(self._oprot)
1368 
    self._oprot.writeMessageEnd()
1369 
    self._oprot.trans.flush()
1370 
 
483 rajveer 1371 
  def recv_createOrder(self, ):
94 ashish 1372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1373 
    if mtype == TMessageType.EXCEPTION:
1374 
      x = TApplicationException()
1375 
      x.read(self._iprot)
1376 
      self._iprot.readMessageEnd()
1377 
      raise x
483 rajveer 1378 
    result = createOrder_result()
94 ashish 1379 
    result.read(self._iprot)
1380 
    self._iprot.readMessageEnd()
3431 rajveer 1381 
    if result.success is not None:
94 ashish 1382 
      return result.success
3431 rajveer 1383 
    if result.ex is not None:
94 ashish 1384 
      raise result.ex
483 rajveer 1385 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1386 
 
483 rajveer 1387 
  def getOrder(self, id):
94 ashish 1388 
    """
1389 
    Parameters:
483 rajveer 1390 
     - id
94 ashish 1391 
    """
483 rajveer 1392 
    self.send_getOrder(id)
1393 
    return self.recv_getOrder()
94 ashish 1394 
 
483 rajveer 1395 
  def send_getOrder(self, id):
1396 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1397 
    args = getOrder_args()
1398 
    args.id = id
94 ashish 1399 
    args.write(self._oprot)
1400 
    self._oprot.writeMessageEnd()
1401 
    self._oprot.trans.flush()
1402 
 
483 rajveer 1403 
  def recv_getOrder(self, ):
94 ashish 1404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1405 
    if mtype == TMessageType.EXCEPTION:
1406 
      x = TApplicationException()
1407 
      x.read(self._iprot)
1408 
      self._iprot.readMessageEnd()
1409 
      raise x
483 rajveer 1410 
    result = getOrder_result()
94 ashish 1411 
    result.read(self._iprot)
1412 
    self._iprot.readMessageEnd()
3431 rajveer 1413 
    if result.success is not None:
94 ashish 1414 
      return result.success
3431 rajveer 1415 
    if result.ex is not None:
94 ashish 1416 
      raise result.ex
483 rajveer 1417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1418 
 
483 rajveer 1419 
  def getLineItemsForOrder(self, orderId):
94 ashish 1420 
    """
1421 
    Parameters:
483 rajveer 1422 
     - orderId
94 ashish 1423 
    """
483 rajveer 1424 
    self.send_getLineItemsForOrder(orderId)
1425 
    return self.recv_getLineItemsForOrder()
94 ashish 1426 
 
483 rajveer 1427 
  def send_getLineItemsForOrder(self, orderId):
1428 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1429 
    args = getLineItemsForOrder_args()
1430 
    args.orderId = orderId
94 ashish 1431 
    args.write(self._oprot)
1432 
    self._oprot.writeMessageEnd()
1433 
    self._oprot.trans.flush()
1434 
 
483 rajveer 1435 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1437 
    if mtype == TMessageType.EXCEPTION:
1438 
      x = TApplicationException()
1439 
      x.read(self._iprot)
1440 
      self._iprot.readMessageEnd()
1441 
      raise x
483 rajveer 1442 
    result = getLineItemsForOrder_result()
94 ashish 1443 
    result.read(self._iprot)
1444 
    self._iprot.readMessageEnd()
3431 rajveer 1445 
    if result.success is not None:
94 ashish 1446 
      return result.success
3431 rajveer 1447 
    if result.ex is not None:
94 ashish 1448 
      raise result.ex
483 rajveer 1449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1450 
 
1528 ankur.sing 1451 
  def getOrderForCustomer(self, orderId, customerId):
1452 
    """
1453 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1454 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1455 
 
1528 ankur.sing 1456 
    Parameters:
1457 
     - orderId
1458 
     - customerId
1459 
    """
1460 
    self.send_getOrderForCustomer(orderId, customerId)
1461 
    return self.recv_getOrderForCustomer()
1462 
 
1463 
  def send_getOrderForCustomer(self, orderId, customerId):
1464 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1465 
    args = getOrderForCustomer_args()
1466 
    args.orderId = orderId
1467 
    args.customerId = customerId
1468 
    args.write(self._oprot)
1469 
    self._oprot.writeMessageEnd()
1470 
    self._oprot.trans.flush()
1471 
 
1472 
  def recv_getOrderForCustomer(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 = getOrderForCustomer_result()
1480 
    result.read(self._iprot)
1481 
    self._iprot.readMessageEnd()
3431 rajveer 1482 
    if result.success is not None:
1528 ankur.sing 1483 
      return result.success
3431 rajveer 1484 
    if result.ex is not None:
1528 ankur.sing 1485 
      raise result.ex
1486 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1487 
 
3064 chandransh 1488 
  def getAlerts(self, orderId, valid):
1489 
    """
1490 
    Parameters:
1491 
     - orderId
1492 
     - valid
1493 
    """
1494 
    self.send_getAlerts(orderId, valid)
1495 
    return self.recv_getAlerts()
1496 
 
1497 
  def send_getAlerts(self, orderId, valid):
1498 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1499 
    args = getAlerts_args()
1500 
    args.orderId = orderId
1501 
    args.valid = valid
1502 
    args.write(self._oprot)
1503 
    self._oprot.writeMessageEnd()
1504 
    self._oprot.trans.flush()
1505 
 
1506 
  def recv_getAlerts(self, ):
1507 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1508 
    if mtype == TMessageType.EXCEPTION:
1509 
      x = TApplicationException()
1510 
      x.read(self._iprot)
1511 
      self._iprot.readMessageEnd()
1512 
      raise x
1513 
    result = getAlerts_result()
1514 
    result.read(self._iprot)
1515 
    self._iprot.readMessageEnd()
3431 rajveer 1516 
    if result.success is not None:
3064 chandransh 1517 
      return result.success
1518 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1519 
 
1520 
  def setAlert(self, orderId, unset, type, comment):
1521 
    """
1522 
    Parameters:
1523 
     - orderId
1524 
     - unset
1525 
     - type
1526 
     - comment
1527 
    """
1528 
    self.send_setAlert(orderId, unset, type, comment)
1529 
    self.recv_setAlert()
1530 
 
1531 
  def send_setAlert(self, orderId, unset, type, comment):
1532 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
1533 
    args = setAlert_args()
1534 
    args.orderId = orderId
1535 
    args.unset = unset
1536 
    args.type = type
1537 
    args.comment = comment
1538 
    args.write(self._oprot)
1539 
    self._oprot.writeMessageEnd()
1540 
    self._oprot.trans.flush()
1541 
 
1542 
  def recv_setAlert(self, ):
1543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1544 
    if mtype == TMessageType.EXCEPTION:
1545 
      x = TApplicationException()
1546 
      x.read(self._iprot)
1547 
      self._iprot.readMessageEnd()
1548 
      raise x
1549 
    result = setAlert_result()
1550 
    result.read(self._iprot)
1551 
    self._iprot.readMessageEnd()
1552 
    return
1553 
 
1554 
  def getValidOrderCount(self, ):
1555 
    """
1556 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1557 
    """
1558 
    self.send_getValidOrderCount()
1559 
    return self.recv_getValidOrderCount()
1560 
 
1561 
  def send_getValidOrderCount(self, ):
1562 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1563 
    args = getValidOrderCount_args()
1564 
    args.write(self._oprot)
1565 
    self._oprot.writeMessageEnd()
1566 
    self._oprot.trans.flush()
1567 
 
1568 
  def recv_getValidOrderCount(self, ):
1569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1570 
    if mtype == TMessageType.EXCEPTION:
1571 
      x = TApplicationException()
1572 
      x.read(self._iprot)
1573 
      self._iprot.readMessageEnd()
1574 
      raise x
1575 
    result = getValidOrderCount_result()
1576 
    result.read(self._iprot)
1577 
    self._iprot.readMessageEnd()
3431 rajveer 1578 
    if result.success is not None:
3064 chandransh 1579 
      return result.success
1580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1581 
 
1582 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1583 
    """
1584 
    Returns the number of distinct customers who have done successful transactions
1585 
    """
1586 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1587 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1588 
 
1589 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1590 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1591 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1592 
    args.write(self._oprot)
1593 
    self._oprot.writeMessageEnd()
1594 
    self._oprot.trans.flush()
1595 
 
1596 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1598 
    if mtype == TMessageType.EXCEPTION:
1599 
      x = TApplicationException()
1600 
      x.read(self._iprot)
1601 
      self._iprot.readMessageEnd()
1602 
      raise x
1603 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1604 
    result.read(self._iprot)
1605 
    self._iprot.readMessageEnd()
3431 rajveer 1606 
    if result.success is not None:
3064 chandransh 1607 
      return result.success
1608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1609 
 
1610 
  def getValidOrdersAmountRange(self, ):
1611 
    """
1612 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1613 
    List contains two values, first minimum amount and second maximum amount.
1614 
    """
1615 
    self.send_getValidOrdersAmountRange()
1616 
    return self.recv_getValidOrdersAmountRange()
1617 
 
1618 
  def send_getValidOrdersAmountRange(self, ):
1619 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1620 
    args = getValidOrdersAmountRange_args()
1621 
    args.write(self._oprot)
1622 
    self._oprot.writeMessageEnd()
1623 
    self._oprot.trans.flush()
1624 
 
1625 
  def recv_getValidOrdersAmountRange(self, ):
1626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1627 
    if mtype == TMessageType.EXCEPTION:
1628 
      x = TApplicationException()
1629 
      x.read(self._iprot)
1630 
      self._iprot.readMessageEnd()
1631 
      raise x
1632 
    result = getValidOrdersAmountRange_result()
1633 
    result.read(self._iprot)
1634 
    self._iprot.readMessageEnd()
3431 rajveer 1635 
    if result.success is not None:
3064 chandransh 1636 
      return result.success
1637 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1638 
 
1639 
  def getValidOrders(self, limit):
1640 
    """
1641 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1642 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1643 
 
3064 chandransh 1644 
    Parameters:
1645 
     - limit
1646 
    """
1647 
    self.send_getValidOrders(limit)
1648 
    return self.recv_getValidOrders()
1649 
 
1650 
  def send_getValidOrders(self, limit):
1651 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1652 
    args = getValidOrders_args()
1653 
    args.limit = limit
1654 
    args.write(self._oprot)
1655 
    self._oprot.writeMessageEnd()
1656 
    self._oprot.trans.flush()
1657 
 
1658 
  def recv_getValidOrders(self, ):
1659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1660 
    if mtype == TMessageType.EXCEPTION:
1661 
      x = TApplicationException()
1662 
      x.read(self._iprot)
1663 
      self._iprot.readMessageEnd()
1664 
      raise x
1665 
    result = getValidOrders_result()
1666 
    result.read(self._iprot)
1667 
    self._iprot.readMessageEnd()
3431 rajveer 1668 
    if result.success is not None:
3064 chandransh 1669 
      return result.success
1670 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1671 
 
1220 chandransh 1672 
  def batchOrders(self, warehouseId):
1673 
    """
1674 
    Create a batch of all the pending orders for the given warehouse.
1675 
    The returned list is orderd by created_timestamp.
1676 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1677 
 
1220 chandransh 1678 
    Parameters:
1679 
     - warehouseId
1680 
    """
1681 
    self.send_batchOrders(warehouseId)
1682 
    return self.recv_batchOrders()
1683 
 
1684 
  def send_batchOrders(self, warehouseId):
1685 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1686 
    args = batchOrders_args()
1687 
    args.warehouseId = warehouseId
1688 
    args.write(self._oprot)
1689 
    self._oprot.writeMessageEnd()
1690 
    self._oprot.trans.flush()
1691 
 
1692 
  def recv_batchOrders(self, ):
1693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1694 
    if mtype == TMessageType.EXCEPTION:
1695 
      x = TApplicationException()
1696 
      x.read(self._iprot)
1697 
      self._iprot.readMessageEnd()
1698 
      raise x
1699 
    result = batchOrders_result()
1700 
    result.read(self._iprot)
1701 
    self._iprot.readMessageEnd()
3431 rajveer 1702 
    if result.success is not None:
1220 chandransh 1703 
      return result.success
3431 rajveer 1704 
    if result.ex is not None:
1220 chandransh 1705 
      raise result.ex
1706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1707 
 
1208 chandransh 1708 
  def markOrderAsOutOfStock(self, orderId):
1709 
    """
1710 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1711 
 
1208 chandransh 1712 
    Parameters:
1713 
     - orderId
1714 
    """
1715 
    self.send_markOrderAsOutOfStock(orderId)
1716 
    return self.recv_markOrderAsOutOfStock()
1717 
 
1718 
  def send_markOrderAsOutOfStock(self, orderId):
1719 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1720 
    args = markOrderAsOutOfStock_args()
1721 
    args.orderId = orderId
1722 
    args.write(self._oprot)
1723 
    self._oprot.writeMessageEnd()
1724 
    self._oprot.trans.flush()
1725 
 
1726 
  def recv_markOrderAsOutOfStock(self, ):
1727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1728 
    if mtype == TMessageType.EXCEPTION:
1729 
      x = TApplicationException()
1730 
      x.read(self._iprot)
1731 
      self._iprot.readMessageEnd()
1732 
      raise x
1733 
    result = markOrderAsOutOfStock_result()
1734 
    result.read(self._iprot)
1735 
    self._iprot.readMessageEnd()
3431 rajveer 1736 
    if result.success is not None:
1208 chandransh 1737 
      return result.success
3431 rajveer 1738 
    if result.ex is not None:
1208 chandransh 1739 
      raise result.ex
1740 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1741 
 
3064 chandransh 1742 
  def verifyOrder(self, orderId):
759 chandransh 1743 
    """
3064 chandransh 1744 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1745 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1746 
    used for all other orders as well.
1747 
    Throws an exception if no such order exists.
3431 rajveer 1748 
 
759 chandransh 1749 
    Parameters:
3064 chandransh 1750 
     - orderId
759 chandransh 1751 
    """
3064 chandransh 1752 
    self.send_verifyOrder(orderId)
1753 
    return self.recv_verifyOrder()
759 chandransh 1754 
 
3064 chandransh 1755 
  def send_verifyOrder(self, orderId):
1756 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1757 
    args = verifyOrder_args()
1758 
    args.orderId = orderId
759 chandransh 1759 
    args.write(self._oprot)
1760 
    self._oprot.writeMessageEnd()
1761 
    self._oprot.trans.flush()
1762 
 
3064 chandransh 1763 
  def recv_verifyOrder(self, ):
759 chandransh 1764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1765 
    if mtype == TMessageType.EXCEPTION:
1766 
      x = TApplicationException()
1767 
      x.read(self._iprot)
1768 
      self._iprot.readMessageEnd()
1769 
      raise x
3064 chandransh 1770 
    result = verifyOrder_result()
759 chandransh 1771 
    result.read(self._iprot)
1772 
    self._iprot.readMessageEnd()
3431 rajveer 1773 
    if result.success is not None:
759 chandransh 1774 
      return result.success
3431 rajveer 1775 
    if result.ex is not None:
759 chandransh 1776 
      raise result.ex
3064 chandransh 1777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1778 
 
3064 chandransh 1779 
  def acceptOrder(self, orderId):
1113 chandransh 1780 
    """
3064 chandransh 1781 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1782 
    given order is not a COD order, it also captures the payment if the same has
1783 
    not been captured.
1784 
    Throws an exception if no such order exists.
3431 rajveer 1785 
 
1113 chandransh 1786 
    Parameters:
3064 chandransh 1787 
     - orderId
1113 chandransh 1788 
    """
3064 chandransh 1789 
    self.send_acceptOrder(orderId)
1790 
    return self.recv_acceptOrder()
1113 chandransh 1791 
 
3064 chandransh 1792 
  def send_acceptOrder(self, orderId):
1793 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1794 
    args = acceptOrder_args()
1795 
    args.orderId = orderId
1113 chandransh 1796 
    args.write(self._oprot)
1797 
    self._oprot.writeMessageEnd()
1798 
    self._oprot.trans.flush()
1799 
 
3064 chandransh 1800 
  def recv_acceptOrder(self, ):
1113 chandransh 1801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1802 
    if mtype == TMessageType.EXCEPTION:
1803 
      x = TApplicationException()
1804 
      x.read(self._iprot)
1805 
      self._iprot.readMessageEnd()
1806 
      raise x
3064 chandransh 1807 
    result = acceptOrder_result()
1113 chandransh 1808 
    result.read(self._iprot)
1809 
    self._iprot.readMessageEnd()
3431 rajveer 1810 
    if result.success is not None:
1113 chandransh 1811 
      return result.success
3431 rajveer 1812 
    if result.ex is not None:
1113 chandransh 1813 
      raise result.ex
3064 chandransh 1814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1815 
 
3064 chandransh 1816 
  def billOrder(self, orderId):
1132 chandransh 1817 
    """
1818 
    Parameters:
3064 chandransh 1819 
     - orderId
1132 chandransh 1820 
    """
3064 chandransh 1821 
    self.send_billOrder(orderId)
1822 
    return self.recv_billOrder()
1132 chandransh 1823 
 
3064 chandransh 1824 
  def send_billOrder(self, orderId):
1825 
    self._oprot.writeMessageBegin('billOrder', TMessageType.CALL, self._seqid)
1826 
    args = billOrder_args()
1827 
    args.orderId = orderId
1132 chandransh 1828 
    args.write(self._oprot)
1829 
    self._oprot.writeMessageEnd()
1830 
    self._oprot.trans.flush()
1831 
 
3064 chandransh 1832 
  def recv_billOrder(self, ):
1132 chandransh 1833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1834 
    if mtype == TMessageType.EXCEPTION:
1835 
      x = TApplicationException()
1836 
      x.read(self._iprot)
1837 
      self._iprot.readMessageEnd()
1838 
      raise x
3064 chandransh 1839 
    result = billOrder_result()
1132 chandransh 1840 
    result.read(self._iprot)
1841 
    self._iprot.readMessageEnd()
3431 rajveer 1842 
    if result.success is not None:
3064 chandransh 1843 
      return result.success
3431 rajveer 1844 
    if result.ex is not None:
1132 chandransh 1845 
      raise result.ex
3064 chandransh 1846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "billOrder failed: unknown result");
1132 chandransh 1847 
 
3064 chandransh 1848 
  def addBillingDetails(self, orderId, invoice_number, billed_by):
1135 chandransh 1849 
    """
3064 chandransh 1850 
    Add billing details such as the bill number and the biller to the Order.
1851 
    Should be used when the bill is issued by a 3rd party and we've to feed
1852 
    the information into our system.
3431 rajveer 1853 
 
1135 chandransh 1854 
    Parameters:
3064 chandransh 1855 
     - orderId
1856 
     - invoice_number
1857 
     - billed_by
1135 chandransh 1858 
    """
3064 chandransh 1859 
    self.send_addBillingDetails(orderId, invoice_number, billed_by)
1860 
    return self.recv_addBillingDetails()
1135 chandransh 1861 
 
3064 chandransh 1862 
  def send_addBillingDetails(self, orderId, invoice_number, billed_by):
1863 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1864 
    args = addBillingDetails_args()
1865 
    args.orderId = orderId
1866 
    args.invoice_number = invoice_number
1867 
    args.billed_by = billed_by
1135 chandransh 1868 
    args.write(self._oprot)
1869 
    self._oprot.writeMessageEnd()
1870 
    self._oprot.trans.flush()
1871 
 
3064 chandransh 1872 
  def recv_addBillingDetails(self, ):
1135 chandransh 1873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1874 
    if mtype == TMessageType.EXCEPTION:
1875 
      x = TApplicationException()
1876 
      x.read(self._iprot)
1877 
      self._iprot.readMessageEnd()
1878 
      raise x
3064 chandransh 1879 
    result = addBillingDetails_result()
1135 chandransh 1880 
    result.read(self._iprot)
1881 
    self._iprot.readMessageEnd()
3431 rajveer 1882 
    if result.success is not None:
3064 chandransh 1883 
      return result.success
3431 rajveer 1884 
    if result.ex is not None:
1135 chandransh 1885 
      raise result.ex
3064 chandransh 1886 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 1887 
 
3064 chandransh 1888 
  def addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
1246 chandransh 1889 
    """
3064 chandransh 1890 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1891 
    the IMEI no. if a -1 is supplied.
1892 
    Also, it generates an invoice number for the order, marks the order as
1893 
    BILLED and sets the billing timestamp.
1894 
    It should be used when we are billing the orders ourselves.
3431 rajveer 1895 
 
3064 chandransh 1896 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1897 
 
1246 chandransh 1898 
    Parameters:
3064 chandransh 1899 
     - orderId
1900 
     - jacketNumber
1901 
     - imeiNumber
1902 
     - itemNumber
1903 
     - billedBy
1904 
     - billingType
1246 chandransh 1905 
    """
3064 chandransh 1906 
    self.send_addJacketNumber(orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType)
1907 
    return self.recv_addJacketNumber()
1246 chandransh 1908 
 
3064 chandransh 1909 
  def send_addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
1910 
    self._oprot.writeMessageBegin('addJacketNumber', TMessageType.CALL, self._seqid)
1911 
    args = addJacketNumber_args()
1912 
    args.orderId = orderId
1913 
    args.jacketNumber = jacketNumber
1914 
    args.imeiNumber = imeiNumber
1915 
    args.itemNumber = itemNumber
1916 
    args.billedBy = billedBy
1917 
    args.billingType = billingType
1246 chandransh 1918 
    args.write(self._oprot)
1919 
    self._oprot.writeMessageEnd()
1920 
    self._oprot.trans.flush()
1921 
 
3064 chandransh 1922 
  def recv_addJacketNumber(self, ):
1246 chandransh 1923 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1924 
    if mtype == TMessageType.EXCEPTION:
1925 
      x = TApplicationException()
1926 
      x.read(self._iprot)
1927 
      self._iprot.readMessageEnd()
1928 
      raise x
3064 chandransh 1929 
    result = addJacketNumber_result()
1246 chandransh 1930 
    result.read(self._iprot)
1931 
    self._iprot.readMessageEnd()
3431 rajveer 1932 
    if result.success is not None:
3064 chandransh 1933 
      return result.success
3431 rajveer 1934 
    if result.ex is not None:
1246 chandransh 1935 
      raise result.ex
3064 chandransh 1936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addJacketNumber failed: unknown result");
1246 chandransh 1937 
 
3064 chandransh 1938 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 1939 
    """
3064 chandransh 1940 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
1941 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 1942 
 
1408 ankur.sing 1943 
    Parameters:
3064 chandransh 1944 
     - warehouseId
1408 ankur.sing 1945 
     - providerId
3064 chandransh 1946 
     - cod
1408 ankur.sing 1947 
    """
3064 chandransh 1948 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
1949 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 1950 
 
3064 chandransh 1951 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
1952 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1953 
    args = markOrdersAsManifested_args()
1954 
    args.warehouseId = warehouseId
1408 ankur.sing 1955 
    args.providerId = providerId
3064 chandransh 1956 
    args.cod = cod
1408 ankur.sing 1957 
    args.write(self._oprot)
1958 
    self._oprot.writeMessageEnd()
1959 
    self._oprot.trans.flush()
1960 
 
3064 chandransh 1961 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 1962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1963 
    if mtype == TMessageType.EXCEPTION:
1964 
      x = TApplicationException()
1965 
      x.read(self._iprot)
1966 
      self._iprot.readMessageEnd()
1967 
      raise x
3064 chandransh 1968 
    result = markOrdersAsManifested_result()
1408 ankur.sing 1969 
    result.read(self._iprot)
1970 
    self._iprot.readMessageEnd()
3431 rajveer 1971 
    if result.success is not None:
1408 ankur.sing 1972 
      return result.success
3431 rajveer 1973 
    if result.ex is not None:
3064 chandransh 1974 
      raise result.ex
1975 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 1976 
 
3064 chandransh 1977 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 1978 
    """
3064 chandransh 1979 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
1980 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
1981 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1982 
 
94 ashish 1983 
    Parameters:
3064 chandransh 1984 
     - providerId
1985 
     - pickupDetails
304 ashish 1986 
    """
3064 chandransh 1987 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
1988 
    return self.recv_markOrdersAsPickedUp()
94 ashish 1989 
 
3064 chandransh 1990 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
1991 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
1992 
    args = markOrdersAsPickedUp_args()
1993 
    args.providerId = providerId
1994 
    args.pickupDetails = pickupDetails
304 ashish 1995 
    args.write(self._oprot)
1996 
    self._oprot.writeMessageEnd()
1997 
    self._oprot.trans.flush()
1998 
 
3064 chandransh 1999 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2001 
    if mtype == TMessageType.EXCEPTION:
2002 
      x = TApplicationException()
2003 
      x.read(self._iprot)
2004 
      self._iprot.readMessageEnd()
2005 
      raise x
3064 chandransh 2006 
    result = markOrdersAsPickedUp_result()
304 ashish 2007 
    result.read(self._iprot)
2008 
    self._iprot.readMessageEnd()
3431 rajveer 2009 
    if result.success is not None:
304 ashish 2010 
      return result.success
3431 rajveer 2011 
    if result.ex is not None:
3064 chandransh 2012 
      raise result.ex
2013 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2014 
 
3064 chandransh 2015 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2016 
    """
3064 chandransh 2017 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2018 
    the name of the receiver.
2019 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2020 
 
304 ashish 2021 
    Parameters:
3064 chandransh 2022 
     - providerId
2023 
     - deliveredOrders
304 ashish 2024 
    """
3064 chandransh 2025 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2026 
    self.recv_markOrdersAsDelivered()
304 ashish 2027 
 
3064 chandransh 2028 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2029 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2030 
    args = markOrdersAsDelivered_args()
2031 
    args.providerId = providerId
2032 
    args.deliveredOrders = deliveredOrders
304 ashish 2033 
    args.write(self._oprot)
2034 
    self._oprot.writeMessageEnd()
2035 
    self._oprot.trans.flush()
2036 
 
3064 chandransh 2037 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2039 
    if mtype == TMessageType.EXCEPTION:
2040 
      x = TApplicationException()
2041 
      x.read(self._iprot)
2042 
      self._iprot.readMessageEnd()
2043 
      raise x
3064 chandransh 2044 
    result = markOrdersAsDelivered_result()
304 ashish 2045 
    result.read(self._iprot)
2046 
    self._iprot.readMessageEnd()
3431 rajveer 2047 
    if result.ex is not None:
3064 chandransh 2048 
      raise result.ex
304 ashish 2049 
    return
2050 
 
3064 chandransh 2051 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2052 
    """
3064 chandransh 2053 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2054 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2055 
 
3064 chandransh 2056 
    Parameters:
2057 
     - providerId
2058 
     - returnedOrders
1596 ankur.sing 2059 
    """
3064 chandransh 2060 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2061 
    self.recv_markOrdersAsFailed()
304 ashish 2062 
 
3064 chandransh 2063 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2064 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2065 
    args = markOrdersAsFailed_args()
2066 
    args.providerId = providerId
2067 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2068 
    args.write(self._oprot)
2069 
    self._oprot.writeMessageEnd()
2070 
    self._oprot.trans.flush()
2071 
 
3064 chandransh 2072 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2074 
    if mtype == TMessageType.EXCEPTION:
2075 
      x = TApplicationException()
2076 
      x.read(self._iprot)
2077 
      self._iprot.readMessageEnd()
2078 
      raise x
3064 chandransh 2079 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2080 
    result.read(self._iprot)
2081 
    self._iprot.readMessageEnd()
3431 rajveer 2082 
    if result.ex is not None:
3064 chandransh 2083 
      raise result.ex
2084 
    return
1596 ankur.sing 2085 
 
3064 chandransh 2086 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2087 
    """
3064 chandransh 2088 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2089 
 
3064 chandransh 2090 
    Parameters:
2091 
     - providerId
2092 
     - undeliveredOrders
1627 ankur.sing 2093 
    """
3064 chandransh 2094 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2095 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2096 
 
3064 chandransh 2097 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2098 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2099 
    args = updateNonDeliveryReason_args()
2100 
    args.providerId = providerId
2101 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2102 
    args.write(self._oprot)
2103 
    self._oprot.writeMessageEnd()
2104 
    self._oprot.trans.flush()
2105 
 
3064 chandransh 2106 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2108 
    if mtype == TMessageType.EXCEPTION:
2109 
      x = TApplicationException()
2110 
      x.read(self._iprot)
2111 
      self._iprot.readMessageEnd()
2112 
      raise x
3064 chandransh 2113 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2114 
    result.read(self._iprot)
2115 
    self._iprot.readMessageEnd()
3431 rajveer 2116 
    if result.ex is not None:
3064 chandransh 2117 
      raise result.ex
2118 
    return
1627 ankur.sing 2119 
 
3064 chandransh 2120 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2121 
    """
3064 chandransh 2122 
    Returns the list of orders whose delivery time has passed but have not been
2123 
    delivered yet for the given provider and warehouse. To get a complete list of
2124 
    undelivered orders, pass them as -1.
2125 
    Returns an empty list if no such orders exist.
3431 rajveer 2126 
 
1886 ankur.sing 2127 
    Parameters:
3064 chandransh 2128 
     - providerId
2129 
     - warehouseId
1886 ankur.sing 2130 
    """
3064 chandransh 2131 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2132 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2133 
 
3064 chandransh 2134 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2135 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2136 
    args = getUndeliveredOrders_args()
2137 
    args.providerId = providerId
2138 
    args.warehouseId = warehouseId
1886 ankur.sing 2139 
    args.write(self._oprot)
2140 
    self._oprot.writeMessageEnd()
2141 
    self._oprot.trans.flush()
2142 
 
3064 chandransh 2143 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2145 
    if mtype == TMessageType.EXCEPTION:
2146 
      x = TApplicationException()
2147 
      x.read(self._iprot)
2148 
      self._iprot.readMessageEnd()
2149 
      raise x
3064 chandransh 2150 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2151 
    result.read(self._iprot)
2152 
    self._iprot.readMessageEnd()
3431 rajveer 2153 
    if result.success is not None:
1886 ankur.sing 2154 
      return result.success
3064 chandransh 2155 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2156 
 
2536 chandransh 2157 
  def toggleDOAFlag(self, orderId):
2158 
    """
2159 
    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.
2160 
    Returns the final flag status.
2161 
    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 2162 
 
2536 chandransh 2163 
    Parameters:
2164 
     - orderId
2165 
    """
2166 
    self.send_toggleDOAFlag(orderId)
2167 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2168 
 
2536 chandransh 2169 
  def send_toggleDOAFlag(self, orderId):
2170 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2171 
    args = toggleDOAFlag_args()
2172 
    args.orderId = orderId
2173 
    args.write(self._oprot)
2174 
    self._oprot.writeMessageEnd()
2175 
    self._oprot.trans.flush()
2176 
 
2177 
  def recv_toggleDOAFlag(self, ):
2178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2179 
    if mtype == TMessageType.EXCEPTION:
2180 
      x = TApplicationException()
2181 
      x.read(self._iprot)
2182 
      self._iprot.readMessageEnd()
2183 
      raise x
2184 
    result = toggleDOAFlag_result()
2185 
    result.read(self._iprot)
2186 
    self._iprot.readMessageEnd()
3431 rajveer 2187 
    if result.success is not None:
2536 chandransh 2188 
      return result.success
3431 rajveer 2189 
    if result.ex is not None:
2536 chandransh 2190 
      raise result.ex
2191 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2192 
 
2193 
  def requestPickupNumber(self, orderId):
2194 
    """
2195 
    Sends out an email to the account manager of the original courier provider used to ship the order.
2196 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
2197 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
2198 
    For any other status, it returns false.
2199 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2200 
 
2536 chandransh 2201 
    Parameters:
2202 
     - orderId
2203 
    """
2204 
    self.send_requestPickupNumber(orderId)
2205 
    return self.recv_requestPickupNumber()
2206 
 
2207 
  def send_requestPickupNumber(self, orderId):
2208 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2209 
    args = requestPickupNumber_args()
2210 
    args.orderId = orderId
2211 
    args.write(self._oprot)
2212 
    self._oprot.writeMessageEnd()
2213 
    self._oprot.trans.flush()
2214 
 
2215 
  def recv_requestPickupNumber(self, ):
2216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2217 
    if mtype == TMessageType.EXCEPTION:
2218 
      x = TApplicationException()
2219 
      x.read(self._iprot)
2220 
      self._iprot.readMessageEnd()
2221 
      raise x
2222 
    result = requestPickupNumber_result()
2223 
    result.read(self._iprot)
2224 
    self._iprot.readMessageEnd()
3431 rajveer 2225 
    if result.success is not None:
2536 chandransh 2226 
      return result.success
3431 rajveer 2227 
    if result.ex is not None:
2536 chandransh 2228 
      raise result.ex
2229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2230 
 
2231 
  def authorizePickup(self, orderId, pickupNumber):
2232 
    """
2233 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
2234 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2235 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2236 
    	3. Returns true
2591 chandransh 2237 
    If the order is in any other status, it returns false.
2536 chandransh 2238 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2239 
 
2536 chandransh 2240 
    Parameters:
2241 
     - orderId
2242 
     - pickupNumber
2243 
    """
2244 
    self.send_authorizePickup(orderId, pickupNumber)
2245 
    return self.recv_authorizePickup()
2246 
 
2247 
  def send_authorizePickup(self, orderId, pickupNumber):
2248 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2249 
    args = authorizePickup_args()
2250 
    args.orderId = orderId
2251 
    args.pickupNumber = pickupNumber
2252 
    args.write(self._oprot)
2253 
    self._oprot.writeMessageEnd()
2254 
    self._oprot.trans.flush()
2255 
 
2256 
  def recv_authorizePickup(self, ):
2257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2258 
    if mtype == TMessageType.EXCEPTION:
2259 
      x = TApplicationException()
2260 
      x.read(self._iprot)
2261 
      self._iprot.readMessageEnd()
2262 
      raise x
2263 
    result = authorizePickup_result()
2264 
    result.read(self._iprot)
2265 
    self._iprot.readMessageEnd()
3431 rajveer 2266 
    if result.success is not None:
2536 chandransh 2267 
      return result.success
3431 rajveer 2268 
    if result.ex is not None:
2536 chandransh 2269 
      raise result.ex
2270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2271 
 
2764 chandransh 2272 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2273 
    """
2274 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2275 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2276 
 
2764 chandransh 2277 
    Parameters:
2278 
     - providerId
2279 
     - pickupDetails
2280 
    """
2281 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2282 
    return self.recv_markDoasAsPickedUp()
2283 
 
2284 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2285 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2286 
    args = markDoasAsPickedUp_args()
2287 
    args.providerId = providerId
2288 
    args.pickupDetails = pickupDetails
2289 
    args.write(self._oprot)
2290 
    self._oprot.writeMessageEnd()
2291 
    self._oprot.trans.flush()
2292 
 
2293 
  def recv_markDoasAsPickedUp(self, ):
2294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2295 
    if mtype == TMessageType.EXCEPTION:
2296 
      x = TApplicationException()
2297 
      x.read(self._iprot)
2298 
      self._iprot.readMessageEnd()
2299 
      raise x
2300 
    result = markDoasAsPickedUp_result()
2301 
    result.read(self._iprot)
2302 
    self._iprot.readMessageEnd()
3431 rajveer 2303 
    if result.success is not None:
2764 chandransh 2304 
      return result.success
2305 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2306 
 
2616 chandransh 2307 
  def receiveReturn(self, orderId):
2591 chandransh 2308 
    """
2599 chandransh 2309 
    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 2310 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 2311 
    If the order is in any other state, it returns false.
2312 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2313 
 
2591 chandransh 2314 
    Parameters:
2315 
     - orderId
2316 
    """
2616 chandransh 2317 
    self.send_receiveReturn(orderId)
2318 
    return self.recv_receiveReturn()
2536 chandransh 2319 
 
2616 chandransh 2320 
  def send_receiveReturn(self, orderId):
2321 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2322 
    args = receiveReturn_args()
2591 chandransh 2323 
    args.orderId = orderId
2324 
    args.write(self._oprot)
2325 
    self._oprot.writeMessageEnd()
2326 
    self._oprot.trans.flush()
2327 
 
2616 chandransh 2328 
  def recv_receiveReturn(self, ):
2591 chandransh 2329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2330 
    if mtype == TMessageType.EXCEPTION:
2331 
      x = TApplicationException()
2332 
      x.read(self._iprot)
2333 
      self._iprot.readMessageEnd()
2334 
      raise x
2616 chandransh 2335 
    result = receiveReturn_result()
2591 chandransh 2336 
    result.read(self._iprot)
2337 
    self._iprot.readMessageEnd()
3431 rajveer 2338 
    if result.success is not None:
2591 chandransh 2339 
      return result.success
3431 rajveer 2340 
    if result.ex is not None:
2591 chandransh 2341 
      raise result.ex
2616 chandransh 2342 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2343 
 
2344 
  def validateDoa(self, orderId, isValid):
2345 
    """
2599 chandransh 2346 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 2347 
    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 2348 
    If the order is in any other state, it returns false.
2349 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2350 
 
2591 chandransh 2351 
    Parameters:
2352 
     - orderId
2353 
     - isValid
2354 
    """
2355 
    self.send_validateDoa(orderId, isValid)
2356 
    return self.recv_validateDoa()
2357 
 
2358 
  def send_validateDoa(self, orderId, isValid):
2359 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2360 
    args = validateDoa_args()
2361 
    args.orderId = orderId
2362 
    args.isValid = isValid
2363 
    args.write(self._oprot)
2364 
    self._oprot.writeMessageEnd()
2365 
    self._oprot.trans.flush()
2366 
 
2367 
  def recv_validateDoa(self, ):
2368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2369 
    if mtype == TMessageType.EXCEPTION:
2370 
      x = TApplicationException()
2371 
      x.read(self._iprot)
2372 
      self._iprot.readMessageEnd()
2373 
      raise x
2374 
    result = validateDoa_result()
2375 
    result.read(self._iprot)
2376 
    self._iprot.readMessageEnd()
3431 rajveer 2377 
    if result.success is not None:
2591 chandransh 2378 
      return result.success
3431 rajveer 2379 
    if result.ex is not None:
2591 chandransh 2380 
      raise result.ex
2381 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2382 
 
2616 chandransh 2383 
  def reshipOrder(self, orderId):
2384 
    """
2385 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2386 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2387 
    	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.
2388 
 
2389 
    If the order is in DOA_CERT_VALID state, it does the following:
2390 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2391 
    	2. Creates a return order for the warehouse executive to return the DOA material.
2392 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 2393 
 
2616 chandransh 2394 
    Returns the id of the newly created order.
3431 rajveer 2395 
 
2616 chandransh 2396 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2397 
 
2616 chandransh 2398 
    Parameters:
2399 
     - orderId
2400 
    """
2401 
    self.send_reshipOrder(orderId)
2402 
    return self.recv_reshipOrder()
2591 chandransh 2403 
 
2616 chandransh 2404 
  def send_reshipOrder(self, orderId):
2405 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2406 
    args = reshipOrder_args()
2407 
    args.orderId = orderId
2408 
    args.write(self._oprot)
2409 
    self._oprot.writeMessageEnd()
2410 
    self._oprot.trans.flush()
2411 
 
2412 
  def recv_reshipOrder(self, ):
2413 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2414 
    if mtype == TMessageType.EXCEPTION:
2415 
      x = TApplicationException()
2416 
      x.read(self._iprot)
2417 
      self._iprot.readMessageEnd()
2418 
      raise x
2419 
    result = reshipOrder_result()
2420 
    result.read(self._iprot)
2421 
    self._iprot.readMessageEnd()
3431 rajveer 2422 
    if result.success is not None:
2616 chandransh 2423 
      return result.success
3431 rajveer 2424 
    if result.ex is not None:
2616 chandransh 2425 
      raise result.ex
2426 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2427 
 
3226 chandransh 2428 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2429 
    """
2430 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2431 
    	1. Creates a refund request for batch processing.
2432 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2433 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2434 
 
2616 chandransh 2435 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2436 
    	1. Creates a refund request for batch processing.
3226 chandransh 2437 
    	2. Cancels the reservation of the item in the warehouse.
2438 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2439 
 
3226 chandransh 2440 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2441 
    	1. Cancels the reservation of the item in the warehouse.
2442 
    	2. Marks the current order as CANCELED.
2443 
 
2444 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2445 
 
2616 chandransh 2446 
    Returns True if it is successful, False otherwise.
3431 rajveer 2447 
 
2616 chandransh 2448 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2449 
 
2616 chandransh 2450 
    Parameters:
2451 
     - orderId
3226 chandransh 2452 
     - refundedBy
2453 
     - reason
2616 chandransh 2454 
    """
3226 chandransh 2455 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2456 
    return self.recv_refundOrder()
2457 
 
3226 chandransh 2458 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2459 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2460 
    args = refundOrder_args()
2461 
    args.orderId = orderId
3226 chandransh 2462 
    args.refundedBy = refundedBy
2463 
    args.reason = reason
2616 chandransh 2464 
    args.write(self._oprot)
2465 
    self._oprot.writeMessageEnd()
2466 
    self._oprot.trans.flush()
2467 
 
2468 
  def recv_refundOrder(self, ):
2469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2470 
    if mtype == TMessageType.EXCEPTION:
2471 
      x = TApplicationException()
2472 
      x.read(self._iprot)
2473 
      self._iprot.readMessageEnd()
2474 
      raise x
2475 
    result = refundOrder_result()
2476 
    result.read(self._iprot)
2477 
    self._iprot.readMessageEnd()
3431 rajveer 2478 
    if result.success is not None:
2616 chandransh 2479 
      return result.success
3431 rajveer 2480 
    if result.ex is not None:
2616 chandransh 2481 
      raise result.ex
2482 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2483 
 
2690 chandransh 2484 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2485 
    """
2486 
    Get all return orders created between the from and to dates for the given warehouse.
2487 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2488 
 
2690 chandransh 2489 
    Parameters:
2490 
     - warehouseId
2491 
     - fromDate
2492 
     - toDate
2493 
    """
2494 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2495 
    return self.recv_getReturnOrders()
2616 chandransh 2496 
 
2690 chandransh 2497 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2498 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2499 
    args = getReturnOrders_args()
2500 
    args.warehouseId = warehouseId
2501 
    args.fromDate = fromDate
2502 
    args.toDate = toDate
2503 
    args.write(self._oprot)
2504 
    self._oprot.writeMessageEnd()
2505 
    self._oprot.trans.flush()
2506 
 
2507 
  def recv_getReturnOrders(self, ):
2508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2509 
    if mtype == TMessageType.EXCEPTION:
2510 
      x = TApplicationException()
2511 
      x.read(self._iprot)
2512 
      self._iprot.readMessageEnd()
2513 
      raise x
2514 
    result = getReturnOrders_result()
2515 
    result.read(self._iprot)
2516 
    self._iprot.readMessageEnd()
3431 rajveer 2517 
    if result.success is not None:
2690 chandransh 2518 
      return result.success
2519 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2520 
 
2700 chandransh 2521 
  def getReturnOrder(self, id):
2522 
    """
2523 
    Returns the ReturnOrder corresponding to the given id.
2524 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2525 
 
2700 chandransh 2526 
    Parameters:
2527 
     - id
2528 
    """
2529 
    self.send_getReturnOrder(id)
2530 
    return self.recv_getReturnOrder()
2531 
 
2532 
  def send_getReturnOrder(self, id):
2533 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2534 
    args = getReturnOrder_args()
2535 
    args.id = id
2536 
    args.write(self._oprot)
2537 
    self._oprot.writeMessageEnd()
2538 
    self._oprot.trans.flush()
2539 
 
2540 
  def recv_getReturnOrder(self, ):
2541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2542 
    if mtype == TMessageType.EXCEPTION:
2543 
      x = TApplicationException()
2544 
      x.read(self._iprot)
2545 
      self._iprot.readMessageEnd()
2546 
      raise x
2547 
    result = getReturnOrder_result()
2548 
    result.read(self._iprot)
2549 
    self._iprot.readMessageEnd()
3431 rajveer 2550 
    if result.success is not None:
2700 chandransh 2551 
      return result.success
3431 rajveer 2552 
    if result.ex is not None:
2700 chandransh 2553 
      raise result.ex
2554 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2555 
 
2690 chandransh 2556 
  def processReturn(self, returnOrderId):
2557 
    """
2558 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2559 
 
2690 chandransh 2560 
    Parameters:
2561 
     - returnOrderId
2562 
    """
2563 
    self.send_processReturn(returnOrderId)
2564 
    self.recv_processReturn()
2565 
 
2566 
  def send_processReturn(self, returnOrderId):
2567 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2568 
    args = processReturn_args()
2569 
    args.returnOrderId = returnOrderId
2570 
    args.write(self._oprot)
2571 
    self._oprot.writeMessageEnd()
2572 
    self._oprot.trans.flush()
2573 
 
2574 
  def recv_processReturn(self, ):
2575 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2576 
    if mtype == TMessageType.EXCEPTION:
2577 
      x = TApplicationException()
2578 
      x.read(self._iprot)
2579 
      self._iprot.readMessageEnd()
2580 
      raise x
2581 
    result = processReturn_result()
2582 
    result.read(self._iprot)
2583 
    self._iprot.readMessageEnd()
3431 rajveer 2584 
    if result.ex is not None:
2690 chandransh 2585 
      raise result.ex
2586 
    return
2587 
 
2819 chandransh 2588 
  def createPurchaseOrder(self, warehouseId):
2589 
    """
2590 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2591 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2592 
 
2819 chandransh 2593 
    Parameters:
2594 
     - warehouseId
2595 
    """
2596 
    self.send_createPurchaseOrder(warehouseId)
2597 
    return self.recv_createPurchaseOrder()
2690 chandransh 2598 
 
2819 chandransh 2599 
  def send_createPurchaseOrder(self, warehouseId):
2600 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2601 
    args = createPurchaseOrder_args()
2602 
    args.warehouseId = warehouseId
2603 
    args.write(self._oprot)
2604 
    self._oprot.writeMessageEnd()
2605 
    self._oprot.trans.flush()
2606 
 
2607 
  def recv_createPurchaseOrder(self, ):
2608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2609 
    if mtype == TMessageType.EXCEPTION:
2610 
      x = TApplicationException()
2611 
      x.read(self._iprot)
2612 
      self._iprot.readMessageEnd()
2613 
      raise x
2614 
    result = createPurchaseOrder_result()
2615 
    result.read(self._iprot)
2616 
    self._iprot.readMessageEnd()
3431 rajveer 2617 
    if result.success is not None:
2819 chandransh 2618 
      return result.success
3431 rajveer 2619 
    if result.ex is not None:
2819 chandransh 2620 
      raise result.ex
2621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2622 
 
3451 chandransh 2623 
  def updateWeight(self, orderId, weight):
2624 
    """
2625 
    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 2626 
 
3451 chandransh 2627 
    Parameters:
2628 
     - orderId
2629 
     - weight
2630 
    """
2631 
    self.send_updateWeight(orderId, weight)
2632 
    return self.recv_updateWeight()
2633 
 
2634 
  def send_updateWeight(self, orderId, weight):
2635 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2636 
    args = updateWeight_args()
2637 
    args.orderId = orderId
2638 
    args.weight = weight
2639 
    args.write(self._oprot)
2640 
    self._oprot.writeMessageEnd()
2641 
    self._oprot.trans.flush()
2642 
 
2643 
  def recv_updateWeight(self, ):
2644 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2645 
    if mtype == TMessageType.EXCEPTION:
2646 
      x = TApplicationException()
2647 
      x.read(self._iprot)
2648 
      self._iprot.readMessageEnd()
2649 
      raise x
2650 
    result = updateWeight_result()
2651 
    result.read(self._iprot)
2652 
    self._iprot.readMessageEnd()
2653 
    if result.success is not None:
2654 
      return result.success
2655 
    if result.ex is not None:
2656 
      raise result.ex
2657 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2658 
 
3469 chandransh 2659 
  def changeItem(self, orderId, itemId):
2660 
    """
2661 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2662 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2663 
 
3469 chandransh 2664 
    Parameters:
2665 
     - orderId
2666 
     - itemId
2667 
    """
2668 
    self.send_changeItem(orderId, itemId)
2669 
    return self.recv_changeItem()
2670 
 
2671 
  def send_changeItem(self, orderId, itemId):
2672 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2673 
    args = changeItem_args()
2674 
    args.orderId = orderId
2675 
    args.itemId = itemId
2676 
    args.write(self._oprot)
2677 
    self._oprot.writeMessageEnd()
2678 
    self._oprot.trans.flush()
2679 
 
2680 
  def recv_changeItem(self, ):
2681 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2682 
    if mtype == TMessageType.EXCEPTION:
2683 
      x = TApplicationException()
2684 
      x.read(self._iprot)
2685 
      self._iprot.readMessageEnd()
2686 
      raise x
2687 
    result = changeItem_result()
2688 
    result.read(self._iprot)
2689 
    self._iprot.readMessageEnd()
2690 
    if result.success is not None:
2691 
      return result.success
2692 
    if result.ex is not None:
2693 
      raise result.ex
2694 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2695 
 
2696 
  def shiftToWarehouse(self, orderId, warehouseId):
2697 
    """
2698 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2699 
 
2700 
    Parameters:
2701 
     - orderId
2702 
     - warehouseId
2703 
    """
2704 
    self.send_shiftToWarehouse(orderId, warehouseId)
2705 
    return self.recv_shiftToWarehouse()
2706 
 
2707 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2708 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2709 
    args = shiftToWarehouse_args()
2710 
    args.orderId = orderId
2711 
    args.warehouseId = warehouseId
2712 
    args.write(self._oprot)
2713 
    self._oprot.writeMessageEnd()
2714 
    self._oprot.trans.flush()
2715 
 
2716 
  def recv_shiftToWarehouse(self, ):
2717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2718 
    if mtype == TMessageType.EXCEPTION:
2719 
      x = TApplicationException()
2720 
      x.read(self._iprot)
2721 
      self._iprot.readMessageEnd()
2722 
      raise x
2723 
    result = shiftToWarehouse_result()
2724 
    result.read(self._iprot)
2725 
    self._iprot.readMessageEnd()
2726 
    if result.success is not None:
2727 
      return result.success
2728 
    if result.ex is not None:
2729 
      raise result.ex
2730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
2731 
 
3986 chandransh 2732 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2733 
    """
2734 
    Adds the given delay reason to the given order.
3986 chandransh 2735 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 2736 
    Raises an exception if no order with the given id can be found.
3469 chandransh 2737 
 
3553 chandransh 2738 
    Parameters:
2739 
     - orderId
2740 
     - delayReason
3986 chandransh 2741 
     - furtherDelay
3553 chandransh 2742 
    """
3986 chandransh 2743 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 2744 
    return self.recv_addDelayReason()
2745 
 
3986 chandransh 2746 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2747 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
2748 
    args = addDelayReason_args()
2749 
    args.orderId = orderId
2750 
    args.delayReason = delayReason
3986 chandransh 2751 
    args.furtherDelay = furtherDelay
3553 chandransh 2752 
    args.write(self._oprot)
2753 
    self._oprot.writeMessageEnd()
2754 
    self._oprot.trans.flush()
2755 
 
2756 
  def recv_addDelayReason(self, ):
2757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2758 
    if mtype == TMessageType.EXCEPTION:
2759 
      x = TApplicationException()
2760 
      x.read(self._iprot)
2761 
      self._iprot.readMessageEnd()
2762 
      raise x
2763 
    result = addDelayReason_result()
2764 
    result.read(self._iprot)
2765 
    self._iprot.readMessageEnd()
2766 
    if result.success is not None:
2767 
      return result.success
2768 
    if result.ex is not None:
2769 
      raise result.ex
2770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
2771 
 
3956 chandransh 2772 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2773 
    """
2774 
    Marks the COD orders with given AWB nos. as having been processed.
2775 
    Updates the captured amount for the corresponding payment.
3553 chandransh 2776 
 
3956 chandransh 2777 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
2778 
    1. There is no order corresponding to an AWB number.
2779 
    2. The captured amount for a payment exceeds the total payment.
2780 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
2781 
 
2782 
    Parameters:
2783 
     - collectedAmountMap
2784 
     - xferBy
2785 
     - xferTxnId
2786 
     - xferDate
2787 
    """
2788 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
2789 
    return self.recv_reconcileCodCollection()
2790 
 
2791 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2792 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
2793 
    args = reconcileCodCollection_args()
2794 
    args.collectedAmountMap = collectedAmountMap
2795 
    args.xferBy = xferBy
2796 
    args.xferTxnId = xferTxnId
2797 
    args.xferDate = xferDate
2798 
    args.write(self._oprot)
2799 
    self._oprot.writeMessageEnd()
2800 
    self._oprot.trans.flush()
2801 
 
2802 
  def recv_reconcileCodCollection(self, ):
2803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2804 
    if mtype == TMessageType.EXCEPTION:
2805 
      x = TApplicationException()
2806 
      x.read(self._iprot)
2807 
      self._iprot.readMessageEnd()
2808 
      raise x
2809 
    result = reconcileCodCollection_result()
2810 
    result.read(self._iprot)
2811 
    self._iprot.readMessageEnd()
2812 
    if result.success is not None:
2813 
      return result.success
2814 
    if result.ex is not None:
2815 
      raise result.ex
2816 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
2817 
 
4008 mandeep.dh 2818 
  def getTransactionsRequiringExtraProcessing(self, category):
2819 
    """
4065 mandeep.dh 2820 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 2821 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 2822 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 2823 
 
4008 mandeep.dh 2824 
    Parameters:
2825 
     - category
2826 
    """
2827 
    self.send_getTransactionsRequiringExtraProcessing(category)
2828 
    return self.recv_getTransactionsRequiringExtraProcessing()
2829 
 
2830 
  def send_getTransactionsRequiringExtraProcessing(self, category):
2831 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
2832 
    args = getTransactionsRequiringExtraProcessing_args()
2833 
    args.category = category
2834 
    args.write(self._oprot)
2835 
    self._oprot.writeMessageEnd()
2836 
    self._oprot.trans.flush()
2837 
 
2838 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
2839 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2840 
    if mtype == TMessageType.EXCEPTION:
2841 
      x = TApplicationException()
2842 
      x.read(self._iprot)
2843 
      self._iprot.readMessageEnd()
2844 
      raise x
2845 
    result = getTransactionsRequiringExtraProcessing_result()
2846 
    result.read(self._iprot)
2847 
    self._iprot.readMessageEnd()
2848 
    if result.success is not None:
2849 
      return result.success
2850 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
2851 
 
2852 
  def markTransactionAsProcessed(self, transactionId, category):
2853 
    """
2854 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 2855 
    It essentially deletes the transaction id record for a particular
2856 
    processing type category (if present) from DB.
2857 
    This is currently used by CRM application.
4008 mandeep.dh 2858 
 
2859 
    Parameters:
2860 
     - transactionId
2861 
     - category
2862 
    """
2863 
    self.send_markTransactionAsProcessed(transactionId, category)
2864 
    self.recv_markTransactionAsProcessed()
2865 
 
2866 
  def send_markTransactionAsProcessed(self, transactionId, category):
2867 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
2868 
    args = markTransactionAsProcessed_args()
2869 
    args.transactionId = transactionId
2870 
    args.category = category
2871 
    args.write(self._oprot)
2872 
    self._oprot.writeMessageEnd()
2873 
    self._oprot.trans.flush()
2874 
 
2875 
  def recv_markTransactionAsProcessed(self, ):
2876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2877 
    if mtype == TMessageType.EXCEPTION:
2878 
      x = TApplicationException()
2879 
      x.read(self._iprot)
2880 
      self._iprot.readMessageEnd()
2881 
      raise x
2882 
    result = markTransactionAsProcessed_result()
2883 
    result.read(self._iprot)
2884 
    self._iprot.readMessageEnd()
2885 
    return
2886 
 
4018 chandransh 2887 
  def getItemWiseRiskyOrdersCount(self, ):
2888 
    """
2889 
    Returns a map containing the number of risky orders keyed by item id. A risky order
2890 
    is defined as one whose shipping date is about to expire.
2891 
    """
2892 
    self.send_getItemWiseRiskyOrdersCount()
2893 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 2894 
 
4018 chandransh 2895 
  def send_getItemWiseRiskyOrdersCount(self, ):
2896 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
2897 
    args = getItemWiseRiskyOrdersCount_args()
2898 
    args.write(self._oprot)
2899 
    self._oprot.writeMessageEnd()
2900 
    self._oprot.trans.flush()
2901 
 
2902 
  def recv_getItemWiseRiskyOrdersCount(self, ):
2903 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2904 
    if mtype == TMessageType.EXCEPTION:
2905 
      x = TApplicationException()
2906 
      x.read(self._iprot)
2907 
      self._iprot.readMessageEnd()
2908 
      raise x
2909 
    result = getItemWiseRiskyOrdersCount_result()
2910 
    result.read(self._iprot)
2911 
    self._iprot.readMessageEnd()
2912 
    if result.success is not None:
2913 
      return result.success
2914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
2915 
 
4247 rajveer 2916 
  def markOrderCancellationRequestReceived(self, orderId):
2917 
    """
2918 
    Mark order as cancellation request received. If customer sends request of cancellation of
2919 
    a particular order, this method will be called. It will just change status of the order
2920 
    depending on its current status. It also records the previous status, so that we can move
2921 
    back to that status if cancellation request is denied.
4018 chandransh 2922 
 
4247 rajveer 2923 
    Parameters:
2924 
     - orderId
2925 
    """
2926 
    self.send_markOrderCancellationRequestReceived(orderId)
2927 
    self.recv_markOrderCancellationRequestReceived()
2928 
 
2929 
  def send_markOrderCancellationRequestReceived(self, orderId):
2930 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
2931 
    args = markOrderCancellationRequestReceived_args()
2932 
    args.orderId = orderId
2933 
    args.write(self._oprot)
2934 
    self._oprot.writeMessageEnd()
2935 
    self._oprot.trans.flush()
2936 
 
2937 
  def recv_markOrderCancellationRequestReceived(self, ):
2938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2939 
    if mtype == TMessageType.EXCEPTION:
2940 
      x = TApplicationException()
2941 
      x.read(self._iprot)
2942 
      self._iprot.readMessageEnd()
2943 
      raise x
2944 
    result = markOrderCancellationRequestReceived_result()
2945 
    result.read(self._iprot)
2946 
    self._iprot.readMessageEnd()
2947 
    if result.ex is not None:
2948 
      raise result.ex
2949 
    return
2950 
 
2951 
  def markOrderCancellationRequestConfirmed(self, orderId):
2952 
    """
2953 
    If we decide to to cancel order, CRM will call this method to move the status of order to
2954 
    cancellation request confirmed. After this OM will be able to cancel the order.
2955 
 
2956 
    Parameters:
2957 
     - orderId
2958 
    """
2959 
    self.send_markOrderCancellationRequestConfirmed(orderId)
2960 
    self.recv_markOrderCancellationRequestConfirmed()
2961 
 
2962 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
2963 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
2964 
    args = markOrderCancellationRequestConfirmed_args()
2965 
    args.orderId = orderId
2966 
    args.write(self._oprot)
2967 
    self._oprot.writeMessageEnd()
2968 
    self._oprot.trans.flush()
2969 
 
2970 
  def recv_markOrderCancellationRequestConfirmed(self, ):
2971 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2972 
    if mtype == TMessageType.EXCEPTION:
2973 
      x = TApplicationException()
2974 
      x.read(self._iprot)
2975 
      self._iprot.readMessageEnd()
2976 
      raise x
2977 
    result = markOrderCancellationRequestConfirmed_result()
2978 
    result.read(self._iprot)
2979 
    self._iprot.readMessageEnd()
2980 
    if result.ex is not None:
2981 
      raise result.ex
2982 
    return
2983 
 
2984 
  def markOrderCancellationRequestDenied(self, orderId):
2985 
    """
2986 
    If we decide to not to cancel order, we will move the order ro previous status.
2987 
 
2988 
    Parameters:
2989 
     - orderId
2990 
    """
2991 
    self.send_markOrderCancellationRequestDenied(orderId)
2992 
    self.recv_markOrderCancellationRequestDenied()
2993 
 
2994 
  def send_markOrderCancellationRequestDenied(self, orderId):
2995 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
2996 
    args = markOrderCancellationRequestDenied_args()
2997 
    args.orderId = orderId
2998 
    args.write(self._oprot)
2999 
    self._oprot.writeMessageEnd()
3000 
    self._oprot.trans.flush()
3001 
 
3002 
  def recv_markOrderCancellationRequestDenied(self, ):
3003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3004 
    if mtype == TMessageType.EXCEPTION:
3005 
      x = TApplicationException()
3006 
      x.read(self._iprot)
3007 
      self._iprot.readMessageEnd()
3008 
      raise x
3009 
    result = markOrderCancellationRequestDenied_result()
3010 
    result.read(self._iprot)
3011 
    self._iprot.readMessageEnd()
3012 
    if result.ex is not None:
3013 
      raise result.ex
3014 
    return
3015 
 
4258 rajveer 3016 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3017 
    """
4258 rajveer 3018 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3019 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3020 
 
3021 
    Parameters:
4258 rajveer 3022 
     - transactionId
4247 rajveer 3023 
    """
4258 rajveer 3024 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3025 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3026 
 
4258 rajveer 3027 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3028 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3029 
    args = markTransactionAsPaymentFlagRemoved_args()
3030 
    args.transactionId = transactionId
4247 rajveer 3031 
    args.write(self._oprot)
3032 
    self._oprot.writeMessageEnd()
3033 
    self._oprot.trans.flush()
3034 
 
4258 rajveer 3035 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3037 
    if mtype == TMessageType.EXCEPTION:
3038 
      x = TApplicationException()
3039 
      x.read(self._iprot)
3040 
      self._iprot.readMessageEnd()
3041 
      raise x
4258 rajveer 3042 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3043 
    result.read(self._iprot)
3044 
    self._iprot.readMessageEnd()
3045 
    if result.ex is not None:
3046 
      raise result.ex
3047 
    return
3048 
 
4259 anupam.sin 3049 
  def refundTransaction(self, transactionId, refundedBy, reason):
3050 
    """
3051 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3052 
    need to be cancelled
4247 rajveer 3053 
 
4259 anupam.sin 3054 
    Parameters:
3055 
     - transactionId
3056 
     - refundedBy
3057 
     - reason
3058 
    """
3059 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3060 
    self.recv_refundTransaction()
3061 
 
3062 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3063 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3064 
    args = refundTransaction_args()
3065 
    args.transactionId = transactionId
3066 
    args.refundedBy = refundedBy
3067 
    args.reason = reason
3068 
    args.write(self._oprot)
3069 
    self._oprot.writeMessageEnd()
3070 
    self._oprot.trans.flush()
3071 
 
3072 
  def recv_refundTransaction(self, ):
3073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3074 
    if mtype == TMessageType.EXCEPTION:
3075 
      x = TApplicationException()
3076 
      x.read(self._iprot)
3077 
      self._iprot.readMessageEnd()
3078 
      raise x
3079 
    result = refundTransaction_result()
3080 
    result.read(self._iprot)
3081 
    self._iprot.readMessageEnd()
3082 
    if result.ex is not None:
3083 
      raise result.ex
3084 
    return
3085 
 
3086 
 
3376 rajveer 3087 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3088 
  def __init__(self, handler):
3376 rajveer 3089 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3090 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3091 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3092 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3093 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3094 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3095 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3096 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3097 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3098 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3099 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3100 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3101 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3102 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3103 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3104 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3105 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3106 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3107 
    self._processMap["createOrder"] = Processor.process_createOrder
3108 
    self._processMap["getOrder"] = Processor.process_getOrder
3109 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3110 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3111 
    self._processMap["getAlerts"] = Processor.process_getAlerts
3112 
    self._processMap["setAlert"] = Processor.process_setAlert
3113 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3114 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3115 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3116 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3117 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3118 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3119 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3120 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3121 
    self._processMap["billOrder"] = Processor.process_billOrder
3122 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
3123 
    self._processMap["addJacketNumber"] = Processor.process_addJacketNumber
759 chandransh 3124 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 3125 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3126 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3127 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3128 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3129 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3130 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
3131 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3132 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3133 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3134 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3135 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 3136 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3137 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3138 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3139 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3140 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3141 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3142 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3143 
    self._processMap["changeItem"] = Processor.process_changeItem
3144 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3145 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3146 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3147 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3148 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3149 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4247 rajveer 3150 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3151 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3152 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3153 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3154 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
94 ashish 3155 
 
3156 
  def process(self, iprot, oprot):
3157 
    (name, type, seqid) = iprot.readMessageBegin()
3158 
    if name not in self._processMap:
3159 
      iprot.skip(TType.STRUCT)
3160 
      iprot.readMessageEnd()
3161 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3162 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3163 
      x.write(oprot)
3164 
      oprot.writeMessageEnd()
3165 
      oprot.trans.flush()
3166 
      return
3167 
    else:
3168 
      self._processMap[name](self, seqid, iprot, oprot)
3169 
    return True
3170 
 
3171 
  def process_createTransaction(self, seqid, iprot, oprot):
3172 
    args = createTransaction_args()
3173 
    args.read(iprot)
3174 
    iprot.readMessageEnd()
3175 
    result = createTransaction_result()
3176 
    try:
132 ashish 3177 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3178 
    except TransactionServiceException, ex:
3179 
      result.ex = ex
3180 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3181 
    result.write(oprot)
3182 
    oprot.writeMessageEnd()
3183 
    oprot.trans.flush()
3184 
 
3185 
  def process_getTransaction(self, seqid, iprot, oprot):
3186 
    args = getTransaction_args()
3187 
    args.read(iprot)
3188 
    iprot.readMessageEnd()
3189 
    result = getTransaction_result()
3190 
    try:
3191 
      result.success = self._handler.getTransaction(args.id)
3192 
    except TransactionServiceException, ex:
3193 
      result.ex = ex
3194 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3195 
    result.write(oprot)
3196 
    oprot.writeMessageEnd()
3197 
    oprot.trans.flush()
3198 
 
3199 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3200 
    args = getTransactionsForCustomer_args()
3201 
    args.read(iprot)
3202 
    iprot.readMessageEnd()
3203 
    result = getTransactionsForCustomer_result()
3204 
    try:
3205 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3206 
    except TransactionServiceException, ex:
3207 
      result.ex = ex
3208 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3209 
    result.write(oprot)
3210 
    oprot.writeMessageEnd()
3211 
    oprot.trans.flush()
3212 
 
132 ashish 3213 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3214 
    args = getTransactionsForShoppingCartId_args()
3215 
    args.read(iprot)
3216 
    iprot.readMessageEnd()
3217 
    result = getTransactionsForShoppingCartId_result()
3218 
    try:
3219 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3220 
    except TransactionServiceException, ex:
3221 
      result.ex = ex
3222 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3223 
    result.write(oprot)
3224 
    oprot.writeMessageEnd()
3225 
    oprot.trans.flush()
3226 
 
94 ashish 3227 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3228 
    args = getTransactionStatus_args()
3229 
    args.read(iprot)
3230 
    iprot.readMessageEnd()
3231 
    result = getTransactionStatus_result()
3232 
    try:
3233 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3234 
    except TransactionServiceException, ex:
3235 
      result.ex = ex
3236 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3237 
    result.write(oprot)
3238 
    oprot.writeMessageEnd()
3239 
    oprot.trans.flush()
3240 
 
3241 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3242 
    args = changeTransactionStatus_args()
3243 
    args.read(iprot)
3244 
    iprot.readMessageEnd()
3245 
    result = changeTransactionStatus_result()
3246 
    try:
3247 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3248 
    except TransactionServiceException, ex:
3249 
      result.ex = ex
3250 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3251 
    result.write(oprot)
3252 
    oprot.writeMessageEnd()
3253 
    oprot.trans.flush()
3254 
 
1398 varun.gupt 3255 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3256 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3257 
    args.read(iprot)
3258 
    iprot.readMessageEnd()
1398 varun.gupt 3259 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3260 
    try:
1398 varun.gupt 3261 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3262 
    except TransactionServiceException, ex:
3263 
      result.ex = ex
1398 varun.gupt 3264 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3265 
    result.write(oprot)
3266 
    oprot.writeMessageEnd()
3267 
    oprot.trans.flush()
3268 
 
483 rajveer 3269 
  def process_getAllOrders(self, seqid, iprot, oprot):
3270 
    args = getAllOrders_args()
94 ashish 3271 
    args.read(iprot)
3272 
    iprot.readMessageEnd()
483 rajveer 3273 
    result = getAllOrders_result()
94 ashish 3274 
    try:
483 rajveer 3275 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3276 
    except TransactionServiceException, ex:
3277 
      result.ex = ex
483 rajveer 3278 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3279 
    result.write(oprot)
3280 
    oprot.writeMessageEnd()
3281 
    oprot.trans.flush()
3282 
 
4133 chandransh 3283 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3284 
    args = getOrdersInBatch_args()
3285 
    args.read(iprot)
3286 
    iprot.readMessageEnd()
3287 
    result = getOrdersInBatch_result()
3288 
    try:
3289 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3290 
    except TransactionServiceException, ex:
3291 
      result.ex = ex
3292 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3293 
    result.write(oprot)
3294 
    oprot.writeMessageEnd()
3295 
    oprot.trans.flush()
3296 
 
3297 
  def process_getOrderCount(self, seqid, iprot, oprot):
3298 
    args = getOrderCount_args()
3299 
    args.read(iprot)
3300 
    iprot.readMessageEnd()
3301 
    result = getOrderCount_result()
3302 
    try:
3303 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3304 
    except TransactionServiceException, ex:
3305 
      result.ex = ex
3306 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3307 
    result.write(oprot)
3308 
    oprot.writeMessageEnd()
3309 
    oprot.trans.flush()
3310 
 
999 varun.gupt 3311 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3312 
    args = getOrdersByBillingDate_args()
3313 
    args.read(iprot)
3314 
    iprot.readMessageEnd()
3315 
    result = getOrdersByBillingDate_result()
3316 
    try:
3317 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3318 
    except TransactionServiceException, ex:
3319 
      result.ex = ex
3320 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3321 
    result.write(oprot)
3322 
    oprot.writeMessageEnd()
3323 
    oprot.trans.flush()
3324 
 
3427 chandransh 3325 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3326 
    args = getOrdersByShippingDate_args()
3327 
    args.read(iprot)
3328 
    iprot.readMessageEnd()
3329 
    result = getOrdersByShippingDate_result()
3330 
    try:
3451 chandransh 3331 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3332 
    except TransactionServiceException, ex:
3333 
      result.ex = ex
3334 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3335 
    result.write(oprot)
3336 
    oprot.writeMessageEnd()
3337 
    oprot.trans.flush()
3338 
 
1382 varun.gupt 3339 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3340 
    args = getReturnableOrdersForCustomer_args()
3341 
    args.read(iprot)
3342 
    iprot.readMessageEnd()
3343 
    result = getReturnableOrdersForCustomer_result()
3344 
    try:
3345 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3346 
    except TransactionServiceException, ex:
3347 
      result.ex = ex
3348 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3349 
    result.write(oprot)
3350 
    oprot.writeMessageEnd()
3351 
    oprot.trans.flush()
3352 
 
3353 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3354 
    args = getCancellableOrdersForCustomer_args()
3355 
    args.read(iprot)
3356 
    iprot.readMessageEnd()
3357 
    result = getCancellableOrdersForCustomer_result()
3358 
    try:
3359 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3360 
    except TransactionServiceException, ex:
3361 
      result.ex = ex
3362 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3363 
    result.write(oprot)
3364 
    oprot.writeMessageEnd()
3365 
    oprot.trans.flush()
3366 
 
483 rajveer 3367 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3368 
    args = changeOrderStatus_args()
94 ashish 3369 
    args.read(iprot)
3370 
    iprot.readMessageEnd()
483 rajveer 3371 
    result = changeOrderStatus_result()
94 ashish 3372 
    try:
483 rajveer 3373 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3374 
    except TransactionServiceException, ex:
3375 
      result.ex = ex
483 rajveer 3376 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3377 
    result.write(oprot)
3378 
    oprot.writeMessageEnd()
3379 
    oprot.trans.flush()
3380 
 
483 rajveer 3381 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3382 
    args = getOrdersForTransaction_args()
94 ashish 3383 
    args.read(iprot)
3384 
    iprot.readMessageEnd()
483 rajveer 3385 
    result = getOrdersForTransaction_result()
94 ashish 3386 
    try:
1528 ankur.sing 3387 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 3388 
    except TransactionServiceException, ex:
3389 
      result.ex = ex
483 rajveer 3390 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 3391 
    result.write(oprot)
3392 
    oprot.writeMessageEnd()
3393 
    oprot.trans.flush()
3394 
 
483 rajveer 3395 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
3396 
    args = getOrdersForCustomer_args()
94 ashish 3397 
    args.read(iprot)
3398 
    iprot.readMessageEnd()
483 rajveer 3399 
    result = getOrdersForCustomer_result()
94 ashish 3400 
    try:
3014 chandransh 3401 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 3402 
    except TransactionServiceException, ex:
3403 
      result.ex = ex
483 rajveer 3404 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 3405 
    result.write(oprot)
3406 
    oprot.writeMessageEnd()
3407 
    oprot.trans.flush()
3408 
 
483 rajveer 3409 
  def process_createOrder(self, seqid, iprot, oprot):
3410 
    args = createOrder_args()
94 ashish 3411 
    args.read(iprot)
3412 
    iprot.readMessageEnd()
483 rajveer 3413 
    result = createOrder_result()
94 ashish 3414 
    try:
483 rajveer 3415 
      result.success = self._handler.createOrder(args.order)
94 ashish 3416 
    except TransactionServiceException, ex:
3417 
      result.ex = ex
483 rajveer 3418 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 3419 
    result.write(oprot)
3420 
    oprot.writeMessageEnd()
3421 
    oprot.trans.flush()
3422 
 
483 rajveer 3423 
  def process_getOrder(self, seqid, iprot, oprot):
3424 
    args = getOrder_args()
94 ashish 3425 
    args.read(iprot)
3426 
    iprot.readMessageEnd()
483 rajveer 3427 
    result = getOrder_result()
94 ashish 3428 
    try:
483 rajveer 3429 
      result.success = self._handler.getOrder(args.id)
94 ashish 3430 
    except TransactionServiceException, ex:
3431 
      result.ex = ex
483 rajveer 3432 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 3433 
    result.write(oprot)
3434 
    oprot.writeMessageEnd()
3435 
    oprot.trans.flush()
3436 
 
483 rajveer 3437 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
3438 
    args = getLineItemsForOrder_args()
94 ashish 3439 
    args.read(iprot)
3440 
    iprot.readMessageEnd()
483 rajveer 3441 
    result = getLineItemsForOrder_result()
94 ashish 3442 
    try:
483 rajveer 3443 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 3444 
    except TransactionServiceException, ex:
3445 
      result.ex = ex
483 rajveer 3446 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 3447 
    result.write(oprot)
3448 
    oprot.writeMessageEnd()
3449 
    oprot.trans.flush()
3450 
 
1528 ankur.sing 3451 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
3452 
    args = getOrderForCustomer_args()
3453 
    args.read(iprot)
3454 
    iprot.readMessageEnd()
3455 
    result = getOrderForCustomer_result()
3456 
    try:
3457 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
3458 
    except TransactionServiceException, ex:
3459 
      result.ex = ex
3460 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
3461 
    result.write(oprot)
3462 
    oprot.writeMessageEnd()
3463 
    oprot.trans.flush()
3464 
 
3064 chandransh 3465 
  def process_getAlerts(self, seqid, iprot, oprot):
3466 
    args = getAlerts_args()
3467 
    args.read(iprot)
3468 
    iprot.readMessageEnd()
3469 
    result = getAlerts_result()
3470 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
3471 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
3472 
    result.write(oprot)
3473 
    oprot.writeMessageEnd()
3474 
    oprot.trans.flush()
3475 
 
3476 
  def process_setAlert(self, seqid, iprot, oprot):
3477 
    args = setAlert_args()
3478 
    args.read(iprot)
3479 
    iprot.readMessageEnd()
3480 
    result = setAlert_result()
3481 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
3482 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
3483 
    result.write(oprot)
3484 
    oprot.writeMessageEnd()
3485 
    oprot.trans.flush()
3486 
 
3487 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
3488 
    args = getValidOrderCount_args()
3489 
    args.read(iprot)
3490 
    iprot.readMessageEnd()
3491 
    result = getValidOrderCount_result()
3492 
    result.success = self._handler.getValidOrderCount()
3493 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
3494 
    result.write(oprot)
3495 
    oprot.writeMessageEnd()
3496 
    oprot.trans.flush()
3497 
 
3498 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
3499 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
3500 
    args.read(iprot)
3501 
    iprot.readMessageEnd()
3502 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
3503 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
3504 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
3505 
    result.write(oprot)
3506 
    oprot.writeMessageEnd()
3507 
    oprot.trans.flush()
3508 
 
3509 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
3510 
    args = getValidOrdersAmountRange_args()
3511 
    args.read(iprot)
3512 
    iprot.readMessageEnd()
3513 
    result = getValidOrdersAmountRange_result()
3514 
    result.success = self._handler.getValidOrdersAmountRange()
3515 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
3516 
    result.write(oprot)
3517 
    oprot.writeMessageEnd()
3518 
    oprot.trans.flush()
3519 
 
3520 
  def process_getValidOrders(self, seqid, iprot, oprot):
3521 
    args = getValidOrders_args()
3522 
    args.read(iprot)
3523 
    iprot.readMessageEnd()
3524 
    result = getValidOrders_result()
3525 
    result.success = self._handler.getValidOrders(args.limit)
3526 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
3527 
    result.write(oprot)
3528 
    oprot.writeMessageEnd()
3529 
    oprot.trans.flush()
3530 
 
1220 chandransh 3531 
  def process_batchOrders(self, seqid, iprot, oprot):
3532 
    args = batchOrders_args()
3533 
    args.read(iprot)
3534 
    iprot.readMessageEnd()
3535 
    result = batchOrders_result()
3536 
    try:
3537 
      result.success = self._handler.batchOrders(args.warehouseId)
3538 
    except TransactionServiceException, ex:
3539 
      result.ex = ex
3540 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
3541 
    result.write(oprot)
3542 
    oprot.writeMessageEnd()
3543 
    oprot.trans.flush()
3544 
 
1208 chandransh 3545 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
3546 
    args = markOrderAsOutOfStock_args()
3547 
    args.read(iprot)
3548 
    iprot.readMessageEnd()
3549 
    result = markOrderAsOutOfStock_result()
3550 
    try:
3551 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
3552 
    except TransactionServiceException, ex:
3553 
      result.ex = ex
3554 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
3555 
    result.write(oprot)
3556 
    oprot.writeMessageEnd()
3557 
    oprot.trans.flush()
3558 
 
3064 chandransh 3559 
  def process_verifyOrder(self, seqid, iprot, oprot):
3560 
    args = verifyOrder_args()
759 chandransh 3561 
    args.read(iprot)
3562 
    iprot.readMessageEnd()
3064 chandransh 3563 
    result = verifyOrder_result()
759 chandransh 3564 
    try:
3064 chandransh 3565 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 3566 
    except TransactionServiceException, ex:
3567 
      result.ex = ex
3064 chandransh 3568 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 3569 
    result.write(oprot)
3570 
    oprot.writeMessageEnd()
3571 
    oprot.trans.flush()
3572 
 
3064 chandransh 3573 
  def process_acceptOrder(self, seqid, iprot, oprot):
3574 
    args = acceptOrder_args()
1113 chandransh 3575 
    args.read(iprot)
3576 
    iprot.readMessageEnd()
3064 chandransh 3577 
    result = acceptOrder_result()
1113 chandransh 3578 
    try:
3064 chandransh 3579 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 3580 
    except TransactionServiceException, ex:
3581 
      result.ex = ex
3064 chandransh 3582 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 3583 
    result.write(oprot)
3584 
    oprot.writeMessageEnd()
3585 
    oprot.trans.flush()
3586 
 
3064 chandransh 3587 
  def process_billOrder(self, seqid, iprot, oprot):
3588 
    args = billOrder_args()
1132 chandransh 3589 
    args.read(iprot)
3590 
    iprot.readMessageEnd()
3064 chandransh 3591 
    result = billOrder_result()
1132 chandransh 3592 
    try:
3064 chandransh 3593 
      result.success = self._handler.billOrder(args.orderId)
1132 chandransh 3594 
    except TransactionServiceException, ex:
3595 
      result.ex = ex
3064 chandransh 3596 
    oprot.writeMessageBegin("billOrder", TMessageType.REPLY, seqid)
1132 chandransh 3597 
    result.write(oprot)
3598 
    oprot.writeMessageEnd()
3599 
    oprot.trans.flush()
3600 
 
3064 chandransh 3601 
  def process_addBillingDetails(self, seqid, iprot, oprot):
3602 
    args = addBillingDetails_args()
1135 chandransh 3603 
    args.read(iprot)
3604 
    iprot.readMessageEnd()
3064 chandransh 3605 
    result = addBillingDetails_result()
1135 chandransh 3606 
    try:
3064 chandransh 3607 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.billed_by)
1135 chandransh 3608 
    except TransactionServiceException, ex:
3609 
      result.ex = ex
3064 chandransh 3610 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 3611 
    result.write(oprot)
3612 
    oprot.writeMessageEnd()
3613 
    oprot.trans.flush()
3614 
 
3064 chandransh 3615 
  def process_addJacketNumber(self, seqid, iprot, oprot):
3616 
    args = addJacketNumber_args()
1246 chandransh 3617 
    args.read(iprot)
3618 
    iprot.readMessageEnd()
3064 chandransh 3619 
    result = addJacketNumber_result()
1246 chandransh 3620 
    try:
3064 chandransh 3621 
      result.success = self._handler.addJacketNumber(args.orderId, args.jacketNumber, args.imeiNumber, args.itemNumber, args.billedBy, args.billingType)
1246 chandransh 3622 
    except TransactionServiceException, ex:
3623 
      result.ex = ex
3064 chandransh 3624 
    oprot.writeMessageBegin("addJacketNumber", TMessageType.REPLY, seqid)
1246 chandransh 3625 
    result.write(oprot)
3626 
    oprot.writeMessageEnd()
3627 
    oprot.trans.flush()
3628 
 
3064 chandransh 3629 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
3630 
    args = markOrdersAsManifested_args()
1408 ankur.sing 3631 
    args.read(iprot)
3632 
    iprot.readMessageEnd()
3064 chandransh 3633 
    result = markOrdersAsManifested_result()
3634 
    try:
3635 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
3636 
    except TransactionServiceException, ex:
3637 
      result.ex = ex
3638 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 3639 
    result.write(oprot)
3640 
    oprot.writeMessageEnd()
3641 
    oprot.trans.flush()
3642 
 
3064 chandransh 3643 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
3644 
    args = markOrdersAsPickedUp_args()
304 ashish 3645 
    args.read(iprot)
3646 
    iprot.readMessageEnd()
3064 chandransh 3647 
    result = markOrdersAsPickedUp_result()
3648 
    try:
3649 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3650 
    except TransactionServiceException, ex:
3651 
      result.ex = ex
3652 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 3653 
    result.write(oprot)
3654 
    oprot.writeMessageEnd()
3655 
    oprot.trans.flush()
94 ashish 3656 
 
3064 chandransh 3657 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
3658 
    args = markOrdersAsDelivered_args()
304 ashish 3659 
    args.read(iprot)
3660 
    iprot.readMessageEnd()
3064 chandransh 3661 
    result = markOrdersAsDelivered_result()
3662 
    try:
3663 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
3664 
    except TransactionServiceException, ex:
3665 
      result.ex = ex
3666 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 3667 
    result.write(oprot)
3668 
    oprot.writeMessageEnd()
3669 
    oprot.trans.flush()
3670 
 
3064 chandransh 3671 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
3672 
    args = markOrdersAsFailed_args()
1596 ankur.sing 3673 
    args.read(iprot)
3674 
    iprot.readMessageEnd()
3064 chandransh 3675 
    result = markOrdersAsFailed_result()
3676 
    try:
3677 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
3678 
    except TransactionServiceException, ex:
3679 
      result.ex = ex
3680 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 3681 
    result.write(oprot)
3682 
    oprot.writeMessageEnd()
3683 
    oprot.trans.flush()
304 ashish 3684 
 
3064 chandransh 3685 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
3686 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 3687 
    args.read(iprot)
3688 
    iprot.readMessageEnd()
3064 chandransh 3689 
    result = updateNonDeliveryReason_result()
3690 
    try:
3691 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3692 
    except TransactionServiceException, ex:
3693 
      result.ex = ex
3694 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 3695 
    result.write(oprot)
3696 
    oprot.writeMessageEnd()
3697 
    oprot.trans.flush()
1596 ankur.sing 3698 
 
3064 chandransh 3699 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
3700 
    args = getUndeliveredOrders_args()
1627 ankur.sing 3701 
    args.read(iprot)
3702 
    iprot.readMessageEnd()
3064 chandransh 3703 
    result = getUndeliveredOrders_result()
3704 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
3705 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 3706 
    result.write(oprot)
3707 
    oprot.writeMessageEnd()
3708 
    oprot.trans.flush()
3709 
 
2536 chandransh 3710 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
3711 
    args = toggleDOAFlag_args()
3712 
    args.read(iprot)
3713 
    iprot.readMessageEnd()
3714 
    result = toggleDOAFlag_result()
3715 
    try:
3716 
      result.success = self._handler.toggleDOAFlag(args.orderId)
3717 
    except TransactionServiceException, ex:
3718 
      result.ex = ex
3719 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
3720 
    result.write(oprot)
3721 
    oprot.writeMessageEnd()
3722 
    oprot.trans.flush()
1886 ankur.sing 3723 
 
2536 chandransh 3724 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
3725 
    args = requestPickupNumber_args()
3726 
    args.read(iprot)
3727 
    iprot.readMessageEnd()
3728 
    result = requestPickupNumber_result()
3729 
    try:
3730 
      result.success = self._handler.requestPickupNumber(args.orderId)
3731 
    except TransactionServiceException, ex:
3732 
      result.ex = ex
3733 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
3734 
    result.write(oprot)
3735 
    oprot.writeMessageEnd()
3736 
    oprot.trans.flush()
3737 
 
3738 
  def process_authorizePickup(self, seqid, iprot, oprot):
3739 
    args = authorizePickup_args()
3740 
    args.read(iprot)
3741 
    iprot.readMessageEnd()
3742 
    result = authorizePickup_result()
3743 
    try:
3744 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
3745 
    except TransactionServiceException, ex:
3746 
      result.ex = ex
3747 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
3748 
    result.write(oprot)
3749 
    oprot.writeMessageEnd()
3750 
    oprot.trans.flush()
3751 
 
2764 chandransh 3752 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
3753 
    args = markDoasAsPickedUp_args()
3754 
    args.read(iprot)
3755 
    iprot.readMessageEnd()
3756 
    result = markDoasAsPickedUp_result()
3757 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
3758 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
3759 
    result.write(oprot)
3760 
    oprot.writeMessageEnd()
3761 
    oprot.trans.flush()
3762 
 
2616 chandransh 3763 
  def process_receiveReturn(self, seqid, iprot, oprot):
3764 
    args = receiveReturn_args()
2591 chandransh 3765 
    args.read(iprot)
3766 
    iprot.readMessageEnd()
2616 chandransh 3767 
    result = receiveReturn_result()
2591 chandransh 3768 
    try:
2616 chandransh 3769 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 3770 
    except TransactionServiceException, ex:
3771 
      result.ex = ex
2616 chandransh 3772 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 3773 
    result.write(oprot)
3774 
    oprot.writeMessageEnd()
3775 
    oprot.trans.flush()
2536 chandransh 3776 
 
2591 chandransh 3777 
  def process_validateDoa(self, seqid, iprot, oprot):
3778 
    args = validateDoa_args()
3779 
    args.read(iprot)
3780 
    iprot.readMessageEnd()
3781 
    result = validateDoa_result()
3782 
    try:
3783 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
3784 
    except TransactionServiceException, ex:
3785 
      result.ex = ex
3786 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
3787 
    result.write(oprot)
3788 
    oprot.writeMessageEnd()
3789 
    oprot.trans.flush()
3790 
 
2616 chandransh 3791 
  def process_reshipOrder(self, seqid, iprot, oprot):
3792 
    args = reshipOrder_args()
3793 
    args.read(iprot)
3794 
    iprot.readMessageEnd()
3795 
    result = reshipOrder_result()
3796 
    try:
3797 
      result.success = self._handler.reshipOrder(args.orderId)
3798 
    except TransactionServiceException, ex:
3799 
      result.ex = ex
3800 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
3801 
    result.write(oprot)
3802 
    oprot.writeMessageEnd()
3803 
    oprot.trans.flush()
2591 chandransh 3804 
 
2616 chandransh 3805 
  def process_refundOrder(self, seqid, iprot, oprot):
3806 
    args = refundOrder_args()
3807 
    args.read(iprot)
3808 
    iprot.readMessageEnd()
3809 
    result = refundOrder_result()
3810 
    try:
3226 chandransh 3811 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 3812 
    except TransactionServiceException, ex:
3813 
      result.ex = ex
3814 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
3815 
    result.write(oprot)
3816 
    oprot.writeMessageEnd()
3817 
    oprot.trans.flush()
3818 
 
2690 chandransh 3819 
  def process_getReturnOrders(self, seqid, iprot, oprot):
3820 
    args = getReturnOrders_args()
3821 
    args.read(iprot)
3822 
    iprot.readMessageEnd()
3823 
    result = getReturnOrders_result()
3824 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
3825 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
3826 
    result.write(oprot)
3827 
    oprot.writeMessageEnd()
3828 
    oprot.trans.flush()
2616 chandransh 3829 
 
2700 chandransh 3830 
  def process_getReturnOrder(self, seqid, iprot, oprot):
3831 
    args = getReturnOrder_args()
3832 
    args.read(iprot)
3833 
    iprot.readMessageEnd()
3834 
    result = getReturnOrder_result()
3835 
    try:
3836 
      result.success = self._handler.getReturnOrder(args.id)
3837 
    except TransactionServiceException, ex:
3838 
      result.ex = ex
3839 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
3840 
    result.write(oprot)
3841 
    oprot.writeMessageEnd()
3842 
    oprot.trans.flush()
3843 
 
2690 chandransh 3844 
  def process_processReturn(self, seqid, iprot, oprot):
3845 
    args = processReturn_args()
3846 
    args.read(iprot)
3847 
    iprot.readMessageEnd()
3848 
    result = processReturn_result()
3849 
    try:
3850 
      self._handler.processReturn(args.returnOrderId)
3851 
    except TransactionServiceException, ex:
3852 
      result.ex = ex
3853 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
3854 
    result.write(oprot)
3855 
    oprot.writeMessageEnd()
3856 
    oprot.trans.flush()
3857 
 
2819 chandransh 3858 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
3859 
    args = createPurchaseOrder_args()
3860 
    args.read(iprot)
3861 
    iprot.readMessageEnd()
3862 
    result = createPurchaseOrder_result()
3863 
    try:
3864 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
3865 
    except TransactionServiceException, ex:
3866 
      result.ex = ex
3867 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
3868 
    result.write(oprot)
3869 
    oprot.writeMessageEnd()
3870 
    oprot.trans.flush()
2690 chandransh 3871 
 
3451 chandransh 3872 
  def process_updateWeight(self, seqid, iprot, oprot):
3873 
    args = updateWeight_args()
3874 
    args.read(iprot)
3875 
    iprot.readMessageEnd()
3876 
    result = updateWeight_result()
3877 
    try:
3878 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
3879 
    except TransactionServiceException, ex:
3880 
      result.ex = ex
3881 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
3882 
    result.write(oprot)
3883 
    oprot.writeMessageEnd()
3884 
    oprot.trans.flush()
2819 chandransh 3885 
 
3469 chandransh 3886 
  def process_changeItem(self, seqid, iprot, oprot):
3887 
    args = changeItem_args()
3888 
    args.read(iprot)
3889 
    iprot.readMessageEnd()
3890 
    result = changeItem_result()
3891 
    try:
3892 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
3893 
    except TransactionServiceException, ex:
3894 
      result.ex = ex
3895 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
3896 
    result.write(oprot)
3897 
    oprot.writeMessageEnd()
3898 
    oprot.trans.flush()
3451 chandransh 3899 
 
3469 chandransh 3900 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
3901 
    args = shiftToWarehouse_args()
3902 
    args.read(iprot)
3903 
    iprot.readMessageEnd()
3904 
    result = shiftToWarehouse_result()
3905 
    try:
3906 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
3907 
    except TransactionServiceException, ex:
3908 
      result.ex = ex
3909 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
3910 
    result.write(oprot)
3911 
    oprot.writeMessageEnd()
3912 
    oprot.trans.flush()
3913 
 
3553 chandransh 3914 
  def process_addDelayReason(self, seqid, iprot, oprot):
3915 
    args = addDelayReason_args()
3916 
    args.read(iprot)
3917 
    iprot.readMessageEnd()
3918 
    result = addDelayReason_result()
3919 
    try:
3986 chandransh 3920 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 3921 
    except TransactionServiceException, ex:
3922 
      result.ex = ex
3923 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
3924 
    result.write(oprot)
3925 
    oprot.writeMessageEnd()
3926 
    oprot.trans.flush()
3469 chandransh 3927 
 
3956 chandransh 3928 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
3929 
    args = reconcileCodCollection_args()
3930 
    args.read(iprot)
3931 
    iprot.readMessageEnd()
3932 
    result = reconcileCodCollection_result()
3933 
    try:
3934 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
3935 
    except TransactionServiceException, ex:
3936 
      result.ex = ex
3937 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
3938 
    result.write(oprot)
3939 
    oprot.writeMessageEnd()
3940 
    oprot.trans.flush()
3553 chandransh 3941 
 
4008 mandeep.dh 3942 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
3943 
    args = getTransactionsRequiringExtraProcessing_args()
3944 
    args.read(iprot)
3945 
    iprot.readMessageEnd()
3946 
    result = getTransactionsRequiringExtraProcessing_result()
3947 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
3948 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
3949 
    result.write(oprot)
3950 
    oprot.writeMessageEnd()
3951 
    oprot.trans.flush()
3956 chandransh 3952 
 
4008 mandeep.dh 3953 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
3954 
    args = markTransactionAsProcessed_args()
3955 
    args.read(iprot)
3956 
    iprot.readMessageEnd()
3957 
    result = markTransactionAsProcessed_result()
3958 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
3959 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
3960 
    result.write(oprot)
3961 
    oprot.writeMessageEnd()
3962 
    oprot.trans.flush()
3963 
 
4018 chandransh 3964 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
3965 
    args = getItemWiseRiskyOrdersCount_args()
3966 
    args.read(iprot)
3967 
    iprot.readMessageEnd()
3968 
    result = getItemWiseRiskyOrdersCount_result()
3969 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
3970 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
3971 
    result.write(oprot)
3972 
    oprot.writeMessageEnd()
3973 
    oprot.trans.flush()
4008 mandeep.dh 3974 
 
4247 rajveer 3975 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
3976 
    args = markOrderCancellationRequestReceived_args()
3977 
    args.read(iprot)
3978 
    iprot.readMessageEnd()
3979 
    result = markOrderCancellationRequestReceived_result()
3980 
    try:
3981 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
3982 
    except TransactionServiceException, ex:
3983 
      result.ex = ex
3984 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
3985 
    result.write(oprot)
3986 
    oprot.writeMessageEnd()
3987 
    oprot.trans.flush()
4018 chandransh 3988 
 
4247 rajveer 3989 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
3990 
    args = markOrderCancellationRequestConfirmed_args()
3991 
    args.read(iprot)
3992 
    iprot.readMessageEnd()
3993 
    result = markOrderCancellationRequestConfirmed_result()
3994 
    try:
3995 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
3996 
    except TransactionServiceException, ex:
3997 
      result.ex = ex
3998 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
3999 
    result.write(oprot)
4000 
    oprot.writeMessageEnd()
4001 
    oprot.trans.flush()
4002 
 
4003 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4004 
    args = markOrderCancellationRequestDenied_args()
4005 
    args.read(iprot)
4006 
    iprot.readMessageEnd()
4007 
    result = markOrderCancellationRequestDenied_result()
4008 
    try:
4009 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4010 
    except TransactionServiceException, ex:
4011 
      result.ex = ex
4012 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4013 
    result.write(oprot)
4014 
    oprot.writeMessageEnd()
4015 
    oprot.trans.flush()
4016 
 
4258 rajveer 4017 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4018 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4019 
    args.read(iprot)
4020 
    iprot.readMessageEnd()
4258 rajveer 4021 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4022 
    try:
4258 rajveer 4023 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4024 
    except TransactionServiceException, ex:
4025 
      result.ex = ex
4258 rajveer 4026 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4027 
    result.write(oprot)
4028 
    oprot.writeMessageEnd()
4029 
    oprot.trans.flush()
4030 
 
4259 anupam.sin 4031 
  def process_refundTransaction(self, seqid, iprot, oprot):
4032 
    args = refundTransaction_args()
4033 
    args.read(iprot)
4034 
    iprot.readMessageEnd()
4035 
    result = refundTransaction_result()
4036 
    try:
4037 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4038 
    except TransactionServiceException, ex:
4039 
      result.ex = ex
4040 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4041 
    result.write(oprot)
4042 
    oprot.writeMessageEnd()
4043 
    oprot.trans.flush()
4247 rajveer 4044 
 
4259 anupam.sin 4045 
 
94 ashish 4046 
# HELPER FUNCTIONS AND STRUCTURES
4047 
 
4048 
class createTransaction_args:
4049 
  """
4050 
  Attributes:
4051 
   - transaction
4052 
  """
4053 
 
4054 
  thrift_spec = (
4055 
    None, # 0
4056 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4057 
  )
4058 
 
4059 
  def __init__(self, transaction=None,):
4060 
    self.transaction = transaction
4061 
 
4062 
  def read(self, iprot):
4063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4065 
      return
4066 
    iprot.readStructBegin()
4067 
    while True:
4068 
      (fname, ftype, fid) = iprot.readFieldBegin()
4069 
      if ftype == TType.STOP:
4070 
        break
4071 
      if fid == 1:
4072 
        if ftype == TType.STRUCT:
4073 
          self.transaction = Transaction()
4074 
          self.transaction.read(iprot)
4075 
        else:
4076 
          iprot.skip(ftype)
4077 
      else:
4078 
        iprot.skip(ftype)
4079 
      iprot.readFieldEnd()
4080 
    iprot.readStructEnd()
4081 
 
4082 
  def write(self, oprot):
4083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4085 
      return
4086 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4087 
    if self.transaction is not None:
94 ashish 4088 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4089 
      self.transaction.write(oprot)
4090 
      oprot.writeFieldEnd()
4091 
    oprot.writeFieldStop()
4092 
    oprot.writeStructEnd()
4093 
 
3431 rajveer 4094 
  def validate(self):
4095 
    return
4096 
 
4097 
 
94 ashish 4098 
  def __repr__(self):
4099 
    L = ['%s=%r' % (key, value)
4100 
      for key, value in self.__dict__.iteritems()]
4101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4102 
 
4103 
  def __eq__(self, other):
4104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4105 
 
4106 
  def __ne__(self, other):
4107 
    return not (self == other)
4108 
 
4109 
class createTransaction_result:
4110 
  """
4111 
  Attributes:
132 ashish 4112 
   - success
94 ashish 4113 
   - ex
4114 
  """
4115 
 
4116 
  thrift_spec = (
132 ashish 4117 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4118 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4119 
  )
4120 
 
132 ashish 4121 
  def __init__(self, success=None, ex=None,):
4122 
    self.success = success
94 ashish 4123 
    self.ex = ex
4124 
 
4125 
  def read(self, iprot):
4126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4128 
      return
4129 
    iprot.readStructBegin()
4130 
    while True:
4131 
      (fname, ftype, fid) = iprot.readFieldBegin()
4132 
      if ftype == TType.STOP:
4133 
        break
132 ashish 4134 
      if fid == 0:
4135 
        if ftype == TType.I64:
4136 
          self.success = iprot.readI64();
4137 
        else:
4138 
          iprot.skip(ftype)
4139 
      elif fid == 1:
94 ashish 4140 
        if ftype == TType.STRUCT:
4141 
          self.ex = TransactionServiceException()
4142 
          self.ex.read(iprot)
4143 
        else:
4144 
          iprot.skip(ftype)
4145 
      else:
4146 
        iprot.skip(ftype)
4147 
      iprot.readFieldEnd()
4148 
    iprot.readStructEnd()
4149 
 
4150 
  def write(self, oprot):
4151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4153 
      return
4154 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4155 
    if self.success is not None:
132 ashish 4156 
      oprot.writeFieldBegin('success', TType.I64, 0)
4157 
      oprot.writeI64(self.success)
4158 
      oprot.writeFieldEnd()
3431 rajveer 4159 
    if self.ex is not None:
94 ashish 4160 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4161 
      self.ex.write(oprot)
4162 
      oprot.writeFieldEnd()
4163 
    oprot.writeFieldStop()
4164 
    oprot.writeStructEnd()
4165 
 
3431 rajveer 4166 
  def validate(self):
4167 
    return
4168 
 
4169 
 
94 ashish 4170 
  def __repr__(self):
4171 
    L = ['%s=%r' % (key, value)
4172 
      for key, value in self.__dict__.iteritems()]
4173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4174 
 
4175 
  def __eq__(self, other):
4176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4177 
 
4178 
  def __ne__(self, other):
4179 
    return not (self == other)
4180 
 
4181 
class getTransaction_args:
4182 
  """
4183 
  Attributes:
4184 
   - id
4185 
  """
4186 
 
4187 
  thrift_spec = (
4188 
    None, # 0
4189 
    (1, TType.I64, 'id', None, None, ), # 1
4190 
  )
4191 
 
4192 
  def __init__(self, id=None,):
4193 
    self.id = id
4194 
 
4195 
  def read(self, iprot):
4196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4198 
      return
4199 
    iprot.readStructBegin()
4200 
    while True:
4201 
      (fname, ftype, fid) = iprot.readFieldBegin()
4202 
      if ftype == TType.STOP:
4203 
        break
4204 
      if fid == 1:
4205 
        if ftype == TType.I64:
4206 
          self.id = iprot.readI64();
4207 
        else:
4208 
          iprot.skip(ftype)
4209 
      else:
4210 
        iprot.skip(ftype)
4211 
      iprot.readFieldEnd()
4212 
    iprot.readStructEnd()
4213 
 
4214 
  def write(self, oprot):
4215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4217 
      return
4218 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 4219 
    if self.id is not None:
94 ashish 4220 
      oprot.writeFieldBegin('id', TType.I64, 1)
4221 
      oprot.writeI64(self.id)
4222 
      oprot.writeFieldEnd()
4223 
    oprot.writeFieldStop()
4224 
    oprot.writeStructEnd()
4225 
 
3431 rajveer 4226 
  def validate(self):
4227 
    return
4228 
 
4229 
 
94 ashish 4230 
  def __repr__(self):
4231 
    L = ['%s=%r' % (key, value)
4232 
      for key, value in self.__dict__.iteritems()]
4233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4234 
 
4235 
  def __eq__(self, other):
4236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4237 
 
4238 
  def __ne__(self, other):
4239 
    return not (self == other)
4240 
 
4241 
class getTransaction_result:
4242 
  """
4243 
  Attributes:
4244 
   - success
4245 
   - ex
4246 
  """
4247 
 
4248 
  thrift_spec = (
4249 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
4250 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4251 
  )
4252 
 
4253 
  def __init__(self, success=None, ex=None,):
4254 
    self.success = success
4255 
    self.ex = ex
4256 
 
4257 
  def read(self, iprot):
4258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4260 
      return
4261 
    iprot.readStructBegin()
4262 
    while True:
4263 
      (fname, ftype, fid) = iprot.readFieldBegin()
4264 
      if ftype == TType.STOP:
4265 
        break
4266 
      if fid == 0:
4267 
        if ftype == TType.STRUCT:
4268 
          self.success = Transaction()
4269 
          self.success.read(iprot)
4270 
        else:
4271 
          iprot.skip(ftype)
4272 
      elif fid == 1:
4273 
        if ftype == TType.STRUCT:
4274 
          self.ex = TransactionServiceException()
4275 
          self.ex.read(iprot)
4276 
        else:
4277 
          iprot.skip(ftype)
4278 
      else:
4279 
        iprot.skip(ftype)
4280 
      iprot.readFieldEnd()
4281 
    iprot.readStructEnd()
4282 
 
4283 
  def write(self, oprot):
4284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4286 
      return
4287 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 4288 
    if self.success is not None:
94 ashish 4289 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4290 
      self.success.write(oprot)
4291 
      oprot.writeFieldEnd()
3431 rajveer 4292 
    if self.ex is not None:
94 ashish 4293 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4294 
      self.ex.write(oprot)
4295 
      oprot.writeFieldEnd()
4296 
    oprot.writeFieldStop()
4297 
    oprot.writeStructEnd()
4298 
 
3431 rajveer 4299 
  def validate(self):
4300 
    return
4301 
 
4302 
 
94 ashish 4303 
  def __repr__(self):
4304 
    L = ['%s=%r' % (key, value)
4305 
      for key, value in self.__dict__.iteritems()]
4306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4307 
 
4308 
  def __eq__(self, other):
4309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4310 
 
4311 
  def __ne__(self, other):
4312 
    return not (self == other)
4313 
 
4314 
class getTransactionsForCustomer_args:
4315 
  """
4316 
  Attributes:
4317 
   - customerId
4318 
   - from_date
4319 
   - to_date
4320 
   - status
4321 
  """
4322 
 
4323 
  thrift_spec = (
4324 
    None, # 0
4325 
    (1, TType.I64, 'customerId', None, None, ), # 1
4326 
    (2, TType.I64, 'from_date', None, None, ), # 2
4327 
    (3, TType.I64, 'to_date', None, None, ), # 3
4328 
    (4, TType.I32, 'status', None, None, ), # 4
4329 
  )
4330 
 
4331 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
4332 
    self.customerId = customerId
4333 
    self.from_date = from_date
4334 
    self.to_date = to_date
4335 
    self.status = status
4336 
 
4337 
  def read(self, iprot):
4338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4340 
      return
4341 
    iprot.readStructBegin()
4342 
    while True:
4343 
      (fname, ftype, fid) = iprot.readFieldBegin()
4344 
      if ftype == TType.STOP:
4345 
        break
4346 
      if fid == 1:
4347 
        if ftype == TType.I64:
4348 
          self.customerId = iprot.readI64();
4349 
        else:
4350 
          iprot.skip(ftype)
4351 
      elif fid == 2:
4352 
        if ftype == TType.I64:
4353 
          self.from_date = iprot.readI64();
4354 
        else:
4355 
          iprot.skip(ftype)
4356 
      elif fid == 3:
4357 
        if ftype == TType.I64:
4358 
          self.to_date = iprot.readI64();
4359 
        else:
4360 
          iprot.skip(ftype)
4361 
      elif fid == 4:
4362 
        if ftype == TType.I32:
4363 
          self.status = iprot.readI32();
4364 
        else:
4365 
          iprot.skip(ftype)
4366 
      else:
4367 
        iprot.skip(ftype)
4368 
      iprot.readFieldEnd()
4369 
    iprot.readStructEnd()
4370 
 
4371 
  def write(self, oprot):
4372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4374 
      return
4375 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 4376 
    if self.customerId is not None:
94 ashish 4377 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
4378 
      oprot.writeI64(self.customerId)
4379 
      oprot.writeFieldEnd()
3431 rajveer 4380 
    if self.from_date is not None:
94 ashish 4381 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4382 
      oprot.writeI64(self.from_date)
4383 
      oprot.writeFieldEnd()
3431 rajveer 4384 
    if self.to_date is not None:
94 ashish 4385 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4386 
      oprot.writeI64(self.to_date)
4387 
      oprot.writeFieldEnd()
3431 rajveer 4388 
    if self.status is not None:
94 ashish 4389 
      oprot.writeFieldBegin('status', TType.I32, 4)
4390 
      oprot.writeI32(self.status)
4391 
      oprot.writeFieldEnd()
4392 
    oprot.writeFieldStop()
4393 
    oprot.writeStructEnd()
4394 
 
3431 rajveer 4395 
  def validate(self):
4396 
    return
4397 
 
4398 
 
94 ashish 4399 
  def __repr__(self):
4400 
    L = ['%s=%r' % (key, value)
4401 
      for key, value in self.__dict__.iteritems()]
4402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4403 
 
4404 
  def __eq__(self, other):
4405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4406 
 
4407 
  def __ne__(self, other):
4408 
    return not (self == other)
4409 
 
4410 
class getTransactionsForCustomer_result:
4411 
  """
4412 
  Attributes:
4413 
   - success
4414 
   - ex
4415 
  """
4416 
 
4417 
  thrift_spec = (
4418 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4419 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4420 
  )
4421 
 
4422 
  def __init__(self, success=None, ex=None,):
4423 
    self.success = success
4424 
    self.ex = ex
4425 
 
4426 
  def read(self, iprot):
4427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4429 
      return
4430 
    iprot.readStructBegin()
4431 
    while True:
4432 
      (fname, ftype, fid) = iprot.readFieldBegin()
4433 
      if ftype == TType.STOP:
4434 
        break
4435 
      if fid == 0:
4436 
        if ftype == TType.LIST:
4437 
          self.success = []
685 chandransh 4438 
          (_etype17, _size14) = iprot.readListBegin()
4439 
          for _i18 in xrange(_size14):
4440 
            _elem19 = Transaction()
4441 
            _elem19.read(iprot)
4442 
            self.success.append(_elem19)
94 ashish 4443 
          iprot.readListEnd()
4444 
        else:
4445 
          iprot.skip(ftype)
4446 
      elif fid == 1:
4447 
        if ftype == TType.STRUCT:
4448 
          self.ex = TransactionServiceException()
4449 
          self.ex.read(iprot)
4450 
        else:
4451 
          iprot.skip(ftype)
4452 
      else:
4453 
        iprot.skip(ftype)
4454 
      iprot.readFieldEnd()
4455 
    iprot.readStructEnd()
4456 
 
4457 
  def write(self, oprot):
4458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4460 
      return
4461 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 4462 
    if self.success is not None:
94 ashish 4463 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4464 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4465 
      for iter20 in self.success:
4466 
        iter20.write(oprot)
94 ashish 4467 
      oprot.writeListEnd()
4468 
      oprot.writeFieldEnd()
3431 rajveer 4469 
    if self.ex is not None:
94 ashish 4470 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4471 
      self.ex.write(oprot)
4472 
      oprot.writeFieldEnd()
4473 
    oprot.writeFieldStop()
4474 
    oprot.writeStructEnd()
4475 
 
3431 rajveer 4476 
  def validate(self):
4477 
    return
4478 
 
4479 
 
94 ashish 4480 
  def __repr__(self):
4481 
    L = ['%s=%r' % (key, value)
4482 
      for key, value in self.__dict__.iteritems()]
4483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4484 
 
4485 
  def __eq__(self, other):
4486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4487 
 
4488 
  def __ne__(self, other):
4489 
    return not (self == other)
4490 
 
132 ashish 4491 
class getTransactionsForShoppingCartId_args:
4492 
  """
4493 
  Attributes:
4494 
   - shoppingCartId
4495 
  """
4496 
 
4497 
  thrift_spec = (
4498 
    None, # 0
4499 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
4500 
  )
4501 
 
4502 
  def __init__(self, shoppingCartId=None,):
4503 
    self.shoppingCartId = shoppingCartId
4504 
 
4505 
  def read(self, iprot):
4506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4508 
      return
4509 
    iprot.readStructBegin()
4510 
    while True:
4511 
      (fname, ftype, fid) = iprot.readFieldBegin()
4512 
      if ftype == TType.STOP:
4513 
        break
4514 
      if fid == 1:
4515 
        if ftype == TType.I64:
4516 
          self.shoppingCartId = iprot.readI64();
4517 
        else:
4518 
          iprot.skip(ftype)
4519 
      else:
4520 
        iprot.skip(ftype)
4521 
      iprot.readFieldEnd()
4522 
    iprot.readStructEnd()
4523 
 
4524 
  def write(self, oprot):
4525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4527 
      return
4528 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 4529 
    if self.shoppingCartId is not None:
132 ashish 4530 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
4531 
      oprot.writeI64(self.shoppingCartId)
4532 
      oprot.writeFieldEnd()
4533 
    oprot.writeFieldStop()
4534 
    oprot.writeStructEnd()
4535 
 
3431 rajveer 4536 
  def validate(self):
4537 
    return
4538 
 
4539 
 
132 ashish 4540 
  def __repr__(self):
4541 
    L = ['%s=%r' % (key, value)
4542 
      for key, value in self.__dict__.iteritems()]
4543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4544 
 
4545 
  def __eq__(self, other):
4546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4547 
 
4548 
  def __ne__(self, other):
4549 
    return not (self == other)
4550 
 
4551 
class getTransactionsForShoppingCartId_result:
4552 
  """
4553 
  Attributes:
4554 
   - success
4555 
   - ex
4556 
  """
4557 
 
4558 
  thrift_spec = (
4559 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4560 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4561 
  )
4562 
 
4563 
  def __init__(self, success=None, ex=None,):
4564 
    self.success = success
4565 
    self.ex = ex
4566 
 
4567 
  def read(self, iprot):
4568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4570 
      return
4571 
    iprot.readStructBegin()
4572 
    while True:
4573 
      (fname, ftype, fid) = iprot.readFieldBegin()
4574 
      if ftype == TType.STOP:
4575 
        break
4576 
      if fid == 0:
4577 
        if ftype == TType.LIST:
4578 
          self.success = []
685 chandransh 4579 
          (_etype24, _size21) = iprot.readListBegin()
4580 
          for _i25 in xrange(_size21):
4581 
            _elem26 = Transaction()
4582 
            _elem26.read(iprot)
4583 
            self.success.append(_elem26)
132 ashish 4584 
          iprot.readListEnd()
4585 
        else:
4586 
          iprot.skip(ftype)
4587 
      elif fid == 1:
4588 
        if ftype == TType.STRUCT:
4589 
          self.ex = TransactionServiceException()
4590 
          self.ex.read(iprot)
4591 
        else:
4592 
          iprot.skip(ftype)
4593 
      else:
4594 
        iprot.skip(ftype)
4595 
      iprot.readFieldEnd()
4596 
    iprot.readStructEnd()
4597 
 
4598 
  def write(self, oprot):
4599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4601 
      return
4602 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 4603 
    if self.success is not None:
132 ashish 4604 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4605 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4606 
      for iter27 in self.success:
4607 
        iter27.write(oprot)
132 ashish 4608 
      oprot.writeListEnd()
4609 
      oprot.writeFieldEnd()
3431 rajveer 4610 
    if self.ex is not None:
132 ashish 4611 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4612 
      self.ex.write(oprot)
4613 
      oprot.writeFieldEnd()
4614 
    oprot.writeFieldStop()
4615 
    oprot.writeStructEnd()
4616 
 
3431 rajveer 4617 
  def validate(self):
4618 
    return
4619 
 
4620 
 
132 ashish 4621 
  def __repr__(self):
4622 
    L = ['%s=%r' % (key, value)
4623 
      for key, value in self.__dict__.iteritems()]
4624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4625 
 
4626 
  def __eq__(self, other):
4627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4628 
 
4629 
  def __ne__(self, other):
4630 
    return not (self == other)
4631 
 
94 ashish 4632 
class getTransactionStatus_args:
4633 
  """
4634 
  Attributes:
4635 
   - transactionId
4636 
  """
4637 
 
4638 
  thrift_spec = (
4639 
    None, # 0
4640 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4641 
  )
4642 
 
4643 
  def __init__(self, transactionId=None,):
4644 
    self.transactionId = transactionId
4645 
 
4646 
  def read(self, iprot):
4647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4649 
      return
4650 
    iprot.readStructBegin()
4651 
    while True:
4652 
      (fname, ftype, fid) = iprot.readFieldBegin()
4653 
      if ftype == TType.STOP:
4654 
        break
4655 
      if fid == 1:
4656 
        if ftype == TType.I64:
4657 
          self.transactionId = iprot.readI64();
4658 
        else:
4659 
          iprot.skip(ftype)
4660 
      else:
4661 
        iprot.skip(ftype)
4662 
      iprot.readFieldEnd()
4663 
    iprot.readStructEnd()
4664 
 
4665 
  def write(self, oprot):
4666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4668 
      return
4669 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 4670 
    if self.transactionId is not None:
94 ashish 4671 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4672 
      oprot.writeI64(self.transactionId)
4673 
      oprot.writeFieldEnd()
4674 
    oprot.writeFieldStop()
4675 
    oprot.writeStructEnd()
4676 
 
3431 rajveer 4677 
  def validate(self):
4678 
    return
4679 
 
4680 
 
94 ashish 4681 
  def __repr__(self):
4682 
    L = ['%s=%r' % (key, value)
4683 
      for key, value in self.__dict__.iteritems()]
4684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4685 
 
4686 
  def __eq__(self, other):
4687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4688 
 
4689 
  def __ne__(self, other):
4690 
    return not (self == other)
4691 
 
4692 
class getTransactionStatus_result:
4693 
  """
4694 
  Attributes:
4695 
   - success
4696 
   - ex
4697 
  """
4698 
 
4699 
  thrift_spec = (
4700 
    (0, TType.I32, 'success', None, None, ), # 0
4701 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4702 
  )
4703 
 
4704 
  def __init__(self, success=None, ex=None,):
4705 
    self.success = success
4706 
    self.ex = ex
4707 
 
4708 
  def read(self, iprot):
4709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4711 
      return
4712 
    iprot.readStructBegin()
4713 
    while True:
4714 
      (fname, ftype, fid) = iprot.readFieldBegin()
4715 
      if ftype == TType.STOP:
4716 
        break
4717 
      if fid == 0:
4718 
        if ftype == TType.I32:
4719 
          self.success = iprot.readI32();
4720 
        else:
4721 
          iprot.skip(ftype)
4722 
      elif fid == 1:
4723 
        if ftype == TType.STRUCT:
4724 
          self.ex = TransactionServiceException()
4725 
          self.ex.read(iprot)
4726 
        else:
4727 
          iprot.skip(ftype)
4728 
      else:
4729 
        iprot.skip(ftype)
4730 
      iprot.readFieldEnd()
4731 
    iprot.readStructEnd()
4732 
 
4733 
  def write(self, oprot):
4734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4736 
      return
4737 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 4738 
    if self.success is not None:
94 ashish 4739 
      oprot.writeFieldBegin('success', TType.I32, 0)
4740 
      oprot.writeI32(self.success)
4741 
      oprot.writeFieldEnd()
3431 rajveer 4742 
    if self.ex is not None:
94 ashish 4743 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4744 
      self.ex.write(oprot)
4745 
      oprot.writeFieldEnd()
4746 
    oprot.writeFieldStop()
4747 
    oprot.writeStructEnd()
4748 
 
3431 rajveer 4749 
  def validate(self):
4750 
    return
4751 
 
4752 
 
94 ashish 4753 
  def __repr__(self):
4754 
    L = ['%s=%r' % (key, value)
4755 
      for key, value in self.__dict__.iteritems()]
4756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4757 
 
4758 
  def __eq__(self, other):
4759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4760 
 
4761 
  def __ne__(self, other):
4762 
    return not (self == other)
4763 
 
4764 
class changeTransactionStatus_args:
4765 
  """
4766 
  Attributes:
4767 
   - transactionId
4768 
   - status
4769 
   - description
4770 
  """
4771 
 
4772 
  thrift_spec = (
4773 
    None, # 0
4774 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4775 
    (2, TType.I32, 'status', None, None, ), # 2
4776 
    (3, TType.STRING, 'description', None, None, ), # 3
4777 
  )
4778 
 
4779 
  def __init__(self, transactionId=None, status=None, description=None,):
4780 
    self.transactionId = transactionId
4781 
    self.status = status
4782 
    self.description = description
4783 
 
4784 
  def read(self, iprot):
4785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4787 
      return
4788 
    iprot.readStructBegin()
4789 
    while True:
4790 
      (fname, ftype, fid) = iprot.readFieldBegin()
4791 
      if ftype == TType.STOP:
4792 
        break
4793 
      if fid == 1:
4794 
        if ftype == TType.I64:
4795 
          self.transactionId = iprot.readI64();
4796 
        else:
4797 
          iprot.skip(ftype)
4798 
      elif fid == 2:
4799 
        if ftype == TType.I32:
4800 
          self.status = iprot.readI32();
4801 
        else:
4802 
          iprot.skip(ftype)
4803 
      elif fid == 3:
4804 
        if ftype == TType.STRING:
4805 
          self.description = iprot.readString();
4806 
        else:
4807 
          iprot.skip(ftype)
4808 
      else:
4809 
        iprot.skip(ftype)
4810 
      iprot.readFieldEnd()
4811 
    iprot.readStructEnd()
4812 
 
4813 
  def write(self, oprot):
4814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4816 
      return
4817 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 4818 
    if self.transactionId is not None:
94 ashish 4819 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4820 
      oprot.writeI64(self.transactionId)
4821 
      oprot.writeFieldEnd()
3431 rajveer 4822 
    if self.status is not None:
94 ashish 4823 
      oprot.writeFieldBegin('status', TType.I32, 2)
4824 
      oprot.writeI32(self.status)
4825 
      oprot.writeFieldEnd()
3431 rajveer 4826 
    if self.description is not None:
94 ashish 4827 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4828 
      oprot.writeString(self.description)
4829 
      oprot.writeFieldEnd()
4830 
    oprot.writeFieldStop()
4831 
    oprot.writeStructEnd()
4832 
 
3431 rajveer 4833 
  def validate(self):
4834 
    return
4835 
 
4836 
 
94 ashish 4837 
  def __repr__(self):
4838 
    L = ['%s=%r' % (key, value)
4839 
      for key, value in self.__dict__.iteritems()]
4840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4841 
 
4842 
  def __eq__(self, other):
4843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4844 
 
4845 
  def __ne__(self, other):
4846 
    return not (self == other)
4847 
 
4848 
class changeTransactionStatus_result:
4849 
  """
4850 
  Attributes:
4851 
   - success
4852 
   - ex
4853 
  """
4854 
 
4855 
  thrift_spec = (
4856 
    (0, TType.BOOL, 'success', None, None, ), # 0
4857 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4858 
  )
4859 
 
4860 
  def __init__(self, success=None, ex=None,):
4861 
    self.success = success
4862 
    self.ex = ex
4863 
 
4864 
  def read(self, iprot):
4865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4867 
      return
4868 
    iprot.readStructBegin()
4869 
    while True:
4870 
      (fname, ftype, fid) = iprot.readFieldBegin()
4871 
      if ftype == TType.STOP:
4872 
        break
4873 
      if fid == 0:
4874 
        if ftype == TType.BOOL:
4875 
          self.success = iprot.readBool();
4876 
        else:
4877 
          iprot.skip(ftype)
4878 
      elif fid == 1:
4879 
        if ftype == TType.STRUCT:
4880 
          self.ex = TransactionServiceException()
4881 
          self.ex.read(iprot)
4882 
        else:
4883 
          iprot.skip(ftype)
4884 
      else:
4885 
        iprot.skip(ftype)
4886 
      iprot.readFieldEnd()
4887 
    iprot.readStructEnd()
4888 
 
4889 
  def write(self, oprot):
4890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4892 
      return
4893 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 4894 
    if self.success is not None:
94 ashish 4895 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4896 
      oprot.writeBool(self.success)
4897 
      oprot.writeFieldEnd()
3431 rajveer 4898 
    if self.ex is not None:
94 ashish 4899 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4900 
      self.ex.write(oprot)
4901 
      oprot.writeFieldEnd()
4902 
    oprot.writeFieldStop()
4903 
    oprot.writeStructEnd()
4904 
 
3431 rajveer 4905 
  def validate(self):
4906 
    return
4907 
 
4908 
 
94 ashish 4909 
  def __repr__(self):
4910 
    L = ['%s=%r' % (key, value)
4911 
      for key, value in self.__dict__.iteritems()]
4912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4913 
 
4914 
  def __eq__(self, other):
4915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4916 
 
4917 
  def __ne__(self, other):
4918 
    return not (self == other)
4919 
 
1398 varun.gupt 4920 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 4921 
  """
4922 
  Attributes:
4923 
   - transactionId
4924 
  """
4925 
 
4926 
  thrift_spec = (
4927 
    None, # 0
4928 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4929 
  )
4930 
 
4931 
  def __init__(self, transactionId=None,):
4932 
    self.transactionId = transactionId
4933 
 
4934 
  def read(self, iprot):
4935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4937 
      return
4938 
    iprot.readStructBegin()
4939 
    while True:
4940 
      (fname, ftype, fid) = iprot.readFieldBegin()
4941 
      if ftype == TType.STOP:
4942 
        break
4943 
      if fid == 1:
4944 
        if ftype == TType.I64:
4945 
          self.transactionId = iprot.readI64();
4946 
        else:
4947 
          iprot.skip(ftype)
4948 
      else:
4949 
        iprot.skip(ftype)
4950 
      iprot.readFieldEnd()
4951 
    iprot.readStructEnd()
4952 
 
4953 
  def write(self, oprot):
4954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4956 
      return
1398 varun.gupt 4957 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 4958 
    if self.transactionId is not None:
1382 varun.gupt 4959 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4960 
      oprot.writeI64(self.transactionId)
4961 
      oprot.writeFieldEnd()
4962 
    oprot.writeFieldStop()
4963 
    oprot.writeStructEnd()
4964 
 
3431 rajveer 4965 
  def validate(self):
4966 
    return
4967 
 
4968 
 
1382 varun.gupt 4969 
  def __repr__(self):
4970 
    L = ['%s=%r' % (key, value)
4971 
      for key, value in self.__dict__.iteritems()]
4972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4973 
 
4974 
  def __eq__(self, other):
4975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4976 
 
4977 
  def __ne__(self, other):
4978 
    return not (self == other)
4979 
 
1398 varun.gupt 4980 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 4981 
  """
4982 
  Attributes:
4983 
   - success
4984 
   - ex
4985 
  """
4986 
 
4987 
  thrift_spec = (
4988 
    (0, TType.BOOL, 'success', None, None, ), # 0
4989 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4990 
  )
4991 
 
4992 
  def __init__(self, success=None, ex=None,):
4993 
    self.success = success
4994 
    self.ex = ex
4995 
 
4996 
  def read(self, iprot):
4997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4999 
      return
5000 
    iprot.readStructBegin()
5001 
    while True:
5002 
      (fname, ftype, fid) = iprot.readFieldBegin()
5003 
      if ftype == TType.STOP:
5004 
        break
5005 
      if fid == 0:
5006 
        if ftype == TType.BOOL:
5007 
          self.success = iprot.readBool();
5008 
        else:
5009 
          iprot.skip(ftype)
5010 
      elif fid == 1:
5011 
        if ftype == TType.STRUCT:
5012 
          self.ex = TransactionServiceException()
5013 
          self.ex.read(iprot)
5014 
        else:
5015 
          iprot.skip(ftype)
5016 
      else:
5017 
        iprot.skip(ftype)
5018 
      iprot.readFieldEnd()
5019 
    iprot.readStructEnd()
5020 
 
5021 
  def write(self, oprot):
5022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5024 
      return
1398 varun.gupt 5025 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5026 
    if self.success is not None:
1382 varun.gupt 5027 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5028 
      oprot.writeBool(self.success)
5029 
      oprot.writeFieldEnd()
3431 rajveer 5030 
    if self.ex is not None:
1382 varun.gupt 5031 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5032 
      self.ex.write(oprot)
5033 
      oprot.writeFieldEnd()
5034 
    oprot.writeFieldStop()
5035 
    oprot.writeStructEnd()
5036 
 
3431 rajveer 5037 
  def validate(self):
5038 
    return
5039 
 
5040 
 
1382 varun.gupt 5041 
  def __repr__(self):
5042 
    L = ['%s=%r' % (key, value)
5043 
      for key, value in self.__dict__.iteritems()]
5044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5045 
 
5046 
  def __eq__(self, other):
5047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5048 
 
5049 
  def __ne__(self, other):
5050 
    return not (self == other)
5051 
 
483 rajveer 5052 
class getAllOrders_args:
94 ashish 5053 
  """
5054 
  Attributes:
483 rajveer 5055 
   - status
5056 
   - from_date
5057 
   - to_date
5058 
   - warehouse_id
94 ashish 5059 
  """
5060 
 
5061 
  thrift_spec = (
5062 
    None, # 0
483 rajveer 5063 
    (1, TType.I32, 'status', None, None, ), # 1
5064 
    (2, TType.I64, 'from_date', None, None, ), # 2
5065 
    (3, TType.I64, 'to_date', None, None, ), # 3
5066 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5067 
  )
5068 
 
483 rajveer 5069 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5070 
    self.status = status
5071 
    self.from_date = from_date
5072 
    self.to_date = to_date
5073 
    self.warehouse_id = warehouse_id
94 ashish 5074 
 
5075 
  def read(self, iprot):
5076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5078 
      return
5079 
    iprot.readStructBegin()
5080 
    while True:
5081 
      (fname, ftype, fid) = iprot.readFieldBegin()
5082 
      if ftype == TType.STOP:
5083 
        break
5084 
      if fid == 1:
483 rajveer 5085 
        if ftype == TType.I32:
5086 
          self.status = iprot.readI32();
94 ashish 5087 
        else:
5088 
          iprot.skip(ftype)
483 rajveer 5089 
      elif fid == 2:
5090 
        if ftype == TType.I64:
5091 
          self.from_date = iprot.readI64();
94 ashish 5092 
        else:
5093 
          iprot.skip(ftype)
483 rajveer 5094 
      elif fid == 3:
5095 
        if ftype == TType.I64:
5096 
          self.to_date = iprot.readI64();
94 ashish 5097 
        else:
5098 
          iprot.skip(ftype)
483 rajveer 5099 
      elif fid == 4:
94 ashish 5100 
        if ftype == TType.I64:
483 rajveer 5101 
          self.warehouse_id = iprot.readI64();
94 ashish 5102 
        else:
5103 
          iprot.skip(ftype)
5104 
      else:
5105 
        iprot.skip(ftype)
5106 
      iprot.readFieldEnd()
5107 
    iprot.readStructEnd()
5108 
 
5109 
  def write(self, oprot):
5110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5112 
      return
483 rajveer 5113 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5114 
    if self.status is not None:
483 rajveer 5115 
      oprot.writeFieldBegin('status', TType.I32, 1)
5116 
      oprot.writeI32(self.status)
94 ashish 5117 
      oprot.writeFieldEnd()
3431 rajveer 5118 
    if self.from_date is not None:
483 rajveer 5119 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5120 
      oprot.writeI64(self.from_date)
94 ashish 5121 
      oprot.writeFieldEnd()
3431 rajveer 5122 
    if self.to_date is not None:
483 rajveer 5123 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5124 
      oprot.writeI64(self.to_date)
94 ashish 5125 
      oprot.writeFieldEnd()
3431 rajveer 5126 
    if self.warehouse_id is not None:
483 rajveer 5127 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5128 
      oprot.writeI64(self.warehouse_id)
94 ashish 5129 
      oprot.writeFieldEnd()
5130 
    oprot.writeFieldStop()
5131 
    oprot.writeStructEnd()
5132 
 
3431 rajveer 5133 
  def validate(self):
5134 
    return
5135 
 
5136 
 
94 ashish 5137 
  def __repr__(self):
5138 
    L = ['%s=%r' % (key, value)
5139 
      for key, value in self.__dict__.iteritems()]
5140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5141 
 
5142 
  def __eq__(self, other):
5143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5144 
 
5145 
  def __ne__(self, other):
5146 
    return not (self == other)
5147 
 
483 rajveer 5148 
class getAllOrders_result:
94 ashish 5149 
  """
5150 
  Attributes:
5151 
   - success
5152 
   - ex
5153 
  """
5154 
 
5155 
  thrift_spec = (
483 rajveer 5156 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5157 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5158 
  )
5159 
 
5160 
  def __init__(self, success=None, ex=None,):
5161 
    self.success = success
5162 
    self.ex = ex
5163 
 
5164 
  def read(self, iprot):
5165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5167 
      return
5168 
    iprot.readStructBegin()
5169 
    while True:
5170 
      (fname, ftype, fid) = iprot.readFieldBegin()
5171 
      if ftype == TType.STOP:
5172 
        break
5173 
      if fid == 0:
483 rajveer 5174 
        if ftype == TType.LIST:
5175 
          self.success = []
685 chandransh 5176 
          (_etype31, _size28) = iprot.readListBegin()
5177 
          for _i32 in xrange(_size28):
5178 
            _elem33 = Order()
5179 
            _elem33.read(iprot)
5180 
            self.success.append(_elem33)
483 rajveer 5181 
          iprot.readListEnd()
94 ashish 5182 
        else:
5183 
          iprot.skip(ftype)
5184 
      elif fid == 1:
5185 
        if ftype == TType.STRUCT:
5186 
          self.ex = TransactionServiceException()
5187 
          self.ex.read(iprot)
5188 
        else:
5189 
          iprot.skip(ftype)
5190 
      else:
5191 
        iprot.skip(ftype)
5192 
      iprot.readFieldEnd()
5193 
    iprot.readStructEnd()
5194 
 
5195 
  def write(self, oprot):
5196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5198 
      return
483 rajveer 5199 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5200 
    if self.success is not None:
483 rajveer 5201 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5202 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5203 
      for iter34 in self.success:
5204 
        iter34.write(oprot)
483 rajveer 5205 
      oprot.writeListEnd()
94 ashish 5206 
      oprot.writeFieldEnd()
3431 rajveer 5207 
    if self.ex is not None:
94 ashish 5208 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5209 
      self.ex.write(oprot)
5210 
      oprot.writeFieldEnd()
5211 
    oprot.writeFieldStop()
5212 
    oprot.writeStructEnd()
5213 
 
3431 rajveer 5214 
  def validate(self):
5215 
    return
5216 
 
5217 
 
94 ashish 5218 
  def __repr__(self):
5219 
    L = ['%s=%r' % (key, value)
5220 
      for key, value in self.__dict__.iteritems()]
5221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5222 
 
5223 
  def __eq__(self, other):
5224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5225 
 
5226 
  def __ne__(self, other):
5227 
    return not (self == other)
5228 
 
4133 chandransh 5229 
class getOrdersInBatch_args:
5230 
  """
5231 
  Attributes:
5232 
   - statuses
5233 
   - offset
5234 
   - limit
5235 
   - warehouse_id
5236 
  """
5237 
 
5238 
  thrift_spec = (
5239 
    None, # 0
5240 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5241 
    (2, TType.I64, 'offset', None, None, ), # 2
5242 
    (3, TType.I64, 'limit', None, None, ), # 3
5243 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5244 
  )
5245 
 
5246 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
5247 
    self.statuses = statuses
5248 
    self.offset = offset
5249 
    self.limit = limit
5250 
    self.warehouse_id = warehouse_id
5251 
 
5252 
  def read(self, iprot):
5253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5255 
      return
5256 
    iprot.readStructBegin()
5257 
    while True:
5258 
      (fname, ftype, fid) = iprot.readFieldBegin()
5259 
      if ftype == TType.STOP:
5260 
        break
5261 
      if fid == 1:
5262 
        if ftype == TType.LIST:
5263 
          self.statuses = []
5264 
          (_etype38, _size35) = iprot.readListBegin()
5265 
          for _i39 in xrange(_size35):
5266 
            _elem40 = iprot.readI32();
5267 
            self.statuses.append(_elem40)
5268 
          iprot.readListEnd()
5269 
        else:
5270 
          iprot.skip(ftype)
5271 
      elif fid == 2:
5272 
        if ftype == TType.I64:
5273 
          self.offset = iprot.readI64();
5274 
        else:
5275 
          iprot.skip(ftype)
5276 
      elif fid == 3:
5277 
        if ftype == TType.I64:
5278 
          self.limit = iprot.readI64();
5279 
        else:
5280 
          iprot.skip(ftype)
5281 
      elif fid == 4:
5282 
        if ftype == TType.I64:
5283 
          self.warehouse_id = iprot.readI64();
5284 
        else:
5285 
          iprot.skip(ftype)
5286 
      else:
5287 
        iprot.skip(ftype)
5288 
      iprot.readFieldEnd()
5289 
    iprot.readStructEnd()
5290 
 
5291 
  def write(self, oprot):
5292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5294 
      return
5295 
    oprot.writeStructBegin('getOrdersInBatch_args')
5296 
    if self.statuses is not None:
5297 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5298 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5299 
      for iter41 in self.statuses:
5300 
        oprot.writeI32(iter41)
5301 
      oprot.writeListEnd()
5302 
      oprot.writeFieldEnd()
5303 
    if self.offset is not None:
5304 
      oprot.writeFieldBegin('offset', TType.I64, 2)
5305 
      oprot.writeI64(self.offset)
5306 
      oprot.writeFieldEnd()
5307 
    if self.limit is not None:
5308 
      oprot.writeFieldBegin('limit', TType.I64, 3)
5309 
      oprot.writeI64(self.limit)
5310 
      oprot.writeFieldEnd()
5311 
    if self.warehouse_id is not None:
5312 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5313 
      oprot.writeI64(self.warehouse_id)
5314 
      oprot.writeFieldEnd()
5315 
    oprot.writeFieldStop()
5316 
    oprot.writeStructEnd()
5317 
 
5318 
  def validate(self):
5319 
    return
5320 
 
5321 
 
5322 
  def __repr__(self):
5323 
    L = ['%s=%r' % (key, value)
5324 
      for key, value in self.__dict__.iteritems()]
5325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5326 
 
5327 
  def __eq__(self, other):
5328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5329 
 
5330 
  def __ne__(self, other):
5331 
    return not (self == other)
5332 
 
5333 
class getOrdersInBatch_result:
5334 
  """
5335 
  Attributes:
5336 
   - success
5337 
   - ex
5338 
  """
5339 
 
5340 
  thrift_spec = (
5341 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5342 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5343 
  )
5344 
 
5345 
  def __init__(self, success=None, ex=None,):
5346 
    self.success = success
5347 
    self.ex = ex
5348 
 
5349 
  def read(self, iprot):
5350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5352 
      return
5353 
    iprot.readStructBegin()
5354 
    while True:
5355 
      (fname, ftype, fid) = iprot.readFieldBegin()
5356 
      if ftype == TType.STOP:
5357 
        break
5358 
      if fid == 0:
5359 
        if ftype == TType.LIST:
5360 
          self.success = []
5361 
          (_etype45, _size42) = iprot.readListBegin()
5362 
          for _i46 in xrange(_size42):
5363 
            _elem47 = Order()
5364 
            _elem47.read(iprot)
5365 
            self.success.append(_elem47)
5366 
          iprot.readListEnd()
5367 
        else:
5368 
          iprot.skip(ftype)
5369 
      elif fid == 1:
5370 
        if ftype == TType.STRUCT:
5371 
          self.ex = TransactionServiceException()
5372 
          self.ex.read(iprot)
5373 
        else:
5374 
          iprot.skip(ftype)
5375 
      else:
5376 
        iprot.skip(ftype)
5377 
      iprot.readFieldEnd()
5378 
    iprot.readStructEnd()
5379 
 
5380 
  def write(self, oprot):
5381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5383 
      return
5384 
    oprot.writeStructBegin('getOrdersInBatch_result')
5385 
    if self.success is not None:
5386 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5387 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5388 
      for iter48 in self.success:
5389 
        iter48.write(oprot)
5390 
      oprot.writeListEnd()
5391 
      oprot.writeFieldEnd()
5392 
    if self.ex is not None:
5393 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5394 
      self.ex.write(oprot)
5395 
      oprot.writeFieldEnd()
5396 
    oprot.writeFieldStop()
5397 
    oprot.writeStructEnd()
5398 
 
5399 
  def validate(self):
5400 
    return
5401 
 
5402 
 
5403 
  def __repr__(self):
5404 
    L = ['%s=%r' % (key, value)
5405 
      for key, value in self.__dict__.iteritems()]
5406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5407 
 
5408 
  def __eq__(self, other):
5409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5410 
 
5411 
  def __ne__(self, other):
5412 
    return not (self == other)
5413 
 
5414 
class getOrderCount_args:
5415 
  """
5416 
  Attributes:
5417 
   - statuses
5418 
   - warehouseId
5419 
  """
5420 
 
5421 
  thrift_spec = (
5422 
    None, # 0
5423 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5424 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5425 
  )
5426 
 
5427 
  def __init__(self, statuses=None, warehouseId=None,):
5428 
    self.statuses = statuses
5429 
    self.warehouseId = warehouseId
5430 
 
5431 
  def read(self, iprot):
5432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5434 
      return
5435 
    iprot.readStructBegin()
5436 
    while True:
5437 
      (fname, ftype, fid) = iprot.readFieldBegin()
5438 
      if ftype == TType.STOP:
5439 
        break
5440 
      if fid == 1:
5441 
        if ftype == TType.LIST:
5442 
          self.statuses = []
5443 
          (_etype52, _size49) = iprot.readListBegin()
5444 
          for _i53 in xrange(_size49):
5445 
            _elem54 = iprot.readI32();
5446 
            self.statuses.append(_elem54)
5447 
          iprot.readListEnd()
5448 
        else:
5449 
          iprot.skip(ftype)
5450 
      elif fid == 2:
5451 
        if ftype == TType.I64:
5452 
          self.warehouseId = iprot.readI64();
5453 
        else:
5454 
          iprot.skip(ftype)
5455 
      else:
5456 
        iprot.skip(ftype)
5457 
      iprot.readFieldEnd()
5458 
    iprot.readStructEnd()
5459 
 
5460 
  def write(self, oprot):
5461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5463 
      return
5464 
    oprot.writeStructBegin('getOrderCount_args')
5465 
    if self.statuses is not None:
5466 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5467 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5468 
      for iter55 in self.statuses:
5469 
        oprot.writeI32(iter55)
5470 
      oprot.writeListEnd()
5471 
      oprot.writeFieldEnd()
5472 
    if self.warehouseId is not None:
5473 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5474 
      oprot.writeI64(self.warehouseId)
5475 
      oprot.writeFieldEnd()
5476 
    oprot.writeFieldStop()
5477 
    oprot.writeStructEnd()
5478 
 
5479 
  def validate(self):
5480 
    return
5481 
 
5482 
 
5483 
  def __repr__(self):
5484 
    L = ['%s=%r' % (key, value)
5485 
      for key, value in self.__dict__.iteritems()]
5486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5487 
 
5488 
  def __eq__(self, other):
5489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5490 
 
5491 
  def __ne__(self, other):
5492 
    return not (self == other)
5493 
 
5494 
class getOrderCount_result:
5495 
  """
5496 
  Attributes:
5497 
   - success
5498 
   - ex
5499 
  """
5500 
 
5501 
  thrift_spec = (
5502 
    (0, TType.I32, 'success', None, None, ), # 0
5503 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5504 
  )
5505 
 
5506 
  def __init__(self, success=None, ex=None,):
5507 
    self.success = success
5508 
    self.ex = ex
5509 
 
5510 
  def read(self, iprot):
5511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5513 
      return
5514 
    iprot.readStructBegin()
5515 
    while True:
5516 
      (fname, ftype, fid) = iprot.readFieldBegin()
5517 
      if ftype == TType.STOP:
5518 
        break
5519 
      if fid == 0:
5520 
        if ftype == TType.I32:
5521 
          self.success = iprot.readI32();
5522 
        else:
5523 
          iprot.skip(ftype)
5524 
      elif fid == 1:
5525 
        if ftype == TType.STRUCT:
5526 
          self.ex = TransactionServiceException()
5527 
          self.ex.read(iprot)
5528 
        else:
5529 
          iprot.skip(ftype)
5530 
      else:
5531 
        iprot.skip(ftype)
5532 
      iprot.readFieldEnd()
5533 
    iprot.readStructEnd()
5534 
 
5535 
  def write(self, oprot):
5536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5538 
      return
5539 
    oprot.writeStructBegin('getOrderCount_result')
5540 
    if self.success is not None:
5541 
      oprot.writeFieldBegin('success', TType.I32, 0)
5542 
      oprot.writeI32(self.success)
5543 
      oprot.writeFieldEnd()
5544 
    if self.ex is not None:
5545 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5546 
      self.ex.write(oprot)
5547 
      oprot.writeFieldEnd()
5548 
    oprot.writeFieldStop()
5549 
    oprot.writeStructEnd()
5550 
 
5551 
  def validate(self):
5552 
    return
5553 
 
5554 
 
5555 
  def __repr__(self):
5556 
    L = ['%s=%r' % (key, value)
5557 
      for key, value in self.__dict__.iteritems()]
5558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5559 
 
5560 
  def __eq__(self, other):
5561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5562 
 
5563 
  def __ne__(self, other):
5564 
    return not (self == other)
5565 
 
999 varun.gupt 5566 
class getOrdersByBillingDate_args:
5567 
  """
5568 
  Attributes:
5569 
   - status
5570 
   - start_billing_date
5571 
   - end_billing_date
5572 
   - warehouse_id
5573 
  """
5574 
 
5575 
  thrift_spec = (
5576 
    None, # 0
5577 
    (1, TType.I32, 'status', None, None, ), # 1
5578 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
5579 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
5580 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5581 
  )
5582 
 
5583 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
5584 
    self.status = status
5585 
    self.start_billing_date = start_billing_date
5586 
    self.end_billing_date = end_billing_date
5587 
    self.warehouse_id = warehouse_id
5588 
 
5589 
  def read(self, iprot):
5590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5592 
      return
5593 
    iprot.readStructBegin()
5594 
    while True:
5595 
      (fname, ftype, fid) = iprot.readFieldBegin()
5596 
      if ftype == TType.STOP:
5597 
        break
5598 
      if fid == 1:
5599 
        if ftype == TType.I32:
5600 
          self.status = iprot.readI32();
5601 
        else:
5602 
          iprot.skip(ftype)
5603 
      elif fid == 2:
5604 
        if ftype == TType.I64:
5605 
          self.start_billing_date = iprot.readI64();
5606 
        else:
5607 
          iprot.skip(ftype)
5608 
      elif fid == 3:
5609 
        if ftype == TType.I64:
5610 
          self.end_billing_date = iprot.readI64();
5611 
        else:
5612 
          iprot.skip(ftype)
5613 
      elif fid == 4:
5614 
        if ftype == TType.I64:
5615 
          self.warehouse_id = iprot.readI64();
5616 
        else:
5617 
          iprot.skip(ftype)
5618 
      else:
5619 
        iprot.skip(ftype)
5620 
      iprot.readFieldEnd()
5621 
    iprot.readStructEnd()
5622 
 
5623 
  def write(self, oprot):
5624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5626 
      return
5627 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 5628 
    if self.status is not None:
999 varun.gupt 5629 
      oprot.writeFieldBegin('status', TType.I32, 1)
5630 
      oprot.writeI32(self.status)
5631 
      oprot.writeFieldEnd()
3431 rajveer 5632 
    if self.start_billing_date is not None:
999 varun.gupt 5633 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
5634 
      oprot.writeI64(self.start_billing_date)
5635 
      oprot.writeFieldEnd()
3431 rajveer 5636 
    if self.end_billing_date is not None:
999 varun.gupt 5637 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
5638 
      oprot.writeI64(self.end_billing_date)
5639 
      oprot.writeFieldEnd()
3431 rajveer 5640 
    if self.warehouse_id is not None:
999 varun.gupt 5641 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5642 
      oprot.writeI64(self.warehouse_id)
5643 
      oprot.writeFieldEnd()
5644 
    oprot.writeFieldStop()
5645 
    oprot.writeStructEnd()
5646 
 
3431 rajveer 5647 
  def validate(self):
5648 
    return
5649 
 
5650 
 
999 varun.gupt 5651 
  def __repr__(self):
5652 
    L = ['%s=%r' % (key, value)
5653 
      for key, value in self.__dict__.iteritems()]
5654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5655 
 
5656 
  def __eq__(self, other):
5657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5658 
 
5659 
  def __ne__(self, other):
5660 
    return not (self == other)
5661 
 
5662 
class getOrdersByBillingDate_result:
5663 
  """
5664 
  Attributes:
5665 
   - success
5666 
   - ex
5667 
  """
5668 
 
5669 
  thrift_spec = (
5670 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5671 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5672 
  )
5673 
 
5674 
  def __init__(self, success=None, ex=None,):
5675 
    self.success = success
5676 
    self.ex = ex
5677 
 
5678 
  def read(self, iprot):
5679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5681 
      return
5682 
    iprot.readStructBegin()
5683 
    while True:
5684 
      (fname, ftype, fid) = iprot.readFieldBegin()
5685 
      if ftype == TType.STOP:
5686 
        break
5687 
      if fid == 0:
5688 
        if ftype == TType.LIST:
5689 
          self.success = []
4133 chandransh 5690 
          (_etype59, _size56) = iprot.readListBegin()
5691 
          for _i60 in xrange(_size56):
5692 
            _elem61 = Order()
5693 
            _elem61.read(iprot)
5694 
            self.success.append(_elem61)
999 varun.gupt 5695 
          iprot.readListEnd()
5696 
        else:
5697 
          iprot.skip(ftype)
5698 
      elif fid == 1:
5699 
        if ftype == TType.STRUCT:
5700 
          self.ex = TransactionServiceException()
5701 
          self.ex.read(iprot)
5702 
        else:
5703 
          iprot.skip(ftype)
5704 
      else:
5705 
        iprot.skip(ftype)
5706 
      iprot.readFieldEnd()
5707 
    iprot.readStructEnd()
5708 
 
5709 
  def write(self, oprot):
5710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5712 
      return
5713 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 5714 
    if self.success is not None:
999 varun.gupt 5715 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5716 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 5717 
      for iter62 in self.success:
5718 
        iter62.write(oprot)
999 varun.gupt 5719 
      oprot.writeListEnd()
5720 
      oprot.writeFieldEnd()
3431 rajveer 5721 
    if self.ex is not None:
999 varun.gupt 5722 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5723 
      self.ex.write(oprot)
5724 
      oprot.writeFieldEnd()
5725 
    oprot.writeFieldStop()
5726 
    oprot.writeStructEnd()
5727 
 
3431 rajveer 5728 
  def validate(self):
5729 
    return
5730 
 
5731 
 
999 varun.gupt 5732 
  def __repr__(self):
5733 
    L = ['%s=%r' % (key, value)
5734 
      for key, value in self.__dict__.iteritems()]
5735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5736 
 
5737 
  def __eq__(self, other):
5738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5739 
 
5740 
  def __ne__(self, other):
5741 
    return not (self == other)
5742 
 
3427 chandransh 5743 
class getOrdersByShippingDate_args:
5744 
  """
5745 
  Attributes:
5746 
   - fromShippingDate
5747 
   - toShippingDate
5748 
   - providerId
5749 
   - warehouseId
3451 chandransh 5750 
   - cod
3427 chandransh 5751 
  """
5752 
 
5753 
  thrift_spec = (
5754 
    None, # 0
5755 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
5756 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
5757 
    (3, TType.I64, 'providerId', None, None, ), # 3
5758 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 5759 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 5760 
  )
5761 
 
3451 chandransh 5762 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 5763 
    self.fromShippingDate = fromShippingDate
5764 
    self.toShippingDate = toShippingDate
5765 
    self.providerId = providerId
5766 
    self.warehouseId = warehouseId
3451 chandransh 5767 
    self.cod = cod
3427 chandransh 5768 
 
5769 
  def read(self, iprot):
5770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5772 
      return
5773 
    iprot.readStructBegin()
5774 
    while True:
5775 
      (fname, ftype, fid) = iprot.readFieldBegin()
5776 
      if ftype == TType.STOP:
5777 
        break
5778 
      if fid == 1:
5779 
        if ftype == TType.I64:
5780 
          self.fromShippingDate = iprot.readI64();
5781 
        else:
5782 
          iprot.skip(ftype)
5783 
      elif fid == 2:
5784 
        if ftype == TType.I64:
5785 
          self.toShippingDate = iprot.readI64();
5786 
        else:
5787 
          iprot.skip(ftype)
5788 
      elif fid == 3:
5789 
        if ftype == TType.I64:
5790 
          self.providerId = iprot.readI64();
5791 
        else:
5792 
          iprot.skip(ftype)
5793 
      elif fid == 4:
5794 
        if ftype == TType.I64:
5795 
          self.warehouseId = iprot.readI64();
5796 
        else:
5797 
          iprot.skip(ftype)
3451 chandransh 5798 
      elif fid == 5:
5799 
        if ftype == TType.BOOL:
5800 
          self.cod = iprot.readBool();
5801 
        else:
5802 
          iprot.skip(ftype)
3427 chandransh 5803 
      else:
5804 
        iprot.skip(ftype)
5805 
      iprot.readFieldEnd()
5806 
    iprot.readStructEnd()
5807 
 
5808 
  def write(self, oprot):
5809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5811 
      return
5812 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 5813 
    if self.fromShippingDate is not None:
3427 chandransh 5814 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
5815 
      oprot.writeI64(self.fromShippingDate)
5816 
      oprot.writeFieldEnd()
3431 rajveer 5817 
    if self.toShippingDate is not None:
3427 chandransh 5818 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
5819 
      oprot.writeI64(self.toShippingDate)
5820 
      oprot.writeFieldEnd()
3431 rajveer 5821 
    if self.providerId is not None:
3427 chandransh 5822 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
5823 
      oprot.writeI64(self.providerId)
5824 
      oprot.writeFieldEnd()
3431 rajveer 5825 
    if self.warehouseId is not None:
3427 chandransh 5826 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
5827 
      oprot.writeI64(self.warehouseId)
5828 
      oprot.writeFieldEnd()
3451 chandransh 5829 
    if self.cod is not None:
5830 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
5831 
      oprot.writeBool(self.cod)
5832 
      oprot.writeFieldEnd()
3427 chandransh 5833 
    oprot.writeFieldStop()
5834 
    oprot.writeStructEnd()
5835 
 
3431 rajveer 5836 
  def validate(self):
5837 
    return
5838 
 
5839 
 
3427 chandransh 5840 
  def __repr__(self):
5841 
    L = ['%s=%r' % (key, value)
5842 
      for key, value in self.__dict__.iteritems()]
5843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5844 
 
5845 
  def __eq__(self, other):
5846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5847 
 
5848 
  def __ne__(self, other):
5849 
    return not (self == other)
5850 
 
5851 
class getOrdersByShippingDate_result:
5852 
  """
5853 
  Attributes:
5854 
   - success
5855 
   - ex
5856 
  """
5857 
 
5858 
  thrift_spec = (
5859 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5860 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5861 
  )
5862 
 
5863 
  def __init__(self, success=None, ex=None,):
5864 
    self.success = success
5865 
    self.ex = ex
5866 
 
5867 
  def read(self, iprot):
5868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5870 
      return
5871 
    iprot.readStructBegin()
5872 
    while True:
5873 
      (fname, ftype, fid) = iprot.readFieldBegin()
5874 
      if ftype == TType.STOP:
5875 
        break
5876 
      if fid == 0:
5877 
        if ftype == TType.LIST:
5878 
          self.success = []
4133 chandransh 5879 
          (_etype66, _size63) = iprot.readListBegin()
5880 
          for _i67 in xrange(_size63):
5881 
            _elem68 = Order()
5882 
            _elem68.read(iprot)
5883 
            self.success.append(_elem68)
3427 chandransh 5884 
          iprot.readListEnd()
5885 
        else:
5886 
          iprot.skip(ftype)
5887 
      elif fid == 1:
5888 
        if ftype == TType.STRUCT:
5889 
          self.ex = TransactionServiceException()
5890 
          self.ex.read(iprot)
5891 
        else:
5892 
          iprot.skip(ftype)
5893 
      else:
5894 
        iprot.skip(ftype)
5895 
      iprot.readFieldEnd()
5896 
    iprot.readStructEnd()
5897 
 
5898 
  def write(self, oprot):
5899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5901 
      return
5902 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 5903 
    if self.success is not None:
3427 chandransh 5904 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5905 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 5906 
      for iter69 in self.success:
5907 
        iter69.write(oprot)
3427 chandransh 5908 
      oprot.writeListEnd()
5909 
      oprot.writeFieldEnd()
3431 rajveer 5910 
    if self.ex is not None:
3427 chandransh 5911 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5912 
      self.ex.write(oprot)
5913 
      oprot.writeFieldEnd()
5914 
    oprot.writeFieldStop()
5915 
    oprot.writeStructEnd()
5916 
 
3431 rajveer 5917 
  def validate(self):
5918 
    return
5919 
 
5920 
 
3427 chandransh 5921 
  def __repr__(self):
5922 
    L = ['%s=%r' % (key, value)
5923 
      for key, value in self.__dict__.iteritems()]
5924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5925 
 
5926 
  def __eq__(self, other):
5927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5928 
 
5929 
  def __ne__(self, other):
5930 
    return not (self == other)
5931 
 
1382 varun.gupt 5932 
class getReturnableOrdersForCustomer_args:
5933 
  """
5934 
  Attributes:
5935 
   - customer_id
5936 
   - limit
5937 
  """
5938 
 
5939 
  thrift_spec = (
5940 
    None, # 0
5941 
    (1, TType.I64, 'customer_id', None, None, ), # 1
5942 
    (2, TType.I64, 'limit', None, None, ), # 2
5943 
  )
5944 
 
5945 
  def __init__(self, customer_id=None, limit=None,):
5946 
    self.customer_id = customer_id
5947 
    self.limit = limit
5948 
 
5949 
  def read(self, iprot):
5950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5952 
      return
5953 
    iprot.readStructBegin()
5954 
    while True:
5955 
      (fname, ftype, fid) = iprot.readFieldBegin()
5956 
      if ftype == TType.STOP:
5957 
        break
5958 
      if fid == 1:
5959 
        if ftype == TType.I64:
5960 
          self.customer_id = iprot.readI64();
5961 
        else:
5962 
          iprot.skip(ftype)
5963 
      elif fid == 2:
5964 
        if ftype == TType.I64:
5965 
          self.limit = iprot.readI64();
5966 
        else:
5967 
          iprot.skip(ftype)
5968 
      else:
5969 
        iprot.skip(ftype)
5970 
      iprot.readFieldEnd()
5971 
    iprot.readStructEnd()
5972 
 
5973 
  def write(self, oprot):
5974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5976 
      return
5977 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 5978 
    if self.customer_id is not None:
1382 varun.gupt 5979 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
5980 
      oprot.writeI64(self.customer_id)
5981 
      oprot.writeFieldEnd()
3431 rajveer 5982 
    if self.limit is not None:
1382 varun.gupt 5983 
      oprot.writeFieldBegin('limit', TType.I64, 2)
5984 
      oprot.writeI64(self.limit)
5985 
      oprot.writeFieldEnd()
5986 
    oprot.writeFieldStop()
5987 
    oprot.writeStructEnd()
5988 
 
3431 rajveer 5989 
  def validate(self):
5990 
    return
5991 
 
5992 
 
1382 varun.gupt 5993 
  def __repr__(self):
5994 
    L = ['%s=%r' % (key, value)
5995 
      for key, value in self.__dict__.iteritems()]
5996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5997 
 
5998 
  def __eq__(self, other):
5999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6000 
 
6001 
  def __ne__(self, other):
6002 
    return not (self == other)
6003 
 
6004 
class getReturnableOrdersForCustomer_result:
6005 
  """
6006 
  Attributes:
6007 
   - success
6008 
   - ex
6009 
  """
6010 
 
6011 
  thrift_spec = (
6012 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6013 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6014 
  )
6015 
 
6016 
  def __init__(self, success=None, ex=None,):
6017 
    self.success = success
6018 
    self.ex = ex
6019 
 
6020 
  def read(self, iprot):
6021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6023 
      return
6024 
    iprot.readStructBegin()
6025 
    while True:
6026 
      (fname, ftype, fid) = iprot.readFieldBegin()
6027 
      if ftype == TType.STOP:
6028 
        break
6029 
      if fid == 0:
6030 
        if ftype == TType.LIST:
6031 
          self.success = []
4133 chandransh 6032 
          (_etype73, _size70) = iprot.readListBegin()
6033 
          for _i74 in xrange(_size70):
6034 
            _elem75 = iprot.readI64();
6035 
            self.success.append(_elem75)
1382 varun.gupt 6036 
          iprot.readListEnd()
6037 
        else:
6038 
          iprot.skip(ftype)
6039 
      elif fid == 1:
6040 
        if ftype == TType.STRUCT:
6041 
          self.ex = TransactionServiceException()
6042 
          self.ex.read(iprot)
6043 
        else:
6044 
          iprot.skip(ftype)
6045 
      else:
6046 
        iprot.skip(ftype)
6047 
      iprot.readFieldEnd()
6048 
    iprot.readStructEnd()
6049 
 
6050 
  def write(self, oprot):
6051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6053 
      return
6054 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6055 
    if self.success is not None:
1382 varun.gupt 6056 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6057 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6058 
      for iter76 in self.success:
6059 
        oprot.writeI64(iter76)
1382 varun.gupt 6060 
      oprot.writeListEnd()
6061 
      oprot.writeFieldEnd()
3431 rajveer 6062 
    if self.ex is not None:
1382 varun.gupt 6063 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6064 
      self.ex.write(oprot)
6065 
      oprot.writeFieldEnd()
6066 
    oprot.writeFieldStop()
6067 
    oprot.writeStructEnd()
6068 
 
3431 rajveer 6069 
  def validate(self):
6070 
    return
6071 
 
6072 
 
1382 varun.gupt 6073 
  def __repr__(self):
6074 
    L = ['%s=%r' % (key, value)
6075 
      for key, value in self.__dict__.iteritems()]
6076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6077 
 
6078 
  def __eq__(self, other):
6079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6080 
 
6081 
  def __ne__(self, other):
6082 
    return not (self == other)
6083 
 
6084 
class getCancellableOrdersForCustomer_args:
6085 
  """
6086 
  Attributes:
6087 
   - customer_id
6088 
   - limit
6089 
  """
6090 
 
6091 
  thrift_spec = (
6092 
    None, # 0
6093 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6094 
    (2, TType.I64, 'limit', None, None, ), # 2
6095 
  )
6096 
 
6097 
  def __init__(self, customer_id=None, limit=None,):
6098 
    self.customer_id = customer_id
6099 
    self.limit = limit
6100 
 
6101 
  def read(self, iprot):
6102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6104 
      return
6105 
    iprot.readStructBegin()
6106 
    while True:
6107 
      (fname, ftype, fid) = iprot.readFieldBegin()
6108 
      if ftype == TType.STOP:
6109 
        break
6110 
      if fid == 1:
6111 
        if ftype == TType.I64:
6112 
          self.customer_id = iprot.readI64();
6113 
        else:
6114 
          iprot.skip(ftype)
6115 
      elif fid == 2:
6116 
        if ftype == TType.I64:
6117 
          self.limit = iprot.readI64();
6118 
        else:
6119 
          iprot.skip(ftype)
6120 
      else:
6121 
        iprot.skip(ftype)
6122 
      iprot.readFieldEnd()
6123 
    iprot.readStructEnd()
6124 
 
6125 
  def write(self, oprot):
6126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6128 
      return
6129 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6130 
    if self.customer_id is not None:
1382 varun.gupt 6131 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6132 
      oprot.writeI64(self.customer_id)
6133 
      oprot.writeFieldEnd()
3431 rajveer 6134 
    if self.limit is not None:
1382 varun.gupt 6135 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6136 
      oprot.writeI64(self.limit)
6137 
      oprot.writeFieldEnd()
6138 
    oprot.writeFieldStop()
6139 
    oprot.writeStructEnd()
6140 
 
3431 rajveer 6141 
  def validate(self):
6142 
    return
6143 
 
6144 
 
1382 varun.gupt 6145 
  def __repr__(self):
6146 
    L = ['%s=%r' % (key, value)
6147 
      for key, value in self.__dict__.iteritems()]
6148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6149 
 
6150 
  def __eq__(self, other):
6151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6152 
 
6153 
  def __ne__(self, other):
6154 
    return not (self == other)
6155 
 
6156 
class getCancellableOrdersForCustomer_result:
6157 
  """
6158 
  Attributes:
6159 
   - success
6160 
   - ex
6161 
  """
6162 
 
6163 
  thrift_spec = (
6164 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6165 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6166 
  )
6167 
 
6168 
  def __init__(self, success=None, ex=None,):
6169 
    self.success = success
6170 
    self.ex = ex
6171 
 
6172 
  def read(self, iprot):
6173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6175 
      return
6176 
    iprot.readStructBegin()
6177 
    while True:
6178 
      (fname, ftype, fid) = iprot.readFieldBegin()
6179 
      if ftype == TType.STOP:
6180 
        break
6181 
      if fid == 0:
6182 
        if ftype == TType.LIST:
6183 
          self.success = []
4133 chandransh 6184 
          (_etype80, _size77) = iprot.readListBegin()
6185 
          for _i81 in xrange(_size77):
6186 
            _elem82 = iprot.readI64();
6187 
            self.success.append(_elem82)
1382 varun.gupt 6188 
          iprot.readListEnd()
6189 
        else:
6190 
          iprot.skip(ftype)
6191 
      elif fid == 1:
6192 
        if ftype == TType.STRUCT:
6193 
          self.ex = TransactionServiceException()
6194 
          self.ex.read(iprot)
6195 
        else:
6196 
          iprot.skip(ftype)
6197 
      else:
6198 
        iprot.skip(ftype)
6199 
      iprot.readFieldEnd()
6200 
    iprot.readStructEnd()
6201 
 
6202 
  def write(self, oprot):
6203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6205 
      return
6206 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6207 
    if self.success is not None:
1382 varun.gupt 6208 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6209 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6210 
      for iter83 in self.success:
6211 
        oprot.writeI64(iter83)
1382 varun.gupt 6212 
      oprot.writeListEnd()
6213 
      oprot.writeFieldEnd()
3431 rajveer 6214 
    if self.ex is not None:
1382 varun.gupt 6215 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6216 
      self.ex.write(oprot)
6217 
      oprot.writeFieldEnd()
6218 
    oprot.writeFieldStop()
6219 
    oprot.writeStructEnd()
6220 
 
3431 rajveer 6221 
  def validate(self):
6222 
    return
6223 
 
6224 
 
1382 varun.gupt 6225 
  def __repr__(self):
6226 
    L = ['%s=%r' % (key, value)
6227 
      for key, value in self.__dict__.iteritems()]
6228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6229 
 
6230 
  def __eq__(self, other):
6231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6232 
 
6233 
  def __ne__(self, other):
6234 
    return not (self == other)
6235 
 
483 rajveer 6236 
class changeOrderStatus_args:
94 ashish 6237 
  """
6238 
  Attributes:
483 rajveer 6239 
   - orderId
6240 
   - status
6241 
   - description
94 ashish 6242 
  """
6243 
 
6244 
  thrift_spec = (
6245 
    None, # 0
483 rajveer 6246 
    (1, TType.I64, 'orderId', None, None, ), # 1
6247 
    (2, TType.I32, 'status', None, None, ), # 2
6248 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 6249 
  )
6250 
 
483 rajveer 6251 
  def __init__(self, orderId=None, status=None, description=None,):
6252 
    self.orderId = orderId
6253 
    self.status = status
6254 
    self.description = description
94 ashish 6255 
 
6256 
  def read(self, iprot):
6257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6259 
      return
6260 
    iprot.readStructBegin()
6261 
    while True:
6262 
      (fname, ftype, fid) = iprot.readFieldBegin()
6263 
      if ftype == TType.STOP:
6264 
        break
6265 
      if fid == 1:
6266 
        if ftype == TType.I64:
483 rajveer 6267 
          self.orderId = iprot.readI64();
94 ashish 6268 
        else:
6269 
          iprot.skip(ftype)
6270 
      elif fid == 2:
483 rajveer 6271 
        if ftype == TType.I32:
6272 
          self.status = iprot.readI32();
94 ashish 6273 
        else:
6274 
          iprot.skip(ftype)
483 rajveer 6275 
      elif fid == 3:
6276 
        if ftype == TType.STRING:
6277 
          self.description = iprot.readString();
6278 
        else:
6279 
          iprot.skip(ftype)
94 ashish 6280 
      else:
6281 
        iprot.skip(ftype)
6282 
      iprot.readFieldEnd()
6283 
    iprot.readStructEnd()
6284 
 
6285 
  def write(self, oprot):
6286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6288 
      return
483 rajveer 6289 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 6290 
    if self.orderId is not None:
483 rajveer 6291 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6292 
      oprot.writeI64(self.orderId)
94 ashish 6293 
      oprot.writeFieldEnd()
3431 rajveer 6294 
    if self.status is not None:
483 rajveer 6295 
      oprot.writeFieldBegin('status', TType.I32, 2)
6296 
      oprot.writeI32(self.status)
94 ashish 6297 
      oprot.writeFieldEnd()
3431 rajveer 6298 
    if self.description is not None:
483 rajveer 6299 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6300 
      oprot.writeString(self.description)
6301 
      oprot.writeFieldEnd()
94 ashish 6302 
    oprot.writeFieldStop()
6303 
    oprot.writeStructEnd()
6304 
 
3431 rajveer 6305 
  def validate(self):
6306 
    return
6307 
 
6308 
 
94 ashish 6309 
  def __repr__(self):
6310 
    L = ['%s=%r' % (key, value)
6311 
      for key, value in self.__dict__.iteritems()]
6312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6313 
 
6314 
  def __eq__(self, other):
6315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6316 
 
6317 
  def __ne__(self, other):
6318 
    return not (self == other)
6319 
 
483 rajveer 6320 
class changeOrderStatus_result:
94 ashish 6321 
  """
6322 
  Attributes:
6323 
   - success
6324 
   - ex
6325 
  """
6326 
 
6327 
  thrift_spec = (
6328 
    (0, TType.BOOL, 'success', None, None, ), # 0
6329 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6330 
  )
6331 
 
6332 
  def __init__(self, success=None, ex=None,):
6333 
    self.success = success
6334 
    self.ex = ex
6335 
 
6336 
  def read(self, iprot):
6337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6339 
      return
6340 
    iprot.readStructBegin()
6341 
    while True:
6342 
      (fname, ftype, fid) = iprot.readFieldBegin()
6343 
      if ftype == TType.STOP:
6344 
        break
6345 
      if fid == 0:
6346 
        if ftype == TType.BOOL:
6347 
          self.success = iprot.readBool();
6348 
        else:
6349 
          iprot.skip(ftype)
6350 
      elif fid == 1:
6351 
        if ftype == TType.STRUCT:
6352 
          self.ex = TransactionServiceException()
6353 
          self.ex.read(iprot)
6354 
        else:
6355 
          iprot.skip(ftype)
6356 
      else:
6357 
        iprot.skip(ftype)
6358 
      iprot.readFieldEnd()
6359 
    iprot.readStructEnd()
6360 
 
6361 
  def write(self, oprot):
6362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6364 
      return
483 rajveer 6365 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 6366 
    if self.success is not None:
94 ashish 6367 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6368 
      oprot.writeBool(self.success)
6369 
      oprot.writeFieldEnd()
3431 rajveer 6370 
    if self.ex is not None:
94 ashish 6371 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6372 
      self.ex.write(oprot)
6373 
      oprot.writeFieldEnd()
6374 
    oprot.writeFieldStop()
6375 
    oprot.writeStructEnd()
6376 
 
3431 rajveer 6377 
  def validate(self):
6378 
    return
6379 
 
6380 
 
94 ashish 6381 
  def __repr__(self):
6382 
    L = ['%s=%r' % (key, value)
6383 
      for key, value in self.__dict__.iteritems()]
6384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6385 
 
6386 
  def __eq__(self, other):
6387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6388 
 
6389 
  def __ne__(self, other):
6390 
    return not (self == other)
6391 
 
3064 chandransh 6392 
class getOrdersForTransaction_args:
494 rajveer 6393 
  """
6394 
  Attributes:
3064 chandransh 6395 
   - transactionId
6396 
   - customerId
494 rajveer 6397 
  """
6398 
 
6399 
  thrift_spec = (
6400 
    None, # 0
3064 chandransh 6401 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6402 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 6403 
  )
6404 
 
3064 chandransh 6405 
  def __init__(self, transactionId=None, customerId=None,):
6406 
    self.transactionId = transactionId
6407 
    self.customerId = customerId
494 rajveer 6408 
 
6409 
  def read(self, iprot):
6410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6412 
      return
6413 
    iprot.readStructBegin()
6414 
    while True:
6415 
      (fname, ftype, fid) = iprot.readFieldBegin()
6416 
      if ftype == TType.STOP:
6417 
        break
6418 
      if fid == 1:
6419 
        if ftype == TType.I64:
3064 chandransh 6420 
          self.transactionId = iprot.readI64();
494 rajveer 6421 
        else:
6422 
          iprot.skip(ftype)
6423 
      elif fid == 2:
3064 chandransh 6424 
        if ftype == TType.I64:
6425 
          self.customerId = iprot.readI64();
494 rajveer 6426 
        else:
6427 
          iprot.skip(ftype)
6428 
      else:
6429 
        iprot.skip(ftype)
6430 
      iprot.readFieldEnd()
6431 
    iprot.readStructEnd()
6432 
 
6433 
  def write(self, oprot):
6434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6436 
      return
3064 chandransh 6437 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 6438 
    if self.transactionId is not None:
3064 chandransh 6439 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6440 
      oprot.writeI64(self.transactionId)
494 rajveer 6441 
      oprot.writeFieldEnd()
3431 rajveer 6442 
    if self.customerId is not None:
3064 chandransh 6443 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
6444 
      oprot.writeI64(self.customerId)
494 rajveer 6445 
      oprot.writeFieldEnd()
6446 
    oprot.writeFieldStop()
6447 
    oprot.writeStructEnd()
6448 
 
3431 rajveer 6449 
  def validate(self):
6450 
    return
6451 
 
6452 
 
494 rajveer 6453 
  def __repr__(self):
6454 
    L = ['%s=%r' % (key, value)
6455 
      for key, value in self.__dict__.iteritems()]
6456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6457 
 
6458 
  def __eq__(self, other):
6459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6460 
 
6461 
  def __ne__(self, other):
6462 
    return not (self == other)
6463 
 
3064 chandransh 6464 
class getOrdersForTransaction_result:
494 rajveer 6465 
  """
6466 
  Attributes:
6467 
   - success
6468 
   - ex
6469 
  """
6470 
 
6471 
  thrift_spec = (
3064 chandransh 6472 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 6473 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6474 
  )
6475 
 
6476 
  def __init__(self, success=None, ex=None,):
6477 
    self.success = success
6478 
    self.ex = ex
6479 
 
6480 
  def read(self, iprot):
6481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6483 
      return
6484 
    iprot.readStructBegin()
6485 
    while True:
6486 
      (fname, ftype, fid) = iprot.readFieldBegin()
6487 
      if ftype == TType.STOP:
6488 
        break
6489 
      if fid == 0:
3064 chandransh 6490 
        if ftype == TType.LIST:
6491 
          self.success = []
4133 chandransh 6492 
          (_etype87, _size84) = iprot.readListBegin()
6493 
          for _i88 in xrange(_size84):
6494 
            _elem89 = Order()
6495 
            _elem89.read(iprot)
6496 
            self.success.append(_elem89)
3064 chandransh 6497 
          iprot.readListEnd()
494 rajveer 6498 
        else:
6499 
          iprot.skip(ftype)
6500 
      elif fid == 1:
6501 
        if ftype == TType.STRUCT:
6502 
          self.ex = TransactionServiceException()
6503 
          self.ex.read(iprot)
6504 
        else:
6505 
          iprot.skip(ftype)
6506 
      else:
6507 
        iprot.skip(ftype)
6508 
      iprot.readFieldEnd()
6509 
    iprot.readStructEnd()
6510 
 
6511 
  def write(self, oprot):
6512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6514 
      return
3064 chandransh 6515 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 6516 
    if self.success is not None:
3064 chandransh 6517 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6518 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6519 
      for iter90 in self.success:
6520 
        iter90.write(oprot)
3064 chandransh 6521 
      oprot.writeListEnd()
494 rajveer 6522 
      oprot.writeFieldEnd()
3431 rajveer 6523 
    if self.ex is not None:
494 rajveer 6524 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6525 
      self.ex.write(oprot)
6526 
      oprot.writeFieldEnd()
6527 
    oprot.writeFieldStop()
6528 
    oprot.writeStructEnd()
6529 
 
3431 rajveer 6530 
  def validate(self):
6531 
    return
6532 
 
6533 
 
494 rajveer 6534 
  def __repr__(self):
6535 
    L = ['%s=%r' % (key, value)
6536 
      for key, value in self.__dict__.iteritems()]
6537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6538 
 
6539 
  def __eq__(self, other):
6540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6541 
 
6542 
  def __ne__(self, other):
6543 
    return not (self == other)
6544 
 
3064 chandransh 6545 
class getOrdersForCustomer_args:
1149 chandransh 6546 
  """
6547 
  Attributes:
3064 chandransh 6548 
   - customerId
6549 
   - from_date
6550 
   - to_date
6551 
   - statuses
1149 chandransh 6552 
  """
6553 
 
6554 
  thrift_spec = (
6555 
    None, # 0
3064 chandransh 6556 
    (1, TType.I64, 'customerId', None, None, ), # 1
6557 
    (2, TType.I64, 'from_date', None, None, ), # 2
6558 
    (3, TType.I64, 'to_date', None, None, ), # 3
6559 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 6560 
  )
6561 
 
3064 chandransh 6562 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
6563 
    self.customerId = customerId
6564 
    self.from_date = from_date
6565 
    self.to_date = to_date
6566 
    self.statuses = statuses
1149 chandransh 6567 
 
6568 
  def read(self, iprot):
6569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6571 
      return
6572 
    iprot.readStructBegin()
6573 
    while True:
6574 
      (fname, ftype, fid) = iprot.readFieldBegin()
6575 
      if ftype == TType.STOP:
6576 
        break
6577 
      if fid == 1:
6578 
        if ftype == TType.I64:
3064 chandransh 6579 
          self.customerId = iprot.readI64();
1149 chandransh 6580 
        else:
6581 
          iprot.skip(ftype)
6582 
      elif fid == 2:
6583 
        if ftype == TType.I64:
3064 chandransh 6584 
          self.from_date = iprot.readI64();
1149 chandransh 6585 
        else:
6586 
          iprot.skip(ftype)
2783 chandransh 6587 
      elif fid == 3:
6588 
        if ftype == TType.I64:
3064 chandransh 6589 
          self.to_date = iprot.readI64();
2783 chandransh 6590 
        else:
6591 
          iprot.skip(ftype)
6592 
      elif fid == 4:
3064 chandransh 6593 
        if ftype == TType.LIST:
6594 
          self.statuses = []
4133 chandransh 6595 
          (_etype94, _size91) = iprot.readListBegin()
6596 
          for _i95 in xrange(_size91):
6597 
            _elem96 = iprot.readI32();
6598 
            self.statuses.append(_elem96)
3064 chandransh 6599 
          iprot.readListEnd()
2783 chandransh 6600 
        else:
6601 
          iprot.skip(ftype)
1149 chandransh 6602 
      else:
6603 
        iprot.skip(ftype)
6604 
      iprot.readFieldEnd()
6605 
    iprot.readStructEnd()
6606 
 
6607 
  def write(self, oprot):
6608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6610 
      return
3064 chandransh 6611 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 6612 
    if self.customerId is not None:
3064 chandransh 6613 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6614 
      oprot.writeI64(self.customerId)
1149 chandransh 6615 
      oprot.writeFieldEnd()
3431 rajveer 6616 
    if self.from_date is not None:
3064 chandransh 6617 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6618 
      oprot.writeI64(self.from_date)
1149 chandransh 6619 
      oprot.writeFieldEnd()
3431 rajveer 6620 
    if self.to_date is not None:
3064 chandransh 6621 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6622 
      oprot.writeI64(self.to_date)
2783 chandransh 6623 
      oprot.writeFieldEnd()
3431 rajveer 6624 
    if self.statuses is not None:
3064 chandransh 6625 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
6626 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 6627 
      for iter97 in self.statuses:
6628 
        oprot.writeI32(iter97)
3064 chandransh 6629 
      oprot.writeListEnd()
2783 chandransh 6630 
      oprot.writeFieldEnd()
1149 chandransh 6631 
    oprot.writeFieldStop()
6632 
    oprot.writeStructEnd()
6633 
 
3431 rajveer 6634 
  def validate(self):
6635 
    return
6636 
 
6637 
 
1149 chandransh 6638 
  def __repr__(self):
6639 
    L = ['%s=%r' % (key, value)
6640 
      for key, value in self.__dict__.iteritems()]
6641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6642 
 
6643 
  def __eq__(self, other):
6644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6645 
 
6646 
  def __ne__(self, other):
6647 
    return not (self == other)
6648 
 
3064 chandransh 6649 
class getOrdersForCustomer_result:
1149 chandransh 6650 
  """
6651 
  Attributes:
6652 
   - success
6653 
   - ex
6654 
  """
6655 
 
6656 
  thrift_spec = (
3064 chandransh 6657 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 6658 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6659 
  )
6660 
 
6661 
  def __init__(self, success=None, ex=None,):
6662 
    self.success = success
6663 
    self.ex = ex
6664 
 
6665 
  def read(self, iprot):
6666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6668 
      return
6669 
    iprot.readStructBegin()
6670 
    while True:
6671 
      (fname, ftype, fid) = iprot.readFieldBegin()
6672 
      if ftype == TType.STOP:
6673 
        break
6674 
      if fid == 0:
3064 chandransh 6675 
        if ftype == TType.LIST:
6676 
          self.success = []
4133 chandransh 6677 
          (_etype101, _size98) = iprot.readListBegin()
6678 
          for _i102 in xrange(_size98):
6679 
            _elem103 = Order()
6680 
            _elem103.read(iprot)
6681 
            self.success.append(_elem103)
3064 chandransh 6682 
          iprot.readListEnd()
1149 chandransh 6683 
        else:
6684 
          iprot.skip(ftype)
6685 
      elif fid == 1:
6686 
        if ftype == TType.STRUCT:
6687 
          self.ex = TransactionServiceException()
6688 
          self.ex.read(iprot)
6689 
        else:
6690 
          iprot.skip(ftype)
6691 
      else:
6692 
        iprot.skip(ftype)
6693 
      iprot.readFieldEnd()
6694 
    iprot.readStructEnd()
6695 
 
6696 
  def write(self, oprot):
6697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6699 
      return
3064 chandransh 6700 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 6701 
    if self.success is not None:
3064 chandransh 6702 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6703 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6704 
      for iter104 in self.success:
6705 
        iter104.write(oprot)
3064 chandransh 6706 
      oprot.writeListEnd()
1149 chandransh 6707 
      oprot.writeFieldEnd()
3431 rajveer 6708 
    if self.ex is not None:
1149 chandransh 6709 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6710 
      self.ex.write(oprot)
6711 
      oprot.writeFieldEnd()
6712 
    oprot.writeFieldStop()
6713 
    oprot.writeStructEnd()
6714 
 
3431 rajveer 6715 
  def validate(self):
6716 
    return
6717 
 
6718 
 
1149 chandransh 6719 
  def __repr__(self):
6720 
    L = ['%s=%r' % (key, value)
6721 
      for key, value in self.__dict__.iteritems()]
6722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6723 
 
6724 
  def __eq__(self, other):
6725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6726 
 
6727 
  def __ne__(self, other):
6728 
    return not (self == other)
6729 
 
3064 chandransh 6730 
class createOrder_args:
921 rajveer 6731 
  """
6732 
  Attributes:
3064 chandransh 6733 
   - order
921 rajveer 6734 
  """
6735 
 
6736 
  thrift_spec = (
6737 
    None, # 0
3064 chandransh 6738 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 6739 
  )
6740 
 
3064 chandransh 6741 
  def __init__(self, order=None,):
6742 
    self.order = order
921 rajveer 6743 
 
6744 
  def read(self, iprot):
6745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6747 
      return
6748 
    iprot.readStructBegin()
6749 
    while True:
6750 
      (fname, ftype, fid) = iprot.readFieldBegin()
6751 
      if ftype == TType.STOP:
6752 
        break
6753 
      if fid == 1:
3064 chandransh 6754 
        if ftype == TType.STRUCT:
6755 
          self.order = Order()
6756 
          self.order.read(iprot)
921 rajveer 6757 
        else:
6758 
          iprot.skip(ftype)
6759 
      else:
6760 
        iprot.skip(ftype)
6761 
      iprot.readFieldEnd()
6762 
    iprot.readStructEnd()
6763 
 
6764 
  def write(self, oprot):
6765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6767 
      return
3064 chandransh 6768 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 6769 
    if self.order is not None:
3064 chandransh 6770 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
6771 
      self.order.write(oprot)
921 rajveer 6772 
      oprot.writeFieldEnd()
6773 
    oprot.writeFieldStop()
6774 
    oprot.writeStructEnd()
6775 
 
3431 rajveer 6776 
  def validate(self):
6777 
    return
6778 
 
6779 
 
921 rajveer 6780 
  def __repr__(self):
6781 
    L = ['%s=%r' % (key, value)
6782 
      for key, value in self.__dict__.iteritems()]
6783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6784 
 
6785 
  def __eq__(self, other):
6786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6787 
 
6788 
  def __ne__(self, other):
6789 
    return not (self == other)
6790 
 
3064 chandransh 6791 
class createOrder_result:
921 rajveer 6792 
  """
6793 
  Attributes:
6794 
   - success
6795 
   - ex
6796 
  """
6797 
 
6798 
  thrift_spec = (
3064 chandransh 6799 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 6800 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6801 
  )
6802 
 
6803 
  def __init__(self, success=None, ex=None,):
6804 
    self.success = success
6805 
    self.ex = ex
6806 
 
6807 
  def read(self, iprot):
6808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6810 
      return
6811 
    iprot.readStructBegin()
6812 
    while True:
6813 
      (fname, ftype, fid) = iprot.readFieldBegin()
6814 
      if ftype == TType.STOP:
6815 
        break
6816 
      if fid == 0:
3064 chandransh 6817 
        if ftype == TType.I64:
6818 
          self.success = iprot.readI64();
921 rajveer 6819 
        else:
6820 
          iprot.skip(ftype)
6821 
      elif fid == 1:
6822 
        if ftype == TType.STRUCT:
6823 
          self.ex = TransactionServiceException()
6824 
          self.ex.read(iprot)
6825 
        else:
6826 
          iprot.skip(ftype)
6827 
      else:
6828 
        iprot.skip(ftype)
6829 
      iprot.readFieldEnd()
6830 
    iprot.readStructEnd()
6831 
 
6832 
  def write(self, oprot):
6833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6835 
      return
3064 chandransh 6836 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 6837 
    if self.success is not None:
3064 chandransh 6838 
      oprot.writeFieldBegin('success', TType.I64, 0)
6839 
      oprot.writeI64(self.success)
921 rajveer 6840 
      oprot.writeFieldEnd()
3431 rajveer 6841 
    if self.ex is not None:
921 rajveer 6842 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6843 
      self.ex.write(oprot)
6844 
      oprot.writeFieldEnd()
6845 
    oprot.writeFieldStop()
6846 
    oprot.writeStructEnd()
6847 
 
3431 rajveer 6848 
  def validate(self):
6849 
    return
6850 
 
6851 
 
921 rajveer 6852 
  def __repr__(self):
6853 
    L = ['%s=%r' % (key, value)
6854 
      for key, value in self.__dict__.iteritems()]
6855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6856 
 
6857 
  def __eq__(self, other):
6858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6859 
 
6860 
  def __ne__(self, other):
6861 
    return not (self == other)
6862 
 
3064 chandransh 6863 
class getOrder_args:
921 rajveer 6864 
  """
6865 
  Attributes:
3064 chandransh 6866 
   - id
921 rajveer 6867 
  """
6868 
 
6869 
  thrift_spec = (
6870 
    None, # 0
3064 chandransh 6871 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 6872 
  )
6873 
 
3064 chandransh 6874 
  def __init__(self, id=None,):
6875 
    self.id = id
921 rajveer 6876 
 
6877 
  def read(self, iprot):
6878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6880 
      return
6881 
    iprot.readStructBegin()
6882 
    while True:
6883 
      (fname, ftype, fid) = iprot.readFieldBegin()
6884 
      if ftype == TType.STOP:
6885 
        break
6886 
      if fid == 1:
6887 
        if ftype == TType.I64:
3064 chandransh 6888 
          self.id = iprot.readI64();
921 rajveer 6889 
        else:
6890 
          iprot.skip(ftype)
6891 
      else:
6892 
        iprot.skip(ftype)
6893 
      iprot.readFieldEnd()
6894 
    iprot.readStructEnd()
6895 
 
6896 
  def write(self, oprot):
6897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6899 
      return
3064 chandransh 6900 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 6901 
    if self.id is not None:
3064 chandransh 6902 
      oprot.writeFieldBegin('id', TType.I64, 1)
6903 
      oprot.writeI64(self.id)
921 rajveer 6904 
      oprot.writeFieldEnd()
6905 
    oprot.writeFieldStop()
6906 
    oprot.writeStructEnd()
6907 
 
3431 rajveer 6908 
  def validate(self):
6909 
    return
6910 
 
6911 
 
921 rajveer 6912 
  def __repr__(self):
6913 
    L = ['%s=%r' % (key, value)
6914 
      for key, value in self.__dict__.iteritems()]
6915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6916 
 
6917 
  def __eq__(self, other):
6918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6919 
 
6920 
  def __ne__(self, other):
6921 
    return not (self == other)
6922 
 
3064 chandransh 6923 
class getOrder_result:
921 rajveer 6924 
  """
6925 
  Attributes:
6926 
   - success
6927 
   - ex
6928 
  """
6929 
 
6930 
  thrift_spec = (
3064 chandransh 6931 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 6932 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6933 
  )
6934 
 
6935 
  def __init__(self, success=None, ex=None,):
6936 
    self.success = success
6937 
    self.ex = ex
6938 
 
6939 
  def read(self, iprot):
6940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6942 
      return
6943 
    iprot.readStructBegin()
6944 
    while True:
6945 
      (fname, ftype, fid) = iprot.readFieldBegin()
6946 
      if ftype == TType.STOP:
6947 
        break
6948 
      if fid == 0:
3064 chandransh 6949 
        if ftype == TType.STRUCT:
6950 
          self.success = Order()
6951 
          self.success.read(iprot)
921 rajveer 6952 
        else:
6953 
          iprot.skip(ftype)
6954 
      elif fid == 1:
6955 
        if ftype == TType.STRUCT:
6956 
          self.ex = TransactionServiceException()
6957 
          self.ex.read(iprot)
6958 
        else:
6959 
          iprot.skip(ftype)
6960 
      else:
6961 
        iprot.skip(ftype)
6962 
      iprot.readFieldEnd()
6963 
    iprot.readStructEnd()
6964 
 
6965 
  def write(self, oprot):
6966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6968 
      return
3064 chandransh 6969 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 6970 
    if self.success is not None:
3064 chandransh 6971 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6972 
      self.success.write(oprot)
921 rajveer 6973 
      oprot.writeFieldEnd()
3431 rajveer 6974 
    if self.ex is not None:
921 rajveer 6975 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6976 
      self.ex.write(oprot)
6977 
      oprot.writeFieldEnd()
6978 
    oprot.writeFieldStop()
6979 
    oprot.writeStructEnd()
6980 
 
3431 rajveer 6981 
  def validate(self):
6982 
    return
6983 
 
6984 
 
921 rajveer 6985 
  def __repr__(self):
6986 
    L = ['%s=%r' % (key, value)
6987 
      for key, value in self.__dict__.iteritems()]
6988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6989 
 
6990 
  def __eq__(self, other):
6991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6992 
 
6993 
  def __ne__(self, other):
6994 
    return not (self == other)
6995 
 
3064 chandransh 6996 
class getLineItemsForOrder_args:
94 ashish 6997 
  """
6998 
  Attributes:
3064 chandransh 6999 
   - orderId
94 ashish 7000 
  """
7001 
 
7002 
  thrift_spec = (
7003 
    None, # 0
3064 chandransh 7004 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7005 
  )
7006 
 
3064 chandransh 7007 
  def __init__(self, orderId=None,):
7008 
    self.orderId = orderId
94 ashish 7009 
 
7010 
  def read(self, iprot):
7011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7013 
      return
7014 
    iprot.readStructBegin()
7015 
    while True:
7016 
      (fname, ftype, fid) = iprot.readFieldBegin()
7017 
      if ftype == TType.STOP:
7018 
        break
7019 
      if fid == 1:
7020 
        if ftype == TType.I64:
3064 chandransh 7021 
          self.orderId = iprot.readI64();
94 ashish 7022 
        else:
7023 
          iprot.skip(ftype)
7024 
      else:
7025 
        iprot.skip(ftype)
7026 
      iprot.readFieldEnd()
7027 
    iprot.readStructEnd()
7028 
 
7029 
  def write(self, oprot):
7030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7032 
      return
3064 chandransh 7033 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7034 
    if self.orderId is not None:
3064 chandransh 7035 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7036 
      oprot.writeI64(self.orderId)
94 ashish 7037 
      oprot.writeFieldEnd()
7038 
    oprot.writeFieldStop()
7039 
    oprot.writeStructEnd()
7040 
 
3431 rajveer 7041 
  def validate(self):
7042 
    return
7043 
 
7044 
 
94 ashish 7045 
  def __repr__(self):
7046 
    L = ['%s=%r' % (key, value)
7047 
      for key, value in self.__dict__.iteritems()]
7048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7049 
 
7050 
  def __eq__(self, other):
7051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7052 
 
7053 
  def __ne__(self, other):
7054 
    return not (self == other)
7055 
 
3064 chandransh 7056 
class getLineItemsForOrder_result:
94 ashish 7057 
  """
7058 
  Attributes:
7059 
   - success
7060 
   - ex
7061 
  """
7062 
 
7063 
  thrift_spec = (
3064 chandransh 7064 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7065 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7066 
  )
7067 
 
7068 
  def __init__(self, success=None, ex=None,):
7069 
    self.success = success
7070 
    self.ex = ex
7071 
 
7072 
  def read(self, iprot):
7073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7075 
      return
7076 
    iprot.readStructBegin()
7077 
    while True:
7078 
      (fname, ftype, fid) = iprot.readFieldBegin()
7079 
      if ftype == TType.STOP:
7080 
        break
7081 
      if fid == 0:
483 rajveer 7082 
        if ftype == TType.LIST:
7083 
          self.success = []
4133 chandransh 7084 
          (_etype108, _size105) = iprot.readListBegin()
7085 
          for _i109 in xrange(_size105):
7086 
            _elem110 = LineItem()
7087 
            _elem110.read(iprot)
7088 
            self.success.append(_elem110)
483 rajveer 7089 
          iprot.readListEnd()
94 ashish 7090 
        else:
7091 
          iprot.skip(ftype)
7092 
      elif fid == 1:
7093 
        if ftype == TType.STRUCT:
7094 
          self.ex = TransactionServiceException()
7095 
          self.ex.read(iprot)
7096 
        else:
7097 
          iprot.skip(ftype)
7098 
      else:
7099 
        iprot.skip(ftype)
7100 
      iprot.readFieldEnd()
7101 
    iprot.readStructEnd()
7102 
 
7103 
  def write(self, oprot):
7104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7106 
      return
3064 chandransh 7107 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7108 
    if self.success is not None:
483 rajveer 7109 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7110 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7111 
      for iter111 in self.success:
7112 
        iter111.write(oprot)
483 rajveer 7113 
      oprot.writeListEnd()
94 ashish 7114 
      oprot.writeFieldEnd()
3431 rajveer 7115 
    if self.ex is not None:
94 ashish 7116 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7117 
      self.ex.write(oprot)
7118 
      oprot.writeFieldEnd()
7119 
    oprot.writeFieldStop()
7120 
    oprot.writeStructEnd()
7121 
 
3431 rajveer 7122 
  def validate(self):
7123 
    return
7124 
 
7125 
 
94 ashish 7126 
  def __repr__(self):
7127 
    L = ['%s=%r' % (key, value)
7128 
      for key, value in self.__dict__.iteritems()]
7129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7130 
 
7131 
  def __eq__(self, other):
7132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7133 
 
7134 
  def __ne__(self, other):
7135 
    return not (self == other)
7136 
 
3064 chandransh 7137 
class getOrderForCustomer_args:
94 ashish 7138 
  """
7139 
  Attributes:
3064 chandransh 7140 
   - orderId
483 rajveer 7141 
   - customerId
94 ashish 7142 
  """
7143 
 
7144 
  thrift_spec = (
7145 
    None, # 0
3064 chandransh 7146 
    (1, TType.I64, 'orderId', None, None, ), # 1
7147 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7148 
  )
7149 
 
3064 chandransh 7150 
  def __init__(self, orderId=None, customerId=None,):
7151 
    self.orderId = orderId
483 rajveer 7152 
    self.customerId = customerId
94 ashish 7153 
 
7154 
  def read(self, iprot):
7155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7157 
      return
7158 
    iprot.readStructBegin()
7159 
    while True:
7160 
      (fname, ftype, fid) = iprot.readFieldBegin()
7161 
      if ftype == TType.STOP:
7162 
        break
7163 
      if fid == 1:
7164 
        if ftype == TType.I64:
3064 chandransh 7165 
          self.orderId = iprot.readI64();
94 ashish 7166 
        else:
7167 
          iprot.skip(ftype)
7168 
      elif fid == 2:
7169 
        if ftype == TType.I64:
3064 chandransh 7170 
          self.customerId = iprot.readI64();
94 ashish 7171 
        else:
7172 
          iprot.skip(ftype)
7173 
      else:
7174 
        iprot.skip(ftype)
7175 
      iprot.readFieldEnd()
7176 
    iprot.readStructEnd()
7177 
 
7178 
  def write(self, oprot):
7179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7181 
      return
3064 chandransh 7182 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 7183 
    if self.orderId is not None:
3064 chandransh 7184 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7185 
      oprot.writeI64(self.orderId)
7186 
      oprot.writeFieldEnd()
3431 rajveer 7187 
    if self.customerId is not None:
3064 chandransh 7188 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7189 
      oprot.writeI64(self.customerId)
94 ashish 7190 
      oprot.writeFieldEnd()
7191 
    oprot.writeFieldStop()
7192 
    oprot.writeStructEnd()
7193 
 
3431 rajveer 7194 
  def validate(self):
7195 
    return
7196 
 
7197 
 
94 ashish 7198 
  def __repr__(self):
7199 
    L = ['%s=%r' % (key, value)
7200 
      for key, value in self.__dict__.iteritems()]
7201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7202 
 
7203 
  def __eq__(self, other):
7204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7205 
 
7206 
  def __ne__(self, other):
7207 
    return not (self == other)
7208 
 
3064 chandransh 7209 
class getOrderForCustomer_result:
94 ashish 7210 
  """
7211 
  Attributes:
7212 
   - success
7213 
   - ex
7214 
  """
7215 
 
7216 
  thrift_spec = (
3064 chandransh 7217 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 7218 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7219 
  )
7220 
 
7221 
  def __init__(self, success=None, ex=None,):
7222 
    self.success = success
7223 
    self.ex = ex
7224 
 
7225 
  def read(self, iprot):
7226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7228 
      return
7229 
    iprot.readStructBegin()
7230 
    while True:
7231 
      (fname, ftype, fid) = iprot.readFieldBegin()
7232 
      if ftype == TType.STOP:
7233 
        break
7234 
      if fid == 0:
3064 chandransh 7235 
        if ftype == TType.STRUCT:
7236 
          self.success = Order()
7237 
          self.success.read(iprot)
94 ashish 7238 
        else:
7239 
          iprot.skip(ftype)
7240 
      elif fid == 1:
7241 
        if ftype == TType.STRUCT:
7242 
          self.ex = TransactionServiceException()
7243 
          self.ex.read(iprot)
7244 
        else:
7245 
          iprot.skip(ftype)
7246 
      else:
7247 
        iprot.skip(ftype)
7248 
      iprot.readFieldEnd()
7249 
    iprot.readStructEnd()
7250 
 
7251 
  def write(self, oprot):
7252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7254 
      return
3064 chandransh 7255 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 7256 
    if self.success is not None:
3064 chandransh 7257 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7258 
      self.success.write(oprot)
94 ashish 7259 
      oprot.writeFieldEnd()
3431 rajveer 7260 
    if self.ex is not None:
94 ashish 7261 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7262 
      self.ex.write(oprot)
7263 
      oprot.writeFieldEnd()
7264 
    oprot.writeFieldStop()
7265 
    oprot.writeStructEnd()
7266 
 
3431 rajveer 7267 
  def validate(self):
7268 
    return
7269 
 
7270 
 
94 ashish 7271 
  def __repr__(self):
7272 
    L = ['%s=%r' % (key, value)
7273 
      for key, value in self.__dict__.iteritems()]
7274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7275 
 
7276 
  def __eq__(self, other):
7277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7278 
 
7279 
  def __ne__(self, other):
7280 
    return not (self == other)
7281 
 
3064 chandransh 7282 
class getAlerts_args:
94 ashish 7283 
  """
7284 
  Attributes:
3064 chandransh 7285 
   - orderId
7286 
   - valid
94 ashish 7287 
  """
7288 
 
7289 
  thrift_spec = (
7290 
    None, # 0
3064 chandransh 7291 
    (1, TType.I64, 'orderId', None, None, ), # 1
7292 
    (2, TType.BOOL, 'valid', None, None, ), # 2
94 ashish 7293 
  )
7294 
 
3064 chandransh 7295 
  def __init__(self, orderId=None, valid=None,):
7296 
    self.orderId = orderId
7297 
    self.valid = valid
94 ashish 7298 
 
7299 
  def read(self, iprot):
7300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7302 
      return
7303 
    iprot.readStructBegin()
7304 
    while True:
7305 
      (fname, ftype, fid) = iprot.readFieldBegin()
7306 
      if ftype == TType.STOP:
7307 
        break
7308 
      if fid == 1:
3064 chandransh 7309 
        if ftype == TType.I64:
7310 
          self.orderId = iprot.readI64();
94 ashish 7311 
        else:
7312 
          iprot.skip(ftype)
3064 chandransh 7313 
      elif fid == 2:
7314 
        if ftype == TType.BOOL:
7315 
          self.valid = iprot.readBool();
7316 
        else:
7317 
          iprot.skip(ftype)
94 ashish 7318 
      else:
7319 
        iprot.skip(ftype)
7320 
      iprot.readFieldEnd()
7321 
    iprot.readStructEnd()
7322 
 
7323 
  def write(self, oprot):
7324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7326 
      return
3064 chandransh 7327 
    oprot.writeStructBegin('getAlerts_args')
3431 rajveer 7328 
    if self.orderId is not None:
3064 chandransh 7329 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7330 
      oprot.writeI64(self.orderId)
94 ashish 7331 
      oprot.writeFieldEnd()
3431 rajveer 7332 
    if self.valid is not None:
3064 chandransh 7333 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
7334 
      oprot.writeBool(self.valid)
7335 
      oprot.writeFieldEnd()
94 ashish 7336 
    oprot.writeFieldStop()
7337 
    oprot.writeStructEnd()
7338 
 
3431 rajveer 7339 
  def validate(self):
7340 
    return
7341 
 
7342 
 
94 ashish 7343 
  def __repr__(self):
7344 
    L = ['%s=%r' % (key, value)
7345 
      for key, value in self.__dict__.iteritems()]
7346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7347 
 
7348 
  def __eq__(self, other):
7349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7350 
 
7351 
  def __ne__(self, other):
7352 
    return not (self == other)
7353 
 
3064 chandransh 7354 
class getAlerts_result:
94 ashish 7355 
  """
7356 
  Attributes:
7357 
   - success
7358 
  """
7359 
 
7360 
  thrift_spec = (
3064 chandransh 7361 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 7362 
  )
7363 
 
3064 chandransh 7364 
  def __init__(self, success=None,):
94 ashish 7365 
    self.success = success
7366 
 
7367 
  def read(self, iprot):
7368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7370 
      return
7371 
    iprot.readStructBegin()
7372 
    while True:
7373 
      (fname, ftype, fid) = iprot.readFieldBegin()
7374 
      if ftype == TType.STOP:
7375 
        break
7376 
      if fid == 0:
3064 chandransh 7377 
        if ftype == TType.LIST:
7378 
          self.success = []
4133 chandransh 7379 
          (_etype115, _size112) = iprot.readListBegin()
7380 
          for _i116 in xrange(_size112):
7381 
            _elem117 = Alert()
7382 
            _elem117.read(iprot)
7383 
            self.success.append(_elem117)
3064 chandransh 7384 
          iprot.readListEnd()
94 ashish 7385 
        else:
7386 
          iprot.skip(ftype)
7387 
      else:
7388 
        iprot.skip(ftype)
7389 
      iprot.readFieldEnd()
7390 
    iprot.readStructEnd()
7391 
 
7392 
  def write(self, oprot):
7393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7395 
      return
3064 chandransh 7396 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 7397 
    if self.success is not None:
3064 chandransh 7398 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7399 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7400 
      for iter118 in self.success:
7401 
        iter118.write(oprot)
3064 chandransh 7402 
      oprot.writeListEnd()
94 ashish 7403 
      oprot.writeFieldEnd()
7404 
    oprot.writeFieldStop()
7405 
    oprot.writeStructEnd()
7406 
 
3431 rajveer 7407 
  def validate(self):
7408 
    return
7409 
 
7410 
 
94 ashish 7411 
  def __repr__(self):
7412 
    L = ['%s=%r' % (key, value)
7413 
      for key, value in self.__dict__.iteritems()]
7414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7415 
 
7416 
  def __eq__(self, other):
7417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7418 
 
7419 
  def __ne__(self, other):
7420 
    return not (self == other)
7421 
 
3064 chandransh 7422 
class setAlert_args:
94 ashish 7423 
  """
7424 
  Attributes:
3064 chandransh 7425 
   - orderId
7426 
   - unset
7427 
   - type
7428 
   - comment
94 ashish 7429 
  """
7430 
 
7431 
  thrift_spec = (
7432 
    None, # 0
3064 chandransh 7433 
    (1, TType.I64, 'orderId', None, None, ), # 1
7434 
    (2, TType.BOOL, 'unset', None, None, ), # 2
7435 
    (3, TType.I64, 'type', None, None, ), # 3
7436 
    (4, TType.STRING, 'comment', None, None, ), # 4
94 ashish 7437 
  )
7438 
 
3064 chandransh 7439 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
7440 
    self.orderId = orderId
7441 
    self.unset = unset
7442 
    self.type = type
7443 
    self.comment = comment
94 ashish 7444 
 
7445 
  def read(self, iprot):
7446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7448 
      return
7449 
    iprot.readStructBegin()
7450 
    while True:
7451 
      (fname, ftype, fid) = iprot.readFieldBegin()
7452 
      if ftype == TType.STOP:
7453 
        break
7454 
      if fid == 1:
7455 
        if ftype == TType.I64:
3064 chandransh 7456 
          self.orderId = iprot.readI64();
94 ashish 7457 
        else:
7458 
          iprot.skip(ftype)
3064 chandransh 7459 
      elif fid == 2:
7460 
        if ftype == TType.BOOL:
7461 
          self.unset = iprot.readBool();
7462 
        else:
7463 
          iprot.skip(ftype)
7464 
      elif fid == 3:
7465 
        if ftype == TType.I64:
7466 
          self.type = iprot.readI64();
7467 
        else:
7468 
          iprot.skip(ftype)
7469 
      elif fid == 4:
7470 
        if ftype == TType.STRING:
7471 
          self.comment = iprot.readString();
7472 
        else:
7473 
          iprot.skip(ftype)
94 ashish 7474 
      else:
7475 
        iprot.skip(ftype)
7476 
      iprot.readFieldEnd()
7477 
    iprot.readStructEnd()
7478 
 
7479 
  def write(self, oprot):
7480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7482 
      return
3064 chandransh 7483 
    oprot.writeStructBegin('setAlert_args')
3431 rajveer 7484 
    if self.orderId is not None:
3064 chandransh 7485 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7486 
      oprot.writeI64(self.orderId)
94 ashish 7487 
      oprot.writeFieldEnd()
3431 rajveer 7488 
    if self.unset is not None:
3064 chandransh 7489 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
7490 
      oprot.writeBool(self.unset)
7491 
      oprot.writeFieldEnd()
3431 rajveer 7492 
    if self.type is not None:
3064 chandransh 7493 
      oprot.writeFieldBegin('type', TType.I64, 3)
7494 
      oprot.writeI64(self.type)
7495 
      oprot.writeFieldEnd()
3431 rajveer 7496 
    if self.comment is not None:
3064 chandransh 7497 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
7498 
      oprot.writeString(self.comment)
7499 
      oprot.writeFieldEnd()
94 ashish 7500 
    oprot.writeFieldStop()
7501 
    oprot.writeStructEnd()
7502 
 
3431 rajveer 7503 
  def validate(self):
7504 
    return
7505 
 
7506 
 
94 ashish 7507 
  def __repr__(self):
7508 
    L = ['%s=%r' % (key, value)
7509 
      for key, value in self.__dict__.iteritems()]
7510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7511 
 
7512 
  def __eq__(self, other):
7513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7514 
 
7515 
  def __ne__(self, other):
7516 
    return not (self == other)
7517 
 
3064 chandransh 7518 
class setAlert_result:
7519 
 
7520 
  thrift_spec = (
7521 
  )
7522 
 
7523 
  def read(self, iprot):
7524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7526 
      return
7527 
    iprot.readStructBegin()
7528 
    while True:
7529 
      (fname, ftype, fid) = iprot.readFieldBegin()
7530 
      if ftype == TType.STOP:
7531 
        break
7532 
      else:
7533 
        iprot.skip(ftype)
7534 
      iprot.readFieldEnd()
7535 
    iprot.readStructEnd()
7536 
 
7537 
  def write(self, oprot):
7538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7540 
      return
7541 
    oprot.writeStructBegin('setAlert_result')
7542 
    oprot.writeFieldStop()
7543 
    oprot.writeStructEnd()
7544 
 
3431 rajveer 7545 
  def validate(self):
7546 
    return
7547 
 
7548 
 
3064 chandransh 7549 
  def __repr__(self):
7550 
    L = ['%s=%r' % (key, value)
7551 
      for key, value in self.__dict__.iteritems()]
7552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7553 
 
7554 
  def __eq__(self, other):
7555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7556 
 
7557 
  def __ne__(self, other):
7558 
    return not (self == other)
7559 
 
7560 
class getValidOrderCount_args:
7561 
 
7562 
  thrift_spec = (
7563 
  )
7564 
 
7565 
  def read(self, iprot):
7566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7568 
      return
7569 
    iprot.readStructBegin()
7570 
    while True:
7571 
      (fname, ftype, fid) = iprot.readFieldBegin()
7572 
      if ftype == TType.STOP:
7573 
        break
7574 
      else:
7575 
        iprot.skip(ftype)
7576 
      iprot.readFieldEnd()
7577 
    iprot.readStructEnd()
7578 
 
7579 
  def write(self, oprot):
7580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7582 
      return
7583 
    oprot.writeStructBegin('getValidOrderCount_args')
7584 
    oprot.writeFieldStop()
7585 
    oprot.writeStructEnd()
7586 
 
3431 rajveer 7587 
  def validate(self):
7588 
    return
7589 
 
7590 
 
3064 chandransh 7591 
  def __repr__(self):
7592 
    L = ['%s=%r' % (key, value)
7593 
      for key, value in self.__dict__.iteritems()]
7594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7595 
 
7596 
  def __eq__(self, other):
7597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7598 
 
7599 
  def __ne__(self, other):
7600 
    return not (self == other)
7601 
 
7602 
class getValidOrderCount_result:
94 ashish 7603 
  """
7604 
  Attributes:
7605 
   - success
7606 
  """
7607 
 
7608 
  thrift_spec = (
3064 chandransh 7609 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7610 
  )
7611 
 
3064 chandransh 7612 
  def __init__(self, success=None,):
94 ashish 7613 
    self.success = success
7614 
 
7615 
  def read(self, iprot):
7616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7618 
      return
7619 
    iprot.readStructBegin()
7620 
    while True:
7621 
      (fname, ftype, fid) = iprot.readFieldBegin()
7622 
      if ftype == TType.STOP:
7623 
        break
7624 
      if fid == 0:
3064 chandransh 7625 
        if ftype == TType.I64:
7626 
          self.success = iprot.readI64();
94 ashish 7627 
        else:
7628 
          iprot.skip(ftype)
7629 
      else:
7630 
        iprot.skip(ftype)
7631 
      iprot.readFieldEnd()
7632 
    iprot.readStructEnd()
7633 
 
7634 
  def write(self, oprot):
7635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7637 
      return
3064 chandransh 7638 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 7639 
    if self.success is not None:
3064 chandransh 7640 
      oprot.writeFieldBegin('success', TType.I64, 0)
7641 
      oprot.writeI64(self.success)
94 ashish 7642 
      oprot.writeFieldEnd()
7643 
    oprot.writeFieldStop()
7644 
    oprot.writeStructEnd()
7645 
 
3431 rajveer 7646 
  def validate(self):
7647 
    return
7648 
 
7649 
 
94 ashish 7650 
  def __repr__(self):
7651 
    L = ['%s=%r' % (key, value)
7652 
      for key, value in self.__dict__.iteritems()]
7653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7654 
 
7655 
  def __eq__(self, other):
7656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7657 
 
7658 
  def __ne__(self, other):
7659 
    return not (self == other)
7660 
 
3064 chandransh 7661 
class getNoOfCustomersWithSuccessfulTransaction_args:
7662 
 
7663 
  thrift_spec = (
7664 
  )
7665 
 
7666 
  def read(self, iprot):
7667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7669 
      return
7670 
    iprot.readStructBegin()
7671 
    while True:
7672 
      (fname, ftype, fid) = iprot.readFieldBegin()
7673 
      if ftype == TType.STOP:
7674 
        break
7675 
      else:
7676 
        iprot.skip(ftype)
7677 
      iprot.readFieldEnd()
7678 
    iprot.readStructEnd()
7679 
 
7680 
  def write(self, oprot):
7681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7683 
      return
7684 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
7685 
    oprot.writeFieldStop()
7686 
    oprot.writeStructEnd()
7687 
 
3431 rajveer 7688 
  def validate(self):
7689 
    return
7690 
 
7691 
 
3064 chandransh 7692 
  def __repr__(self):
7693 
    L = ['%s=%r' % (key, value)
7694 
      for key, value in self.__dict__.iteritems()]
7695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7696 
 
7697 
  def __eq__(self, other):
7698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7699 
 
7700 
  def __ne__(self, other):
7701 
    return not (self == other)
7702 
 
7703 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 7704 
  """
7705 
  Attributes:
3064 chandransh 7706 
   - success
94 ashish 7707 
  """
7708 
 
7709 
  thrift_spec = (
3064 chandransh 7710 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7711 
  )
7712 
 
3064 chandransh 7713 
  def __init__(self, success=None,):
7714 
    self.success = success
94 ashish 7715 
 
7716 
  def read(self, iprot):
7717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7719 
      return
7720 
    iprot.readStructBegin()
7721 
    while True:
7722 
      (fname, ftype, fid) = iprot.readFieldBegin()
7723 
      if ftype == TType.STOP:
7724 
        break
3064 chandransh 7725 
      if fid == 0:
94 ashish 7726 
        if ftype == TType.I64:
3064 chandransh 7727 
          self.success = iprot.readI64();
94 ashish 7728 
        else:
7729 
          iprot.skip(ftype)
7730 
      else:
7731 
        iprot.skip(ftype)
7732 
      iprot.readFieldEnd()
7733 
    iprot.readStructEnd()
7734 
 
7735 
  def write(self, oprot):
7736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7738 
      return
3064 chandransh 7739 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 7740 
    if self.success is not None:
3064 chandransh 7741 
      oprot.writeFieldBegin('success', TType.I64, 0)
7742 
      oprot.writeI64(self.success)
94 ashish 7743 
      oprot.writeFieldEnd()
7744 
    oprot.writeFieldStop()
7745 
    oprot.writeStructEnd()
7746 
 
3431 rajveer 7747 
  def validate(self):
7748 
    return
7749 
 
7750 
 
94 ashish 7751 
  def __repr__(self):
7752 
    L = ['%s=%r' % (key, value)
7753 
      for key, value in self.__dict__.iteritems()]
7754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7755 
 
7756 
  def __eq__(self, other):
7757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7758 
 
7759 
  def __ne__(self, other):
7760 
    return not (self == other)
7761 
 
3064 chandransh 7762 
class getValidOrdersAmountRange_args:
7763 
 
7764 
  thrift_spec = (
7765 
  )
7766 
 
7767 
  def read(self, iprot):
7768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7770 
      return
7771 
    iprot.readStructBegin()
7772 
    while True:
7773 
      (fname, ftype, fid) = iprot.readFieldBegin()
7774 
      if ftype == TType.STOP:
7775 
        break
7776 
      else:
7777 
        iprot.skip(ftype)
7778 
      iprot.readFieldEnd()
7779 
    iprot.readStructEnd()
7780 
 
7781 
  def write(self, oprot):
7782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7784 
      return
7785 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
7786 
    oprot.writeFieldStop()
7787 
    oprot.writeStructEnd()
7788 
 
3431 rajveer 7789 
  def validate(self):
7790 
    return
7791 
 
7792 
 
3064 chandransh 7793 
  def __repr__(self):
7794 
    L = ['%s=%r' % (key, value)
7795 
      for key, value in self.__dict__.iteritems()]
7796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7797 
 
7798 
  def __eq__(self, other):
7799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7800 
 
7801 
  def __ne__(self, other):
7802 
    return not (self == other)
7803 
 
7804 
class getValidOrdersAmountRange_result:
94 ashish 7805 
  """
7806 
  Attributes:
7807 
   - success
7808 
  """
7809 
 
7810 
  thrift_spec = (
3064 chandransh 7811 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 7812 
  )
7813 
 
3064 chandransh 7814 
  def __init__(self, success=None,):
94 ashish 7815 
    self.success = success
7816 
 
7817 
  def read(self, iprot):
7818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7820 
      return
7821 
    iprot.readStructBegin()
7822 
    while True:
7823 
      (fname, ftype, fid) = iprot.readFieldBegin()
7824 
      if ftype == TType.STOP:
7825 
        break
7826 
      if fid == 0:
483 rajveer 7827 
        if ftype == TType.LIST:
7828 
          self.success = []
4133 chandransh 7829 
          (_etype122, _size119) = iprot.readListBegin()
7830 
          for _i123 in xrange(_size119):
7831 
            _elem124 = iprot.readDouble();
7832 
            self.success.append(_elem124)
483 rajveer 7833 
          iprot.readListEnd()
94 ashish 7834 
        else:
7835 
          iprot.skip(ftype)
7836 
      else:
7837 
        iprot.skip(ftype)
7838 
      iprot.readFieldEnd()
7839 
    iprot.readStructEnd()
7840 
 
7841 
  def write(self, oprot):
7842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7844 
      return
3064 chandransh 7845 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 7846 
    if self.success is not None:
483 rajveer 7847 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 7848 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 7849 
      for iter125 in self.success:
7850 
        oprot.writeDouble(iter125)
483 rajveer 7851 
      oprot.writeListEnd()
94 ashish 7852 
      oprot.writeFieldEnd()
7853 
    oprot.writeFieldStop()
7854 
    oprot.writeStructEnd()
7855 
 
3431 rajveer 7856 
  def validate(self):
7857 
    return
7858 
 
7859 
 
94 ashish 7860 
  def __repr__(self):
7861 
    L = ['%s=%r' % (key, value)
7862 
      for key, value in self.__dict__.iteritems()]
7863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7864 
 
7865 
  def __eq__(self, other):
7866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7867 
 
7868 
  def __ne__(self, other):
7869 
    return not (self == other)
7870 
 
3064 chandransh 7871 
class getValidOrders_args:
1528 ankur.sing 7872 
  """
7873 
  Attributes:
3064 chandransh 7874 
   - limit
1528 ankur.sing 7875 
  """
7876 
 
7877 
  thrift_spec = (
7878 
    None, # 0
3064 chandransh 7879 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 7880 
  )
7881 
 
3064 chandransh 7882 
  def __init__(self, limit=None,):
7883 
    self.limit = limit
1528 ankur.sing 7884 
 
7885 
  def read(self, iprot):
7886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7888 
      return
7889 
    iprot.readStructBegin()
7890 
    while True:
7891 
      (fname, ftype, fid) = iprot.readFieldBegin()
7892 
      if ftype == TType.STOP:
7893 
        break
7894 
      if fid == 1:
7895 
        if ftype == TType.I64:
3064 chandransh 7896 
          self.limit = iprot.readI64();
1528 ankur.sing 7897 
        else:
7898 
          iprot.skip(ftype)
7899 
      else:
7900 
        iprot.skip(ftype)
7901 
      iprot.readFieldEnd()
7902 
    iprot.readStructEnd()
7903 
 
7904 
  def write(self, oprot):
7905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7907 
      return
3064 chandransh 7908 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 7909 
    if self.limit is not None:
3064 chandransh 7910 
      oprot.writeFieldBegin('limit', TType.I64, 1)
7911 
      oprot.writeI64(self.limit)
1528 ankur.sing 7912 
      oprot.writeFieldEnd()
7913 
    oprot.writeFieldStop()
7914 
    oprot.writeStructEnd()
7915 
 
3431 rajveer 7916 
  def validate(self):
7917 
    return
7918 
 
7919 
 
1528 ankur.sing 7920 
  def __repr__(self):
7921 
    L = ['%s=%r' % (key, value)
7922 
      for key, value in self.__dict__.iteritems()]
7923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7924 
 
7925 
  def __eq__(self, other):
7926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7927 
 
7928 
  def __ne__(self, other):
7929 
    return not (self == other)
7930 
 
3064 chandransh 7931 
class getValidOrders_result:
1528 ankur.sing 7932 
  """
7933 
  Attributes:
7934 
   - success
7935 
  """
7936 
 
7937 
  thrift_spec = (
3064 chandransh 7938 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 7939 
  )
7940 
 
3064 chandransh 7941 
  def __init__(self, success=None,):
1528 ankur.sing 7942 
    self.success = success
7943 
 
7944 
  def read(self, iprot):
7945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7947 
      return
7948 
    iprot.readStructBegin()
7949 
    while True:
7950 
      (fname, ftype, fid) = iprot.readFieldBegin()
7951 
      if ftype == TType.STOP:
7952 
        break
7953 
      if fid == 0:
3064 chandransh 7954 
        if ftype == TType.LIST:
7955 
          self.success = []
4133 chandransh 7956 
          (_etype129, _size126) = iprot.readListBegin()
7957 
          for _i130 in xrange(_size126):
7958 
            _elem131 = Order()
7959 
            _elem131.read(iprot)
7960 
            self.success.append(_elem131)
3064 chandransh 7961 
          iprot.readListEnd()
1528 ankur.sing 7962 
        else:
7963 
          iprot.skip(ftype)
7964 
      else:
7965 
        iprot.skip(ftype)
7966 
      iprot.readFieldEnd()
7967 
    iprot.readStructEnd()
7968 
 
7969 
  def write(self, oprot):
7970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7972 
      return
3064 chandransh 7973 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 7974 
    if self.success is not None:
3064 chandransh 7975 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7976 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7977 
      for iter132 in self.success:
7978 
        iter132.write(oprot)
3064 chandransh 7979 
      oprot.writeListEnd()
1528 ankur.sing 7980 
      oprot.writeFieldEnd()
7981 
    oprot.writeFieldStop()
7982 
    oprot.writeStructEnd()
7983 
 
3431 rajveer 7984 
  def validate(self):
7985 
    return
7986 
 
7987 
 
1528 ankur.sing 7988 
  def __repr__(self):
7989 
    L = ['%s=%r' % (key, value)
7990 
      for key, value in self.__dict__.iteritems()]
7991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7992 
 
7993 
  def __eq__(self, other):
7994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7995 
 
7996 
  def __ne__(self, other):
7997 
    return not (self == other)
7998 
 
1220 chandransh 7999 
class batchOrders_args:
8000 
  """
8001 
  Attributes:
8002 
   - warehouseId
8003 
  """
8004 
 
8005 
  thrift_spec = (
8006 
    None, # 0
8007 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8008 
  )
8009 
 
8010 
  def __init__(self, warehouseId=None,):
8011 
    self.warehouseId = warehouseId
8012 
 
8013 
  def read(self, iprot):
8014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8016 
      return
8017 
    iprot.readStructBegin()
8018 
    while True:
8019 
      (fname, ftype, fid) = iprot.readFieldBegin()
8020 
      if ftype == TType.STOP:
8021 
        break
8022 
      if fid == 1:
8023 
        if ftype == TType.I64:
8024 
          self.warehouseId = iprot.readI64();
8025 
        else:
8026 
          iprot.skip(ftype)
8027 
      else:
8028 
        iprot.skip(ftype)
8029 
      iprot.readFieldEnd()
8030 
    iprot.readStructEnd()
8031 
 
8032 
  def write(self, oprot):
8033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8035 
      return
8036 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 8037 
    if self.warehouseId is not None:
1220 chandransh 8038 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8039 
      oprot.writeI64(self.warehouseId)
8040 
      oprot.writeFieldEnd()
8041 
    oprot.writeFieldStop()
8042 
    oprot.writeStructEnd()
8043 
 
3431 rajveer 8044 
  def validate(self):
8045 
    return
8046 
 
8047 
 
1220 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 
 
8059 
class batchOrders_result:
8060 
  """
8061 
  Attributes:
8062 
   - success
8063 
   - ex
8064 
  """
8065 
 
8066 
  thrift_spec = (
8067 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8068 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8069 
  )
8070 
 
8071 
  def __init__(self, success=None, ex=None,):
8072 
    self.success = success
8073 
    self.ex = ex
8074 
 
8075 
  def read(self, iprot):
8076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8078 
      return
8079 
    iprot.readStructBegin()
8080 
    while True:
8081 
      (fname, ftype, fid) = iprot.readFieldBegin()
8082 
      if ftype == TType.STOP:
8083 
        break
8084 
      if fid == 0:
8085 
        if ftype == TType.LIST:
8086 
          self.success = []
4133 chandransh 8087 
          (_etype136, _size133) = iprot.readListBegin()
8088 
          for _i137 in xrange(_size133):
8089 
            _elem138 = Order()
8090 
            _elem138.read(iprot)
8091 
            self.success.append(_elem138)
1220 chandransh 8092 
          iprot.readListEnd()
8093 
        else:
8094 
          iprot.skip(ftype)
8095 
      elif fid == 1:
8096 
        if ftype == TType.STRUCT:
8097 
          self.ex = TransactionServiceException()
8098 
          self.ex.read(iprot)
8099 
        else:
8100 
          iprot.skip(ftype)
8101 
      else:
8102 
        iprot.skip(ftype)
8103 
      iprot.readFieldEnd()
8104 
    iprot.readStructEnd()
8105 
 
8106 
  def write(self, oprot):
8107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8109 
      return
8110 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 8111 
    if self.success is not None:
1220 chandransh 8112 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8113 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8114 
      for iter139 in self.success:
8115 
        iter139.write(oprot)
1220 chandransh 8116 
      oprot.writeListEnd()
8117 
      oprot.writeFieldEnd()
3431 rajveer 8118 
    if self.ex is not None:
1220 chandransh 8119 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8120 
      self.ex.write(oprot)
8121 
      oprot.writeFieldEnd()
8122 
    oprot.writeFieldStop()
8123 
    oprot.writeStructEnd()
8124 
 
3431 rajveer 8125 
  def validate(self):
8126 
    return
8127 
 
8128 
 
1220 chandransh 8129 
  def __repr__(self):
8130 
    L = ['%s=%r' % (key, value)
8131 
      for key, value in self.__dict__.iteritems()]
8132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8133 
 
8134 
  def __eq__(self, other):
8135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8136 
 
8137 
  def __ne__(self, other):
8138 
    return not (self == other)
8139 
 
1208 chandransh 8140 
class markOrderAsOutOfStock_args:
8141 
  """
8142 
  Attributes:
8143 
   - orderId
8144 
  """
8145 
 
8146 
  thrift_spec = (
8147 
    None, # 0
8148 
    (1, TType.I64, 'orderId', None, None, ), # 1
8149 
  )
8150 
 
8151 
  def __init__(self, orderId=None,):
8152 
    self.orderId = orderId
8153 
 
8154 
  def read(self, iprot):
8155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8157 
      return
8158 
    iprot.readStructBegin()
8159 
    while True:
8160 
      (fname, ftype, fid) = iprot.readFieldBegin()
8161 
      if ftype == TType.STOP:
8162 
        break
8163 
      if fid == 1:
8164 
        if ftype == TType.I64:
8165 
          self.orderId = iprot.readI64();
8166 
        else:
8167 
          iprot.skip(ftype)
8168 
      else:
8169 
        iprot.skip(ftype)
8170 
      iprot.readFieldEnd()
8171 
    iprot.readStructEnd()
8172 
 
8173 
  def write(self, oprot):
8174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8176 
      return
8177 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 8178 
    if self.orderId is not None:
1208 chandransh 8179 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8180 
      oprot.writeI64(self.orderId)
8181 
      oprot.writeFieldEnd()
8182 
    oprot.writeFieldStop()
8183 
    oprot.writeStructEnd()
8184 
 
3431 rajveer 8185 
  def validate(self):
8186 
    return
8187 
 
8188 
 
1208 chandransh 8189 
  def __repr__(self):
8190 
    L = ['%s=%r' % (key, value)
8191 
      for key, value in self.__dict__.iteritems()]
8192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8193 
 
8194 
  def __eq__(self, other):
8195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8196 
 
8197 
  def __ne__(self, other):
8198 
    return not (self == other)
8199 
 
8200 
class markOrderAsOutOfStock_result:
8201 
  """
8202 
  Attributes:
8203 
   - success
8204 
   - ex
8205 
  """
8206 
 
8207 
  thrift_spec = (
8208 
    (0, TType.BOOL, 'success', None, None, ), # 0
8209 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8210 
  )
8211 
 
8212 
  def __init__(self, success=None, ex=None,):
8213 
    self.success = success
8214 
    self.ex = ex
8215 
 
8216 
  def read(self, iprot):
8217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8219 
      return
8220 
    iprot.readStructBegin()
8221 
    while True:
8222 
      (fname, ftype, fid) = iprot.readFieldBegin()
8223 
      if ftype == TType.STOP:
8224 
        break
8225 
      if fid == 0:
8226 
        if ftype == TType.BOOL:
8227 
          self.success = iprot.readBool();
8228 
        else:
8229 
          iprot.skip(ftype)
8230 
      elif fid == 1:
8231 
        if ftype == TType.STRUCT:
8232 
          self.ex = TransactionServiceException()
8233 
          self.ex.read(iprot)
8234 
        else:
8235 
          iprot.skip(ftype)
8236 
      else:
8237 
        iprot.skip(ftype)
8238 
      iprot.readFieldEnd()
8239 
    iprot.readStructEnd()
8240 
 
8241 
  def write(self, oprot):
8242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8244 
      return
8245 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 8246 
    if self.success is not None:
1208 chandransh 8247 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8248 
      oprot.writeBool(self.success)
8249 
      oprot.writeFieldEnd()
3431 rajveer 8250 
    if self.ex is not None:
1208 chandransh 8251 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8252 
      self.ex.write(oprot)
8253 
      oprot.writeFieldEnd()
8254 
    oprot.writeFieldStop()
8255 
    oprot.writeStructEnd()
8256 
 
3431 rajveer 8257 
  def validate(self):
8258 
    return
8259 
 
8260 
 
1208 chandransh 8261 
  def __repr__(self):
8262 
    L = ['%s=%r' % (key, value)
8263 
      for key, value in self.__dict__.iteritems()]
8264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8265 
 
8266 
  def __eq__(self, other):
8267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8268 
 
8269 
  def __ne__(self, other):
8270 
    return not (self == other)
8271 
 
3064 chandransh 8272 
class verifyOrder_args:
759 chandransh 8273 
  """
8274 
  Attributes:
3064 chandransh 8275 
   - orderId
759 chandransh 8276 
  """
8277 
 
8278 
  thrift_spec = (
8279 
    None, # 0
3064 chandransh 8280 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 8281 
  )
8282 
 
3064 chandransh 8283 
  def __init__(self, orderId=None,):
8284 
    self.orderId = orderId
759 chandransh 8285 
 
8286 
  def read(self, iprot):
8287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8289 
      return
8290 
    iprot.readStructBegin()
8291 
    while True:
8292 
      (fname, ftype, fid) = iprot.readFieldBegin()
8293 
      if ftype == TType.STOP:
8294 
        break
8295 
      if fid == 1:
8296 
        if ftype == TType.I64:
3064 chandransh 8297 
          self.orderId = iprot.readI64();
759 chandransh 8298 
        else:
8299 
          iprot.skip(ftype)
8300 
      else:
8301 
        iprot.skip(ftype)
8302 
      iprot.readFieldEnd()
8303 
    iprot.readStructEnd()
8304 
 
8305 
  def write(self, oprot):
8306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8308 
      return
3064 chandransh 8309 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 8310 
    if self.orderId is not None:
3064 chandransh 8311 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8312 
      oprot.writeI64(self.orderId)
759 chandransh 8313 
      oprot.writeFieldEnd()
8314 
    oprot.writeFieldStop()
8315 
    oprot.writeStructEnd()
8316 
 
3431 rajveer 8317 
  def validate(self):
8318 
    return
8319 
 
8320 
 
759 chandransh 8321 
  def __repr__(self):
8322 
    L = ['%s=%r' % (key, value)
8323 
      for key, value in self.__dict__.iteritems()]
8324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8325 
 
8326 
  def __eq__(self, other):
8327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8328 
 
8329 
  def __ne__(self, other):
8330 
    return not (self == other)
8331 
 
3064 chandransh 8332 
class verifyOrder_result:
759 chandransh 8333 
  """
8334 
  Attributes:
8335 
   - success
8336 
   - ex
8337 
  """
8338 
 
8339 
  thrift_spec = (
8340 
    (0, TType.BOOL, 'success', None, None, ), # 0
8341 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8342 
  )
8343 
 
8344 
  def __init__(self, success=None, ex=None,):
8345 
    self.success = success
8346 
    self.ex = ex
8347 
 
8348 
  def read(self, iprot):
8349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8351 
      return
8352 
    iprot.readStructBegin()
8353 
    while True:
8354 
      (fname, ftype, fid) = iprot.readFieldBegin()
8355 
      if ftype == TType.STOP:
8356 
        break
8357 
      if fid == 0:
8358 
        if ftype == TType.BOOL:
8359 
          self.success = iprot.readBool();
8360 
        else:
8361 
          iprot.skip(ftype)
8362 
      elif fid == 1:
8363 
        if ftype == TType.STRUCT:
8364 
          self.ex = TransactionServiceException()
8365 
          self.ex.read(iprot)
8366 
        else:
8367 
          iprot.skip(ftype)
8368 
      else:
8369 
        iprot.skip(ftype)
8370 
      iprot.readFieldEnd()
8371 
    iprot.readStructEnd()
8372 
 
8373 
  def write(self, oprot):
8374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8376 
      return
3064 chandransh 8377 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 8378 
    if self.success is not None:
759 chandransh 8379 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8380 
      oprot.writeBool(self.success)
8381 
      oprot.writeFieldEnd()
3431 rajveer 8382 
    if self.ex is not None:
759 chandransh 8383 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8384 
      self.ex.write(oprot)
8385 
      oprot.writeFieldEnd()
8386 
    oprot.writeFieldStop()
8387 
    oprot.writeStructEnd()
8388 
 
3431 rajveer 8389 
  def validate(self):
8390 
    return
8391 
 
8392 
 
759 chandransh 8393 
  def __repr__(self):
8394 
    L = ['%s=%r' % (key, value)
8395 
      for key, value in self.__dict__.iteritems()]
8396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8397 
 
8398 
  def __eq__(self, other):
8399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8400 
 
8401 
  def __ne__(self, other):
8402 
    return not (self == other)
8403 
 
3064 chandransh 8404 
class acceptOrder_args:
1113 chandransh 8405 
  """
8406 
  Attributes:
3064 chandransh 8407 
   - orderId
1113 chandransh 8408 
  """
8409 
 
8410 
  thrift_spec = (
8411 
    None, # 0
3064 chandransh 8412 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 8413 
  )
8414 
 
3064 chandransh 8415 
  def __init__(self, orderId=None,):
8416 
    self.orderId = orderId
1113 chandransh 8417 
 
8418 
  def read(self, iprot):
8419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8421 
      return
8422 
    iprot.readStructBegin()
8423 
    while True:
8424 
      (fname, ftype, fid) = iprot.readFieldBegin()
8425 
      if ftype == TType.STOP:
8426 
        break
8427 
      if fid == 1:
8428 
        if ftype == TType.I64:
3064 chandransh 8429 
          self.orderId = iprot.readI64();
1113 chandransh 8430 
        else:
8431 
          iprot.skip(ftype)
8432 
      else:
8433 
        iprot.skip(ftype)
8434 
      iprot.readFieldEnd()
8435 
    iprot.readStructEnd()
8436 
 
8437 
  def write(self, oprot):
8438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8440 
      return
3064 chandransh 8441 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 8442 
    if self.orderId is not None:
3064 chandransh 8443 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8444 
      oprot.writeI64(self.orderId)
1113 chandransh 8445 
      oprot.writeFieldEnd()
8446 
    oprot.writeFieldStop()
8447 
    oprot.writeStructEnd()
8448 
 
3431 rajveer 8449 
  def validate(self):
8450 
    return
8451 
 
8452 
 
1113 chandransh 8453 
  def __repr__(self):
8454 
    L = ['%s=%r' % (key, value)
8455 
      for key, value in self.__dict__.iteritems()]
8456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8457 
 
8458 
  def __eq__(self, other):
8459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8460 
 
8461 
  def __ne__(self, other):
8462 
    return not (self == other)
8463 
 
3064 chandransh 8464 
class acceptOrder_result:
1113 chandransh 8465 
  """
8466 
  Attributes:
8467 
   - success
8468 
   - ex
8469 
  """
8470 
 
8471 
  thrift_spec = (
3064 chandransh 8472 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 8473 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8474 
  )
8475 
 
8476 
  def __init__(self, success=None, ex=None,):
8477 
    self.success = success
8478 
    self.ex = ex
8479 
 
8480 
  def read(self, iprot):
8481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8483 
      return
8484 
    iprot.readStructBegin()
8485 
    while True:
8486 
      (fname, ftype, fid) = iprot.readFieldBegin()
8487 
      if ftype == TType.STOP:
8488 
        break
8489 
      if fid == 0:
3064 chandransh 8490 
        if ftype == TType.BOOL:
8491 
          self.success = iprot.readBool();
1113 chandransh 8492 
        else:
8493 
          iprot.skip(ftype)
8494 
      elif fid == 1:
8495 
        if ftype == TType.STRUCT:
8496 
          self.ex = TransactionServiceException()
8497 
          self.ex.read(iprot)
8498 
        else:
8499 
          iprot.skip(ftype)
8500 
      else:
8501 
        iprot.skip(ftype)
8502 
      iprot.readFieldEnd()
8503 
    iprot.readStructEnd()
8504 
 
8505 
  def write(self, oprot):
8506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8508 
      return
3064 chandransh 8509 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 8510 
    if self.success is not None:
3064 chandransh 8511 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8512 
      oprot.writeBool(self.success)
1113 chandransh 8513 
      oprot.writeFieldEnd()
3431 rajveer 8514 
    if self.ex is not None:
1113 chandransh 8515 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8516 
      self.ex.write(oprot)
8517 
      oprot.writeFieldEnd()
8518 
    oprot.writeFieldStop()
8519 
    oprot.writeStructEnd()
8520 
 
3431 rajveer 8521 
  def validate(self):
8522 
    return
8523 
 
8524 
 
1113 chandransh 8525 
  def __repr__(self):
8526 
    L = ['%s=%r' % (key, value)
8527 
      for key, value in self.__dict__.iteritems()]
8528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8529 
 
8530 
  def __eq__(self, other):
8531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8532 
 
8533 
  def __ne__(self, other):
8534 
    return not (self == other)
8535 
 
3064 chandransh 8536 
class billOrder_args:
1132 chandransh 8537 
  """
8538 
  Attributes:
3064 chandransh 8539 
   - orderId
1132 chandransh 8540 
  """
8541 
 
8542 
  thrift_spec = (
8543 
    None, # 0
3064 chandransh 8544 
    (1, TType.I64, 'orderId', None, None, ), # 1
1132 chandransh 8545 
  )
8546 
 
3064 chandransh 8547 
  def __init__(self, orderId=None,):
8548 
    self.orderId = orderId
1132 chandransh 8549 
 
8550 
  def read(self, iprot):
8551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8553 
      return
8554 
    iprot.readStructBegin()
8555 
    while True:
8556 
      (fname, ftype, fid) = iprot.readFieldBegin()
8557 
      if ftype == TType.STOP:
8558 
        break
8559 
      if fid == 1:
8560 
        if ftype == TType.I64:
3064 chandransh 8561 
          self.orderId = iprot.readI64();
1132 chandransh 8562 
        else:
8563 
          iprot.skip(ftype)
8564 
      else:
8565 
        iprot.skip(ftype)
8566 
      iprot.readFieldEnd()
8567 
    iprot.readStructEnd()
8568 
 
8569 
  def write(self, oprot):
8570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8572 
      return
3064 chandransh 8573 
    oprot.writeStructBegin('billOrder_args')
3431 rajveer 8574 
    if self.orderId is not None:
3064 chandransh 8575 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8576 
      oprot.writeI64(self.orderId)
1132 chandransh 8577 
      oprot.writeFieldEnd()
8578 
    oprot.writeFieldStop()
8579 
    oprot.writeStructEnd()
8580 
 
3431 rajveer 8581 
  def validate(self):
8582 
    return
8583 
 
8584 
 
1132 chandransh 8585 
  def __repr__(self):
8586 
    L = ['%s=%r' % (key, value)
8587 
      for key, value in self.__dict__.iteritems()]
8588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8589 
 
8590 
  def __eq__(self, other):
8591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8592 
 
8593 
  def __ne__(self, other):
8594 
    return not (self == other)
8595 
 
3064 chandransh 8596 
class billOrder_result:
1132 chandransh 8597 
  """
8598 
  Attributes:
3064 chandransh 8599 
   - success
1132 chandransh 8600 
   - ex
8601 
  """
8602 
 
8603 
  thrift_spec = (
3064 chandransh 8604 
    (0, TType.BOOL, 'success', None, None, ), # 0
1132 chandransh 8605 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8606 
  )
8607 
 
3064 chandransh 8608 
  def __init__(self, success=None, ex=None,):
8609 
    self.success = success
1132 chandransh 8610 
    self.ex = ex
8611 
 
8612 
  def read(self, iprot):
8613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8615 
      return
8616 
    iprot.readStructBegin()
8617 
    while True:
8618 
      (fname, ftype, fid) = iprot.readFieldBegin()
8619 
      if ftype == TType.STOP:
8620 
        break
3064 chandransh 8621 
      if fid == 0:
8622 
        if ftype == TType.BOOL:
8623 
          self.success = iprot.readBool();
8624 
        else:
8625 
          iprot.skip(ftype)
8626 
      elif fid == 1:
1132 chandransh 8627 
        if ftype == TType.STRUCT:
8628 
          self.ex = TransactionServiceException()
8629 
          self.ex.read(iprot)
8630 
        else:
8631 
          iprot.skip(ftype)
8632 
      else:
8633 
        iprot.skip(ftype)
8634 
      iprot.readFieldEnd()
8635 
    iprot.readStructEnd()
8636 
 
8637 
  def write(self, oprot):
8638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8640 
      return
3064 chandransh 8641 
    oprot.writeStructBegin('billOrder_result')
3431 rajveer 8642 
    if self.success is not None:
3064 chandransh 8643 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8644 
      oprot.writeBool(self.success)
8645 
      oprot.writeFieldEnd()
3431 rajveer 8646 
    if self.ex is not None:
1132 chandransh 8647 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8648 
      self.ex.write(oprot)
8649 
      oprot.writeFieldEnd()
8650 
    oprot.writeFieldStop()
8651 
    oprot.writeStructEnd()
8652 
 
3431 rajveer 8653 
  def validate(self):
8654 
    return
8655 
 
8656 
 
1132 chandransh 8657 
  def __repr__(self):
8658 
    L = ['%s=%r' % (key, value)
8659 
      for key, value in self.__dict__.iteritems()]
8660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8661 
 
8662 
  def __eq__(self, other):
8663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8664 
 
8665 
  def __ne__(self, other):
8666 
    return not (self == other)
8667 
 
3064 chandransh 8668 
class addBillingDetails_args:
1135 chandransh 8669 
  """
8670 
  Attributes:
3064 chandransh 8671 
   - orderId
8672 
   - invoice_number
8673 
   - billed_by
1135 chandransh 8674 
  """
8675 
 
8676 
  thrift_spec = (
8677 
    None, # 0
3064 chandransh 8678 
    (1, TType.I64, 'orderId', None, None, ), # 1
8679 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
8680 
    (3, TType.STRING, 'billed_by', None, None, ), # 3
1135 chandransh 8681 
  )
8682 
 
3064 chandransh 8683 
  def __init__(self, orderId=None, invoice_number=None, billed_by=None,):
8684 
    self.orderId = orderId
8685 
    self.invoice_number = invoice_number
8686 
    self.billed_by = billed_by
1135 chandransh 8687 
 
8688 
  def read(self, iprot):
8689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8691 
      return
8692 
    iprot.readStructBegin()
8693 
    while True:
8694 
      (fname, ftype, fid) = iprot.readFieldBegin()
8695 
      if ftype == TType.STOP:
8696 
        break
8697 
      if fid == 1:
8698 
        if ftype == TType.I64:
3064 chandransh 8699 
          self.orderId = iprot.readI64();
1135 chandransh 8700 
        else:
8701 
          iprot.skip(ftype)
8702 
      elif fid == 2:
3064 chandransh 8703 
        if ftype == TType.STRING:
8704 
          self.invoice_number = iprot.readString();
1135 chandransh 8705 
        else:
8706 
          iprot.skip(ftype)
3064 chandransh 8707 
      elif fid == 3:
8708 
        if ftype == TType.STRING:
8709 
          self.billed_by = iprot.readString();
8710 
        else:
8711 
          iprot.skip(ftype)
1135 chandransh 8712 
      else:
8713 
        iprot.skip(ftype)
8714 
      iprot.readFieldEnd()
8715 
    iprot.readStructEnd()
8716 
 
8717 
  def write(self, oprot):
8718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8720 
      return
3064 chandransh 8721 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 8722 
    if self.orderId is not None:
3064 chandransh 8723 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8724 
      oprot.writeI64(self.orderId)
1135 chandransh 8725 
      oprot.writeFieldEnd()
3431 rajveer 8726 
    if self.invoice_number is not None:
3064 chandransh 8727 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
8728 
      oprot.writeString(self.invoice_number)
1135 chandransh 8729 
      oprot.writeFieldEnd()
3431 rajveer 8730 
    if self.billed_by is not None:
3064 chandransh 8731 
      oprot.writeFieldBegin('billed_by', TType.STRING, 3)
8732 
      oprot.writeString(self.billed_by)
8733 
      oprot.writeFieldEnd()
1135 chandransh 8734 
    oprot.writeFieldStop()
8735 
    oprot.writeStructEnd()
8736 
 
3431 rajveer 8737 
  def validate(self):
8738 
    return
8739 
 
8740 
 
1135 chandransh 8741 
  def __repr__(self):
8742 
    L = ['%s=%r' % (key, value)
8743 
      for key, value in self.__dict__.iteritems()]
8744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8745 
 
8746 
  def __eq__(self, other):
8747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8748 
 
8749 
  def __ne__(self, other):
8750 
    return not (self == other)
8751 
 
3064 chandransh 8752 
class addBillingDetails_result:
1135 chandransh 8753 
  """
8754 
  Attributes:
3064 chandransh 8755 
   - success
1135 chandransh 8756 
   - ex
8757 
  """
8758 
 
8759 
  thrift_spec = (
3064 chandransh 8760 
    (0, TType.BOOL, 'success', None, None, ), # 0
1135 chandransh 8761 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8762 
  )
8763 
 
3064 chandransh 8764 
  def __init__(self, success=None, ex=None,):
8765 
    self.success = success
1135 chandransh 8766 
    self.ex = ex
8767 
 
8768 
  def read(self, iprot):
8769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8771 
      return
8772 
    iprot.readStructBegin()
8773 
    while True:
8774 
      (fname, ftype, fid) = iprot.readFieldBegin()
8775 
      if ftype == TType.STOP:
8776 
        break
3064 chandransh 8777 
      if fid == 0:
8778 
        if ftype == TType.BOOL:
8779 
          self.success = iprot.readBool();
8780 
        else:
8781 
          iprot.skip(ftype)
8782 
      elif fid == 1:
1135 chandransh 8783 
        if ftype == TType.STRUCT:
8784 
          self.ex = TransactionServiceException()
8785 
          self.ex.read(iprot)
8786 
        else:
8787 
          iprot.skip(ftype)
8788 
      else:
8789 
        iprot.skip(ftype)
8790 
      iprot.readFieldEnd()
8791 
    iprot.readStructEnd()
8792 
 
8793 
  def write(self, oprot):
8794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8796 
      return
3064 chandransh 8797 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 8798 
    if self.success is not None:
3064 chandransh 8799 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8800 
      oprot.writeBool(self.success)
8801 
      oprot.writeFieldEnd()
3431 rajveer 8802 
    if self.ex is not None:
1135 chandransh 8803 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8804 
      self.ex.write(oprot)
8805 
      oprot.writeFieldEnd()
8806 
    oprot.writeFieldStop()
8807 
    oprot.writeStructEnd()
8808 
 
3431 rajveer 8809 
  def validate(self):
8810 
    return
8811 
 
8812 
 
1135 chandransh 8813 
  def __repr__(self):
8814 
    L = ['%s=%r' % (key, value)
8815 
      for key, value in self.__dict__.iteritems()]
8816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8817 
 
8818 
  def __eq__(self, other):
8819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8820 
 
8821 
  def __ne__(self, other):
8822 
    return not (self == other)
8823 
 
3064 chandransh 8824 
class addJacketNumber_args:
1246 chandransh 8825 
  """
8826 
  Attributes:
3064 chandransh 8827 
   - orderId
8828 
   - jacketNumber
8829 
   - imeiNumber
8830 
   - itemNumber
8831 
   - billedBy
8832 
   - billingType
1246 chandransh 8833 
  """
8834 
 
8835 
  thrift_spec = (
8836 
    None, # 0
3064 chandransh 8837 
    (1, TType.I64, 'orderId', None, None, ), # 1
8838 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
8839 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
8840 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
8841 
    (5, TType.STRING, 'billedBy', None, None, ), # 5
8842 
    (6, TType.I64, 'billingType', None, None, ), # 6
1246 chandransh 8843 
  )
8844 
 
3064 chandransh 8845 
  def __init__(self, orderId=None, jacketNumber=None, imeiNumber=None, itemNumber=None, billedBy=None, billingType=None,):
8846 
    self.orderId = orderId
8847 
    self.jacketNumber = jacketNumber
8848 
    self.imeiNumber = imeiNumber
8849 
    self.itemNumber = itemNumber
8850 
    self.billedBy = billedBy
8851 
    self.billingType = billingType
1246 chandransh 8852 
 
8853 
  def read(self, iprot):
8854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8856 
      return
8857 
    iprot.readStructBegin()
8858 
    while True:
8859 
      (fname, ftype, fid) = iprot.readFieldBegin()
8860 
      if ftype == TType.STOP:
8861 
        break
8862 
      if fid == 1:
8863 
        if ftype == TType.I64:
3064 chandransh 8864 
          self.orderId = iprot.readI64();
1246 chandransh 8865 
        else:
8866 
          iprot.skip(ftype)
8867 
      elif fid == 2:
3064 chandransh 8868 
        if ftype == TType.I64:
8869 
          self.jacketNumber = iprot.readI64();
1246 chandransh 8870 
        else:
8871 
          iprot.skip(ftype)
3064 chandransh 8872 
      elif fid == 3:
8873 
        if ftype == TType.I64:
8874 
          self.imeiNumber = iprot.readI64();
8875 
        else:
8876 
          iprot.skip(ftype)
8877 
      elif fid == 4:
8878 
        if ftype == TType.STRING:
8879 
          self.itemNumber = iprot.readString();
8880 
        else:
8881 
          iprot.skip(ftype)
8882 
      elif fid == 5:
8883 
        if ftype == TType.STRING:
8884 
          self.billedBy = iprot.readString();
8885 
        else:
8886 
          iprot.skip(ftype)
8887 
      elif fid == 6:
8888 
        if ftype == TType.I64:
8889 
          self.billingType = iprot.readI64();
8890 
        else:
8891 
          iprot.skip(ftype)
1246 chandransh 8892 
      else:
8893 
        iprot.skip(ftype)
8894 
      iprot.readFieldEnd()
8895 
    iprot.readStructEnd()
8896 
 
8897 
  def write(self, oprot):
8898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8900 
      return
3064 chandransh 8901 
    oprot.writeStructBegin('addJacketNumber_args')
3431 rajveer 8902 
    if self.orderId is not None:
3064 chandransh 8903 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8904 
      oprot.writeI64(self.orderId)
1246 chandransh 8905 
      oprot.writeFieldEnd()
3431 rajveer 8906 
    if self.jacketNumber is not None:
3064 chandransh 8907 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
8908 
      oprot.writeI64(self.jacketNumber)
1246 chandransh 8909 
      oprot.writeFieldEnd()
3431 rajveer 8910 
    if self.imeiNumber is not None:
3064 chandransh 8911 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
8912 
      oprot.writeI64(self.imeiNumber)
8913 
      oprot.writeFieldEnd()
3431 rajveer 8914 
    if self.itemNumber is not None:
3064 chandransh 8915 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
8916 
      oprot.writeString(self.itemNumber)
8917 
      oprot.writeFieldEnd()
3431 rajveer 8918 
    if self.billedBy is not None:
3064 chandransh 8919 
      oprot.writeFieldBegin('billedBy', TType.STRING, 5)
8920 
      oprot.writeString(self.billedBy)
8921 
      oprot.writeFieldEnd()
3431 rajveer 8922 
    if self.billingType is not None:
3064 chandransh 8923 
      oprot.writeFieldBegin('billingType', TType.I64, 6)
8924 
      oprot.writeI64(self.billingType)
8925 
      oprot.writeFieldEnd()
1246 chandransh 8926 
    oprot.writeFieldStop()
8927 
    oprot.writeStructEnd()
8928 
 
3431 rajveer 8929 
  def validate(self):
8930 
    return
8931 
 
8932 
 
1246 chandransh 8933 
  def __repr__(self):
8934 
    L = ['%s=%r' % (key, value)
8935 
      for key, value in self.__dict__.iteritems()]
8936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8937 
 
8938 
  def __eq__(self, other):
8939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8940 
 
8941 
  def __ne__(self, other):
8942 
    return not (self == other)
8943 
 
3064 chandransh 8944 
class addJacketNumber_result:
1246 chandransh 8945 
  """
8946 
  Attributes:
3064 chandransh 8947 
   - success
1246 chandransh 8948 
   - ex
8949 
  """
8950 
 
8951 
  thrift_spec = (
3064 chandransh 8952 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 8953 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8954 
  )
8955 
 
3064 chandransh 8956 
  def __init__(self, success=None, ex=None,):
8957 
    self.success = success
1246 chandransh 8958 
    self.ex = ex
8959 
 
8960 
  def read(self, iprot):
8961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8963 
      return
8964 
    iprot.readStructBegin()
8965 
    while True:
8966 
      (fname, ftype, fid) = iprot.readFieldBegin()
8967 
      if ftype == TType.STOP:
8968 
        break
3064 chandransh 8969 
      if fid == 0:
8970 
        if ftype == TType.BOOL:
8971 
          self.success = iprot.readBool();
8972 
        else:
8973 
          iprot.skip(ftype)
8974 
      elif fid == 1:
1246 chandransh 8975 
        if ftype == TType.STRUCT:
8976 
          self.ex = TransactionServiceException()
8977 
          self.ex.read(iprot)
8978 
        else:
8979 
          iprot.skip(ftype)
8980 
      else:
8981 
        iprot.skip(ftype)
8982 
      iprot.readFieldEnd()
8983 
    iprot.readStructEnd()
8984 
 
8985 
  def write(self, oprot):
8986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8988 
      return
3064 chandransh 8989 
    oprot.writeStructBegin('addJacketNumber_result')
3431 rajveer 8990 
    if self.success is not None:
3064 chandransh 8991 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8992 
      oprot.writeBool(self.success)
8993 
      oprot.writeFieldEnd()
3431 rajveer 8994 
    if self.ex is not None:
1246 chandransh 8995 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8996 
      self.ex.write(oprot)
8997 
      oprot.writeFieldEnd()
8998 
    oprot.writeFieldStop()
8999 
    oprot.writeStructEnd()
9000 
 
3431 rajveer 9001 
  def validate(self):
9002 
    return
9003 
 
9004 
 
1246 chandransh 9005 
  def __repr__(self):
9006 
    L = ['%s=%r' % (key, value)
9007 
      for key, value in self.__dict__.iteritems()]
9008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9009 
 
9010 
  def __eq__(self, other):
9011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9012 
 
9013 
  def __ne__(self, other):
9014 
    return not (self == other)
9015 
 
3064 chandransh 9016 
class markOrdersAsManifested_args:
1408 ankur.sing 9017 
  """
9018 
  Attributes:
3064 chandransh 9019 
   - warehouseId
1408 ankur.sing 9020 
   - providerId
3064 chandransh 9021 
   - cod
1408 ankur.sing 9022 
  """
9023 
 
9024 
  thrift_spec = (
9025 
    None, # 0
3064 chandransh 9026 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9027 
    (2, TType.I64, 'providerId', None, None, ), # 2
9028 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 9029 
  )
9030 
 
3064 chandransh 9031 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9032 
    self.warehouseId = warehouseId
1408 ankur.sing 9033 
    self.providerId = providerId
3064 chandransh 9034 
    self.cod = cod
1408 ankur.sing 9035 
 
9036 
  def read(self, iprot):
9037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9039 
      return
9040 
    iprot.readStructBegin()
9041 
    while True:
9042 
      (fname, ftype, fid) = iprot.readFieldBegin()
9043 
      if ftype == TType.STOP:
9044 
        break
9045 
      if fid == 1:
9046 
        if ftype == TType.I64:
3064 chandransh 9047 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 9048 
        else:
9049 
          iprot.skip(ftype)
9050 
      elif fid == 2:
9051 
        if ftype == TType.I64:
3064 chandransh 9052 
          self.providerId = iprot.readI64();
1408 ankur.sing 9053 
        else:
9054 
          iprot.skip(ftype)
3064 chandransh 9055 
      elif fid == 3:
9056 
        if ftype == TType.BOOL:
9057 
          self.cod = iprot.readBool();
9058 
        else:
9059 
          iprot.skip(ftype)
1408 ankur.sing 9060 
      else:
9061 
        iprot.skip(ftype)
9062 
      iprot.readFieldEnd()
9063 
    iprot.readStructEnd()
9064 
 
9065 
  def write(self, oprot):
9066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9068 
      return
3064 chandransh 9069 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 9070 
    if self.warehouseId is not None:
3064 chandransh 9071 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9072 
      oprot.writeI64(self.warehouseId)
9073 
      oprot.writeFieldEnd()
3431 rajveer 9074 
    if self.providerId is not None:
3064 chandransh 9075 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9076 
      oprot.writeI64(self.providerId)
9077 
      oprot.writeFieldEnd()
3431 rajveer 9078 
    if self.cod is not None:
3064 chandransh 9079 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9080 
      oprot.writeBool(self.cod)
1408 ankur.sing 9081 
      oprot.writeFieldEnd()
9082 
    oprot.writeFieldStop()
9083 
    oprot.writeStructEnd()
9084 
 
3431 rajveer 9085 
  def validate(self):
9086 
    return
9087 
 
9088 
 
1408 ankur.sing 9089 
  def __repr__(self):
9090 
    L = ['%s=%r' % (key, value)
9091 
      for key, value in self.__dict__.iteritems()]
9092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9093 
 
9094 
  def __eq__(self, other):
9095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9096 
 
9097 
  def __ne__(self, other):
9098 
    return not (self == other)
9099 
 
3064 chandransh 9100 
class markOrdersAsManifested_result:
1408 ankur.sing 9101 
  """
9102 
  Attributes:
9103 
   - success
3064 chandransh 9104 
   - ex
1408 ankur.sing 9105 
  """
9106 
 
9107 
  thrift_spec = (
3064 chandransh 9108 
    (0, TType.BOOL, 'success', None, None, ), # 0
9109 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 9110 
  )
9111 
 
3064 chandransh 9112 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 9113 
    self.success = success
3064 chandransh 9114 
    self.ex = ex
1408 ankur.sing 9115 
 
9116 
  def read(self, iprot):
9117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9119 
      return
9120 
    iprot.readStructBegin()
9121 
    while True:
9122 
      (fname, ftype, fid) = iprot.readFieldBegin()
9123 
      if ftype == TType.STOP:
9124 
        break
9125 
      if fid == 0:
3064 chandransh 9126 
        if ftype == TType.BOOL:
9127 
          self.success = iprot.readBool();
1408 ankur.sing 9128 
        else:
9129 
          iprot.skip(ftype)
3064 chandransh 9130 
      elif fid == 1:
9131 
        if ftype == TType.STRUCT:
9132 
          self.ex = TransactionServiceException()
9133 
          self.ex.read(iprot)
9134 
        else:
9135 
          iprot.skip(ftype)
1408 ankur.sing 9136 
      else:
9137 
        iprot.skip(ftype)
9138 
      iprot.readFieldEnd()
9139 
    iprot.readStructEnd()
9140 
 
9141 
  def write(self, oprot):
9142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9144 
      return
3064 chandransh 9145 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 9146 
    if self.success is not None:
3064 chandransh 9147 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9148 
      oprot.writeBool(self.success)
1408 ankur.sing 9149 
      oprot.writeFieldEnd()
3431 rajveer 9150 
    if self.ex is not None:
3064 chandransh 9151 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9152 
      self.ex.write(oprot)
9153 
      oprot.writeFieldEnd()
1408 ankur.sing 9154 
    oprot.writeFieldStop()
9155 
    oprot.writeStructEnd()
9156 
 
3431 rajveer 9157 
  def validate(self):
9158 
    return
9159 
 
9160 
 
1408 ankur.sing 9161 
  def __repr__(self):
9162 
    L = ['%s=%r' % (key, value)
9163 
      for key, value in self.__dict__.iteritems()]
9164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9165 
 
9166 
  def __eq__(self, other):
9167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9168 
 
9169 
  def __ne__(self, other):
9170 
    return not (self == other)
9171 
 
3064 chandransh 9172 
class markOrdersAsPickedUp_args:
304 ashish 9173 
  """
9174 
  Attributes:
3064 chandransh 9175 
   - providerId
9176 
   - pickupDetails
304 ashish 9177 
  """
94 ashish 9178 
 
304 ashish 9179 
  thrift_spec = (
9180 
    None, # 0
3064 chandransh 9181 
    (1, TType.I64, 'providerId', None, None, ), # 1
9182 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9183 
  )
9184 
 
3064 chandransh 9185 
  def __init__(self, providerId=None, pickupDetails=None,):
9186 
    self.providerId = providerId
9187 
    self.pickupDetails = pickupDetails
304 ashish 9188 
 
9189 
  def read(self, iprot):
9190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9192 
      return
9193 
    iprot.readStructBegin()
9194 
    while True:
9195 
      (fname, ftype, fid) = iprot.readFieldBegin()
9196 
      if ftype == TType.STOP:
9197 
        break
9198 
      if fid == 1:
9199 
        if ftype == TType.I64:
3064 chandransh 9200 
          self.providerId = iprot.readI64();
304 ashish 9201 
        else:
9202 
          iprot.skip(ftype)
9203 
      elif fid == 2:
3064 chandransh 9204 
        if ftype == TType.MAP:
9205 
          self.pickupDetails = {}
4133 chandransh 9206 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
9207 
          for _i144 in xrange(_size140):
9208 
            _key145 = iprot.readString();
9209 
            _val146 = iprot.readString();
9210 
            self.pickupDetails[_key145] = _val146
3064 chandransh 9211 
          iprot.readMapEnd()
304 ashish 9212 
        else:
9213 
          iprot.skip(ftype)
9214 
      else:
9215 
        iprot.skip(ftype)
9216 
      iprot.readFieldEnd()
9217 
    iprot.readStructEnd()
9218 
 
9219 
  def write(self, oprot):
9220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9222 
      return
3064 chandransh 9223 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 9224 
    if self.providerId is not None:
3064 chandransh 9225 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9226 
      oprot.writeI64(self.providerId)
304 ashish 9227 
      oprot.writeFieldEnd()
3431 rajveer 9228 
    if self.pickupDetails is not None:
3064 chandransh 9229 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
9230 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 9231 
      for kiter147,viter148 in self.pickupDetails.items():
9232 
        oprot.writeString(kiter147)
9233 
        oprot.writeString(viter148)
3064 chandransh 9234 
      oprot.writeMapEnd()
304 ashish 9235 
      oprot.writeFieldEnd()
9236 
    oprot.writeFieldStop()
9237 
    oprot.writeStructEnd()
9238 
 
3431 rajveer 9239 
  def validate(self):
9240 
    return
9241 
 
9242 
 
304 ashish 9243 
  def __repr__(self):
9244 
    L = ['%s=%r' % (key, value)
9245 
      for key, value in self.__dict__.iteritems()]
9246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9247 
 
9248 
  def __eq__(self, other):
9249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9250 
 
9251 
  def __ne__(self, other):
9252 
    return not (self == other)
9253 
 
3064 chandransh 9254 
class markOrdersAsPickedUp_result:
304 ashish 9255 
  """
9256 
  Attributes:
9257 
   - success
3064 chandransh 9258 
   - ex
304 ashish 9259 
  """
9260 
 
9261 
  thrift_spec = (
3064 chandransh 9262 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9263 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9264 
  )
9265 
 
3064 chandransh 9266 
  def __init__(self, success=None, ex=None,):
304 ashish 9267 
    self.success = success
3064 chandransh 9268 
    self.ex = ex
304 ashish 9269 
 
9270 
  def read(self, iprot):
9271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9273 
      return
9274 
    iprot.readStructBegin()
9275 
    while True:
9276 
      (fname, ftype, fid) = iprot.readFieldBegin()
9277 
      if ftype == TType.STOP:
9278 
        break
9279 
      if fid == 0:
9280 
        if ftype == TType.LIST:
9281 
          self.success = []
4133 chandransh 9282 
          (_etype152, _size149) = iprot.readListBegin()
9283 
          for _i153 in xrange(_size149):
9284 
            _elem154 = Order()
9285 
            _elem154.read(iprot)
9286 
            self.success.append(_elem154)
304 ashish 9287 
          iprot.readListEnd()
9288 
        else:
9289 
          iprot.skip(ftype)
3064 chandransh 9290 
      elif fid == 1:
9291 
        if ftype == TType.STRUCT:
9292 
          self.ex = TransactionServiceException()
9293 
          self.ex.read(iprot)
9294 
        else:
9295 
          iprot.skip(ftype)
304 ashish 9296 
      else:
9297 
        iprot.skip(ftype)
9298 
      iprot.readFieldEnd()
9299 
    iprot.readStructEnd()
9300 
 
9301 
  def write(self, oprot):
9302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9304 
      return
3064 chandransh 9305 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 9306 
    if self.success is not None:
304 ashish 9307 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9308 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9309 
      for iter155 in self.success:
9310 
        iter155.write(oprot)
304 ashish 9311 
      oprot.writeListEnd()
9312 
      oprot.writeFieldEnd()
3431 rajveer 9313 
    if self.ex is not None:
3064 chandransh 9314 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9315 
      self.ex.write(oprot)
9316 
      oprot.writeFieldEnd()
304 ashish 9317 
    oprot.writeFieldStop()
9318 
    oprot.writeStructEnd()
9319 
 
3431 rajveer 9320 
  def validate(self):
9321 
    return
9322 
 
9323 
 
304 ashish 9324 
  def __repr__(self):
9325 
    L = ['%s=%r' % (key, value)
9326 
      for key, value in self.__dict__.iteritems()]
9327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9328 
 
9329 
  def __eq__(self, other):
9330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9331 
 
9332 
  def __ne__(self, other):
9333 
    return not (self == other)
9334 
 
3064 chandransh 9335 
class markOrdersAsDelivered_args:
304 ashish 9336 
  """
9337 
  Attributes:
3064 chandransh 9338 
   - providerId
9339 
   - deliveredOrders
304 ashish 9340 
  """
9341 
 
9342 
  thrift_spec = (
9343 
    None, # 0
3064 chandransh 9344 
    (1, TType.I64, 'providerId', None, None, ), # 1
9345 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9346 
  )
9347 
 
3064 chandransh 9348 
  def __init__(self, providerId=None, deliveredOrders=None,):
9349 
    self.providerId = providerId
9350 
    self.deliveredOrders = deliveredOrders
304 ashish 9351 
 
9352 
  def read(self, iprot):
9353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9355 
      return
9356 
    iprot.readStructBegin()
9357 
    while True:
9358 
      (fname, ftype, fid) = iprot.readFieldBegin()
9359 
      if ftype == TType.STOP:
9360 
        break
9361 
      if fid == 1:
9362 
        if ftype == TType.I64:
3064 chandransh 9363 
          self.providerId = iprot.readI64();
304 ashish 9364 
        else:
9365 
          iprot.skip(ftype)
9366 
      elif fid == 2:
3064 chandransh 9367 
        if ftype == TType.MAP:
9368 
          self.deliveredOrders = {}
4133 chandransh 9369 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9370 
          for _i160 in xrange(_size156):
9371 
            _key161 = iprot.readString();
9372 
            _val162 = iprot.readString();
9373 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 9374 
          iprot.readMapEnd()
304 ashish 9375 
        else:
9376 
          iprot.skip(ftype)
9377 
      else:
9378 
        iprot.skip(ftype)
9379 
      iprot.readFieldEnd()
9380 
    iprot.readStructEnd()
9381 
 
9382 
  def write(self, oprot):
9383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9385 
      return
3064 chandransh 9386 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 9387 
    if self.providerId is not None:
3064 chandransh 9388 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9389 
      oprot.writeI64(self.providerId)
304 ashish 9390 
      oprot.writeFieldEnd()
3431 rajveer 9391 
    if self.deliveredOrders is not None:
3064 chandransh 9392 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
9393 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 9394 
      for kiter163,viter164 in self.deliveredOrders.items():
9395 
        oprot.writeString(kiter163)
9396 
        oprot.writeString(viter164)
3064 chandransh 9397 
      oprot.writeMapEnd()
304 ashish 9398 
      oprot.writeFieldEnd()
9399 
    oprot.writeFieldStop()
9400 
    oprot.writeStructEnd()
9401 
 
3431 rajveer 9402 
  def validate(self):
9403 
    return
9404 
 
9405 
 
304 ashish 9406 
  def __repr__(self):
9407 
    L = ['%s=%r' % (key, value)
9408 
      for key, value in self.__dict__.iteritems()]
9409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9410 
 
9411 
  def __eq__(self, other):
9412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9413 
 
9414 
  def __ne__(self, other):
9415 
    return not (self == other)
9416 
 
3064 chandransh 9417 
class markOrdersAsDelivered_result:
9418 
  """
9419 
  Attributes:
9420 
   - ex
9421 
  """
304 ashish 9422 
 
9423 
  thrift_spec = (
3064 chandransh 9424 
    None, # 0
9425 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9426 
  )
9427 
 
3064 chandransh 9428 
  def __init__(self, ex=None,):
9429 
    self.ex = ex
304 ashish 9430 
 
1596 ankur.sing 9431 
  def read(self, iprot):
9432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9434 
      return
9435 
    iprot.readStructBegin()
9436 
    while True:
9437 
      (fname, ftype, fid) = iprot.readFieldBegin()
9438 
      if ftype == TType.STOP:
9439 
        break
3064 chandransh 9440 
      if fid == 1:
9441 
        if ftype == TType.STRUCT:
9442 
          self.ex = TransactionServiceException()
9443 
          self.ex.read(iprot)
9444 
        else:
9445 
          iprot.skip(ftype)
1596 ankur.sing 9446 
      else:
9447 
        iprot.skip(ftype)
9448 
      iprot.readFieldEnd()
9449 
    iprot.readStructEnd()
9450 
 
9451 
  def write(self, oprot):
9452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9454 
      return
3064 chandransh 9455 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 9456 
    if self.ex is not None:
3064 chandransh 9457 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9458 
      self.ex.write(oprot)
9459 
      oprot.writeFieldEnd()
1596 ankur.sing 9460 
    oprot.writeFieldStop()
9461 
    oprot.writeStructEnd()
9462 
 
3431 rajveer 9463 
  def validate(self):
9464 
    return
9465 
 
9466 
 
1596 ankur.sing 9467 
  def __repr__(self):
9468 
    L = ['%s=%r' % (key, value)
9469 
      for key, value in self.__dict__.iteritems()]
9470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9471 
 
9472 
  def __eq__(self, other):
9473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9474 
 
9475 
  def __ne__(self, other):
9476 
    return not (self == other)
9477 
 
3064 chandransh 9478 
class markOrdersAsFailed_args:
1596 ankur.sing 9479 
  """
9480 
  Attributes:
3064 chandransh 9481 
   - providerId
9482 
   - returnedOrders
1596 ankur.sing 9483 
  """
9484 
 
9485 
  thrift_spec = (
3064 chandransh 9486 
    None, # 0
9487 
    (1, TType.I64, 'providerId', None, None, ), # 1
9488 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 9489 
  )
9490 
 
3064 chandransh 9491 
  def __init__(self, providerId=None, returnedOrders=None,):
9492 
    self.providerId = providerId
9493 
    self.returnedOrders = returnedOrders
1596 ankur.sing 9494 
 
9495 
  def read(self, iprot):
9496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9498 
      return
9499 
    iprot.readStructBegin()
9500 
    while True:
9501 
      (fname, ftype, fid) = iprot.readFieldBegin()
9502 
      if ftype == TType.STOP:
9503 
        break
3064 chandransh 9504 
      if fid == 1:
1596 ankur.sing 9505 
        if ftype == TType.I64:
3064 chandransh 9506 
          self.providerId = iprot.readI64();
1596 ankur.sing 9507 
        else:
9508 
          iprot.skip(ftype)
3064 chandransh 9509 
      elif fid == 2:
9510 
        if ftype == TType.MAP:
9511 
          self.returnedOrders = {}
4133 chandransh 9512 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
9513 
          for _i169 in xrange(_size165):
9514 
            _key170 = iprot.readString();
9515 
            _val171 = iprot.readString();
9516 
            self.returnedOrders[_key170] = _val171
3064 chandransh 9517 
          iprot.readMapEnd()
9518 
        else:
9519 
          iprot.skip(ftype)
1596 ankur.sing 9520 
      else:
9521 
        iprot.skip(ftype)
9522 
      iprot.readFieldEnd()
9523 
    iprot.readStructEnd()
9524 
 
9525 
  def write(self, oprot):
9526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9528 
      return
3064 chandransh 9529 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 9530 
    if self.providerId is not None:
3064 chandransh 9531 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9532 
      oprot.writeI64(self.providerId)
1596 ankur.sing 9533 
      oprot.writeFieldEnd()
3431 rajveer 9534 
    if self.returnedOrders is not None:
3064 chandransh 9535 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
9536 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 9537 
      for kiter172,viter173 in self.returnedOrders.items():
9538 
        oprot.writeString(kiter172)
9539 
        oprot.writeString(viter173)
3064 chandransh 9540 
      oprot.writeMapEnd()
9541 
      oprot.writeFieldEnd()
1596 ankur.sing 9542 
    oprot.writeFieldStop()
9543 
    oprot.writeStructEnd()
9544 
 
3431 rajveer 9545 
  def validate(self):
9546 
    return
9547 
 
9548 
 
1596 ankur.sing 9549 
  def __repr__(self):
9550 
    L = ['%s=%r' % (key, value)
9551 
      for key, value in self.__dict__.iteritems()]
9552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9553 
 
9554 
  def __eq__(self, other):
9555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9556 
 
9557 
  def __ne__(self, other):
9558 
    return not (self == other)
9559 
 
3064 chandransh 9560 
class markOrdersAsFailed_result:
9561 
  """
9562 
  Attributes:
9563 
   - ex
9564 
  """
1596 ankur.sing 9565 
 
1627 ankur.sing 9566 
  thrift_spec = (
3064 chandransh 9567 
    None, # 0
9568 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9569 
  )
9570 
 
3064 chandransh 9571 
  def __init__(self, ex=None,):
9572 
    self.ex = ex
9573 
 
1627 ankur.sing 9574 
  def read(self, iprot):
9575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9577 
      return
9578 
    iprot.readStructBegin()
9579 
    while True:
9580 
      (fname, ftype, fid) = iprot.readFieldBegin()
9581 
      if ftype == TType.STOP:
9582 
        break
3064 chandransh 9583 
      if fid == 1:
9584 
        if ftype == TType.STRUCT:
9585 
          self.ex = TransactionServiceException()
9586 
          self.ex.read(iprot)
9587 
        else:
9588 
          iprot.skip(ftype)
1627 ankur.sing 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
3064 chandransh 9598 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 9599 
    if self.ex is not None:
3064 chandransh 9600 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9601 
      self.ex.write(oprot)
9602 
      oprot.writeFieldEnd()
1627 ankur.sing 9603 
    oprot.writeFieldStop()
9604 
    oprot.writeStructEnd()
9605 
 
3431 rajveer 9606 
  def validate(self):
9607 
    return
9608 
 
9609 
 
1627 ankur.sing 9610 
  def __repr__(self):
9611 
    L = ['%s=%r' % (key, value)
9612 
      for key, value in self.__dict__.iteritems()]
9613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9614 
 
9615 
  def __eq__(self, other):
9616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9617 
 
9618 
  def __ne__(self, other):
9619 
    return not (self == other)
9620 
 
3064 chandransh 9621 
class updateNonDeliveryReason_args:
1627 ankur.sing 9622 
  """
9623 
  Attributes:
3064 chandransh 9624 
   - providerId
9625 
   - undeliveredOrders
1627 ankur.sing 9626 
  """
9627 
 
9628 
  thrift_spec = (
3064 chandransh 9629 
    None, # 0
9630 
    (1, TType.I64, 'providerId', None, None, ), # 1
9631 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 9632 
  )
9633 
 
3064 chandransh 9634 
  def __init__(self, providerId=None, undeliveredOrders=None,):
9635 
    self.providerId = providerId
9636 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 9637 
 
9638 
  def read(self, iprot):
9639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9641 
      return
9642 
    iprot.readStructBegin()
9643 
    while True:
9644 
      (fname, ftype, fid) = iprot.readFieldBegin()
9645 
      if ftype == TType.STOP:
9646 
        break
3064 chandransh 9647 
      if fid == 1:
1627 ankur.sing 9648 
        if ftype == TType.I64:
3064 chandransh 9649 
          self.providerId = iprot.readI64();
1627 ankur.sing 9650 
        else:
9651 
          iprot.skip(ftype)
3064 chandransh 9652 
      elif fid == 2:
9653 
        if ftype == TType.MAP:
9654 
          self.undeliveredOrders = {}
4133 chandransh 9655 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
9656 
          for _i178 in xrange(_size174):
9657 
            _key179 = iprot.readString();
9658 
            _val180 = iprot.readString();
9659 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 9660 
          iprot.readMapEnd()
9661 
        else:
9662 
          iprot.skip(ftype)
1627 ankur.sing 9663 
      else:
9664 
        iprot.skip(ftype)
9665 
      iprot.readFieldEnd()
9666 
    iprot.readStructEnd()
9667 
 
9668 
  def write(self, oprot):
9669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9671 
      return
3064 chandransh 9672 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 9673 
    if self.providerId is not None:
3064 chandransh 9674 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9675 
      oprot.writeI64(self.providerId)
1627 ankur.sing 9676 
      oprot.writeFieldEnd()
3431 rajveer 9677 
    if self.undeliveredOrders is not None:
3064 chandransh 9678 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
9679 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 9680 
      for kiter181,viter182 in self.undeliveredOrders.items():
9681 
        oprot.writeString(kiter181)
9682 
        oprot.writeString(viter182)
3064 chandransh 9683 
      oprot.writeMapEnd()
9684 
      oprot.writeFieldEnd()
1627 ankur.sing 9685 
    oprot.writeFieldStop()
9686 
    oprot.writeStructEnd()
9687 
 
3431 rajveer 9688 
  def validate(self):
9689 
    return
9690 
 
9691 
 
1627 ankur.sing 9692 
  def __repr__(self):
9693 
    L = ['%s=%r' % (key, value)
9694 
      for key, value in self.__dict__.iteritems()]
9695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9696 
 
9697 
  def __eq__(self, other):
9698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9699 
 
9700 
  def __ne__(self, other):
9701 
    return not (self == other)
9702 
 
3064 chandransh 9703 
class updateNonDeliveryReason_result:
1627 ankur.sing 9704 
  """
9705 
  Attributes:
3064 chandransh 9706 
   - ex
1627 ankur.sing 9707 
  """
9708 
 
9709 
  thrift_spec = (
3064 chandransh 9710 
    None, # 0
9711 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9712 
  )
9713 
 
3064 chandransh 9714 
  def __init__(self, ex=None,):
9715 
    self.ex = ex
1627 ankur.sing 9716 
 
9717 
  def read(self, iprot):
9718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9720 
      return
9721 
    iprot.readStructBegin()
9722 
    while True:
9723 
      (fname, ftype, fid) = iprot.readFieldBegin()
9724 
      if ftype == TType.STOP:
9725 
        break
3064 chandransh 9726 
      if fid == 1:
9727 
        if ftype == TType.STRUCT:
9728 
          self.ex = TransactionServiceException()
9729 
          self.ex.read(iprot)
1627 ankur.sing 9730 
        else:
9731 
          iprot.skip(ftype)
9732 
      else:
9733 
        iprot.skip(ftype)
9734 
      iprot.readFieldEnd()
9735 
    iprot.readStructEnd()
9736 
 
9737 
  def write(self, oprot):
9738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9740 
      return
3064 chandransh 9741 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 9742 
    if self.ex is not None:
3064 chandransh 9743 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9744 
      self.ex.write(oprot)
1627 ankur.sing 9745 
      oprot.writeFieldEnd()
9746 
    oprot.writeFieldStop()
9747 
    oprot.writeStructEnd()
9748 
 
3431 rajveer 9749 
  def validate(self):
9750 
    return
9751 
 
9752 
 
1627 ankur.sing 9753 
  def __repr__(self):
9754 
    L = ['%s=%r' % (key, value)
9755 
      for key, value in self.__dict__.iteritems()]
9756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9757 
 
9758 
  def __eq__(self, other):
9759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9760 
 
9761 
  def __ne__(self, other):
9762 
    return not (self == other)
9763 
 
3064 chandransh 9764 
class getUndeliveredOrders_args:
1886 ankur.sing 9765 
  """
9766 
  Attributes:
3064 chandransh 9767 
   - providerId
9768 
   - warehouseId
1886 ankur.sing 9769 
  """
1627 ankur.sing 9770 
 
1886 ankur.sing 9771 
  thrift_spec = (
9772 
    None, # 0
3064 chandransh 9773 
    (1, TType.I64, 'providerId', None, None, ), # 1
9774 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 9775 
  )
9776 
 
3064 chandransh 9777 
  def __init__(self, providerId=None, warehouseId=None,):
9778 
    self.providerId = providerId
9779 
    self.warehouseId = warehouseId
1886 ankur.sing 9780 
 
9781 
  def read(self, iprot):
9782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9784 
      return
9785 
    iprot.readStructBegin()
9786 
    while True:
9787 
      (fname, ftype, fid) = iprot.readFieldBegin()
9788 
      if ftype == TType.STOP:
9789 
        break
9790 
      if fid == 1:
9791 
        if ftype == TType.I64:
3064 chandransh 9792 
          self.providerId = iprot.readI64();
1886 ankur.sing 9793 
        else:
9794 
          iprot.skip(ftype)
3064 chandransh 9795 
      elif fid == 2:
9796 
        if ftype == TType.I64:
9797 
          self.warehouseId = iprot.readI64();
9798 
        else:
9799 
          iprot.skip(ftype)
1886 ankur.sing 9800 
      else:
9801 
        iprot.skip(ftype)
9802 
      iprot.readFieldEnd()
9803 
    iprot.readStructEnd()
9804 
 
9805 
  def write(self, oprot):
9806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9808 
      return
3064 chandransh 9809 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 9810 
    if self.providerId is not None:
3064 chandransh 9811 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9812 
      oprot.writeI64(self.providerId)
1886 ankur.sing 9813 
      oprot.writeFieldEnd()
3431 rajveer 9814 
    if self.warehouseId is not None:
3064 chandransh 9815 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9816 
      oprot.writeI64(self.warehouseId)
9817 
      oprot.writeFieldEnd()
1886 ankur.sing 9818 
    oprot.writeFieldStop()
9819 
    oprot.writeStructEnd()
9820 
 
3431 rajveer 9821 
  def validate(self):
9822 
    return
9823 
 
9824 
 
1886 ankur.sing 9825 
  def __repr__(self):
9826 
    L = ['%s=%r' % (key, value)
9827 
      for key, value in self.__dict__.iteritems()]
9828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9829 
 
9830 
  def __eq__(self, other):
9831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9832 
 
9833 
  def __ne__(self, other):
9834 
    return not (self == other)
9835 
 
3064 chandransh 9836 
class getUndeliveredOrders_result:
1886 ankur.sing 9837 
  """
9838 
  Attributes:
9839 
   - success
9840 
  """
9841 
 
9842 
  thrift_spec = (
9843 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9844 
  )
9845 
 
9846 
  def __init__(self, success=None,):
9847 
    self.success = success
9848 
 
9849 
  def read(self, iprot):
9850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9852 
      return
9853 
    iprot.readStructBegin()
9854 
    while True:
9855 
      (fname, ftype, fid) = iprot.readFieldBegin()
9856 
      if ftype == TType.STOP:
9857 
        break
9858 
      if fid == 0:
9859 
        if ftype == TType.LIST:
9860 
          self.success = []
4133 chandransh 9861 
          (_etype186, _size183) = iprot.readListBegin()
9862 
          for _i187 in xrange(_size183):
9863 
            _elem188 = Order()
9864 
            _elem188.read(iprot)
9865 
            self.success.append(_elem188)
1886 ankur.sing 9866 
          iprot.readListEnd()
9867 
        else:
9868 
          iprot.skip(ftype)
9869 
      else:
9870 
        iprot.skip(ftype)
9871 
      iprot.readFieldEnd()
9872 
    iprot.readStructEnd()
9873 
 
9874 
  def write(self, oprot):
9875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9877 
      return
3064 chandransh 9878 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 9879 
    if self.success is not None:
1886 ankur.sing 9880 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9881 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9882 
      for iter189 in self.success:
9883 
        iter189.write(oprot)
1886 ankur.sing 9884 
      oprot.writeListEnd()
9885 
      oprot.writeFieldEnd()
9886 
    oprot.writeFieldStop()
9887 
    oprot.writeStructEnd()
9888 
 
3431 rajveer 9889 
  def validate(self):
9890 
    return
9891 
 
9892 
 
1886 ankur.sing 9893 
  def __repr__(self):
9894 
    L = ['%s=%r' % (key, value)
9895 
      for key, value in self.__dict__.iteritems()]
9896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9897 
 
9898 
  def __eq__(self, other):
9899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9900 
 
9901 
  def __ne__(self, other):
9902 
    return not (self == other)
9903 
 
2536 chandransh 9904 
class toggleDOAFlag_args:
9905 
  """
9906 
  Attributes:
9907 
   - orderId
9908 
  """
1886 ankur.sing 9909 
 
2536 chandransh 9910 
  thrift_spec = (
9911 
    None, # 0
9912 
    (1, TType.I64, 'orderId', None, None, ), # 1
9913 
  )
9914 
 
9915 
  def __init__(self, orderId=None,):
9916 
    self.orderId = orderId
9917 
 
9918 
  def read(self, iprot):
9919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9921 
      return
9922 
    iprot.readStructBegin()
9923 
    while True:
9924 
      (fname, ftype, fid) = iprot.readFieldBegin()
9925 
      if ftype == TType.STOP:
9926 
        break
9927 
      if fid == 1:
9928 
        if ftype == TType.I64:
9929 
          self.orderId = iprot.readI64();
9930 
        else:
9931 
          iprot.skip(ftype)
9932 
      else:
9933 
        iprot.skip(ftype)
9934 
      iprot.readFieldEnd()
9935 
    iprot.readStructEnd()
9936 
 
9937 
  def write(self, oprot):
9938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9940 
      return
9941 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 9942 
    if self.orderId is not None:
2536 chandransh 9943 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9944 
      oprot.writeI64(self.orderId)
9945 
      oprot.writeFieldEnd()
9946 
    oprot.writeFieldStop()
9947 
    oprot.writeStructEnd()
9948 
 
3431 rajveer 9949 
  def validate(self):
9950 
    return
9951 
 
9952 
 
2536 chandransh 9953 
  def __repr__(self):
9954 
    L = ['%s=%r' % (key, value)
9955 
      for key, value in self.__dict__.iteritems()]
9956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9957 
 
9958 
  def __eq__(self, other):
9959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9960 
 
9961 
  def __ne__(self, other):
9962 
    return not (self == other)
9963 
 
9964 
class toggleDOAFlag_result:
9965 
  """
9966 
  Attributes:
9967 
   - success
9968 
   - ex
9969 
  """
9970 
 
9971 
  thrift_spec = (
9972 
    (0, TType.BOOL, 'success', None, None, ), # 0
9973 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9974 
  )
9975 
 
9976 
  def __init__(self, success=None, ex=None,):
9977 
    self.success = success
9978 
    self.ex = ex
9979 
 
9980 
  def read(self, iprot):
9981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9983 
      return
9984 
    iprot.readStructBegin()
9985 
    while True:
9986 
      (fname, ftype, fid) = iprot.readFieldBegin()
9987 
      if ftype == TType.STOP:
9988 
        break
9989 
      if fid == 0:
9990 
        if ftype == TType.BOOL:
9991 
          self.success = iprot.readBool();
9992 
        else:
9993 
          iprot.skip(ftype)
9994 
      elif fid == 1:
9995 
        if ftype == TType.STRUCT:
9996 
          self.ex = TransactionServiceException()
9997 
          self.ex.read(iprot)
9998 
        else:
9999 
          iprot.skip(ftype)
10000 
      else:
10001 
        iprot.skip(ftype)
10002 
      iprot.readFieldEnd()
10003 
    iprot.readStructEnd()
10004 
 
10005 
  def write(self, oprot):
10006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10008 
      return
10009 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 10010 
    if self.success is not None:
2536 chandransh 10011 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10012 
      oprot.writeBool(self.success)
10013 
      oprot.writeFieldEnd()
3431 rajveer 10014 
    if self.ex is not None:
2536 chandransh 10015 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10016 
      self.ex.write(oprot)
10017 
      oprot.writeFieldEnd()
10018 
    oprot.writeFieldStop()
10019 
    oprot.writeStructEnd()
10020 
 
3431 rajveer 10021 
  def validate(self):
10022 
    return
10023 
 
10024 
 
2536 chandransh 10025 
  def __repr__(self):
10026 
    L = ['%s=%r' % (key, value)
10027 
      for key, value in self.__dict__.iteritems()]
10028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10029 
 
10030 
  def __eq__(self, other):
10031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10032 
 
10033 
  def __ne__(self, other):
10034 
    return not (self == other)
10035 
 
10036 
class requestPickupNumber_args:
10037 
  """
10038 
  Attributes:
10039 
   - orderId
10040 
  """
10041 
 
10042 
  thrift_spec = (
10043 
    None, # 0
10044 
    (1, TType.I64, 'orderId', None, None, ), # 1
10045 
  )
10046 
 
10047 
  def __init__(self, orderId=None,):
10048 
    self.orderId = orderId
10049 
 
10050 
  def read(self, iprot):
10051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10053 
      return
10054 
    iprot.readStructBegin()
10055 
    while True:
10056 
      (fname, ftype, fid) = iprot.readFieldBegin()
10057 
      if ftype == TType.STOP:
10058 
        break
10059 
      if fid == 1:
10060 
        if ftype == TType.I64:
10061 
          self.orderId = iprot.readI64();
10062 
        else:
10063 
          iprot.skip(ftype)
10064 
      else:
10065 
        iprot.skip(ftype)
10066 
      iprot.readFieldEnd()
10067 
    iprot.readStructEnd()
10068 
 
10069 
  def write(self, oprot):
10070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10072 
      return
10073 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 10074 
    if self.orderId is not None:
2536 chandransh 10075 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10076 
      oprot.writeI64(self.orderId)
10077 
      oprot.writeFieldEnd()
10078 
    oprot.writeFieldStop()
10079 
    oprot.writeStructEnd()
10080 
 
3431 rajveer 10081 
  def validate(self):
10082 
    return
10083 
 
10084 
 
2536 chandransh 10085 
  def __repr__(self):
10086 
    L = ['%s=%r' % (key, value)
10087 
      for key, value in self.__dict__.iteritems()]
10088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10089 
 
10090 
  def __eq__(self, other):
10091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10092 
 
10093 
  def __ne__(self, other):
10094 
    return not (self == other)
10095 
 
10096 
class requestPickupNumber_result:
10097 
  """
10098 
  Attributes:
10099 
   - success
10100 
   - ex
10101 
  """
10102 
 
10103 
  thrift_spec = (
10104 
    (0, TType.BOOL, 'success', None, None, ), # 0
10105 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10106 
  )
10107 
 
10108 
  def __init__(self, success=None, ex=None,):
10109 
    self.success = success
10110 
    self.ex = ex
10111 
 
10112 
  def read(self, iprot):
10113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10115 
      return
10116 
    iprot.readStructBegin()
10117 
    while True:
10118 
      (fname, ftype, fid) = iprot.readFieldBegin()
10119 
      if ftype == TType.STOP:
10120 
        break
10121 
      if fid == 0:
10122 
        if ftype == TType.BOOL:
10123 
          self.success = iprot.readBool();
10124 
        else:
10125 
          iprot.skip(ftype)
10126 
      elif fid == 1:
10127 
        if ftype == TType.STRUCT:
10128 
          self.ex = TransactionServiceException()
10129 
          self.ex.read(iprot)
10130 
        else:
10131 
          iprot.skip(ftype)
10132 
      else:
10133 
        iprot.skip(ftype)
10134 
      iprot.readFieldEnd()
10135 
    iprot.readStructEnd()
10136 
 
10137 
  def write(self, oprot):
10138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10140 
      return
10141 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 10142 
    if self.success is not None:
2536 chandransh 10143 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10144 
      oprot.writeBool(self.success)
10145 
      oprot.writeFieldEnd()
3431 rajveer 10146 
    if self.ex is not None:
2536 chandransh 10147 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10148 
      self.ex.write(oprot)
10149 
      oprot.writeFieldEnd()
10150 
    oprot.writeFieldStop()
10151 
    oprot.writeStructEnd()
10152 
 
3431 rajveer 10153 
  def validate(self):
10154 
    return
10155 
 
10156 
 
2536 chandransh 10157 
  def __repr__(self):
10158 
    L = ['%s=%r' % (key, value)
10159 
      for key, value in self.__dict__.iteritems()]
10160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10161 
 
10162 
  def __eq__(self, other):
10163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10164 
 
10165 
  def __ne__(self, other):
10166 
    return not (self == other)
10167 
 
10168 
class authorizePickup_args:
10169 
  """
10170 
  Attributes:
10171 
   - orderId
10172 
   - pickupNumber
10173 
  """
10174 
 
10175 
  thrift_spec = (
10176 
    None, # 0
10177 
    (1, TType.I64, 'orderId', None, None, ), # 1
10178 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
10179 
  )
10180 
 
10181 
  def __init__(self, orderId=None, pickupNumber=None,):
10182 
    self.orderId = orderId
10183 
    self.pickupNumber = pickupNumber
10184 
 
10185 
  def read(self, iprot):
10186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10188 
      return
10189 
    iprot.readStructBegin()
10190 
    while True:
10191 
      (fname, ftype, fid) = iprot.readFieldBegin()
10192 
      if ftype == TType.STOP:
10193 
        break
10194 
      if fid == 1:
10195 
        if ftype == TType.I64:
10196 
          self.orderId = iprot.readI64();
10197 
        else:
10198 
          iprot.skip(ftype)
10199 
      elif fid == 2:
10200 
        if ftype == TType.STRING:
10201 
          self.pickupNumber = iprot.readString();
10202 
        else:
10203 
          iprot.skip(ftype)
10204 
      else:
10205 
        iprot.skip(ftype)
10206 
      iprot.readFieldEnd()
10207 
    iprot.readStructEnd()
10208 
 
10209 
  def write(self, oprot):
10210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10212 
      return
10213 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 10214 
    if self.orderId is not None:
2536 chandransh 10215 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10216 
      oprot.writeI64(self.orderId)
10217 
      oprot.writeFieldEnd()
3431 rajveer 10218 
    if self.pickupNumber is not None:
2536 chandransh 10219 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
10220 
      oprot.writeString(self.pickupNumber)
10221 
      oprot.writeFieldEnd()
10222 
    oprot.writeFieldStop()
10223 
    oprot.writeStructEnd()
10224 
 
3431 rajveer 10225 
  def validate(self):
10226 
    return
10227 
 
10228 
 
2536 chandransh 10229 
  def __repr__(self):
10230 
    L = ['%s=%r' % (key, value)
10231 
      for key, value in self.__dict__.iteritems()]
10232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10233 
 
10234 
  def __eq__(self, other):
10235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10236 
 
10237 
  def __ne__(self, other):
10238 
    return not (self == other)
10239 
 
10240 
class authorizePickup_result:
10241 
  """
10242 
  Attributes:
10243 
   - success
10244 
   - ex
10245 
  """
10246 
 
10247 
  thrift_spec = (
10248 
    (0, TType.BOOL, 'success', None, None, ), # 0
10249 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10250 
  )
10251 
 
10252 
  def __init__(self, success=None, ex=None,):
10253 
    self.success = success
10254 
    self.ex = ex
10255 
 
10256 
  def read(self, iprot):
10257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10259 
      return
10260 
    iprot.readStructBegin()
10261 
    while True:
10262 
      (fname, ftype, fid) = iprot.readFieldBegin()
10263 
      if ftype == TType.STOP:
10264 
        break
10265 
      if fid == 0:
10266 
        if ftype == TType.BOOL:
10267 
          self.success = iprot.readBool();
10268 
        else:
10269 
          iprot.skip(ftype)
10270 
      elif fid == 1:
10271 
        if ftype == TType.STRUCT:
10272 
          self.ex = TransactionServiceException()
10273 
          self.ex.read(iprot)
10274 
        else:
10275 
          iprot.skip(ftype)
10276 
      else:
10277 
        iprot.skip(ftype)
10278 
      iprot.readFieldEnd()
10279 
    iprot.readStructEnd()
10280 
 
10281 
  def write(self, oprot):
10282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10284 
      return
10285 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 10286 
    if self.success is not None:
2536 chandransh 10287 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10288 
      oprot.writeBool(self.success)
10289 
      oprot.writeFieldEnd()
3431 rajveer 10290 
    if self.ex is not None:
2536 chandransh 10291 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10292 
      self.ex.write(oprot)
10293 
      oprot.writeFieldEnd()
10294 
    oprot.writeFieldStop()
10295 
    oprot.writeStructEnd()
10296 
 
3431 rajveer 10297 
  def validate(self):
10298 
    return
10299 
 
10300 
 
2536 chandransh 10301 
  def __repr__(self):
10302 
    L = ['%s=%r' % (key, value)
10303 
      for key, value in self.__dict__.iteritems()]
10304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10305 
 
10306 
  def __eq__(self, other):
10307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10308 
 
10309 
  def __ne__(self, other):
10310 
    return not (self == other)
10311 
 
2764 chandransh 10312 
class markDoasAsPickedUp_args:
10313 
  """
10314 
  Attributes:
10315 
   - providerId
10316 
   - pickupDetails
10317 
  """
10318 
 
10319 
  thrift_spec = (
10320 
    None, # 0
10321 
    (1, TType.I64, 'providerId', None, None, ), # 1
10322 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
10323 
  )
10324 
 
10325 
  def __init__(self, providerId=None, pickupDetails=None,):
10326 
    self.providerId = providerId
10327 
    self.pickupDetails = pickupDetails
10328 
 
10329 
  def read(self, iprot):
10330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10332 
      return
10333 
    iprot.readStructBegin()
10334 
    while True:
10335 
      (fname, ftype, fid) = iprot.readFieldBegin()
10336 
      if ftype == TType.STOP:
10337 
        break
10338 
      if fid == 1:
10339 
        if ftype == TType.I64:
10340 
          self.providerId = iprot.readI64();
10341 
        else:
10342 
          iprot.skip(ftype)
10343 
      elif fid == 2:
10344 
        if ftype == TType.MAP:
10345 
          self.pickupDetails = {}
4133 chandransh 10346 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
10347 
          for _i194 in xrange(_size190):
10348 
            _key195 = iprot.readString();
10349 
            _val196 = iprot.readString();
10350 
            self.pickupDetails[_key195] = _val196
2764 chandransh 10351 
          iprot.readMapEnd()
10352 
        else:
10353 
          iprot.skip(ftype)
10354 
      else:
10355 
        iprot.skip(ftype)
10356 
      iprot.readFieldEnd()
10357 
    iprot.readStructEnd()
10358 
 
10359 
  def write(self, oprot):
10360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10362 
      return
10363 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 10364 
    if self.providerId is not None:
2764 chandransh 10365 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10366 
      oprot.writeI64(self.providerId)
10367 
      oprot.writeFieldEnd()
3431 rajveer 10368 
    if self.pickupDetails is not None:
2764 chandransh 10369 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10370 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10371 
      for kiter197,viter198 in self.pickupDetails.items():
10372 
        oprot.writeString(kiter197)
10373 
        oprot.writeString(viter198)
2764 chandransh 10374 
      oprot.writeMapEnd()
10375 
      oprot.writeFieldEnd()
10376 
    oprot.writeFieldStop()
10377 
    oprot.writeStructEnd()
10378 
 
3431 rajveer 10379 
  def validate(self):
10380 
    return
10381 
 
10382 
 
2764 chandransh 10383 
  def __repr__(self):
10384 
    L = ['%s=%r' % (key, value)
10385 
      for key, value in self.__dict__.iteritems()]
10386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10387 
 
10388 
  def __eq__(self, other):
10389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10390 
 
10391 
  def __ne__(self, other):
10392 
    return not (self == other)
10393 
 
10394 
class markDoasAsPickedUp_result:
10395 
  """
10396 
  Attributes:
10397 
   - success
10398 
  """
10399 
 
10400 
  thrift_spec = (
10401 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10402 
  )
10403 
 
10404 
  def __init__(self, success=None,):
10405 
    self.success = success
10406 
 
10407 
  def read(self, iprot):
10408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10410 
      return
10411 
    iprot.readStructBegin()
10412 
    while True:
10413 
      (fname, ftype, fid) = iprot.readFieldBegin()
10414 
      if ftype == TType.STOP:
10415 
        break
10416 
      if fid == 0:
10417 
        if ftype == TType.LIST:
10418 
          self.success = []
4133 chandransh 10419 
          (_etype202, _size199) = iprot.readListBegin()
10420 
          for _i203 in xrange(_size199):
10421 
            _elem204 = Order()
10422 
            _elem204.read(iprot)
10423 
            self.success.append(_elem204)
2764 chandransh 10424 
          iprot.readListEnd()
10425 
        else:
10426 
          iprot.skip(ftype)
10427 
      else:
10428 
        iprot.skip(ftype)
10429 
      iprot.readFieldEnd()
10430 
    iprot.readStructEnd()
10431 
 
10432 
  def write(self, oprot):
10433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10435 
      return
10436 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 10437 
    if self.success is not None:
2764 chandransh 10438 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10439 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10440 
      for iter205 in self.success:
10441 
        iter205.write(oprot)
2764 chandransh 10442 
      oprot.writeListEnd()
10443 
      oprot.writeFieldEnd()
10444 
    oprot.writeFieldStop()
10445 
    oprot.writeStructEnd()
10446 
 
3431 rajveer 10447 
  def validate(self):
10448 
    return
10449 
 
10450 
 
2764 chandransh 10451 
  def __repr__(self):
10452 
    L = ['%s=%r' % (key, value)
10453 
      for key, value in self.__dict__.iteritems()]
10454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10455 
 
10456 
  def __eq__(self, other):
10457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10458 
 
10459 
  def __ne__(self, other):
10460 
    return not (self == other)
10461 
 
2616 chandransh 10462 
class receiveReturn_args:
2591 chandransh 10463 
  """
10464 
  Attributes:
10465 
   - orderId
10466 
  """
2536 chandransh 10467 
 
2591 chandransh 10468 
  thrift_spec = (
10469 
    None, # 0
10470 
    (1, TType.I64, 'orderId', None, None, ), # 1
10471 
  )
10472 
 
10473 
  def __init__(self, orderId=None,):
10474 
    self.orderId = orderId
10475 
 
10476 
  def read(self, iprot):
10477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10479 
      return
10480 
    iprot.readStructBegin()
10481 
    while True:
10482 
      (fname, ftype, fid) = iprot.readFieldBegin()
10483 
      if ftype == TType.STOP:
10484 
        break
10485 
      if fid == 1:
10486 
        if ftype == TType.I64:
10487 
          self.orderId = iprot.readI64();
10488 
        else:
10489 
          iprot.skip(ftype)
10490 
      else:
10491 
        iprot.skip(ftype)
10492 
      iprot.readFieldEnd()
10493 
    iprot.readStructEnd()
10494 
 
10495 
  def write(self, oprot):
10496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10498 
      return
2616 chandransh 10499 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 10500 
    if self.orderId is not None:
2591 chandransh 10501 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10502 
      oprot.writeI64(self.orderId)
10503 
      oprot.writeFieldEnd()
10504 
    oprot.writeFieldStop()
10505 
    oprot.writeStructEnd()
10506 
 
3431 rajveer 10507 
  def validate(self):
10508 
    return
10509 
 
10510 
 
2591 chandransh 10511 
  def __repr__(self):
10512 
    L = ['%s=%r' % (key, value)
10513 
      for key, value in self.__dict__.iteritems()]
10514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10515 
 
10516 
  def __eq__(self, other):
10517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10518 
 
10519 
  def __ne__(self, other):
10520 
    return not (self == other)
10521 
 
2616 chandransh 10522 
class receiveReturn_result:
2591 chandransh 10523 
  """
10524 
  Attributes:
10525 
   - success
10526 
   - ex
10527 
  """
10528 
 
10529 
  thrift_spec = (
10530 
    (0, TType.BOOL, 'success', None, None, ), # 0
10531 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10532 
  )
10533 
 
10534 
  def __init__(self, success=None, ex=None,):
10535 
    self.success = success
10536 
    self.ex = ex
10537 
 
10538 
  def read(self, iprot):
10539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10541 
      return
10542 
    iprot.readStructBegin()
10543 
    while True:
10544 
      (fname, ftype, fid) = iprot.readFieldBegin()
10545 
      if ftype == TType.STOP:
10546 
        break
10547 
      if fid == 0:
10548 
        if ftype == TType.BOOL:
10549 
          self.success = iprot.readBool();
10550 
        else:
10551 
          iprot.skip(ftype)
10552 
      elif fid == 1:
10553 
        if ftype == TType.STRUCT:
10554 
          self.ex = TransactionServiceException()
10555 
          self.ex.read(iprot)
10556 
        else:
10557 
          iprot.skip(ftype)
10558 
      else:
10559 
        iprot.skip(ftype)
10560 
      iprot.readFieldEnd()
10561 
    iprot.readStructEnd()
10562 
 
10563 
  def write(self, oprot):
10564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10566 
      return
2616 chandransh 10567 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 10568 
    if self.success is not None:
2591 chandransh 10569 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10570 
      oprot.writeBool(self.success)
10571 
      oprot.writeFieldEnd()
3431 rajveer 10572 
    if self.ex is not None:
2591 chandransh 10573 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10574 
      self.ex.write(oprot)
10575 
      oprot.writeFieldEnd()
10576 
    oprot.writeFieldStop()
10577 
    oprot.writeStructEnd()
10578 
 
3431 rajveer 10579 
  def validate(self):
10580 
    return
10581 
 
10582 
 
2591 chandransh 10583 
  def __repr__(self):
10584 
    L = ['%s=%r' % (key, value)
10585 
      for key, value in self.__dict__.iteritems()]
10586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10587 
 
10588 
  def __eq__(self, other):
10589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10590 
 
10591 
  def __ne__(self, other):
10592 
    return not (self == other)
10593 
 
10594 
class validateDoa_args:
10595 
  """
10596 
  Attributes:
10597 
   - orderId
10598 
   - isValid
10599 
  """
10600 
 
10601 
  thrift_spec = (
10602 
    None, # 0
10603 
    (1, TType.I64, 'orderId', None, None, ), # 1
10604 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
10605 
  )
10606 
 
10607 
  def __init__(self, orderId=None, isValid=None,):
10608 
    self.orderId = orderId
10609 
    self.isValid = isValid
10610 
 
10611 
  def read(self, iprot):
10612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10614 
      return
10615 
    iprot.readStructBegin()
10616 
    while True:
10617 
      (fname, ftype, fid) = iprot.readFieldBegin()
10618 
      if ftype == TType.STOP:
10619 
        break
10620 
      if fid == 1:
10621 
        if ftype == TType.I64:
10622 
          self.orderId = iprot.readI64();
10623 
        else:
10624 
          iprot.skip(ftype)
10625 
      elif fid == 2:
10626 
        if ftype == TType.BOOL:
10627 
          self.isValid = iprot.readBool();
10628 
        else:
10629 
          iprot.skip(ftype)
10630 
      else:
10631 
        iprot.skip(ftype)
10632 
      iprot.readFieldEnd()
10633 
    iprot.readStructEnd()
10634 
 
10635 
  def write(self, oprot):
10636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10638 
      return
10639 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 10640 
    if self.orderId is not None:
2591 chandransh 10641 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10642 
      oprot.writeI64(self.orderId)
10643 
      oprot.writeFieldEnd()
3431 rajveer 10644 
    if self.isValid is not None:
2591 chandransh 10645 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
10646 
      oprot.writeBool(self.isValid)
10647 
      oprot.writeFieldEnd()
10648 
    oprot.writeFieldStop()
10649 
    oprot.writeStructEnd()
10650 
 
3431 rajveer 10651 
  def validate(self):
10652 
    return
10653 
 
10654 
 
2591 chandransh 10655 
  def __repr__(self):
10656 
    L = ['%s=%r' % (key, value)
10657 
      for key, value in self.__dict__.iteritems()]
10658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10659 
 
10660 
  def __eq__(self, other):
10661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10662 
 
10663 
  def __ne__(self, other):
10664 
    return not (self == other)
10665 
 
10666 
class validateDoa_result:
10667 
  """
10668 
  Attributes:
10669 
   - success
10670 
   - ex
10671 
  """
10672 
 
10673 
  thrift_spec = (
10674 
    (0, TType.BOOL, 'success', None, None, ), # 0
10675 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10676 
  )
10677 
 
10678 
  def __init__(self, success=None, ex=None,):
10679 
    self.success = success
10680 
    self.ex = ex
10681 
 
10682 
  def read(self, iprot):
10683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10685 
      return
10686 
    iprot.readStructBegin()
10687 
    while True:
10688 
      (fname, ftype, fid) = iprot.readFieldBegin()
10689 
      if ftype == TType.STOP:
10690 
        break
10691 
      if fid == 0:
10692 
        if ftype == TType.BOOL:
10693 
          self.success = iprot.readBool();
10694 
        else:
10695 
          iprot.skip(ftype)
10696 
      elif fid == 1:
10697 
        if ftype == TType.STRUCT:
10698 
          self.ex = TransactionServiceException()
10699 
          self.ex.read(iprot)
10700 
        else:
10701 
          iprot.skip(ftype)
10702 
      else:
10703 
        iprot.skip(ftype)
10704 
      iprot.readFieldEnd()
10705 
    iprot.readStructEnd()
10706 
 
10707 
  def write(self, oprot):
10708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10710 
      return
10711 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 10712 
    if self.success is not None:
2591 chandransh 10713 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10714 
      oprot.writeBool(self.success)
10715 
      oprot.writeFieldEnd()
3431 rajveer 10716 
    if self.ex is not None:
2591 chandransh 10717 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10718 
      self.ex.write(oprot)
10719 
      oprot.writeFieldEnd()
10720 
    oprot.writeFieldStop()
10721 
    oprot.writeStructEnd()
10722 
 
3431 rajveer 10723 
  def validate(self):
10724 
    return
10725 
 
10726 
 
2591 chandransh 10727 
  def __repr__(self):
10728 
    L = ['%s=%r' % (key, value)
10729 
      for key, value in self.__dict__.iteritems()]
10730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10731 
 
10732 
  def __eq__(self, other):
10733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10734 
 
10735 
  def __ne__(self, other):
10736 
    return not (self == other)
10737 
 
2616 chandransh 10738 
class reshipOrder_args:
10739 
  """
10740 
  Attributes:
10741 
   - orderId
10742 
  """
2591 chandransh 10743 
 
2616 chandransh 10744 
  thrift_spec = (
10745 
    None, # 0
10746 
    (1, TType.I64, 'orderId', None, None, ), # 1
10747 
  )
10748 
 
10749 
  def __init__(self, orderId=None,):
10750 
    self.orderId = orderId
10751 
 
10752 
  def read(self, iprot):
10753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10755 
      return
10756 
    iprot.readStructBegin()
10757 
    while True:
10758 
      (fname, ftype, fid) = iprot.readFieldBegin()
10759 
      if ftype == TType.STOP:
10760 
        break
10761 
      if fid == 1:
10762 
        if ftype == TType.I64:
10763 
          self.orderId = iprot.readI64();
10764 
        else:
10765 
          iprot.skip(ftype)
10766 
      else:
10767 
        iprot.skip(ftype)
10768 
      iprot.readFieldEnd()
10769 
    iprot.readStructEnd()
10770 
 
10771 
  def write(self, oprot):
10772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10774 
      return
10775 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 10776 
    if self.orderId is not None:
2616 chandransh 10777 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10778 
      oprot.writeI64(self.orderId)
10779 
      oprot.writeFieldEnd()
10780 
    oprot.writeFieldStop()
10781 
    oprot.writeStructEnd()
10782 
 
3431 rajveer 10783 
  def validate(self):
10784 
    return
10785 
 
10786 
 
2616 chandransh 10787 
  def __repr__(self):
10788 
    L = ['%s=%r' % (key, value)
10789 
      for key, value in self.__dict__.iteritems()]
10790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10791 
 
10792 
  def __eq__(self, other):
10793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10794 
 
10795 
  def __ne__(self, other):
10796 
    return not (self == other)
10797 
 
10798 
class reshipOrder_result:
10799 
  """
10800 
  Attributes:
10801 
   - success
10802 
   - ex
10803 
  """
10804 
 
10805 
  thrift_spec = (
10806 
    (0, TType.I64, 'success', None, None, ), # 0
10807 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10808 
  )
10809 
 
10810 
  def __init__(self, success=None, ex=None,):
10811 
    self.success = success
10812 
    self.ex = ex
10813 
 
10814 
  def read(self, iprot):
10815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10817 
      return
10818 
    iprot.readStructBegin()
10819 
    while True:
10820 
      (fname, ftype, fid) = iprot.readFieldBegin()
10821 
      if ftype == TType.STOP:
10822 
        break
10823 
      if fid == 0:
10824 
        if ftype == TType.I64:
10825 
          self.success = iprot.readI64();
10826 
        else:
10827 
          iprot.skip(ftype)
10828 
      elif fid == 1:
10829 
        if ftype == TType.STRUCT:
10830 
          self.ex = TransactionServiceException()
10831 
          self.ex.read(iprot)
10832 
        else:
10833 
          iprot.skip(ftype)
10834 
      else:
10835 
        iprot.skip(ftype)
10836 
      iprot.readFieldEnd()
10837 
    iprot.readStructEnd()
10838 
 
10839 
  def write(self, oprot):
10840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10842 
      return
10843 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 10844 
    if self.success is not None:
2616 chandransh 10845 
      oprot.writeFieldBegin('success', TType.I64, 0)
10846 
      oprot.writeI64(self.success)
10847 
      oprot.writeFieldEnd()
3431 rajveer 10848 
    if self.ex is not None:
2616 chandransh 10849 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10850 
      self.ex.write(oprot)
10851 
      oprot.writeFieldEnd()
10852 
    oprot.writeFieldStop()
10853 
    oprot.writeStructEnd()
10854 
 
3431 rajveer 10855 
  def validate(self):
10856 
    return
10857 
 
10858 
 
2616 chandransh 10859 
  def __repr__(self):
10860 
    L = ['%s=%r' % (key, value)
10861 
      for key, value in self.__dict__.iteritems()]
10862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10863 
 
10864 
  def __eq__(self, other):
10865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10866 
 
10867 
  def __ne__(self, other):
10868 
    return not (self == other)
10869 
 
10870 
class refundOrder_args:
10871 
  """
10872 
  Attributes:
10873 
   - orderId
3226 chandransh 10874 
   - refundedBy
10875 
   - reason
2616 chandransh 10876 
  """
10877 
 
10878 
  thrift_spec = (
10879 
    None, # 0
10880 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 10881 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
10882 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 10883 
  )
10884 
 
3226 chandransh 10885 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 10886 
    self.orderId = orderId
3226 chandransh 10887 
    self.refundedBy = refundedBy
10888 
    self.reason = reason
2616 chandransh 10889 
 
10890 
  def read(self, iprot):
10891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10893 
      return
10894 
    iprot.readStructBegin()
10895 
    while True:
10896 
      (fname, ftype, fid) = iprot.readFieldBegin()
10897 
      if ftype == TType.STOP:
10898 
        break
10899 
      if fid == 1:
10900 
        if ftype == TType.I64:
10901 
          self.orderId = iprot.readI64();
10902 
        else:
10903 
          iprot.skip(ftype)
3226 chandransh 10904 
      elif fid == 2:
10905 
        if ftype == TType.STRING:
10906 
          self.refundedBy = iprot.readString();
10907 
        else:
10908 
          iprot.skip(ftype)
10909 
      elif fid == 3:
10910 
        if ftype == TType.STRING:
10911 
          self.reason = iprot.readString();
10912 
        else:
10913 
          iprot.skip(ftype)
2616 chandransh 10914 
      else:
10915 
        iprot.skip(ftype)
10916 
      iprot.readFieldEnd()
10917 
    iprot.readStructEnd()
10918 
 
10919 
  def write(self, oprot):
10920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10922 
      return
10923 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 10924 
    if self.orderId is not None:
2616 chandransh 10925 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10926 
      oprot.writeI64(self.orderId)
10927 
      oprot.writeFieldEnd()
3431 rajveer 10928 
    if self.refundedBy is not None:
3226 chandransh 10929 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
10930 
      oprot.writeString(self.refundedBy)
10931 
      oprot.writeFieldEnd()
3431 rajveer 10932 
    if self.reason is not None:
3226 chandransh 10933 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
10934 
      oprot.writeString(self.reason)
10935 
      oprot.writeFieldEnd()
2616 chandransh 10936 
    oprot.writeFieldStop()
10937 
    oprot.writeStructEnd()
10938 
 
3431 rajveer 10939 
  def validate(self):
10940 
    return
10941 
 
10942 
 
2616 chandransh 10943 
  def __repr__(self):
10944 
    L = ['%s=%r' % (key, value)
10945 
      for key, value in self.__dict__.iteritems()]
10946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10947 
 
10948 
  def __eq__(self, other):
10949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10950 
 
10951 
  def __ne__(self, other):
10952 
    return not (self == other)
10953 
 
10954 
class refundOrder_result:
10955 
  """
10956 
  Attributes:
10957 
   - success
10958 
   - ex
10959 
  """
10960 
 
10961 
  thrift_spec = (
10962 
    (0, TType.BOOL, 'success', None, None, ), # 0
10963 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10964 
  )
10965 
 
10966 
  def __init__(self, success=None, ex=None,):
10967 
    self.success = success
10968 
    self.ex = ex
10969 
 
10970 
  def read(self, iprot):
10971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10973 
      return
10974 
    iprot.readStructBegin()
10975 
    while True:
10976 
      (fname, ftype, fid) = iprot.readFieldBegin()
10977 
      if ftype == TType.STOP:
10978 
        break
10979 
      if fid == 0:
10980 
        if ftype == TType.BOOL:
10981 
          self.success = iprot.readBool();
10982 
        else:
10983 
          iprot.skip(ftype)
10984 
      elif fid == 1:
10985 
        if ftype == TType.STRUCT:
10986 
          self.ex = TransactionServiceException()
10987 
          self.ex.read(iprot)
10988 
        else:
10989 
          iprot.skip(ftype)
10990 
      else:
10991 
        iprot.skip(ftype)
10992 
      iprot.readFieldEnd()
10993 
    iprot.readStructEnd()
10994 
 
10995 
  def write(self, oprot):
10996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10998 
      return
10999 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 11000 
    if self.success is not None:
2616 chandransh 11001 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11002 
      oprot.writeBool(self.success)
11003 
      oprot.writeFieldEnd()
3431 rajveer 11004 
    if self.ex is not None:
2616 chandransh 11005 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11006 
      self.ex.write(oprot)
11007 
      oprot.writeFieldEnd()
11008 
    oprot.writeFieldStop()
11009 
    oprot.writeStructEnd()
11010 
 
3431 rajveer 11011 
  def validate(self):
11012 
    return
11013 
 
11014 
 
2616 chandransh 11015 
  def __repr__(self):
11016 
    L = ['%s=%r' % (key, value)
11017 
      for key, value in self.__dict__.iteritems()]
11018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11019 
 
11020 
  def __eq__(self, other):
11021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11022 
 
11023 
  def __ne__(self, other):
11024 
    return not (self == other)
11025 
 
2690 chandransh 11026 
class getReturnOrders_args:
11027 
  """
11028 
  Attributes:
11029 
   - warehouseId
11030 
   - fromDate
11031 
   - toDate
11032 
  """
2616 chandransh 11033 
 
2690 chandransh 11034 
  thrift_spec = (
11035 
    None, # 0
11036 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11037 
    (2, TType.I64, 'fromDate', None, None, ), # 2
11038 
    (3, TType.I64, 'toDate', None, None, ), # 3
11039 
  )
11040 
 
11041 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
11042 
    self.warehouseId = warehouseId
11043 
    self.fromDate = fromDate
11044 
    self.toDate = toDate
11045 
 
11046 
  def read(self, iprot):
11047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11049 
      return
11050 
    iprot.readStructBegin()
11051 
    while True:
11052 
      (fname, ftype, fid) = iprot.readFieldBegin()
11053 
      if ftype == TType.STOP:
11054 
        break
11055 
      if fid == 1:
11056 
        if ftype == TType.I64:
11057 
          self.warehouseId = iprot.readI64();
11058 
        else:
11059 
          iprot.skip(ftype)
11060 
      elif fid == 2:
11061 
        if ftype == TType.I64:
11062 
          self.fromDate = iprot.readI64();
11063 
        else:
11064 
          iprot.skip(ftype)
11065 
      elif fid == 3:
11066 
        if ftype == TType.I64:
11067 
          self.toDate = iprot.readI64();
11068 
        else:
11069 
          iprot.skip(ftype)
11070 
      else:
11071 
        iprot.skip(ftype)
11072 
      iprot.readFieldEnd()
11073 
    iprot.readStructEnd()
11074 
 
11075 
  def write(self, oprot):
11076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11078 
      return
11079 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 11080 
    if self.warehouseId is not None:
2690 chandransh 11081 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11082 
      oprot.writeI64(self.warehouseId)
11083 
      oprot.writeFieldEnd()
3431 rajveer 11084 
    if self.fromDate is not None:
2690 chandransh 11085 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
11086 
      oprot.writeI64(self.fromDate)
11087 
      oprot.writeFieldEnd()
3431 rajveer 11088 
    if self.toDate is not None:
2690 chandransh 11089 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
11090 
      oprot.writeI64(self.toDate)
11091 
      oprot.writeFieldEnd()
11092 
    oprot.writeFieldStop()
11093 
    oprot.writeStructEnd()
11094 
 
3431 rajveer 11095 
  def validate(self):
11096 
    return
11097 
 
11098 
 
2690 chandransh 11099 
  def __repr__(self):
11100 
    L = ['%s=%r' % (key, value)
11101 
      for key, value in self.__dict__.iteritems()]
11102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11103 
 
11104 
  def __eq__(self, other):
11105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11106 
 
11107 
  def __ne__(self, other):
11108 
    return not (self == other)
11109 
 
11110 
class getReturnOrders_result:
11111 
  """
11112 
  Attributes:
11113 
   - success
11114 
  """
11115 
 
11116 
  thrift_spec = (
11117 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
11118 
  )
11119 
 
11120 
  def __init__(self, success=None,):
11121 
    self.success = success
11122 
 
11123 
  def read(self, iprot):
11124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11126 
      return
11127 
    iprot.readStructBegin()
11128 
    while True:
11129 
      (fname, ftype, fid) = iprot.readFieldBegin()
11130 
      if ftype == TType.STOP:
11131 
        break
11132 
      if fid == 0:
11133 
        if ftype == TType.LIST:
11134 
          self.success = []
4133 chandransh 11135 
          (_etype209, _size206) = iprot.readListBegin()
11136 
          for _i210 in xrange(_size206):
11137 
            _elem211 = ReturnOrder()
11138 
            _elem211.read(iprot)
11139 
            self.success.append(_elem211)
2690 chandransh 11140 
          iprot.readListEnd()
11141 
        else:
11142 
          iprot.skip(ftype)
11143 
      else:
11144 
        iprot.skip(ftype)
11145 
      iprot.readFieldEnd()
11146 
    iprot.readStructEnd()
11147 
 
11148 
  def write(self, oprot):
11149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11151 
      return
11152 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 11153 
    if self.success is not None:
2690 chandransh 11154 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11155 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11156 
      for iter212 in self.success:
11157 
        iter212.write(oprot)
2690 chandransh 11158 
      oprot.writeListEnd()
11159 
      oprot.writeFieldEnd()
11160 
    oprot.writeFieldStop()
11161 
    oprot.writeStructEnd()
11162 
 
3431 rajveer 11163 
  def validate(self):
11164 
    return
11165 
 
11166 
 
2690 chandransh 11167 
  def __repr__(self):
11168 
    L = ['%s=%r' % (key, value)
11169 
      for key, value in self.__dict__.iteritems()]
11170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11171 
 
11172 
  def __eq__(self, other):
11173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11174 
 
11175 
  def __ne__(self, other):
11176 
    return not (self == other)
11177 
 
2700 chandransh 11178 
class getReturnOrder_args:
11179 
  """
11180 
  Attributes:
11181 
   - id
11182 
  """
11183 
 
11184 
  thrift_spec = (
11185 
    None, # 0
11186 
    (1, TType.I64, 'id', None, None, ), # 1
11187 
  )
11188 
 
11189 
  def __init__(self, id=None,):
11190 
    self.id = id
11191 
 
11192 
  def read(self, iprot):
11193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11195 
      return
11196 
    iprot.readStructBegin()
11197 
    while True:
11198 
      (fname, ftype, fid) = iprot.readFieldBegin()
11199 
      if ftype == TType.STOP:
11200 
        break
11201 
      if fid == 1:
11202 
        if ftype == TType.I64:
11203 
          self.id = iprot.readI64();
11204 
        else:
11205 
          iprot.skip(ftype)
11206 
      else:
11207 
        iprot.skip(ftype)
11208 
      iprot.readFieldEnd()
11209 
    iprot.readStructEnd()
11210 
 
11211 
  def write(self, oprot):
11212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11214 
      return
11215 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 11216 
    if self.id is not None:
2700 chandransh 11217 
      oprot.writeFieldBegin('id', TType.I64, 1)
11218 
      oprot.writeI64(self.id)
11219 
      oprot.writeFieldEnd()
11220 
    oprot.writeFieldStop()
11221 
    oprot.writeStructEnd()
11222 
 
3431 rajveer 11223 
  def validate(self):
11224 
    return
11225 
 
11226 
 
2700 chandransh 11227 
  def __repr__(self):
11228 
    L = ['%s=%r' % (key, value)
11229 
      for key, value in self.__dict__.iteritems()]
11230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11231 
 
11232 
  def __eq__(self, other):
11233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11234 
 
11235 
  def __ne__(self, other):
11236 
    return not (self == other)
11237 
 
11238 
class getReturnOrder_result:
11239 
  """
11240 
  Attributes:
11241 
   - success
11242 
   - ex
11243 
  """
11244 
 
11245 
  thrift_spec = (
11246 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
11247 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11248 
  )
11249 
 
11250 
  def __init__(self, success=None, ex=None,):
11251 
    self.success = success
11252 
    self.ex = ex
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 == 0:
11264 
        if ftype == TType.STRUCT:
11265 
          self.success = ReturnOrder()
11266 
          self.success.read(iprot)
11267 
        else:
11268 
          iprot.skip(ftype)
11269 
      elif fid == 1:
11270 
        if ftype == TType.STRUCT:
11271 
          self.ex = TransactionServiceException()
11272 
          self.ex.read(iprot)
11273 
        else:
11274 
          iprot.skip(ftype)
11275 
      else:
11276 
        iprot.skip(ftype)
11277 
      iprot.readFieldEnd()
11278 
    iprot.readStructEnd()
11279 
 
11280 
  def write(self, oprot):
11281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11283 
      return
11284 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 11285 
    if self.success is not None:
2700 chandransh 11286 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11287 
      self.success.write(oprot)
11288 
      oprot.writeFieldEnd()
3431 rajveer 11289 
    if self.ex is not None:
2700 chandransh 11290 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11291 
      self.ex.write(oprot)
11292 
      oprot.writeFieldEnd()
11293 
    oprot.writeFieldStop()
11294 
    oprot.writeStructEnd()
11295 
 
3431 rajveer 11296 
  def validate(self):
11297 
    return
11298 
 
11299 
 
2700 chandransh 11300 
  def __repr__(self):
11301 
    L = ['%s=%r' % (key, value)
11302 
      for key, value in self.__dict__.iteritems()]
11303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11304 
 
11305 
  def __eq__(self, other):
11306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11307 
 
11308 
  def __ne__(self, other):
11309 
    return not (self == other)
11310 
 
2690 chandransh 11311 
class processReturn_args:
11312 
  """
11313 
  Attributes:
11314 
   - returnOrderId
11315 
  """
11316 
 
11317 
  thrift_spec = (
11318 
    None, # 0
11319 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
11320 
  )
11321 
 
11322 
  def __init__(self, returnOrderId=None,):
11323 
    self.returnOrderId = returnOrderId
11324 
 
11325 
  def read(self, iprot):
11326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11328 
      return
11329 
    iprot.readStructBegin()
11330 
    while True:
11331 
      (fname, ftype, fid) = iprot.readFieldBegin()
11332 
      if ftype == TType.STOP:
11333 
        break
11334 
      if fid == 1:
11335 
        if ftype == TType.I64:
11336 
          self.returnOrderId = iprot.readI64();
11337 
        else:
11338 
          iprot.skip(ftype)
11339 
      else:
11340 
        iprot.skip(ftype)
11341 
      iprot.readFieldEnd()
11342 
    iprot.readStructEnd()
11343 
 
11344 
  def write(self, oprot):
11345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11347 
      return
11348 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 11349 
    if self.returnOrderId is not None:
2690 chandransh 11350 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
11351 
      oprot.writeI64(self.returnOrderId)
11352 
      oprot.writeFieldEnd()
11353 
    oprot.writeFieldStop()
11354 
    oprot.writeStructEnd()
11355 
 
3431 rajveer 11356 
  def validate(self):
11357 
    return
11358 
 
11359 
 
2690 chandransh 11360 
  def __repr__(self):
11361 
    L = ['%s=%r' % (key, value)
11362 
      for key, value in self.__dict__.iteritems()]
11363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11364 
 
11365 
  def __eq__(self, other):
11366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11367 
 
11368 
  def __ne__(self, other):
11369 
    return not (self == other)
11370 
 
11371 
class processReturn_result:
11372 
  """
11373 
  Attributes:
11374 
   - ex
11375 
  """
11376 
 
11377 
  thrift_spec = (
11378 
    None, # 0
11379 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11380 
  )
11381 
 
11382 
  def __init__(self, ex=None,):
11383 
    self.ex = ex
11384 
 
11385 
  def read(self, iprot):
11386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11388 
      return
11389 
    iprot.readStructBegin()
11390 
    while True:
11391 
      (fname, ftype, fid) = iprot.readFieldBegin()
11392 
      if ftype == TType.STOP:
11393 
        break
11394 
      if fid == 1:
11395 
        if ftype == TType.STRUCT:
11396 
          self.ex = TransactionServiceException()
11397 
          self.ex.read(iprot)
11398 
        else:
11399 
          iprot.skip(ftype)
11400 
      else:
11401 
        iprot.skip(ftype)
11402 
      iprot.readFieldEnd()
11403 
    iprot.readStructEnd()
11404 
 
11405 
  def write(self, oprot):
11406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11408 
      return
11409 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 11410 
    if self.ex is not None:
2690 chandransh 11411 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11412 
      self.ex.write(oprot)
11413 
      oprot.writeFieldEnd()
11414 
    oprot.writeFieldStop()
11415 
    oprot.writeStructEnd()
11416 
 
3431 rajveer 11417 
  def validate(self):
11418 
    return
11419 
 
11420 
 
2690 chandransh 11421 
  def __repr__(self):
11422 
    L = ['%s=%r' % (key, value)
11423 
      for key, value in self.__dict__.iteritems()]
11424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11425 
 
11426 
  def __eq__(self, other):
11427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11428 
 
11429 
  def __ne__(self, other):
11430 
    return not (self == other)
11431 
 
2819 chandransh 11432 
class createPurchaseOrder_args:
11433 
  """
11434 
  Attributes:
11435 
   - warehouseId
11436 
  """
2690 chandransh 11437 
 
2819 chandransh 11438 
  thrift_spec = (
11439 
    None, # 0
11440 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11441 
  )
11442 
 
11443 
  def __init__(self, warehouseId=None,):
11444 
    self.warehouseId = warehouseId
11445 
 
11446 
  def read(self, iprot):
11447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11449 
      return
11450 
    iprot.readStructBegin()
11451 
    while True:
11452 
      (fname, ftype, fid) = iprot.readFieldBegin()
11453 
      if ftype == TType.STOP:
11454 
        break
11455 
      if fid == 1:
11456 
        if ftype == TType.I64:
11457 
          self.warehouseId = iprot.readI64();
11458 
        else:
11459 
          iprot.skip(ftype)
11460 
      else:
11461 
        iprot.skip(ftype)
11462 
      iprot.readFieldEnd()
11463 
    iprot.readStructEnd()
11464 
 
11465 
  def write(self, oprot):
11466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11468 
      return
11469 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 11470 
    if self.warehouseId is not None:
2819 chandransh 11471 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11472 
      oprot.writeI64(self.warehouseId)
11473 
      oprot.writeFieldEnd()
11474 
    oprot.writeFieldStop()
11475 
    oprot.writeStructEnd()
11476 
 
3431 rajveer 11477 
  def validate(self):
11478 
    return
11479 
 
11480 
 
2819 chandransh 11481 
  def __repr__(self):
11482 
    L = ['%s=%r' % (key, value)
11483 
      for key, value in self.__dict__.iteritems()]
11484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11485 
 
11486 
  def __eq__(self, other):
11487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11488 
 
11489 
  def __ne__(self, other):
11490 
    return not (self == other)
11491 
 
11492 
class createPurchaseOrder_result:
11493 
  """
11494 
  Attributes:
11495 
   - success
11496 
   - ex
11497 
  """
11498 
 
11499 
  thrift_spec = (
11500 
    (0, TType.I64, 'success', None, None, ), # 0
11501 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11502 
  )
11503 
 
11504 
  def __init__(self, success=None, ex=None,):
11505 
    self.success = success
11506 
    self.ex = ex
11507 
 
11508 
  def read(self, iprot):
11509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11511 
      return
11512 
    iprot.readStructBegin()
11513 
    while True:
11514 
      (fname, ftype, fid) = iprot.readFieldBegin()
11515 
      if ftype == TType.STOP:
11516 
        break
11517 
      if fid == 0:
11518 
        if ftype == TType.I64:
11519 
          self.success = iprot.readI64();
11520 
        else:
11521 
          iprot.skip(ftype)
11522 
      elif fid == 1:
11523 
        if ftype == TType.STRUCT:
11524 
          self.ex = TransactionServiceException()
11525 
          self.ex.read(iprot)
11526 
        else:
11527 
          iprot.skip(ftype)
11528 
      else:
11529 
        iprot.skip(ftype)
11530 
      iprot.readFieldEnd()
11531 
    iprot.readStructEnd()
11532 
 
11533 
  def write(self, oprot):
11534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11536 
      return
11537 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 11538 
    if self.success is not None:
2819 chandransh 11539 
      oprot.writeFieldBegin('success', TType.I64, 0)
11540 
      oprot.writeI64(self.success)
11541 
      oprot.writeFieldEnd()
3431 rajveer 11542 
    if self.ex is not None:
2819 chandransh 11543 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11544 
      self.ex.write(oprot)
11545 
      oprot.writeFieldEnd()
11546 
    oprot.writeFieldStop()
11547 
    oprot.writeStructEnd()
11548 
 
3431 rajveer 11549 
  def validate(self):
11550 
    return
11551 
 
11552 
 
2819 chandransh 11553 
  def __repr__(self):
11554 
    L = ['%s=%r' % (key, value)
11555 
      for key, value in self.__dict__.iteritems()]
11556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11557 
 
11558 
  def __eq__(self, other):
11559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11560 
 
11561 
  def __ne__(self, other):
11562 
    return not (self == other)
3451 chandransh 11563 
 
11564 
class updateWeight_args:
11565 
  """
11566 
  Attributes:
11567 
   - orderId
11568 
   - weight
11569 
  """
11570 
 
11571 
  thrift_spec = (
11572 
    None, # 0
11573 
    (1, TType.I64, 'orderId', None, None, ), # 1
11574 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
11575 
  )
11576 
 
11577 
  def __init__(self, orderId=None, weight=None,):
11578 
    self.orderId = orderId
11579 
    self.weight = weight
11580 
 
11581 
  def read(self, iprot):
11582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11584 
      return
11585 
    iprot.readStructBegin()
11586 
    while True:
11587 
      (fname, ftype, fid) = iprot.readFieldBegin()
11588 
      if ftype == TType.STOP:
11589 
        break
11590 
      if fid == 1:
11591 
        if ftype == TType.I64:
11592 
          self.orderId = iprot.readI64();
11593 
        else:
11594 
          iprot.skip(ftype)
11595 
      elif fid == 2:
11596 
        if ftype == TType.DOUBLE:
11597 
          self.weight = iprot.readDouble();
11598 
        else:
11599 
          iprot.skip(ftype)
11600 
      else:
11601 
        iprot.skip(ftype)
11602 
      iprot.readFieldEnd()
11603 
    iprot.readStructEnd()
11604 
 
11605 
  def write(self, oprot):
11606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11608 
      return
11609 
    oprot.writeStructBegin('updateWeight_args')
11610 
    if self.orderId is not None:
11611 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11612 
      oprot.writeI64(self.orderId)
11613 
      oprot.writeFieldEnd()
11614 
    if self.weight is not None:
11615 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
11616 
      oprot.writeDouble(self.weight)
11617 
      oprot.writeFieldEnd()
11618 
    oprot.writeFieldStop()
11619 
    oprot.writeStructEnd()
11620 
 
11621 
  def validate(self):
11622 
    return
11623 
 
11624 
 
11625 
  def __repr__(self):
11626 
    L = ['%s=%r' % (key, value)
11627 
      for key, value in self.__dict__.iteritems()]
11628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11629 
 
11630 
  def __eq__(self, other):
11631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11632 
 
11633 
  def __ne__(self, other):
11634 
    return not (self == other)
11635 
 
11636 
class updateWeight_result:
11637 
  """
11638 
  Attributes:
11639 
   - success
11640 
   - ex
11641 
  """
11642 
 
11643 
  thrift_spec = (
11644 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11645 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11646 
  )
11647 
 
11648 
  def __init__(self, success=None, ex=None,):
11649 
    self.success = success
11650 
    self.ex = ex
11651 
 
11652 
  def read(self, iprot):
11653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11655 
      return
11656 
    iprot.readStructBegin()
11657 
    while True:
11658 
      (fname, ftype, fid) = iprot.readFieldBegin()
11659 
      if ftype == TType.STOP:
11660 
        break
11661 
      if fid == 0:
11662 
        if ftype == TType.STRUCT:
11663 
          self.success = Order()
11664 
          self.success.read(iprot)
11665 
        else:
11666 
          iprot.skip(ftype)
11667 
      elif fid == 1:
11668 
        if ftype == TType.STRUCT:
11669 
          self.ex = TransactionServiceException()
11670 
          self.ex.read(iprot)
11671 
        else:
11672 
          iprot.skip(ftype)
11673 
      else:
11674 
        iprot.skip(ftype)
11675 
      iprot.readFieldEnd()
11676 
    iprot.readStructEnd()
11677 
 
11678 
  def write(self, oprot):
11679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11681 
      return
11682 
    oprot.writeStructBegin('updateWeight_result')
11683 
    if self.success is not None:
11684 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11685 
      self.success.write(oprot)
11686 
      oprot.writeFieldEnd()
11687 
    if self.ex is not None:
11688 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11689 
      self.ex.write(oprot)
11690 
      oprot.writeFieldEnd()
11691 
    oprot.writeFieldStop()
11692 
    oprot.writeStructEnd()
11693 
 
11694 
  def validate(self):
11695 
    return
11696 
 
11697 
 
11698 
  def __repr__(self):
11699 
    L = ['%s=%r' % (key, value)
11700 
      for key, value in self.__dict__.iteritems()]
11701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11702 
 
11703 
  def __eq__(self, other):
11704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11705 
 
11706 
  def __ne__(self, other):
11707 
    return not (self == other)
3469 chandransh 11708 
 
11709 
class changeItem_args:
11710 
  """
11711 
  Attributes:
11712 
   - orderId
11713 
   - itemId
11714 
  """
11715 
 
11716 
  thrift_spec = (
11717 
    None, # 0
11718 
    (1, TType.I64, 'orderId', None, None, ), # 1
11719 
    (2, TType.I64, 'itemId', None, None, ), # 2
11720 
  )
11721 
 
11722 
  def __init__(self, orderId=None, itemId=None,):
11723 
    self.orderId = orderId
11724 
    self.itemId = itemId
11725 
 
11726 
  def read(self, iprot):
11727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11729 
      return
11730 
    iprot.readStructBegin()
11731 
    while True:
11732 
      (fname, ftype, fid) = iprot.readFieldBegin()
11733 
      if ftype == TType.STOP:
11734 
        break
11735 
      if fid == 1:
11736 
        if ftype == TType.I64:
11737 
          self.orderId = iprot.readI64();
11738 
        else:
11739 
          iprot.skip(ftype)
11740 
      elif fid == 2:
11741 
        if ftype == TType.I64:
11742 
          self.itemId = iprot.readI64();
11743 
        else:
11744 
          iprot.skip(ftype)
11745 
      else:
11746 
        iprot.skip(ftype)
11747 
      iprot.readFieldEnd()
11748 
    iprot.readStructEnd()
11749 
 
11750 
  def write(self, oprot):
11751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11753 
      return
11754 
    oprot.writeStructBegin('changeItem_args')
11755 
    if self.orderId is not None:
11756 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11757 
      oprot.writeI64(self.orderId)
11758 
      oprot.writeFieldEnd()
11759 
    if self.itemId is not None:
11760 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11761 
      oprot.writeI64(self.itemId)
11762 
      oprot.writeFieldEnd()
11763 
    oprot.writeFieldStop()
11764 
    oprot.writeStructEnd()
11765 
 
11766 
  def validate(self):
11767 
    return
11768 
 
11769 
 
11770 
  def __repr__(self):
11771 
    L = ['%s=%r' % (key, value)
11772 
      for key, value in self.__dict__.iteritems()]
11773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11774 
 
11775 
  def __eq__(self, other):
11776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11777 
 
11778 
  def __ne__(self, other):
11779 
    return not (self == other)
11780 
 
11781 
class changeItem_result:
11782 
  """
11783 
  Attributes:
11784 
   - success
11785 
   - ex
11786 
  """
11787 
 
11788 
  thrift_spec = (
11789 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11790 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11791 
  )
11792 
 
11793 
  def __init__(self, success=None, ex=None,):
11794 
    self.success = success
11795 
    self.ex = ex
11796 
 
11797 
  def read(self, iprot):
11798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11800 
      return
11801 
    iprot.readStructBegin()
11802 
    while True:
11803 
      (fname, ftype, fid) = iprot.readFieldBegin()
11804 
      if ftype == TType.STOP:
11805 
        break
11806 
      if fid == 0:
11807 
        if ftype == TType.STRUCT:
11808 
          self.success = Order()
11809 
          self.success.read(iprot)
11810 
        else:
11811 
          iprot.skip(ftype)
11812 
      elif fid == 1:
11813 
        if ftype == TType.STRUCT:
11814 
          self.ex = TransactionServiceException()
11815 
          self.ex.read(iprot)
11816 
        else:
11817 
          iprot.skip(ftype)
11818 
      else:
11819 
        iprot.skip(ftype)
11820 
      iprot.readFieldEnd()
11821 
    iprot.readStructEnd()
11822 
 
11823 
  def write(self, oprot):
11824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11826 
      return
11827 
    oprot.writeStructBegin('changeItem_result')
11828 
    if self.success is not None:
11829 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11830 
      self.success.write(oprot)
11831 
      oprot.writeFieldEnd()
11832 
    if self.ex is not None:
11833 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11834 
      self.ex.write(oprot)
11835 
      oprot.writeFieldEnd()
11836 
    oprot.writeFieldStop()
11837 
    oprot.writeStructEnd()
11838 
 
11839 
  def validate(self):
11840 
    return
11841 
 
11842 
 
11843 
  def __repr__(self):
11844 
    L = ['%s=%r' % (key, value)
11845 
      for key, value in self.__dict__.iteritems()]
11846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11847 
 
11848 
  def __eq__(self, other):
11849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11850 
 
11851 
  def __ne__(self, other):
11852 
    return not (self == other)
11853 
 
11854 
class shiftToWarehouse_args:
11855 
  """
11856 
  Attributes:
11857 
   - orderId
11858 
   - warehouseId
11859 
  """
11860 
 
11861 
  thrift_spec = (
11862 
    None, # 0
11863 
    (1, TType.I64, 'orderId', None, None, ), # 1
11864 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11865 
  )
11866 
 
11867 
  def __init__(self, orderId=None, warehouseId=None,):
11868 
    self.orderId = orderId
11869 
    self.warehouseId = warehouseId
11870 
 
11871 
  def read(self, iprot):
11872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11874 
      return
11875 
    iprot.readStructBegin()
11876 
    while True:
11877 
      (fname, ftype, fid) = iprot.readFieldBegin()
11878 
      if ftype == TType.STOP:
11879 
        break
11880 
      if fid == 1:
11881 
        if ftype == TType.I64:
11882 
          self.orderId = iprot.readI64();
11883 
        else:
11884 
          iprot.skip(ftype)
11885 
      elif fid == 2:
11886 
        if ftype == TType.I64:
11887 
          self.warehouseId = iprot.readI64();
11888 
        else:
11889 
          iprot.skip(ftype)
11890 
      else:
11891 
        iprot.skip(ftype)
11892 
      iprot.readFieldEnd()
11893 
    iprot.readStructEnd()
11894 
 
11895 
  def write(self, oprot):
11896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11898 
      return
11899 
    oprot.writeStructBegin('shiftToWarehouse_args')
11900 
    if self.orderId is not None:
11901 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11902 
      oprot.writeI64(self.orderId)
11903 
      oprot.writeFieldEnd()
11904 
    if self.warehouseId is not None:
11905 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11906 
      oprot.writeI64(self.warehouseId)
11907 
      oprot.writeFieldEnd()
11908 
    oprot.writeFieldStop()
11909 
    oprot.writeStructEnd()
11910 
 
11911 
  def validate(self):
11912 
    return
11913 
 
11914 
 
11915 
  def __repr__(self):
11916 
    L = ['%s=%r' % (key, value)
11917 
      for key, value in self.__dict__.iteritems()]
11918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11919 
 
11920 
  def __eq__(self, other):
11921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11922 
 
11923 
  def __ne__(self, other):
11924 
    return not (self == other)
11925 
 
11926 
class shiftToWarehouse_result:
11927 
  """
11928 
  Attributes:
11929 
   - success
11930 
   - ex
11931 
  """
11932 
 
11933 
  thrift_spec = (
11934 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11935 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11936 
  )
11937 
 
11938 
  def __init__(self, success=None, ex=None,):
11939 
    self.success = success
11940 
    self.ex = ex
11941 
 
11942 
  def read(self, iprot):
11943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11945 
      return
11946 
    iprot.readStructBegin()
11947 
    while True:
11948 
      (fname, ftype, fid) = iprot.readFieldBegin()
11949 
      if ftype == TType.STOP:
11950 
        break
11951 
      if fid == 0:
11952 
        if ftype == TType.STRUCT:
11953 
          self.success = Order()
11954 
          self.success.read(iprot)
11955 
        else:
11956 
          iprot.skip(ftype)
11957 
      elif fid == 1:
11958 
        if ftype == TType.STRUCT:
11959 
          self.ex = TransactionServiceException()
11960 
          self.ex.read(iprot)
11961 
        else:
11962 
          iprot.skip(ftype)
11963 
      else:
11964 
        iprot.skip(ftype)
11965 
      iprot.readFieldEnd()
11966 
    iprot.readStructEnd()
11967 
 
11968 
  def write(self, oprot):
11969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11971 
      return
11972 
    oprot.writeStructBegin('shiftToWarehouse_result')
11973 
    if self.success is not None:
11974 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11975 
      self.success.write(oprot)
11976 
      oprot.writeFieldEnd()
11977 
    if self.ex is not None:
11978 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11979 
      self.ex.write(oprot)
11980 
      oprot.writeFieldEnd()
11981 
    oprot.writeFieldStop()
11982 
    oprot.writeStructEnd()
11983 
 
11984 
  def validate(self):
11985 
    return
11986 
 
11987 
 
11988 
  def __repr__(self):
11989 
    L = ['%s=%r' % (key, value)
11990 
      for key, value in self.__dict__.iteritems()]
11991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11992 
 
11993 
  def __eq__(self, other):
11994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11995 
 
11996 
  def __ne__(self, other):
11997 
    return not (self == other)
3553 chandransh 11998 
 
11999 
class addDelayReason_args:
12000 
  """
12001 
  Attributes:
12002 
   - orderId
12003 
   - delayReason
3986 chandransh 12004 
   - furtherDelay
3553 chandransh 12005 
  """
12006 
 
12007 
  thrift_spec = (
12008 
    None, # 0
12009 
    (1, TType.I64, 'orderId', None, None, ), # 1
12010 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 12011 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 12012 
  )
12013 
 
3986 chandransh 12014 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 12015 
    self.orderId = orderId
12016 
    self.delayReason = delayReason
3986 chandransh 12017 
    self.furtherDelay = furtherDelay
3553 chandransh 12018 
 
12019 
  def read(self, iprot):
12020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12022 
      return
12023 
    iprot.readStructBegin()
12024 
    while True:
12025 
      (fname, ftype, fid) = iprot.readFieldBegin()
12026 
      if ftype == TType.STOP:
12027 
        break
12028 
      if fid == 1:
12029 
        if ftype == TType.I64:
12030 
          self.orderId = iprot.readI64();
12031 
        else:
12032 
          iprot.skip(ftype)
12033 
      elif fid == 2:
12034 
        if ftype == TType.I32:
12035 
          self.delayReason = iprot.readI32();
12036 
        else:
12037 
          iprot.skip(ftype)
3986 chandransh 12038 
      elif fid == 3:
12039 
        if ftype == TType.I64:
12040 
          self.furtherDelay = iprot.readI64();
12041 
        else:
12042 
          iprot.skip(ftype)
3553 chandransh 12043 
      else:
12044 
        iprot.skip(ftype)
12045 
      iprot.readFieldEnd()
12046 
    iprot.readStructEnd()
12047 
 
12048 
  def write(self, oprot):
12049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12051 
      return
12052 
    oprot.writeStructBegin('addDelayReason_args')
12053 
    if self.orderId is not None:
12054 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12055 
      oprot.writeI64(self.orderId)
12056 
      oprot.writeFieldEnd()
12057 
    if self.delayReason is not None:
12058 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
12059 
      oprot.writeI32(self.delayReason)
12060 
      oprot.writeFieldEnd()
3986 chandransh 12061 
    if self.furtherDelay is not None:
12062 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
12063 
      oprot.writeI64(self.furtherDelay)
12064 
      oprot.writeFieldEnd()
3553 chandransh 12065 
    oprot.writeFieldStop()
12066 
    oprot.writeStructEnd()
12067 
 
12068 
  def validate(self):
12069 
    return
12070 
 
12071 
 
12072 
  def __repr__(self):
12073 
    L = ['%s=%r' % (key, value)
12074 
      for key, value in self.__dict__.iteritems()]
12075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12076 
 
12077 
  def __eq__(self, other):
12078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12079 
 
12080 
  def __ne__(self, other):
12081 
    return not (self == other)
12082 
 
12083 
class addDelayReason_result:
12084 
  """
12085 
  Attributes:
12086 
   - success
12087 
   - ex
12088 
  """
12089 
 
12090 
  thrift_spec = (
12091 
    (0, TType.BOOL, 'success', None, None, ), # 0
12092 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12093 
  )
12094 
 
12095 
  def __init__(self, success=None, ex=None,):
12096 
    self.success = success
12097 
    self.ex = ex
12098 
 
12099 
  def read(self, iprot):
12100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12102 
      return
12103 
    iprot.readStructBegin()
12104 
    while True:
12105 
      (fname, ftype, fid) = iprot.readFieldBegin()
12106 
      if ftype == TType.STOP:
12107 
        break
12108 
      if fid == 0:
12109 
        if ftype == TType.BOOL:
12110 
          self.success = iprot.readBool();
12111 
        else:
12112 
          iprot.skip(ftype)
12113 
      elif fid == 1:
12114 
        if ftype == TType.STRUCT:
12115 
          self.ex = TransactionServiceException()
12116 
          self.ex.read(iprot)
12117 
        else:
12118 
          iprot.skip(ftype)
12119 
      else:
12120 
        iprot.skip(ftype)
12121 
      iprot.readFieldEnd()
12122 
    iprot.readStructEnd()
12123 
 
12124 
  def write(self, oprot):
12125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12127 
      return
12128 
    oprot.writeStructBegin('addDelayReason_result')
12129 
    if self.success is not None:
12130 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12131 
      oprot.writeBool(self.success)
12132 
      oprot.writeFieldEnd()
12133 
    if self.ex is not None:
12134 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12135 
      self.ex.write(oprot)
12136 
      oprot.writeFieldEnd()
12137 
    oprot.writeFieldStop()
12138 
    oprot.writeStructEnd()
12139 
 
12140 
  def validate(self):
12141 
    return
12142 
 
12143 
 
12144 
  def __repr__(self):
12145 
    L = ['%s=%r' % (key, value)
12146 
      for key, value in self.__dict__.iteritems()]
12147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12148 
 
12149 
  def __eq__(self, other):
12150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12151 
 
12152 
  def __ne__(self, other):
12153 
    return not (self == other)
3956 chandransh 12154 
 
12155 
class reconcileCodCollection_args:
12156 
  """
12157 
  Attributes:
12158 
   - collectedAmountMap
12159 
   - xferBy
12160 
   - xferTxnId
12161 
   - xferDate
12162 
  """
12163 
 
12164 
  thrift_spec = (
12165 
    None, # 0
12166 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
12167 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
12168 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
12169 
    (4, TType.I64, 'xferDate', None, None, ), # 4
12170 
  )
12171 
 
12172 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
12173 
    self.collectedAmountMap = collectedAmountMap
12174 
    self.xferBy = xferBy
12175 
    self.xferTxnId = xferTxnId
12176 
    self.xferDate = xferDate
12177 
 
12178 
  def read(self, iprot):
12179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12181 
      return
12182 
    iprot.readStructBegin()
12183 
    while True:
12184 
      (fname, ftype, fid) = iprot.readFieldBegin()
12185 
      if ftype == TType.STOP:
12186 
        break
12187 
      if fid == 1:
12188 
        if ftype == TType.MAP:
12189 
          self.collectedAmountMap = {}
4133 chandransh 12190 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
12191 
          for _i217 in xrange(_size213):
12192 
            _key218 = iprot.readString();
12193 
            _val219 = iprot.readDouble();
12194 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 12195 
          iprot.readMapEnd()
12196 
        else:
12197 
          iprot.skip(ftype)
12198 
      elif fid == 2:
12199 
        if ftype == TType.STRING:
12200 
          self.xferBy = iprot.readString();
12201 
        else:
12202 
          iprot.skip(ftype)
12203 
      elif fid == 3:
12204 
        if ftype == TType.STRING:
12205 
          self.xferTxnId = iprot.readString();
12206 
        else:
12207 
          iprot.skip(ftype)
12208 
      elif fid == 4:
12209 
        if ftype == TType.I64:
12210 
          self.xferDate = iprot.readI64();
12211 
        else:
12212 
          iprot.skip(ftype)
12213 
      else:
12214 
        iprot.skip(ftype)
12215 
      iprot.readFieldEnd()
12216 
    iprot.readStructEnd()
12217 
 
12218 
  def write(self, oprot):
12219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12221 
      return
12222 
    oprot.writeStructBegin('reconcileCodCollection_args')
12223 
    if self.collectedAmountMap is not None:
12224 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
12225 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 12226 
      for kiter220,viter221 in self.collectedAmountMap.items():
12227 
        oprot.writeString(kiter220)
12228 
        oprot.writeDouble(viter221)
3956 chandransh 12229 
      oprot.writeMapEnd()
12230 
      oprot.writeFieldEnd()
12231 
    if self.xferBy is not None:
12232 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
12233 
      oprot.writeString(self.xferBy)
12234 
      oprot.writeFieldEnd()
12235 
    if self.xferTxnId is not None:
12236 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
12237 
      oprot.writeString(self.xferTxnId)
12238 
      oprot.writeFieldEnd()
12239 
    if self.xferDate is not None:
12240 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
12241 
      oprot.writeI64(self.xferDate)
12242 
      oprot.writeFieldEnd()
12243 
    oprot.writeFieldStop()
12244 
    oprot.writeStructEnd()
12245 
 
12246 
  def validate(self):
12247 
    return
12248 
 
12249 
 
12250 
  def __repr__(self):
12251 
    L = ['%s=%r' % (key, value)
12252 
      for key, value in self.__dict__.iteritems()]
12253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12254 
 
12255 
  def __eq__(self, other):
12256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12257 
 
12258 
  def __ne__(self, other):
12259 
    return not (self == other)
12260 
 
12261 
class reconcileCodCollection_result:
12262 
  """
12263 
  Attributes:
12264 
   - success
12265 
   - ex
12266 
  """
12267 
 
12268 
  thrift_spec = (
12269 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
12270 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12271 
  )
12272 
 
12273 
  def __init__(self, success=None, ex=None,):
12274 
    self.success = success
12275 
    self.ex = ex
12276 
 
12277 
  def read(self, iprot):
12278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12280 
      return
12281 
    iprot.readStructBegin()
12282 
    while True:
12283 
      (fname, ftype, fid) = iprot.readFieldBegin()
12284 
      if ftype == TType.STOP:
12285 
        break
12286 
      if fid == 0:
12287 
        if ftype == TType.MAP:
12288 
          self.success = {}
4133 chandransh 12289 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
12290 
          for _i226 in xrange(_size222):
12291 
            _key227 = iprot.readString();
12292 
            _val228 = iprot.readString();
12293 
            self.success[_key227] = _val228
3956 chandransh 12294 
          iprot.readMapEnd()
12295 
        else:
12296 
          iprot.skip(ftype)
12297 
      elif fid == 1:
12298 
        if ftype == TType.STRUCT:
12299 
          self.ex = TransactionServiceException()
12300 
          self.ex.read(iprot)
12301 
        else:
12302 
          iprot.skip(ftype)
12303 
      else:
12304 
        iprot.skip(ftype)
12305 
      iprot.readFieldEnd()
12306 
    iprot.readStructEnd()
12307 
 
12308 
  def write(self, oprot):
12309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12311 
      return
12312 
    oprot.writeStructBegin('reconcileCodCollection_result')
12313 
    if self.success is not None:
12314 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12315 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 12316 
      for kiter229,viter230 in self.success.items():
12317 
        oprot.writeString(kiter229)
12318 
        oprot.writeString(viter230)
3956 chandransh 12319 
      oprot.writeMapEnd()
12320 
      oprot.writeFieldEnd()
12321 
    if self.ex is not None:
12322 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12323 
      self.ex.write(oprot)
12324 
      oprot.writeFieldEnd()
12325 
    oprot.writeFieldStop()
12326 
    oprot.writeStructEnd()
12327 
 
12328 
  def validate(self):
12329 
    return
12330 
 
12331 
 
12332 
  def __repr__(self):
12333 
    L = ['%s=%r' % (key, value)
12334 
      for key, value in self.__dict__.iteritems()]
12335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12336 
 
12337 
  def __eq__(self, other):
12338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12339 
 
12340 
  def __ne__(self, other):
12341 
    return not (self == other)
4008 mandeep.dh 12342 
 
12343 
class getTransactionsRequiringExtraProcessing_args:
12344 
  """
12345 
  Attributes:
12346 
   - category
12347 
  """
12348 
 
12349 
  thrift_spec = (
12350 
    None, # 0
12351 
    (1, TType.I32, 'category', None, None, ), # 1
12352 
  )
12353 
 
12354 
  def __init__(self, category=None,):
12355 
    self.category = category
12356 
 
12357 
  def read(self, iprot):
12358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12360 
      return
12361 
    iprot.readStructBegin()
12362 
    while True:
12363 
      (fname, ftype, fid) = iprot.readFieldBegin()
12364 
      if ftype == TType.STOP:
12365 
        break
12366 
      if fid == 1:
12367 
        if ftype == TType.I32:
12368 
          self.category = iprot.readI32();
12369 
        else:
12370 
          iprot.skip(ftype)
12371 
      else:
12372 
        iprot.skip(ftype)
12373 
      iprot.readFieldEnd()
12374 
    iprot.readStructEnd()
12375 
 
12376 
  def write(self, oprot):
12377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12379 
      return
12380 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
12381 
    if self.category is not None:
12382 
      oprot.writeFieldBegin('category', TType.I32, 1)
12383 
      oprot.writeI32(self.category)
12384 
      oprot.writeFieldEnd()
12385 
    oprot.writeFieldStop()
12386 
    oprot.writeStructEnd()
12387 
 
12388 
  def validate(self):
12389 
    return
12390 
 
12391 
 
12392 
  def __repr__(self):
12393 
    L = ['%s=%r' % (key, value)
12394 
      for key, value in self.__dict__.iteritems()]
12395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12396 
 
12397 
  def __eq__(self, other):
12398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12399 
 
12400 
  def __ne__(self, other):
12401 
    return not (self == other)
12402 
 
12403 
class getTransactionsRequiringExtraProcessing_result:
12404 
  """
12405 
  Attributes:
12406 
   - success
12407 
  """
12408 
 
12409 
  thrift_spec = (
12410 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12411 
  )
12412 
 
12413 
  def __init__(self, success=None,):
12414 
    self.success = success
12415 
 
12416 
  def read(self, iprot):
12417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12419 
      return
12420 
    iprot.readStructBegin()
12421 
    while True:
12422 
      (fname, ftype, fid) = iprot.readFieldBegin()
12423 
      if ftype == TType.STOP:
12424 
        break
12425 
      if fid == 0:
12426 
        if ftype == TType.LIST:
12427 
          self.success = []
4133 chandransh 12428 
          (_etype234, _size231) = iprot.readListBegin()
12429 
          for _i235 in xrange(_size231):
12430 
            _elem236 = iprot.readI64();
12431 
            self.success.append(_elem236)
4008 mandeep.dh 12432 
          iprot.readListEnd()
12433 
        else:
12434 
          iprot.skip(ftype)
12435 
      else:
12436 
        iprot.skip(ftype)
12437 
      iprot.readFieldEnd()
12438 
    iprot.readStructEnd()
12439 
 
12440 
  def write(self, oprot):
12441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12443 
      return
12444 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
12445 
    if self.success is not None:
12446 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12447 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 12448 
      for iter237 in self.success:
12449 
        oprot.writeI64(iter237)
4008 mandeep.dh 12450 
      oprot.writeListEnd()
12451 
      oprot.writeFieldEnd()
12452 
    oprot.writeFieldStop()
12453 
    oprot.writeStructEnd()
12454 
 
12455 
  def validate(self):
12456 
    return
12457 
 
12458 
 
12459 
  def __repr__(self):
12460 
    L = ['%s=%r' % (key, value)
12461 
      for key, value in self.__dict__.iteritems()]
12462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12463 
 
12464 
  def __eq__(self, other):
12465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12466 
 
12467 
  def __ne__(self, other):
12468 
    return not (self == other)
12469 
 
12470 
class markTransactionAsProcessed_args:
12471 
  """
12472 
  Attributes:
12473 
   - transactionId
12474 
   - category
12475 
  """
12476 
 
12477 
  thrift_spec = (
12478 
    None, # 0
12479 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12480 
    (2, TType.I32, 'category', None, None, ), # 2
12481 
  )
12482 
 
12483 
  def __init__(self, transactionId=None, category=None,):
12484 
    self.transactionId = transactionId
12485 
    self.category = category
12486 
 
12487 
  def read(self, iprot):
12488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12490 
      return
12491 
    iprot.readStructBegin()
12492 
    while True:
12493 
      (fname, ftype, fid) = iprot.readFieldBegin()
12494 
      if ftype == TType.STOP:
12495 
        break
12496 
      if fid == 1:
12497 
        if ftype == TType.I64:
12498 
          self.transactionId = iprot.readI64();
12499 
        else:
12500 
          iprot.skip(ftype)
12501 
      elif fid == 2:
12502 
        if ftype == TType.I32:
12503 
          self.category = iprot.readI32();
12504 
        else:
12505 
          iprot.skip(ftype)
12506 
      else:
12507 
        iprot.skip(ftype)
12508 
      iprot.readFieldEnd()
12509 
    iprot.readStructEnd()
12510 
 
12511 
  def write(self, oprot):
12512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12514 
      return
12515 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
12516 
    if self.transactionId is not None:
12517 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12518 
      oprot.writeI64(self.transactionId)
12519 
      oprot.writeFieldEnd()
12520 
    if self.category is not None:
12521 
      oprot.writeFieldBegin('category', TType.I32, 2)
12522 
      oprot.writeI32(self.category)
12523 
      oprot.writeFieldEnd()
12524 
    oprot.writeFieldStop()
12525 
    oprot.writeStructEnd()
12526 
 
12527 
  def validate(self):
12528 
    return
12529 
 
12530 
 
12531 
  def __repr__(self):
12532 
    L = ['%s=%r' % (key, value)
12533 
      for key, value in self.__dict__.iteritems()]
12534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12535 
 
12536 
  def __eq__(self, other):
12537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12538 
 
12539 
  def __ne__(self, other):
12540 
    return not (self == other)
12541 
 
12542 
class markTransactionAsProcessed_result:
12543 
 
12544 
  thrift_spec = (
12545 
  )
12546 
 
12547 
  def read(self, iprot):
12548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12550 
      return
12551 
    iprot.readStructBegin()
12552 
    while True:
12553 
      (fname, ftype, fid) = iprot.readFieldBegin()
12554 
      if ftype == TType.STOP:
12555 
        break
12556 
      else:
12557 
        iprot.skip(ftype)
12558 
      iprot.readFieldEnd()
12559 
    iprot.readStructEnd()
12560 
 
12561 
  def write(self, oprot):
12562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12564 
      return
12565 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
12566 
    oprot.writeFieldStop()
12567 
    oprot.writeStructEnd()
12568 
 
12569 
  def validate(self):
12570 
    return
12571 
 
12572 
 
12573 
  def __repr__(self):
12574 
    L = ['%s=%r' % (key, value)
12575 
      for key, value in self.__dict__.iteritems()]
12576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12577 
 
12578 
  def __eq__(self, other):
12579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12580 
 
12581 
  def __ne__(self, other):
12582 
    return not (self == other)
4018 chandransh 12583 
 
12584 
class getItemWiseRiskyOrdersCount_args:
12585 
 
12586 
  thrift_spec = (
12587 
  )
12588 
 
12589 
  def read(self, iprot):
12590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12592 
      return
12593 
    iprot.readStructBegin()
12594 
    while True:
12595 
      (fname, ftype, fid) = iprot.readFieldBegin()
12596 
      if ftype == TType.STOP:
12597 
        break
12598 
      else:
12599 
        iprot.skip(ftype)
12600 
      iprot.readFieldEnd()
12601 
    iprot.readStructEnd()
12602 
 
12603 
  def write(self, oprot):
12604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12606 
      return
12607 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
12608 
    oprot.writeFieldStop()
12609 
    oprot.writeStructEnd()
12610 
 
12611 
  def validate(self):
12612 
    return
12613 
 
12614 
 
12615 
  def __repr__(self):
12616 
    L = ['%s=%r' % (key, value)
12617 
      for key, value in self.__dict__.iteritems()]
12618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12619 
 
12620 
  def __eq__(self, other):
12621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12622 
 
12623 
  def __ne__(self, other):
12624 
    return not (self == other)
12625 
 
12626 
class getItemWiseRiskyOrdersCount_result:
12627 
  """
12628 
  Attributes:
12629 
   - success
12630 
  """
12631 
 
12632 
  thrift_spec = (
12633 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
12634 
  )
12635 
 
12636 
  def __init__(self, success=None,):
12637 
    self.success = success
12638 
 
12639 
  def read(self, iprot):
12640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12642 
      return
12643 
    iprot.readStructBegin()
12644 
    while True:
12645 
      (fname, ftype, fid) = iprot.readFieldBegin()
12646 
      if ftype == TType.STOP:
12647 
        break
12648 
      if fid == 0:
12649 
        if ftype == TType.MAP:
12650 
          self.success = {}
4133 chandransh 12651 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
12652 
          for _i242 in xrange(_size238):
12653 
            _key243 = iprot.readI64();
12654 
            _val244 = iprot.readI64();
12655 
            self.success[_key243] = _val244
4018 chandransh 12656 
          iprot.readMapEnd()
12657 
        else:
12658 
          iprot.skip(ftype)
12659 
      else:
12660 
        iprot.skip(ftype)
12661 
      iprot.readFieldEnd()
12662 
    iprot.readStructEnd()
12663 
 
12664 
  def write(self, oprot):
12665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12667 
      return
12668 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
12669 
    if self.success is not None:
12670 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12671 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 12672 
      for kiter245,viter246 in self.success.items():
12673 
        oprot.writeI64(kiter245)
12674 
        oprot.writeI64(viter246)
4018 chandransh 12675 
      oprot.writeMapEnd()
12676 
      oprot.writeFieldEnd()
12677 
    oprot.writeFieldStop()
12678 
    oprot.writeStructEnd()
12679 
 
12680 
  def validate(self):
12681 
    return
12682 
 
12683 
 
12684 
  def __repr__(self):
12685 
    L = ['%s=%r' % (key, value)
12686 
      for key, value in self.__dict__.iteritems()]
12687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12688 
 
12689 
  def __eq__(self, other):
12690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12691 
 
12692 
  def __ne__(self, other):
12693 
    return not (self == other)
4247 rajveer 12694 
 
12695 
class markOrderCancellationRequestReceived_args:
12696 
  """
12697 
  Attributes:
12698 
   - orderId
12699 
  """
12700 
 
12701 
  thrift_spec = (
12702 
    None, # 0
12703 
    (1, TType.I64, 'orderId', None, None, ), # 1
12704 
  )
12705 
 
12706 
  def __init__(self, orderId=None,):
12707 
    self.orderId = orderId
12708 
 
12709 
  def read(self, iprot):
12710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12712 
      return
12713 
    iprot.readStructBegin()
12714 
    while True:
12715 
      (fname, ftype, fid) = iprot.readFieldBegin()
12716 
      if ftype == TType.STOP:
12717 
        break
12718 
      if fid == 1:
12719 
        if ftype == TType.I64:
12720 
          self.orderId = iprot.readI64();
12721 
        else:
12722 
          iprot.skip(ftype)
12723 
      else:
12724 
        iprot.skip(ftype)
12725 
      iprot.readFieldEnd()
12726 
    iprot.readStructEnd()
12727 
 
12728 
  def write(self, oprot):
12729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12731 
      return
12732 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
12733 
    if self.orderId is not None:
12734 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12735 
      oprot.writeI64(self.orderId)
12736 
      oprot.writeFieldEnd()
12737 
    oprot.writeFieldStop()
12738 
    oprot.writeStructEnd()
12739 
 
12740 
  def validate(self):
12741 
    return
12742 
 
12743 
 
12744 
  def __repr__(self):
12745 
    L = ['%s=%r' % (key, value)
12746 
      for key, value in self.__dict__.iteritems()]
12747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12748 
 
12749 
  def __eq__(self, other):
12750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12751 
 
12752 
  def __ne__(self, other):
12753 
    return not (self == other)
12754 
 
12755 
class markOrderCancellationRequestReceived_result:
12756 
  """
12757 
  Attributes:
12758 
   - ex
12759 
  """
12760 
 
12761 
  thrift_spec = (
12762 
    None, # 0
12763 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12764 
  )
12765 
 
12766 
  def __init__(self, ex=None,):
12767 
    self.ex = ex
12768 
 
12769 
  def read(self, iprot):
12770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12772 
      return
12773 
    iprot.readStructBegin()
12774 
    while True:
12775 
      (fname, ftype, fid) = iprot.readFieldBegin()
12776 
      if ftype == TType.STOP:
12777 
        break
12778 
      if fid == 1:
12779 
        if ftype == TType.STRUCT:
12780 
          self.ex = TransactionServiceException()
12781 
          self.ex.read(iprot)
12782 
        else:
12783 
          iprot.skip(ftype)
12784 
      else:
12785 
        iprot.skip(ftype)
12786 
      iprot.readFieldEnd()
12787 
    iprot.readStructEnd()
12788 
 
12789 
  def write(self, oprot):
12790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12792 
      return
12793 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
12794 
    if self.ex is not None:
12795 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12796 
      self.ex.write(oprot)
12797 
      oprot.writeFieldEnd()
12798 
    oprot.writeFieldStop()
12799 
    oprot.writeStructEnd()
12800 
 
12801 
  def validate(self):
12802 
    return
12803 
 
12804 
 
12805 
  def __repr__(self):
12806 
    L = ['%s=%r' % (key, value)
12807 
      for key, value in self.__dict__.iteritems()]
12808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12809 
 
12810 
  def __eq__(self, other):
12811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12812 
 
12813 
  def __ne__(self, other):
12814 
    return not (self == other)
12815 
 
12816 
class markOrderCancellationRequestConfirmed_args:
12817 
  """
12818 
  Attributes:
12819 
   - orderId
12820 
  """
12821 
 
12822 
  thrift_spec = (
12823 
    None, # 0
12824 
    (1, TType.I64, 'orderId', None, None, ), # 1
12825 
  )
12826 
 
12827 
  def __init__(self, orderId=None,):
12828 
    self.orderId = orderId
12829 
 
12830 
  def read(self, iprot):
12831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12833 
      return
12834 
    iprot.readStructBegin()
12835 
    while True:
12836 
      (fname, ftype, fid) = iprot.readFieldBegin()
12837 
      if ftype == TType.STOP:
12838 
        break
12839 
      if fid == 1:
12840 
        if ftype == TType.I64:
12841 
          self.orderId = iprot.readI64();
12842 
        else:
12843 
          iprot.skip(ftype)
12844 
      else:
12845 
        iprot.skip(ftype)
12846 
      iprot.readFieldEnd()
12847 
    iprot.readStructEnd()
12848 
 
12849 
  def write(self, oprot):
12850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12852 
      return
12853 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
12854 
    if self.orderId is not None:
12855 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12856 
      oprot.writeI64(self.orderId)
12857 
      oprot.writeFieldEnd()
12858 
    oprot.writeFieldStop()
12859 
    oprot.writeStructEnd()
12860 
 
12861 
  def validate(self):
12862 
    return
12863 
 
12864 
 
12865 
  def __repr__(self):
12866 
    L = ['%s=%r' % (key, value)
12867 
      for key, value in self.__dict__.iteritems()]
12868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12869 
 
12870 
  def __eq__(self, other):
12871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12872 
 
12873 
  def __ne__(self, other):
12874 
    return not (self == other)
12875 
 
12876 
class markOrderCancellationRequestConfirmed_result:
12877 
  """
12878 
  Attributes:
12879 
   - ex
12880 
  """
12881 
 
12882 
  thrift_spec = (
12883 
    None, # 0
12884 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12885 
  )
12886 
 
12887 
  def __init__(self, ex=None,):
12888 
    self.ex = ex
12889 
 
12890 
  def read(self, iprot):
12891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12893 
      return
12894 
    iprot.readStructBegin()
12895 
    while True:
12896 
      (fname, ftype, fid) = iprot.readFieldBegin()
12897 
      if ftype == TType.STOP:
12898 
        break
12899 
      if fid == 1:
12900 
        if ftype == TType.STRUCT:
12901 
          self.ex = TransactionServiceException()
12902 
          self.ex.read(iprot)
12903 
        else:
12904 
          iprot.skip(ftype)
12905 
      else:
12906 
        iprot.skip(ftype)
12907 
      iprot.readFieldEnd()
12908 
    iprot.readStructEnd()
12909 
 
12910 
  def write(self, oprot):
12911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12913 
      return
12914 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
12915 
    if self.ex is not None:
12916 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12917 
      self.ex.write(oprot)
12918 
      oprot.writeFieldEnd()
12919 
    oprot.writeFieldStop()
12920 
    oprot.writeStructEnd()
12921 
 
12922 
  def validate(self):
12923 
    return
12924 
 
12925 
 
12926 
  def __repr__(self):
12927 
    L = ['%s=%r' % (key, value)
12928 
      for key, value in self.__dict__.iteritems()]
12929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12930 
 
12931 
  def __eq__(self, other):
12932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12933 
 
12934 
  def __ne__(self, other):
12935 
    return not (self == other)
12936 
 
12937 
class markOrderCancellationRequestDenied_args:
12938 
  """
12939 
  Attributes:
12940 
   - orderId
12941 
  """
12942 
 
12943 
  thrift_spec = (
12944 
    None, # 0
12945 
    (1, TType.I64, 'orderId', None, None, ), # 1
12946 
  )
12947 
 
12948 
  def __init__(self, orderId=None,):
12949 
    self.orderId = orderId
12950 
 
12951 
  def read(self, iprot):
12952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12954 
      return
12955 
    iprot.readStructBegin()
12956 
    while True:
12957 
      (fname, ftype, fid) = iprot.readFieldBegin()
12958 
      if ftype == TType.STOP:
12959 
        break
12960 
      if fid == 1:
12961 
        if ftype == TType.I64:
12962 
          self.orderId = iprot.readI64();
12963 
        else:
12964 
          iprot.skip(ftype)
12965 
      else:
12966 
        iprot.skip(ftype)
12967 
      iprot.readFieldEnd()
12968 
    iprot.readStructEnd()
12969 
 
12970 
  def write(self, oprot):
12971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12973 
      return
12974 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
12975 
    if self.orderId is not None:
12976 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12977 
      oprot.writeI64(self.orderId)
12978 
      oprot.writeFieldEnd()
12979 
    oprot.writeFieldStop()
12980 
    oprot.writeStructEnd()
12981 
 
12982 
  def validate(self):
12983 
    return
12984 
 
12985 
 
12986 
  def __repr__(self):
12987 
    L = ['%s=%r' % (key, value)
12988 
      for key, value in self.__dict__.iteritems()]
12989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12990 
 
12991 
  def __eq__(self, other):
12992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12993 
 
12994 
  def __ne__(self, other):
12995 
    return not (self == other)
12996 
 
12997 
class markOrderCancellationRequestDenied_result:
12998 
  """
12999 
  Attributes:
13000 
   - ex
13001 
  """
13002 
 
13003 
  thrift_spec = (
13004 
    None, # 0
13005 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13006 
  )
13007 
 
13008 
  def __init__(self, ex=None,):
13009 
    self.ex = ex
13010 
 
13011 
  def read(self, iprot):
13012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13014 
      return
13015 
    iprot.readStructBegin()
13016 
    while True:
13017 
      (fname, ftype, fid) = iprot.readFieldBegin()
13018 
      if ftype == TType.STOP:
13019 
        break
13020 
      if fid == 1:
13021 
        if ftype == TType.STRUCT:
13022 
          self.ex = TransactionServiceException()
13023 
          self.ex.read(iprot)
13024 
        else:
13025 
          iprot.skip(ftype)
13026 
      else:
13027 
        iprot.skip(ftype)
13028 
      iprot.readFieldEnd()
13029 
    iprot.readStructEnd()
13030 
 
13031 
  def write(self, oprot):
13032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13034 
      return
13035 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
13036 
    if self.ex is not None:
13037 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13038 
      self.ex.write(oprot)
13039 
      oprot.writeFieldEnd()
13040 
    oprot.writeFieldStop()
13041 
    oprot.writeStructEnd()
13042 
 
13043 
  def validate(self):
13044 
    return
13045 
 
13046 
 
13047 
  def __repr__(self):
13048 
    L = ['%s=%r' % (key, value)
13049 
      for key, value in self.__dict__.iteritems()]
13050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13051 
 
13052 
  def __eq__(self, other):
13053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13054 
 
13055 
  def __ne__(self, other):
13056 
    return not (self == other)
13057 
 
4258 rajveer 13058 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 13059 
  """
13060 
  Attributes:
4258 rajveer 13061 
   - transactionId
4247 rajveer 13062 
  """
13063 
 
13064 
  thrift_spec = (
13065 
    None, # 0
4258 rajveer 13066 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 13067 
  )
13068 
 
4258 rajveer 13069 
  def __init__(self, transactionId=None,):
13070 
    self.transactionId = transactionId
4247 rajveer 13071 
 
13072 
  def read(self, iprot):
13073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13075 
      return
13076 
    iprot.readStructBegin()
13077 
    while True:
13078 
      (fname, ftype, fid) = iprot.readFieldBegin()
13079 
      if ftype == TType.STOP:
13080 
        break
13081 
      if fid == 1:
13082 
        if ftype == TType.I64:
4258 rajveer 13083 
          self.transactionId = iprot.readI64();
4247 rajveer 13084 
        else:
13085 
          iprot.skip(ftype)
13086 
      else:
13087 
        iprot.skip(ftype)
13088 
      iprot.readFieldEnd()
13089 
    iprot.readStructEnd()
13090 
 
13091 
  def write(self, oprot):
13092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13094 
      return
4258 rajveer 13095 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
13096 
    if self.transactionId is not None:
13097 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13098 
      oprot.writeI64(self.transactionId)
4247 rajveer 13099 
      oprot.writeFieldEnd()
13100 
    oprot.writeFieldStop()
13101 
    oprot.writeStructEnd()
13102 
 
13103 
  def validate(self):
13104 
    return
13105 
 
13106 
 
13107 
  def __repr__(self):
13108 
    L = ['%s=%r' % (key, value)
13109 
      for key, value in self.__dict__.iteritems()]
13110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13111 
 
13112 
  def __eq__(self, other):
13113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13114 
 
13115 
  def __ne__(self, other):
13116 
    return not (self == other)
13117 
 
4258 rajveer 13118 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 13119 
  """
13120 
  Attributes:
13121 
   - ex
13122 
  """
13123 
 
13124 
  thrift_spec = (
13125 
    None, # 0
13126 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13127 
  )
13128 
 
13129 
  def __init__(self, ex=None,):
13130 
    self.ex = ex
13131 
 
13132 
  def read(self, iprot):
13133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13135 
      return
13136 
    iprot.readStructBegin()
13137 
    while True:
13138 
      (fname, ftype, fid) = iprot.readFieldBegin()
13139 
      if ftype == TType.STOP:
13140 
        break
13141 
      if fid == 1:
13142 
        if ftype == TType.STRUCT:
13143 
          self.ex = TransactionServiceException()
13144 
          self.ex.read(iprot)
13145 
        else:
13146 
          iprot.skip(ftype)
13147 
      else:
13148 
        iprot.skip(ftype)
13149 
      iprot.readFieldEnd()
13150 
    iprot.readStructEnd()
13151 
 
13152 
  def write(self, oprot):
13153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13155 
      return
4258 rajveer 13156 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 13157 
    if self.ex is not None:
13158 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13159 
      self.ex.write(oprot)
13160 
      oprot.writeFieldEnd()
13161 
    oprot.writeFieldStop()
13162 
    oprot.writeStructEnd()
13163 
 
13164 
  def validate(self):
13165 
    return
13166 
 
13167 
 
13168 
  def __repr__(self):
13169 
    L = ['%s=%r' % (key, value)
13170 
      for key, value in self.__dict__.iteritems()]
13171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13172 
 
13173 
  def __eq__(self, other):
13174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13175 
 
13176 
  def __ne__(self, other):
13177 
    return not (self == other)
4259 anupam.sin 13178 
 
13179 
class refundTransaction_args:
13180 
  """
13181 
  Attributes:
13182 
   - transactionId
13183 
   - refundedBy
13184 
   - reason
13185 
  """
13186 
 
13187 
  thrift_spec = (
13188 
    None, # 0
13189 
    (1, TType.I64, 'transactionId', None, None, ), # 1
13190 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13191 
    (3, TType.STRING, 'reason', None, None, ), # 3
13192 
  )
13193 
 
13194 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
13195 
    self.transactionId = transactionId
13196 
    self.refundedBy = refundedBy
13197 
    self.reason = reason
13198 
 
13199 
  def read(self, iprot):
13200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13202 
      return
13203 
    iprot.readStructBegin()
13204 
    while True:
13205 
      (fname, ftype, fid) = iprot.readFieldBegin()
13206 
      if ftype == TType.STOP:
13207 
        break
13208 
      if fid == 1:
13209 
        if ftype == TType.I64:
13210 
          self.transactionId = iprot.readI64();
13211 
        else:
13212 
          iprot.skip(ftype)
13213 
      elif fid == 2:
13214 
        if ftype == TType.STRING:
13215 
          self.refundedBy = iprot.readString();
13216 
        else:
13217 
          iprot.skip(ftype)
13218 
      elif fid == 3:
13219 
        if ftype == TType.STRING:
13220 
          self.reason = iprot.readString();
13221 
        else:
13222 
          iprot.skip(ftype)
13223 
      else:
13224 
        iprot.skip(ftype)
13225 
      iprot.readFieldEnd()
13226 
    iprot.readStructEnd()
13227 
 
13228 
  def write(self, oprot):
13229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13231 
      return
13232 
    oprot.writeStructBegin('refundTransaction_args')
13233 
    if self.transactionId is not None:
13234 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13235 
      oprot.writeI64(self.transactionId)
13236 
      oprot.writeFieldEnd()
13237 
    if self.refundedBy is not None:
13238 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13239 
      oprot.writeString(self.refundedBy)
13240 
      oprot.writeFieldEnd()
13241 
    if self.reason is not None:
13242 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13243 
      oprot.writeString(self.reason)
13244 
      oprot.writeFieldEnd()
13245 
    oprot.writeFieldStop()
13246 
    oprot.writeStructEnd()
13247 
 
13248 
  def validate(self):
13249 
    return
13250 
 
13251 
 
13252 
  def __repr__(self):
13253 
    L = ['%s=%r' % (key, value)
13254 
      for key, value in self.__dict__.iteritems()]
13255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13256 
 
13257 
  def __eq__(self, other):
13258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13259 
 
13260 
  def __ne__(self, other):
13261 
    return not (self == other)
13262 
 
13263 
class refundTransaction_result:
13264 
  """
13265 
  Attributes:
13266 
   - ex
13267 
  """
13268 
 
13269 
  thrift_spec = (
13270 
    None, # 0
13271 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13272 
  )
13273 
 
13274 
  def __init__(self, ex=None,):
13275 
    self.ex = ex
13276 
 
13277 
  def read(self, iprot):
13278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13280 
      return
13281 
    iprot.readStructBegin()
13282 
    while True:
13283 
      (fname, ftype, fid) = iprot.readFieldBegin()
13284 
      if ftype == TType.STOP:
13285 
        break
13286 
      if fid == 1:
13287 
        if ftype == TType.STRUCT:
13288 
          self.ex = TransactionServiceException()
13289 
          self.ex.read(iprot)
13290 
        else:
13291 
          iprot.skip(ftype)
13292 
      else:
13293 
        iprot.skip(ftype)
13294 
      iprot.readFieldEnd()
13295 
    iprot.readStructEnd()
13296 
 
13297 
  def write(self, oprot):
13298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13300 
      return
13301 
    oprot.writeStructBegin('refundTransaction_result')
13302 
    if self.ex is not None:
13303 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13304 
      self.ex.write(oprot)
13305 
      oprot.writeFieldEnd()
13306 
    oprot.writeFieldStop()
13307 
    oprot.writeStructEnd()
13308 
 
13309 
  def validate(self):
13310 
    return
13311 
 
13312 
 
13313 
  def __repr__(self):
13314 
    L = ['%s=%r' % (key, value)
13315 
      for key, value in self.__dict__.iteritems()]
13316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13317 
 
13318 
  def __eq__(self, other):
13319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13320 
 
13321 
  def __ne__(self, other):
13322 
    return not (self == other)