Subversion Repositories SmartDukaan

Rev

Rev 4247 | Rev 4259 | 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 
 
719 
 
3376 rajveer 720 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 721 
  def __init__(self, iprot, oprot=None):
3376 rajveer 722 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 723 
 
724 
  def createTransaction(self, transaction):
725 
    """
726 
    Parameters:
727 
     - transaction
728 
    """
729 
    self.send_createTransaction(transaction)
132 ashish 730 
    return self.recv_createTransaction()
94 ashish 731 
 
732 
  def send_createTransaction(self, transaction):
733 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
734 
    args = createTransaction_args()
735 
    args.transaction = transaction
736 
    args.write(self._oprot)
737 
    self._oprot.writeMessageEnd()
738 
    self._oprot.trans.flush()
739 
 
740 
  def recv_createTransaction(self, ):
741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
742 
    if mtype == TMessageType.EXCEPTION:
743 
      x = TApplicationException()
744 
      x.read(self._iprot)
745 
      self._iprot.readMessageEnd()
746 
      raise x
747 
    result = createTransaction_result()
748 
    result.read(self._iprot)
749 
    self._iprot.readMessageEnd()
3431 rajveer 750 
    if result.success is not None:
132 ashish 751 
      return result.success
3431 rajveer 752 
    if result.ex is not None:
94 ashish 753 
      raise result.ex
132 ashish 754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 755 
 
756 
  def getTransaction(self, id):
757 
    """
758 
    Parameters:
759 
     - id
760 
    """
761 
    self.send_getTransaction(id)
762 
    return self.recv_getTransaction()
763 
 
764 
  def send_getTransaction(self, id):
765 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
766 
    args = getTransaction_args()
767 
    args.id = id
768 
    args.write(self._oprot)
769 
    self._oprot.writeMessageEnd()
770 
    self._oprot.trans.flush()
771 
 
772 
  def recv_getTransaction(self, ):
773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
774 
    if mtype == TMessageType.EXCEPTION:
775 
      x = TApplicationException()
776 
      x.read(self._iprot)
777 
      self._iprot.readMessageEnd()
778 
      raise x
779 
    result = getTransaction_result()
780 
    result.read(self._iprot)
781 
    self._iprot.readMessageEnd()
3431 rajveer 782 
    if result.success is not None:
94 ashish 783 
      return result.success
3431 rajveer 784 
    if result.ex is not None:
94 ashish 785 
      raise result.ex
786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
787 
 
788 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
789 
    """
790 
    Parameters:
791 
     - customerId
792 
     - from_date
793 
     - to_date
794 
     - status
795 
    """
796 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
797 
    return self.recv_getTransactionsForCustomer()
798 
 
799 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
800 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
801 
    args = getTransactionsForCustomer_args()
802 
    args.customerId = customerId
803 
    args.from_date = from_date
804 
    args.to_date = to_date
805 
    args.status = status
806 
    args.write(self._oprot)
807 
    self._oprot.writeMessageEnd()
808 
    self._oprot.trans.flush()
809 
 
810 
  def recv_getTransactionsForCustomer(self, ):
811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
812 
    if mtype == TMessageType.EXCEPTION:
813 
      x = TApplicationException()
814 
      x.read(self._iprot)
815 
      self._iprot.readMessageEnd()
816 
      raise x
817 
    result = getTransactionsForCustomer_result()
818 
    result.read(self._iprot)
819 
    self._iprot.readMessageEnd()
3431 rajveer 820 
    if result.success is not None:
94 ashish 821 
      return result.success
3431 rajveer 822 
    if result.ex is not None:
94 ashish 823 
      raise result.ex
824 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
825 
 
132 ashish 826 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
827 
    """
828 
    Parameters:
829 
     - shoppingCartId
830 
    """
831 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
832 
    return self.recv_getTransactionsForShoppingCartId()
833 
 
834 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
835 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
836 
    args = getTransactionsForShoppingCartId_args()
837 
    args.shoppingCartId = shoppingCartId
838 
    args.write(self._oprot)
839 
    self._oprot.writeMessageEnd()
840 
    self._oprot.trans.flush()
841 
 
842 
  def recv_getTransactionsForShoppingCartId(self, ):
843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
844 
    if mtype == TMessageType.EXCEPTION:
845 
      x = TApplicationException()
846 
      x.read(self._iprot)
847 
      self._iprot.readMessageEnd()
848 
      raise x
849 
    result = getTransactionsForShoppingCartId_result()
850 
    result.read(self._iprot)
851 
    self._iprot.readMessageEnd()
3431 rajveer 852 
    if result.success is not None:
132 ashish 853 
      return result.success
3431 rajveer 854 
    if result.ex is not None:
132 ashish 855 
      raise result.ex
856 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
857 
 
94 ashish 858 
  def getTransactionStatus(self, transactionId):
859 
    """
860 
    Parameters:
861 
     - transactionId
862 
    """
863 
    self.send_getTransactionStatus(transactionId)
864 
    return self.recv_getTransactionStatus()
865 
 
866 
  def send_getTransactionStatus(self, transactionId):
867 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
868 
    args = getTransactionStatus_args()
869 
    args.transactionId = transactionId
870 
    args.write(self._oprot)
871 
    self._oprot.writeMessageEnd()
872 
    self._oprot.trans.flush()
873 
 
874 
  def recv_getTransactionStatus(self, ):
875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
876 
    if mtype == TMessageType.EXCEPTION:
877 
      x = TApplicationException()
878 
      x.read(self._iprot)
879 
      self._iprot.readMessageEnd()
880 
      raise x
881 
    result = getTransactionStatus_result()
882 
    result.read(self._iprot)
883 
    self._iprot.readMessageEnd()
3431 rajveer 884 
    if result.success is not None:
94 ashish 885 
      return result.success
3431 rajveer 886 
    if result.ex is not None:
94 ashish 887 
      raise result.ex
888 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
889 
 
890 
  def changeTransactionStatus(self, transactionId, status, description):
891 
    """
892 
    Parameters:
893 
     - transactionId
894 
     - status
895 
     - description
896 
    """
897 
    self.send_changeTransactionStatus(transactionId, status, description)
898 
    return self.recv_changeTransactionStatus()
899 
 
900 
  def send_changeTransactionStatus(self, transactionId, status, description):
901 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
902 
    args = changeTransactionStatus_args()
903 
    args.transactionId = transactionId
904 
    args.status = status
905 
    args.description = description
906 
    args.write(self._oprot)
907 
    self._oprot.writeMessageEnd()
908 
    self._oprot.trans.flush()
909 
 
910 
  def recv_changeTransactionStatus(self, ):
911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
912 
    if mtype == TMessageType.EXCEPTION:
913 
      x = TApplicationException()
914 
      x.read(self._iprot)
915 
      self._iprot.readMessageEnd()
916 
      raise x
917 
    result = changeTransactionStatus_result()
918 
    result.read(self._iprot)
919 
    self._iprot.readMessageEnd()
3431 rajveer 920 
    if result.success is not None:
94 ashish 921 
      return result.success
3431 rajveer 922 
    if result.ex is not None:
94 ashish 923 
      raise result.ex
924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
925 
 
1398 varun.gupt 926 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 927 
    """
928 
    Parameters:
929 
     - transactionId
930 
    """
1398 varun.gupt 931 
    self.send_enqueueTransactionInfoEmail(transactionId)
932 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 933 
 
1398 varun.gupt 934 
  def send_enqueueTransactionInfoEmail(self, transactionId):
935 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
936 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 937 
    args.transactionId = transactionId
938 
    args.write(self._oprot)
939 
    self._oprot.writeMessageEnd()
940 
    self._oprot.trans.flush()
941 
 
1398 varun.gupt 942 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
944 
    if mtype == TMessageType.EXCEPTION:
945 
      x = TApplicationException()
946 
      x.read(self._iprot)
947 
      self._iprot.readMessageEnd()
948 
      raise x
1398 varun.gupt 949 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 950 
    result.read(self._iprot)
951 
    self._iprot.readMessageEnd()
3431 rajveer 952 
    if result.success is not None:
1382 varun.gupt 953 
      return result.success
3431 rajveer 954 
    if result.ex is not None:
1382 varun.gupt 955 
      raise result.ex
1398 varun.gupt 956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 957 
 
483 rajveer 958 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 959 
    """
960 
    Parameters:
483 rajveer 961 
     - status
962 
     - from_date
963 
     - to_date
964 
     - warehouse_id
94 ashish 965 
    """
483 rajveer 966 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
967 
    return self.recv_getAllOrders()
94 ashish 968 
 
483 rajveer 969 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
970 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
971 
    args = getAllOrders_args()
972 
    args.status = status
973 
    args.from_date = from_date
974 
    args.to_date = to_date
975 
    args.warehouse_id = warehouse_id
94 ashish 976 
    args.write(self._oprot)
977 
    self._oprot.writeMessageEnd()
978 
    self._oprot.trans.flush()
979 
 
483 rajveer 980 
  def recv_getAllOrders(self, ):
94 ashish 981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
982 
    if mtype == TMessageType.EXCEPTION:
983 
      x = TApplicationException()
984 
      x.read(self._iprot)
985 
      self._iprot.readMessageEnd()
986 
      raise x
483 rajveer 987 
    result = getAllOrders_result()
94 ashish 988 
    result.read(self._iprot)
989 
    self._iprot.readMessageEnd()
3431 rajveer 990 
    if result.success is not None:
94 ashish 991 
      return result.success
3431 rajveer 992 
    if result.ex is not None:
94 ashish 993 
      raise result.ex
483 rajveer 994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 995 
 
4133 chandransh 996 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
997 
    """
998 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
999 
    Pass the status as null and the limit as 0 to ignore them.
1000 
 
1001 
    Parameters:
1002 
     - statuses
1003 
     - offset
1004 
     - limit
1005 
     - warehouse_id
1006 
    """
1007 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1008 
    return self.recv_getOrdersInBatch()
1009 
 
1010 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1011 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1012 
    args = getOrdersInBatch_args()
1013 
    args.statuses = statuses
1014 
    args.offset = offset
1015 
    args.limit = limit
1016 
    args.warehouse_id = warehouse_id
1017 
    args.write(self._oprot)
1018 
    self._oprot.writeMessageEnd()
1019 
    self._oprot.trans.flush()
1020 
 
1021 
  def recv_getOrdersInBatch(self, ):
1022 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1023 
    if mtype == TMessageType.EXCEPTION:
1024 
      x = TApplicationException()
1025 
      x.read(self._iprot)
1026 
      self._iprot.readMessageEnd()
1027 
      raise x
1028 
    result = getOrdersInBatch_result()
1029 
    result.read(self._iprot)
1030 
    self._iprot.readMessageEnd()
1031 
    if result.success is not None:
1032 
      return result.success
1033 
    if result.ex is not None:
1034 
      raise result.ex
1035 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1036 
 
1037 
  def getOrderCount(self, statuses, warehouseId):
1038 
    """
1039 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1040 
 
1041 
    Parameters:
1042 
     - statuses
1043 
     - warehouseId
1044 
    """
1045 
    self.send_getOrderCount(statuses, warehouseId)
1046 
    return self.recv_getOrderCount()
1047 
 
1048 
  def send_getOrderCount(self, statuses, warehouseId):
1049 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1050 
    args = getOrderCount_args()
1051 
    args.statuses = statuses
1052 
    args.warehouseId = warehouseId
1053 
    args.write(self._oprot)
1054 
    self._oprot.writeMessageEnd()
1055 
    self._oprot.trans.flush()
1056 
 
1057 
  def recv_getOrderCount(self, ):
1058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1059 
    if mtype == TMessageType.EXCEPTION:
1060 
      x = TApplicationException()
1061 
      x.read(self._iprot)
1062 
      self._iprot.readMessageEnd()
1063 
      raise x
1064 
    result = getOrderCount_result()
1065 
    result.read(self._iprot)
1066 
    self._iprot.readMessageEnd()
1067 
    if result.success is not None:
1068 
      return result.success
1069 
    if result.ex is not None:
1070 
      raise result.ex
1071 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1072 
 
999 varun.gupt 1073 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1074 
    """
1132 chandransh 1075 
    Returns orders within a range of their billing dates
3431 rajveer 1076 
 
999 varun.gupt 1077 
    Parameters:
1078 
     - status
1079 
     - start_billing_date
1080 
     - end_billing_date
1081 
     - warehouse_id
1082 
    """
1083 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1084 
    return self.recv_getOrdersByBillingDate()
1085 
 
1086 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1087 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1088 
    args = getOrdersByBillingDate_args()
1089 
    args.status = status
1090 
    args.start_billing_date = start_billing_date
1091 
    args.end_billing_date = end_billing_date
1092 
    args.warehouse_id = warehouse_id
1093 
    args.write(self._oprot)
1094 
    self._oprot.writeMessageEnd()
1095 
    self._oprot.trans.flush()
1096 
 
1097 
  def recv_getOrdersByBillingDate(self, ):
1098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1099 
    if mtype == TMessageType.EXCEPTION:
1100 
      x = TApplicationException()
1101 
      x.read(self._iprot)
1102 
      self._iprot.readMessageEnd()
1103 
      raise x
1104 
    result = getOrdersByBillingDate_result()
1105 
    result.read(self._iprot)
1106 
    self._iprot.readMessageEnd()
3431 rajveer 1107 
    if result.success is not None:
999 varun.gupt 1108 
      return result.success
3431 rajveer 1109 
    if result.ex is not None:
999 varun.gupt 1110 
      raise result.ex
1111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1112 
 
3451 chandransh 1113 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1114 
    """
1115 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1116 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1117 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1118 
 
3427 chandransh 1119 
    Parameters:
1120 
     - fromShippingDate
1121 
     - toShippingDate
1122 
     - providerId
1123 
     - warehouseId
3451 chandransh 1124 
     - cod
3427 chandransh 1125 
    """
3451 chandransh 1126 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1127 
    return self.recv_getOrdersByShippingDate()
1128 
 
3451 chandransh 1129 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1130 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1131 
    args = getOrdersByShippingDate_args()
1132 
    args.fromShippingDate = fromShippingDate
1133 
    args.toShippingDate = toShippingDate
1134 
    args.providerId = providerId
1135 
    args.warehouseId = warehouseId
3451 chandransh 1136 
    args.cod = cod
3427 chandransh 1137 
    args.write(self._oprot)
1138 
    self._oprot.writeMessageEnd()
1139 
    self._oprot.trans.flush()
1140 
 
1141 
  def recv_getOrdersByShippingDate(self, ):
1142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1143 
    if mtype == TMessageType.EXCEPTION:
1144 
      x = TApplicationException()
1145 
      x.read(self._iprot)
1146 
      self._iprot.readMessageEnd()
1147 
      raise x
1148 
    result = getOrdersByShippingDate_result()
1149 
    result.read(self._iprot)
1150 
    self._iprot.readMessageEnd()
3431 rajveer 1151 
    if result.success is not None:
3427 chandransh 1152 
      return result.success
3431 rajveer 1153 
    if result.ex is not None:
3427 chandransh 1154 
      raise result.ex
1155 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1156 
 
1382 varun.gupt 1157 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1158 
    """
1159 
    Returns order ids for orders which can be returned
3431 rajveer 1160 
 
1382 varun.gupt 1161 
    Parameters:
1162 
     - customer_id
1163 
     - limit
1164 
    """
1165 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1166 
    return self.recv_getReturnableOrdersForCustomer()
1167 
 
1168 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1169 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1170 
    args = getReturnableOrdersForCustomer_args()
1171 
    args.customer_id = customer_id
1172 
    args.limit = limit
1173 
    args.write(self._oprot)
1174 
    self._oprot.writeMessageEnd()
1175 
    self._oprot.trans.flush()
1176 
 
1177 
  def recv_getReturnableOrdersForCustomer(self, ):
1178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1179 
    if mtype == TMessageType.EXCEPTION:
1180 
      x = TApplicationException()
1181 
      x.read(self._iprot)
1182 
      self._iprot.readMessageEnd()
1183 
      raise x
1184 
    result = getReturnableOrdersForCustomer_result()
1185 
    result.read(self._iprot)
1186 
    self._iprot.readMessageEnd()
3431 rajveer 1187 
    if result.success is not None:
1382 varun.gupt 1188 
      return result.success
3431 rajveer 1189 
    if result.ex is not None:
1382 varun.gupt 1190 
      raise result.ex
1191 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1192 
 
1193 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1194 
    """
1195 
    Returns order ids for orders which can be cancelled
3431 rajveer 1196 
 
1382 varun.gupt 1197 
    Parameters:
1198 
     - customer_id
1199 
     - limit
1200 
    """
1201 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1202 
    return self.recv_getCancellableOrdersForCustomer()
1203 
 
1204 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1205 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1206 
    args = getCancellableOrdersForCustomer_args()
1207 
    args.customer_id = customer_id
1208 
    args.limit = limit
1209 
    args.write(self._oprot)
1210 
    self._oprot.writeMessageEnd()
1211 
    self._oprot.trans.flush()
1212 
 
1213 
  def recv_getCancellableOrdersForCustomer(self, ):
1214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1215 
    if mtype == TMessageType.EXCEPTION:
1216 
      x = TApplicationException()
1217 
      x.read(self._iprot)
1218 
      self._iprot.readMessageEnd()
1219 
      raise x
1220 
    result = getCancellableOrdersForCustomer_result()
1221 
    result.read(self._iprot)
1222 
    self._iprot.readMessageEnd()
3431 rajveer 1223 
    if result.success is not None:
1382 varun.gupt 1224 
      return result.success
3431 rajveer 1225 
    if result.ex is not None:
1382 varun.gupt 1226 
      raise result.ex
1227 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1228 
 
483 rajveer 1229 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1230 
    """
1231 
    Parameters:
483 rajveer 1232 
     - orderId
1233 
     - status
1234 
     - description
94 ashish 1235 
    """
483 rajveer 1236 
    self.send_changeOrderStatus(orderId, status, description)
1237 
    return self.recv_changeOrderStatus()
94 ashish 1238 
 
483 rajveer 1239 
  def send_changeOrderStatus(self, orderId, status, description):
1240 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1241 
    args = changeOrderStatus_args()
1242 
    args.orderId = orderId
1243 
    args.status = status
1244 
    args.description = description
94 ashish 1245 
    args.write(self._oprot)
1246 
    self._oprot.writeMessageEnd()
1247 
    self._oprot.trans.flush()
1248 
 
483 rajveer 1249 
  def recv_changeOrderStatus(self, ):
94 ashish 1250 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1251 
    if mtype == TMessageType.EXCEPTION:
1252 
      x = TApplicationException()
1253 
      x.read(self._iprot)
1254 
      self._iprot.readMessageEnd()
1255 
      raise x
483 rajveer 1256 
    result = changeOrderStatus_result()
94 ashish 1257 
    result.read(self._iprot)
1258 
    self._iprot.readMessageEnd()
3431 rajveer 1259 
    if result.success is not None:
94 ashish 1260 
      return result.success
3431 rajveer 1261 
    if result.ex is not None:
94 ashish 1262 
      raise result.ex
483 rajveer 1263 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1264 
 
1528 ankur.sing 1265 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1266 
    """
1528 ankur.sing 1267 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1268 
    only user who owns the transaction can view its order details.
3431 rajveer 1269 
 
94 ashish 1270 
    Parameters:
1271 
     - transactionId
1528 ankur.sing 1272 
     - customerId
94 ashish 1273 
    """
1528 ankur.sing 1274 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1275 
    return self.recv_getOrdersForTransaction()
94 ashish 1276 
 
1528 ankur.sing 1277 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1278 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1279 
    args = getOrdersForTransaction_args()
94 ashish 1280 
    args.transactionId = transactionId
1528 ankur.sing 1281 
    args.customerId = customerId
94 ashish 1282 
    args.write(self._oprot)
1283 
    self._oprot.writeMessageEnd()
1284 
    self._oprot.trans.flush()
1285 
 
483 rajveer 1286 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1288 
    if mtype == TMessageType.EXCEPTION:
1289 
      x = TApplicationException()
1290 
      x.read(self._iprot)
1291 
      self._iprot.readMessageEnd()
1292 
      raise x
483 rajveer 1293 
    result = getOrdersForTransaction_result()
94 ashish 1294 
    result.read(self._iprot)
1295 
    self._iprot.readMessageEnd()
3431 rajveer 1296 
    if result.success is not None:
94 ashish 1297 
      return result.success
3431 rajveer 1298 
    if result.ex is not None:
94 ashish 1299 
      raise result.ex
483 rajveer 1300 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1301 
 
3014 chandransh 1302 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1303 
    """
3014 chandransh 1304 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1305 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1306 
 
94 ashish 1307 
    Parameters:
483 rajveer 1308 
     - customerId
1309 
     - from_date
1310 
     - to_date
3014 chandransh 1311 
     - statuses
94 ashish 1312 
    """
3014 chandransh 1313 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1314 
    return self.recv_getOrdersForCustomer()
94 ashish 1315 
 
3014 chandransh 1316 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1317 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1318 
    args = getOrdersForCustomer_args()
1319 
    args.customerId = customerId
1320 
    args.from_date = from_date
1321 
    args.to_date = to_date
3014 chandransh 1322 
    args.statuses = statuses
94 ashish 1323 
    args.write(self._oprot)
1324 
    self._oprot.writeMessageEnd()
1325 
    self._oprot.trans.flush()
1326 
 
483 rajveer 1327 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1328 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1329 
    if mtype == TMessageType.EXCEPTION:
1330 
      x = TApplicationException()
1331 
      x.read(self._iprot)
1332 
      self._iprot.readMessageEnd()
1333 
      raise x
483 rajveer 1334 
    result = getOrdersForCustomer_result()
94 ashish 1335 
    result.read(self._iprot)
1336 
    self._iprot.readMessageEnd()
3431 rajveer 1337 
    if result.success is not None:
94 ashish 1338 
      return result.success
3431 rajveer 1339 
    if result.ex is not None:
94 ashish 1340 
      raise result.ex
483 rajveer 1341 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1342 
 
483 rajveer 1343 
  def createOrder(self, order):
94 ashish 1344 
    """
1345 
    Parameters:
483 rajveer 1346 
     - order
94 ashish 1347 
    """
483 rajveer 1348 
    self.send_createOrder(order)
1349 
    return self.recv_createOrder()
94 ashish 1350 
 
483 rajveer 1351 
  def send_createOrder(self, order):
1352 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1353 
    args = createOrder_args()
1354 
    args.order = order
94 ashish 1355 
    args.write(self._oprot)
1356 
    self._oprot.writeMessageEnd()
1357 
    self._oprot.trans.flush()
1358 
 
483 rajveer 1359 
  def recv_createOrder(self, ):
94 ashish 1360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1361 
    if mtype == TMessageType.EXCEPTION:
1362 
      x = TApplicationException()
1363 
      x.read(self._iprot)
1364 
      self._iprot.readMessageEnd()
1365 
      raise x
483 rajveer 1366 
    result = createOrder_result()
94 ashish 1367 
    result.read(self._iprot)
1368 
    self._iprot.readMessageEnd()
3431 rajveer 1369 
    if result.success is not None:
94 ashish 1370 
      return result.success
3431 rajveer 1371 
    if result.ex is not None:
94 ashish 1372 
      raise result.ex
483 rajveer 1373 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1374 
 
483 rajveer 1375 
  def getOrder(self, id):
94 ashish 1376 
    """
1377 
    Parameters:
483 rajveer 1378 
     - id
94 ashish 1379 
    """
483 rajveer 1380 
    self.send_getOrder(id)
1381 
    return self.recv_getOrder()
94 ashish 1382 
 
483 rajveer 1383 
  def send_getOrder(self, id):
1384 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1385 
    args = getOrder_args()
1386 
    args.id = id
94 ashish 1387 
    args.write(self._oprot)
1388 
    self._oprot.writeMessageEnd()
1389 
    self._oprot.trans.flush()
1390 
 
483 rajveer 1391 
  def recv_getOrder(self, ):
94 ashish 1392 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1393 
    if mtype == TMessageType.EXCEPTION:
1394 
      x = TApplicationException()
1395 
      x.read(self._iprot)
1396 
      self._iprot.readMessageEnd()
1397 
      raise x
483 rajveer 1398 
    result = getOrder_result()
94 ashish 1399 
    result.read(self._iprot)
1400 
    self._iprot.readMessageEnd()
3431 rajveer 1401 
    if result.success is not None:
94 ashish 1402 
      return result.success
3431 rajveer 1403 
    if result.ex is not None:
94 ashish 1404 
      raise result.ex
483 rajveer 1405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1406 
 
483 rajveer 1407 
  def getLineItemsForOrder(self, orderId):
94 ashish 1408 
    """
1409 
    Parameters:
483 rajveer 1410 
     - orderId
94 ashish 1411 
    """
483 rajveer 1412 
    self.send_getLineItemsForOrder(orderId)
1413 
    return self.recv_getLineItemsForOrder()
94 ashish 1414 
 
483 rajveer 1415 
  def send_getLineItemsForOrder(self, orderId):
1416 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1417 
    args = getLineItemsForOrder_args()
1418 
    args.orderId = orderId
94 ashish 1419 
    args.write(self._oprot)
1420 
    self._oprot.writeMessageEnd()
1421 
    self._oprot.trans.flush()
1422 
 
483 rajveer 1423 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1425 
    if mtype == TMessageType.EXCEPTION:
1426 
      x = TApplicationException()
1427 
      x.read(self._iprot)
1428 
      self._iprot.readMessageEnd()
1429 
      raise x
483 rajveer 1430 
    result = getLineItemsForOrder_result()
94 ashish 1431 
    result.read(self._iprot)
1432 
    self._iprot.readMessageEnd()
3431 rajveer 1433 
    if result.success is not None:
94 ashish 1434 
      return result.success
3431 rajveer 1435 
    if result.ex is not None:
94 ashish 1436 
      raise result.ex
483 rajveer 1437 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1438 
 
1528 ankur.sing 1439 
  def getOrderForCustomer(self, orderId, customerId):
1440 
    """
1441 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1442 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1443 
 
1528 ankur.sing 1444 
    Parameters:
1445 
     - orderId
1446 
     - customerId
1447 
    """
1448 
    self.send_getOrderForCustomer(orderId, customerId)
1449 
    return self.recv_getOrderForCustomer()
1450 
 
1451 
  def send_getOrderForCustomer(self, orderId, customerId):
1452 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1453 
    args = getOrderForCustomer_args()
1454 
    args.orderId = orderId
1455 
    args.customerId = customerId
1456 
    args.write(self._oprot)
1457 
    self._oprot.writeMessageEnd()
1458 
    self._oprot.trans.flush()
1459 
 
1460 
  def recv_getOrderForCustomer(self, ):
1461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1462 
    if mtype == TMessageType.EXCEPTION:
1463 
      x = TApplicationException()
1464 
      x.read(self._iprot)
1465 
      self._iprot.readMessageEnd()
1466 
      raise x
1467 
    result = getOrderForCustomer_result()
1468 
    result.read(self._iprot)
1469 
    self._iprot.readMessageEnd()
3431 rajveer 1470 
    if result.success is not None:
1528 ankur.sing 1471 
      return result.success
3431 rajveer 1472 
    if result.ex is not None:
1528 ankur.sing 1473 
      raise result.ex
1474 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1475 
 
3064 chandransh 1476 
  def getAlerts(self, orderId, valid):
1477 
    """
1478 
    Parameters:
1479 
     - orderId
1480 
     - valid
1481 
    """
1482 
    self.send_getAlerts(orderId, valid)
1483 
    return self.recv_getAlerts()
1484 
 
1485 
  def send_getAlerts(self, orderId, valid):
1486 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1487 
    args = getAlerts_args()
1488 
    args.orderId = orderId
1489 
    args.valid = valid
1490 
    args.write(self._oprot)
1491 
    self._oprot.writeMessageEnd()
1492 
    self._oprot.trans.flush()
1493 
 
1494 
  def recv_getAlerts(self, ):
1495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1496 
    if mtype == TMessageType.EXCEPTION:
1497 
      x = TApplicationException()
1498 
      x.read(self._iprot)
1499 
      self._iprot.readMessageEnd()
1500 
      raise x
1501 
    result = getAlerts_result()
1502 
    result.read(self._iprot)
1503 
    self._iprot.readMessageEnd()
3431 rajveer 1504 
    if result.success is not None:
3064 chandransh 1505 
      return result.success
1506 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1507 
 
1508 
  def setAlert(self, orderId, unset, type, comment):
1509 
    """
1510 
    Parameters:
1511 
     - orderId
1512 
     - unset
1513 
     - type
1514 
     - comment
1515 
    """
1516 
    self.send_setAlert(orderId, unset, type, comment)
1517 
    self.recv_setAlert()
1518 
 
1519 
  def send_setAlert(self, orderId, unset, type, comment):
1520 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
1521 
    args = setAlert_args()
1522 
    args.orderId = orderId
1523 
    args.unset = unset
1524 
    args.type = type
1525 
    args.comment = comment
1526 
    args.write(self._oprot)
1527 
    self._oprot.writeMessageEnd()
1528 
    self._oprot.trans.flush()
1529 
 
1530 
  def recv_setAlert(self, ):
1531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1532 
    if mtype == TMessageType.EXCEPTION:
1533 
      x = TApplicationException()
1534 
      x.read(self._iprot)
1535 
      self._iprot.readMessageEnd()
1536 
      raise x
1537 
    result = setAlert_result()
1538 
    result.read(self._iprot)
1539 
    self._iprot.readMessageEnd()
1540 
    return
1541 
 
1542 
  def getValidOrderCount(self, ):
1543 
    """
1544 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1545 
    """
1546 
    self.send_getValidOrderCount()
1547 
    return self.recv_getValidOrderCount()
1548 
 
1549 
  def send_getValidOrderCount(self, ):
1550 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1551 
    args = getValidOrderCount_args()
1552 
    args.write(self._oprot)
1553 
    self._oprot.writeMessageEnd()
1554 
    self._oprot.trans.flush()
1555 
 
1556 
  def recv_getValidOrderCount(self, ):
1557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1558 
    if mtype == TMessageType.EXCEPTION:
1559 
      x = TApplicationException()
1560 
      x.read(self._iprot)
1561 
      self._iprot.readMessageEnd()
1562 
      raise x
1563 
    result = getValidOrderCount_result()
1564 
    result.read(self._iprot)
1565 
    self._iprot.readMessageEnd()
3431 rajveer 1566 
    if result.success is not None:
3064 chandransh 1567 
      return result.success
1568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1569 
 
1570 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1571 
    """
1572 
    Returns the number of distinct customers who have done successful transactions
1573 
    """
1574 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1575 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1576 
 
1577 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1578 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1579 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1580 
    args.write(self._oprot)
1581 
    self._oprot.writeMessageEnd()
1582 
    self._oprot.trans.flush()
1583 
 
1584 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1586 
    if mtype == TMessageType.EXCEPTION:
1587 
      x = TApplicationException()
1588 
      x.read(self._iprot)
1589 
      self._iprot.readMessageEnd()
1590 
      raise x
1591 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1592 
    result.read(self._iprot)
1593 
    self._iprot.readMessageEnd()
3431 rajveer 1594 
    if result.success is not None:
3064 chandransh 1595 
      return result.success
1596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1597 
 
1598 
  def getValidOrdersAmountRange(self, ):
1599 
    """
1600 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1601 
    List contains two values, first minimum amount and second maximum amount.
1602 
    """
1603 
    self.send_getValidOrdersAmountRange()
1604 
    return self.recv_getValidOrdersAmountRange()
1605 
 
1606 
  def send_getValidOrdersAmountRange(self, ):
1607 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1608 
    args = getValidOrdersAmountRange_args()
1609 
    args.write(self._oprot)
1610 
    self._oprot.writeMessageEnd()
1611 
    self._oprot.trans.flush()
1612 
 
1613 
  def recv_getValidOrdersAmountRange(self, ):
1614 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1615 
    if mtype == TMessageType.EXCEPTION:
1616 
      x = TApplicationException()
1617 
      x.read(self._iprot)
1618 
      self._iprot.readMessageEnd()
1619 
      raise x
1620 
    result = getValidOrdersAmountRange_result()
1621 
    result.read(self._iprot)
1622 
    self._iprot.readMessageEnd()
3431 rajveer 1623 
    if result.success is not None:
3064 chandransh 1624 
      return result.success
1625 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1626 
 
1627 
  def getValidOrders(self, limit):
1628 
    """
1629 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1630 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1631 
 
3064 chandransh 1632 
    Parameters:
1633 
     - limit
1634 
    """
1635 
    self.send_getValidOrders(limit)
1636 
    return self.recv_getValidOrders()
1637 
 
1638 
  def send_getValidOrders(self, limit):
1639 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1640 
    args = getValidOrders_args()
1641 
    args.limit = limit
1642 
    args.write(self._oprot)
1643 
    self._oprot.writeMessageEnd()
1644 
    self._oprot.trans.flush()
1645 
 
1646 
  def recv_getValidOrders(self, ):
1647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1648 
    if mtype == TMessageType.EXCEPTION:
1649 
      x = TApplicationException()
1650 
      x.read(self._iprot)
1651 
      self._iprot.readMessageEnd()
1652 
      raise x
1653 
    result = getValidOrders_result()
1654 
    result.read(self._iprot)
1655 
    self._iprot.readMessageEnd()
3431 rajveer 1656 
    if result.success is not None:
3064 chandransh 1657 
      return result.success
1658 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1659 
 
1220 chandransh 1660 
  def batchOrders(self, warehouseId):
1661 
    """
1662 
    Create a batch of all the pending orders for the given warehouse.
1663 
    The returned list is orderd by created_timestamp.
1664 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1665 
 
1220 chandransh 1666 
    Parameters:
1667 
     - warehouseId
1668 
    """
1669 
    self.send_batchOrders(warehouseId)
1670 
    return self.recv_batchOrders()
1671 
 
1672 
  def send_batchOrders(self, warehouseId):
1673 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1674 
    args = batchOrders_args()
1675 
    args.warehouseId = warehouseId
1676 
    args.write(self._oprot)
1677 
    self._oprot.writeMessageEnd()
1678 
    self._oprot.trans.flush()
1679 
 
1680 
  def recv_batchOrders(self, ):
1681 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1682 
    if mtype == TMessageType.EXCEPTION:
1683 
      x = TApplicationException()
1684 
      x.read(self._iprot)
1685 
      self._iprot.readMessageEnd()
1686 
      raise x
1687 
    result = batchOrders_result()
1688 
    result.read(self._iprot)
1689 
    self._iprot.readMessageEnd()
3431 rajveer 1690 
    if result.success is not None:
1220 chandransh 1691 
      return result.success
3431 rajveer 1692 
    if result.ex is not None:
1220 chandransh 1693 
      raise result.ex
1694 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1695 
 
1208 chandransh 1696 
  def markOrderAsOutOfStock(self, orderId):
1697 
    """
1698 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1699 
 
1208 chandransh 1700 
    Parameters:
1701 
     - orderId
1702 
    """
1703 
    self.send_markOrderAsOutOfStock(orderId)
1704 
    return self.recv_markOrderAsOutOfStock()
1705 
 
1706 
  def send_markOrderAsOutOfStock(self, orderId):
1707 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1708 
    args = markOrderAsOutOfStock_args()
1709 
    args.orderId = orderId
1710 
    args.write(self._oprot)
1711 
    self._oprot.writeMessageEnd()
1712 
    self._oprot.trans.flush()
1713 
 
1714 
  def recv_markOrderAsOutOfStock(self, ):
1715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1716 
    if mtype == TMessageType.EXCEPTION:
1717 
      x = TApplicationException()
1718 
      x.read(self._iprot)
1719 
      self._iprot.readMessageEnd()
1720 
      raise x
1721 
    result = markOrderAsOutOfStock_result()
1722 
    result.read(self._iprot)
1723 
    self._iprot.readMessageEnd()
3431 rajveer 1724 
    if result.success is not None:
1208 chandransh 1725 
      return result.success
3431 rajveer 1726 
    if result.ex is not None:
1208 chandransh 1727 
      raise result.ex
1728 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1729 
 
3064 chandransh 1730 
  def verifyOrder(self, orderId):
759 chandransh 1731 
    """
3064 chandransh 1732 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1733 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1734 
    used for all other orders as well.
1735 
    Throws an exception if no such order exists.
3431 rajveer 1736 
 
759 chandransh 1737 
    Parameters:
3064 chandransh 1738 
     - orderId
759 chandransh 1739 
    """
3064 chandransh 1740 
    self.send_verifyOrder(orderId)
1741 
    return self.recv_verifyOrder()
759 chandransh 1742 
 
3064 chandransh 1743 
  def send_verifyOrder(self, orderId):
1744 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1745 
    args = verifyOrder_args()
1746 
    args.orderId = orderId
759 chandransh 1747 
    args.write(self._oprot)
1748 
    self._oprot.writeMessageEnd()
1749 
    self._oprot.trans.flush()
1750 
 
3064 chandransh 1751 
  def recv_verifyOrder(self, ):
759 chandransh 1752 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1753 
    if mtype == TMessageType.EXCEPTION:
1754 
      x = TApplicationException()
1755 
      x.read(self._iprot)
1756 
      self._iprot.readMessageEnd()
1757 
      raise x
3064 chandransh 1758 
    result = verifyOrder_result()
759 chandransh 1759 
    result.read(self._iprot)
1760 
    self._iprot.readMessageEnd()
3431 rajveer 1761 
    if result.success is not None:
759 chandransh 1762 
      return result.success
3431 rajveer 1763 
    if result.ex is not None:
759 chandransh 1764 
      raise result.ex
3064 chandransh 1765 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1766 
 
3064 chandransh 1767 
  def acceptOrder(self, orderId):
1113 chandransh 1768 
    """
3064 chandransh 1769 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1770 
    given order is not a COD order, it also captures the payment if the same has
1771 
    not been captured.
1772 
    Throws an exception if no such order exists.
3431 rajveer 1773 
 
1113 chandransh 1774 
    Parameters:
3064 chandransh 1775 
     - orderId
1113 chandransh 1776 
    """
3064 chandransh 1777 
    self.send_acceptOrder(orderId)
1778 
    return self.recv_acceptOrder()
1113 chandransh 1779 
 
3064 chandransh 1780 
  def send_acceptOrder(self, orderId):
1781 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1782 
    args = acceptOrder_args()
1783 
    args.orderId = orderId
1113 chandransh 1784 
    args.write(self._oprot)
1785 
    self._oprot.writeMessageEnd()
1786 
    self._oprot.trans.flush()
1787 
 
3064 chandransh 1788 
  def recv_acceptOrder(self, ):
1113 chandransh 1789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1790 
    if mtype == TMessageType.EXCEPTION:
1791 
      x = TApplicationException()
1792 
      x.read(self._iprot)
1793 
      self._iprot.readMessageEnd()
1794 
      raise x
3064 chandransh 1795 
    result = acceptOrder_result()
1113 chandransh 1796 
    result.read(self._iprot)
1797 
    self._iprot.readMessageEnd()
3431 rajveer 1798 
    if result.success is not None:
1113 chandransh 1799 
      return result.success
3431 rajveer 1800 
    if result.ex is not None:
1113 chandransh 1801 
      raise result.ex
3064 chandransh 1802 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1803 
 
3064 chandransh 1804 
  def billOrder(self, orderId):
1132 chandransh 1805 
    """
1806 
    Parameters:
3064 chandransh 1807 
     - orderId
1132 chandransh 1808 
    """
3064 chandransh 1809 
    self.send_billOrder(orderId)
1810 
    return self.recv_billOrder()
1132 chandransh 1811 
 
3064 chandransh 1812 
  def send_billOrder(self, orderId):
1813 
    self._oprot.writeMessageBegin('billOrder', TMessageType.CALL, self._seqid)
1814 
    args = billOrder_args()
1815 
    args.orderId = orderId
1132 chandransh 1816 
    args.write(self._oprot)
1817 
    self._oprot.writeMessageEnd()
1818 
    self._oprot.trans.flush()
1819 
 
3064 chandransh 1820 
  def recv_billOrder(self, ):
1132 chandransh 1821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1822 
    if mtype == TMessageType.EXCEPTION:
1823 
      x = TApplicationException()
1824 
      x.read(self._iprot)
1825 
      self._iprot.readMessageEnd()
1826 
      raise x
3064 chandransh 1827 
    result = billOrder_result()
1132 chandransh 1828 
    result.read(self._iprot)
1829 
    self._iprot.readMessageEnd()
3431 rajveer 1830 
    if result.success is not None:
3064 chandransh 1831 
      return result.success
3431 rajveer 1832 
    if result.ex is not None:
1132 chandransh 1833 
      raise result.ex
3064 chandransh 1834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "billOrder failed: unknown result");
1132 chandransh 1835 
 
3064 chandransh 1836 
  def addBillingDetails(self, orderId, invoice_number, billed_by):
1135 chandransh 1837 
    """
3064 chandransh 1838 
    Add billing details such as the bill number and the biller to the Order.
1839 
    Should be used when the bill is issued by a 3rd party and we've to feed
1840 
    the information into our system.
3431 rajveer 1841 
 
1135 chandransh 1842 
    Parameters:
3064 chandransh 1843 
     - orderId
1844 
     - invoice_number
1845 
     - billed_by
1135 chandransh 1846 
    """
3064 chandransh 1847 
    self.send_addBillingDetails(orderId, invoice_number, billed_by)
1848 
    return self.recv_addBillingDetails()
1135 chandransh 1849 
 
3064 chandransh 1850 
  def send_addBillingDetails(self, orderId, invoice_number, billed_by):
1851 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1852 
    args = addBillingDetails_args()
1853 
    args.orderId = orderId
1854 
    args.invoice_number = invoice_number
1855 
    args.billed_by = billed_by
1135 chandransh 1856 
    args.write(self._oprot)
1857 
    self._oprot.writeMessageEnd()
1858 
    self._oprot.trans.flush()
1859 
 
3064 chandransh 1860 
  def recv_addBillingDetails(self, ):
1135 chandransh 1861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1862 
    if mtype == TMessageType.EXCEPTION:
1863 
      x = TApplicationException()
1864 
      x.read(self._iprot)
1865 
      self._iprot.readMessageEnd()
1866 
      raise x
3064 chandransh 1867 
    result = addBillingDetails_result()
1135 chandransh 1868 
    result.read(self._iprot)
1869 
    self._iprot.readMessageEnd()
3431 rajveer 1870 
    if result.success is not None:
3064 chandransh 1871 
      return result.success
3431 rajveer 1872 
    if result.ex is not None:
1135 chandransh 1873 
      raise result.ex
3064 chandransh 1874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 1875 
 
3064 chandransh 1876 
  def addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
1246 chandransh 1877 
    """
3064 chandransh 1878 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1879 
    the IMEI no. if a -1 is supplied.
1880 
    Also, it generates an invoice number for the order, marks the order as
1881 
    BILLED and sets the billing timestamp.
1882 
    It should be used when we are billing the orders ourselves.
3431 rajveer 1883 
 
3064 chandransh 1884 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1885 
 
1246 chandransh 1886 
    Parameters:
3064 chandransh 1887 
     - orderId
1888 
     - jacketNumber
1889 
     - imeiNumber
1890 
     - itemNumber
1891 
     - billedBy
1892 
     - billingType
1246 chandransh 1893 
    """
3064 chandransh 1894 
    self.send_addJacketNumber(orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType)
1895 
    return self.recv_addJacketNumber()
1246 chandransh 1896 
 
3064 chandransh 1897 
  def send_addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
1898 
    self._oprot.writeMessageBegin('addJacketNumber', TMessageType.CALL, self._seqid)
1899 
    args = addJacketNumber_args()
1900 
    args.orderId = orderId
1901 
    args.jacketNumber = jacketNumber
1902 
    args.imeiNumber = imeiNumber
1903 
    args.itemNumber = itemNumber
1904 
    args.billedBy = billedBy
1905 
    args.billingType = billingType
1246 chandransh 1906 
    args.write(self._oprot)
1907 
    self._oprot.writeMessageEnd()
1908 
    self._oprot.trans.flush()
1909 
 
3064 chandransh 1910 
  def recv_addJacketNumber(self, ):
1246 chandransh 1911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1912 
    if mtype == TMessageType.EXCEPTION:
1913 
      x = TApplicationException()
1914 
      x.read(self._iprot)
1915 
      self._iprot.readMessageEnd()
1916 
      raise x
3064 chandransh 1917 
    result = addJacketNumber_result()
1246 chandransh 1918 
    result.read(self._iprot)
1919 
    self._iprot.readMessageEnd()
3431 rajveer 1920 
    if result.success is not None:
3064 chandransh 1921 
      return result.success
3431 rajveer 1922 
    if result.ex is not None:
1246 chandransh 1923 
      raise result.ex
3064 chandransh 1924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addJacketNumber failed: unknown result");
1246 chandransh 1925 
 
3064 chandransh 1926 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 1927 
    """
3064 chandransh 1928 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
1929 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 1930 
 
1408 ankur.sing 1931 
    Parameters:
3064 chandransh 1932 
     - warehouseId
1408 ankur.sing 1933 
     - providerId
3064 chandransh 1934 
     - cod
1408 ankur.sing 1935 
    """
3064 chandransh 1936 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
1937 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 1938 
 
3064 chandransh 1939 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
1940 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1941 
    args = markOrdersAsManifested_args()
1942 
    args.warehouseId = warehouseId
1408 ankur.sing 1943 
    args.providerId = providerId
3064 chandransh 1944 
    args.cod = cod
1408 ankur.sing 1945 
    args.write(self._oprot)
1946 
    self._oprot.writeMessageEnd()
1947 
    self._oprot.trans.flush()
1948 
 
3064 chandransh 1949 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 1950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1951 
    if mtype == TMessageType.EXCEPTION:
1952 
      x = TApplicationException()
1953 
      x.read(self._iprot)
1954 
      self._iprot.readMessageEnd()
1955 
      raise x
3064 chandransh 1956 
    result = markOrdersAsManifested_result()
1408 ankur.sing 1957 
    result.read(self._iprot)
1958 
    self._iprot.readMessageEnd()
3431 rajveer 1959 
    if result.success is not None:
1408 ankur.sing 1960 
      return result.success
3431 rajveer 1961 
    if result.ex is not None:
3064 chandransh 1962 
      raise result.ex
1963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 1964 
 
3064 chandransh 1965 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 1966 
    """
3064 chandransh 1967 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
1968 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
1969 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1970 
 
94 ashish 1971 
    Parameters:
3064 chandransh 1972 
     - providerId
1973 
     - pickupDetails
304 ashish 1974 
    """
3064 chandransh 1975 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
1976 
    return self.recv_markOrdersAsPickedUp()
94 ashish 1977 
 
3064 chandransh 1978 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
1979 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
1980 
    args = markOrdersAsPickedUp_args()
1981 
    args.providerId = providerId
1982 
    args.pickupDetails = pickupDetails
304 ashish 1983 
    args.write(self._oprot)
1984 
    self._oprot.writeMessageEnd()
1985 
    self._oprot.trans.flush()
1986 
 
3064 chandransh 1987 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 1988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1989 
    if mtype == TMessageType.EXCEPTION:
1990 
      x = TApplicationException()
1991 
      x.read(self._iprot)
1992 
      self._iprot.readMessageEnd()
1993 
      raise x
3064 chandransh 1994 
    result = markOrdersAsPickedUp_result()
304 ashish 1995 
    result.read(self._iprot)
1996 
    self._iprot.readMessageEnd()
3431 rajveer 1997 
    if result.success is not None:
304 ashish 1998 
      return result.success
3431 rajveer 1999 
    if result.ex is not None:
3064 chandransh 2000 
      raise result.ex
2001 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2002 
 
3064 chandransh 2003 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2004 
    """
3064 chandransh 2005 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2006 
    the name of the receiver.
2007 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2008 
 
304 ashish 2009 
    Parameters:
3064 chandransh 2010 
     - providerId
2011 
     - deliveredOrders
304 ashish 2012 
    """
3064 chandransh 2013 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2014 
    self.recv_markOrdersAsDelivered()
304 ashish 2015 
 
3064 chandransh 2016 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2017 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2018 
    args = markOrdersAsDelivered_args()
2019 
    args.providerId = providerId
2020 
    args.deliveredOrders = deliveredOrders
304 ashish 2021 
    args.write(self._oprot)
2022 
    self._oprot.writeMessageEnd()
2023 
    self._oprot.trans.flush()
2024 
 
3064 chandransh 2025 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2027 
    if mtype == TMessageType.EXCEPTION:
2028 
      x = TApplicationException()
2029 
      x.read(self._iprot)
2030 
      self._iprot.readMessageEnd()
2031 
      raise x
3064 chandransh 2032 
    result = markOrdersAsDelivered_result()
304 ashish 2033 
    result.read(self._iprot)
2034 
    self._iprot.readMessageEnd()
3431 rajveer 2035 
    if result.ex is not None:
3064 chandransh 2036 
      raise result.ex
304 ashish 2037 
    return
2038 
 
3064 chandransh 2039 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2040 
    """
3064 chandransh 2041 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2042 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2043 
 
3064 chandransh 2044 
    Parameters:
2045 
     - providerId
2046 
     - returnedOrders
1596 ankur.sing 2047 
    """
3064 chandransh 2048 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2049 
    self.recv_markOrdersAsFailed()
304 ashish 2050 
 
3064 chandransh 2051 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2052 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2053 
    args = markOrdersAsFailed_args()
2054 
    args.providerId = providerId
2055 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2056 
    args.write(self._oprot)
2057 
    self._oprot.writeMessageEnd()
2058 
    self._oprot.trans.flush()
2059 
 
3064 chandransh 2060 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2062 
    if mtype == TMessageType.EXCEPTION:
2063 
      x = TApplicationException()
2064 
      x.read(self._iprot)
2065 
      self._iprot.readMessageEnd()
2066 
      raise x
3064 chandransh 2067 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2068 
    result.read(self._iprot)
2069 
    self._iprot.readMessageEnd()
3431 rajveer 2070 
    if result.ex is not None:
3064 chandransh 2071 
      raise result.ex
2072 
    return
1596 ankur.sing 2073 
 
3064 chandransh 2074 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2075 
    """
3064 chandransh 2076 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2077 
 
3064 chandransh 2078 
    Parameters:
2079 
     - providerId
2080 
     - undeliveredOrders
1627 ankur.sing 2081 
    """
3064 chandransh 2082 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2083 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2084 
 
3064 chandransh 2085 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2086 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2087 
    args = updateNonDeliveryReason_args()
2088 
    args.providerId = providerId
2089 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2090 
    args.write(self._oprot)
2091 
    self._oprot.writeMessageEnd()
2092 
    self._oprot.trans.flush()
2093 
 
3064 chandransh 2094 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2096 
    if mtype == TMessageType.EXCEPTION:
2097 
      x = TApplicationException()
2098 
      x.read(self._iprot)
2099 
      self._iprot.readMessageEnd()
2100 
      raise x
3064 chandransh 2101 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2102 
    result.read(self._iprot)
2103 
    self._iprot.readMessageEnd()
3431 rajveer 2104 
    if result.ex is not None:
3064 chandransh 2105 
      raise result.ex
2106 
    return
1627 ankur.sing 2107 
 
3064 chandransh 2108 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2109 
    """
3064 chandransh 2110 
    Returns the list of orders whose delivery time has passed but have not been
2111 
    delivered yet for the given provider and warehouse. To get a complete list of
2112 
    undelivered orders, pass them as -1.
2113 
    Returns an empty list if no such orders exist.
3431 rajveer 2114 
 
1886 ankur.sing 2115 
    Parameters:
3064 chandransh 2116 
     - providerId
2117 
     - warehouseId
1886 ankur.sing 2118 
    """
3064 chandransh 2119 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2120 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2121 
 
3064 chandransh 2122 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2123 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2124 
    args = getUndeliveredOrders_args()
2125 
    args.providerId = providerId
2126 
    args.warehouseId = warehouseId
1886 ankur.sing 2127 
    args.write(self._oprot)
2128 
    self._oprot.writeMessageEnd()
2129 
    self._oprot.trans.flush()
2130 
 
3064 chandransh 2131 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2133 
    if mtype == TMessageType.EXCEPTION:
2134 
      x = TApplicationException()
2135 
      x.read(self._iprot)
2136 
      self._iprot.readMessageEnd()
2137 
      raise x
3064 chandransh 2138 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2139 
    result.read(self._iprot)
2140 
    self._iprot.readMessageEnd()
3431 rajveer 2141 
    if result.success is not None:
1886 ankur.sing 2142 
      return result.success
3064 chandransh 2143 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2144 
 
2536 chandransh 2145 
  def toggleDOAFlag(self, orderId):
2146 
    """
2147 
    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.
2148 
    Returns the final flag status.
2149 
    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 2150 
 
2536 chandransh 2151 
    Parameters:
2152 
     - orderId
2153 
    """
2154 
    self.send_toggleDOAFlag(orderId)
2155 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2156 
 
2536 chandransh 2157 
  def send_toggleDOAFlag(self, orderId):
2158 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2159 
    args = toggleDOAFlag_args()
2160 
    args.orderId = orderId
2161 
    args.write(self._oprot)
2162 
    self._oprot.writeMessageEnd()
2163 
    self._oprot.trans.flush()
2164 
 
2165 
  def recv_toggleDOAFlag(self, ):
2166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2167 
    if mtype == TMessageType.EXCEPTION:
2168 
      x = TApplicationException()
2169 
      x.read(self._iprot)
2170 
      self._iprot.readMessageEnd()
2171 
      raise x
2172 
    result = toggleDOAFlag_result()
2173 
    result.read(self._iprot)
2174 
    self._iprot.readMessageEnd()
3431 rajveer 2175 
    if result.success is not None:
2536 chandransh 2176 
      return result.success
3431 rajveer 2177 
    if result.ex is not None:
2536 chandransh 2178 
      raise result.ex
2179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2180 
 
2181 
  def requestPickupNumber(self, orderId):
2182 
    """
2183 
    Sends out an email to the account manager of the original courier provider used to ship the order.
2184 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
2185 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
2186 
    For any other status, it returns false.
2187 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2188 
 
2536 chandransh 2189 
    Parameters:
2190 
     - orderId
2191 
    """
2192 
    self.send_requestPickupNumber(orderId)
2193 
    return self.recv_requestPickupNumber()
2194 
 
2195 
  def send_requestPickupNumber(self, orderId):
2196 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2197 
    args = requestPickupNumber_args()
2198 
    args.orderId = orderId
2199 
    args.write(self._oprot)
2200 
    self._oprot.writeMessageEnd()
2201 
    self._oprot.trans.flush()
2202 
 
2203 
  def recv_requestPickupNumber(self, ):
2204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2205 
    if mtype == TMessageType.EXCEPTION:
2206 
      x = TApplicationException()
2207 
      x.read(self._iprot)
2208 
      self._iprot.readMessageEnd()
2209 
      raise x
2210 
    result = requestPickupNumber_result()
2211 
    result.read(self._iprot)
2212 
    self._iprot.readMessageEnd()
3431 rajveer 2213 
    if result.success is not None:
2536 chandransh 2214 
      return result.success
3431 rajveer 2215 
    if result.ex is not None:
2536 chandransh 2216 
      raise result.ex
2217 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2218 
 
2219 
  def authorizePickup(self, orderId, pickupNumber):
2220 
    """
2221 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
2222 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2223 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2224 
    	3. Returns true
2591 chandransh 2225 
    If the order is in any other status, it returns false.
2536 chandransh 2226 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2227 
 
2536 chandransh 2228 
    Parameters:
2229 
     - orderId
2230 
     - pickupNumber
2231 
    """
2232 
    self.send_authorizePickup(orderId, pickupNumber)
2233 
    return self.recv_authorizePickup()
2234 
 
2235 
  def send_authorizePickup(self, orderId, pickupNumber):
2236 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2237 
    args = authorizePickup_args()
2238 
    args.orderId = orderId
2239 
    args.pickupNumber = pickupNumber
2240 
    args.write(self._oprot)
2241 
    self._oprot.writeMessageEnd()
2242 
    self._oprot.trans.flush()
2243 
 
2244 
  def recv_authorizePickup(self, ):
2245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2246 
    if mtype == TMessageType.EXCEPTION:
2247 
      x = TApplicationException()
2248 
      x.read(self._iprot)
2249 
      self._iprot.readMessageEnd()
2250 
      raise x
2251 
    result = authorizePickup_result()
2252 
    result.read(self._iprot)
2253 
    self._iprot.readMessageEnd()
3431 rajveer 2254 
    if result.success is not None:
2536 chandransh 2255 
      return result.success
3431 rajveer 2256 
    if result.ex is not None:
2536 chandransh 2257 
      raise result.ex
2258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2259 
 
2764 chandransh 2260 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2261 
    """
2262 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2263 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2264 
 
2764 chandransh 2265 
    Parameters:
2266 
     - providerId
2267 
     - pickupDetails
2268 
    """
2269 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2270 
    return self.recv_markDoasAsPickedUp()
2271 
 
2272 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2273 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2274 
    args = markDoasAsPickedUp_args()
2275 
    args.providerId = providerId
2276 
    args.pickupDetails = pickupDetails
2277 
    args.write(self._oprot)
2278 
    self._oprot.writeMessageEnd()
2279 
    self._oprot.trans.flush()
2280 
 
2281 
  def recv_markDoasAsPickedUp(self, ):
2282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2283 
    if mtype == TMessageType.EXCEPTION:
2284 
      x = TApplicationException()
2285 
      x.read(self._iprot)
2286 
      self._iprot.readMessageEnd()
2287 
      raise x
2288 
    result = markDoasAsPickedUp_result()
2289 
    result.read(self._iprot)
2290 
    self._iprot.readMessageEnd()
3431 rajveer 2291 
    if result.success is not None:
2764 chandransh 2292 
      return result.success
2293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2294 
 
2616 chandransh 2295 
  def receiveReturn(self, orderId):
2591 chandransh 2296 
    """
2599 chandransh 2297 
    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 2298 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 2299 
    If the order is in any other state, it returns false.
2300 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2301 
 
2591 chandransh 2302 
    Parameters:
2303 
     - orderId
2304 
    """
2616 chandransh 2305 
    self.send_receiveReturn(orderId)
2306 
    return self.recv_receiveReturn()
2536 chandransh 2307 
 
2616 chandransh 2308 
  def send_receiveReturn(self, orderId):
2309 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2310 
    args = receiveReturn_args()
2591 chandransh 2311 
    args.orderId = orderId
2312 
    args.write(self._oprot)
2313 
    self._oprot.writeMessageEnd()
2314 
    self._oprot.trans.flush()
2315 
 
2616 chandransh 2316 
  def recv_receiveReturn(self, ):
2591 chandransh 2317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2318 
    if mtype == TMessageType.EXCEPTION:
2319 
      x = TApplicationException()
2320 
      x.read(self._iprot)
2321 
      self._iprot.readMessageEnd()
2322 
      raise x
2616 chandransh 2323 
    result = receiveReturn_result()
2591 chandransh 2324 
    result.read(self._iprot)
2325 
    self._iprot.readMessageEnd()
3431 rajveer 2326 
    if result.success is not None:
2591 chandransh 2327 
      return result.success
3431 rajveer 2328 
    if result.ex is not None:
2591 chandransh 2329 
      raise result.ex
2616 chandransh 2330 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2331 
 
2332 
  def validateDoa(self, orderId, isValid):
2333 
    """
2599 chandransh 2334 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 2335 
    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 2336 
    If the order is in any other state, it returns false.
2337 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2338 
 
2591 chandransh 2339 
    Parameters:
2340 
     - orderId
2341 
     - isValid
2342 
    """
2343 
    self.send_validateDoa(orderId, isValid)
2344 
    return self.recv_validateDoa()
2345 
 
2346 
  def send_validateDoa(self, orderId, isValid):
2347 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2348 
    args = validateDoa_args()
2349 
    args.orderId = orderId
2350 
    args.isValid = isValid
2351 
    args.write(self._oprot)
2352 
    self._oprot.writeMessageEnd()
2353 
    self._oprot.trans.flush()
2354 
 
2355 
  def recv_validateDoa(self, ):
2356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2357 
    if mtype == TMessageType.EXCEPTION:
2358 
      x = TApplicationException()
2359 
      x.read(self._iprot)
2360 
      self._iprot.readMessageEnd()
2361 
      raise x
2362 
    result = validateDoa_result()
2363 
    result.read(self._iprot)
2364 
    self._iprot.readMessageEnd()
3431 rajveer 2365 
    if result.success is not None:
2591 chandransh 2366 
      return result.success
3431 rajveer 2367 
    if result.ex is not None:
2591 chandransh 2368 
      raise result.ex
2369 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2370 
 
2616 chandransh 2371 
  def reshipOrder(self, orderId):
2372 
    """
2373 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2374 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2375 
    	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.
2376 
 
2377 
    If the order is in DOA_CERT_VALID state, it does the following:
2378 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2379 
    	2. Creates a return order for the warehouse executive to return the DOA material.
2380 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 2381 
 
2616 chandransh 2382 
    Returns the id of the newly created order.
3431 rajveer 2383 
 
2616 chandransh 2384 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2385 
 
2616 chandransh 2386 
    Parameters:
2387 
     - orderId
2388 
    """
2389 
    self.send_reshipOrder(orderId)
2390 
    return self.recv_reshipOrder()
2591 chandransh 2391 
 
2616 chandransh 2392 
  def send_reshipOrder(self, orderId):
2393 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2394 
    args = reshipOrder_args()
2395 
    args.orderId = orderId
2396 
    args.write(self._oprot)
2397 
    self._oprot.writeMessageEnd()
2398 
    self._oprot.trans.flush()
2399 
 
2400 
  def recv_reshipOrder(self, ):
2401 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2402 
    if mtype == TMessageType.EXCEPTION:
2403 
      x = TApplicationException()
2404 
      x.read(self._iprot)
2405 
      self._iprot.readMessageEnd()
2406 
      raise x
2407 
    result = reshipOrder_result()
2408 
    result.read(self._iprot)
2409 
    self._iprot.readMessageEnd()
3431 rajveer 2410 
    if result.success is not None:
2616 chandransh 2411 
      return result.success
3431 rajveer 2412 
    if result.ex is not None:
2616 chandransh 2413 
      raise result.ex
2414 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2415 
 
3226 chandransh 2416 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2417 
    """
2418 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2419 
    	1. Creates a refund request for batch processing.
2420 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2421 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2422 
 
2616 chandransh 2423 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2424 
    	1. Creates a refund request for batch processing.
3226 chandransh 2425 
    	2. Cancels the reservation of the item in the warehouse.
2426 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2427 
 
3226 chandransh 2428 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2429 
    	1. Cancels the reservation of the item in the warehouse.
2430 
    	2. Marks the current order as CANCELED.
2431 
 
2432 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2433 
 
2616 chandransh 2434 
    Returns True if it is successful, False otherwise.
3431 rajveer 2435 
 
2616 chandransh 2436 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2437 
 
2616 chandransh 2438 
    Parameters:
2439 
     - orderId
3226 chandransh 2440 
     - refundedBy
2441 
     - reason
2616 chandransh 2442 
    """
3226 chandransh 2443 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2444 
    return self.recv_refundOrder()
2445 
 
3226 chandransh 2446 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2447 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2448 
    args = refundOrder_args()
2449 
    args.orderId = orderId
3226 chandransh 2450 
    args.refundedBy = refundedBy
2451 
    args.reason = reason
2616 chandransh 2452 
    args.write(self._oprot)
2453 
    self._oprot.writeMessageEnd()
2454 
    self._oprot.trans.flush()
2455 
 
2456 
  def recv_refundOrder(self, ):
2457 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2458 
    if mtype == TMessageType.EXCEPTION:
2459 
      x = TApplicationException()
2460 
      x.read(self._iprot)
2461 
      self._iprot.readMessageEnd()
2462 
      raise x
2463 
    result = refundOrder_result()
2464 
    result.read(self._iprot)
2465 
    self._iprot.readMessageEnd()
3431 rajveer 2466 
    if result.success is not None:
2616 chandransh 2467 
      return result.success
3431 rajveer 2468 
    if result.ex is not None:
2616 chandransh 2469 
      raise result.ex
2470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2471 
 
2690 chandransh 2472 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2473 
    """
2474 
    Get all return orders created between the from and to dates for the given warehouse.
2475 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2476 
 
2690 chandransh 2477 
    Parameters:
2478 
     - warehouseId
2479 
     - fromDate
2480 
     - toDate
2481 
    """
2482 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2483 
    return self.recv_getReturnOrders()
2616 chandransh 2484 
 
2690 chandransh 2485 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2486 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2487 
    args = getReturnOrders_args()
2488 
    args.warehouseId = warehouseId
2489 
    args.fromDate = fromDate
2490 
    args.toDate = toDate
2491 
    args.write(self._oprot)
2492 
    self._oprot.writeMessageEnd()
2493 
    self._oprot.trans.flush()
2494 
 
2495 
  def recv_getReturnOrders(self, ):
2496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2497 
    if mtype == TMessageType.EXCEPTION:
2498 
      x = TApplicationException()
2499 
      x.read(self._iprot)
2500 
      self._iprot.readMessageEnd()
2501 
      raise x
2502 
    result = getReturnOrders_result()
2503 
    result.read(self._iprot)
2504 
    self._iprot.readMessageEnd()
3431 rajveer 2505 
    if result.success is not None:
2690 chandransh 2506 
      return result.success
2507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2508 
 
2700 chandransh 2509 
  def getReturnOrder(self, id):
2510 
    """
2511 
    Returns the ReturnOrder corresponding to the given id.
2512 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2513 
 
2700 chandransh 2514 
    Parameters:
2515 
     - id
2516 
    """
2517 
    self.send_getReturnOrder(id)
2518 
    return self.recv_getReturnOrder()
2519 
 
2520 
  def send_getReturnOrder(self, id):
2521 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2522 
    args = getReturnOrder_args()
2523 
    args.id = id
2524 
    args.write(self._oprot)
2525 
    self._oprot.writeMessageEnd()
2526 
    self._oprot.trans.flush()
2527 
 
2528 
  def recv_getReturnOrder(self, ):
2529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2530 
    if mtype == TMessageType.EXCEPTION:
2531 
      x = TApplicationException()
2532 
      x.read(self._iprot)
2533 
      self._iprot.readMessageEnd()
2534 
      raise x
2535 
    result = getReturnOrder_result()
2536 
    result.read(self._iprot)
2537 
    self._iprot.readMessageEnd()
3431 rajveer 2538 
    if result.success is not None:
2700 chandransh 2539 
      return result.success
3431 rajveer 2540 
    if result.ex is not None:
2700 chandransh 2541 
      raise result.ex
2542 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2543 
 
2690 chandransh 2544 
  def processReturn(self, returnOrderId):
2545 
    """
2546 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2547 
 
2690 chandransh 2548 
    Parameters:
2549 
     - returnOrderId
2550 
    """
2551 
    self.send_processReturn(returnOrderId)
2552 
    self.recv_processReturn()
2553 
 
2554 
  def send_processReturn(self, returnOrderId):
2555 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2556 
    args = processReturn_args()
2557 
    args.returnOrderId = returnOrderId
2558 
    args.write(self._oprot)
2559 
    self._oprot.writeMessageEnd()
2560 
    self._oprot.trans.flush()
2561 
 
2562 
  def recv_processReturn(self, ):
2563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2564 
    if mtype == TMessageType.EXCEPTION:
2565 
      x = TApplicationException()
2566 
      x.read(self._iprot)
2567 
      self._iprot.readMessageEnd()
2568 
      raise x
2569 
    result = processReturn_result()
2570 
    result.read(self._iprot)
2571 
    self._iprot.readMessageEnd()
3431 rajveer 2572 
    if result.ex is not None:
2690 chandransh 2573 
      raise result.ex
2574 
    return
2575 
 
2819 chandransh 2576 
  def createPurchaseOrder(self, warehouseId):
2577 
    """
2578 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2579 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2580 
 
2819 chandransh 2581 
    Parameters:
2582 
     - warehouseId
2583 
    """
2584 
    self.send_createPurchaseOrder(warehouseId)
2585 
    return self.recv_createPurchaseOrder()
2690 chandransh 2586 
 
2819 chandransh 2587 
  def send_createPurchaseOrder(self, warehouseId):
2588 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2589 
    args = createPurchaseOrder_args()
2590 
    args.warehouseId = warehouseId
2591 
    args.write(self._oprot)
2592 
    self._oprot.writeMessageEnd()
2593 
    self._oprot.trans.flush()
2594 
 
2595 
  def recv_createPurchaseOrder(self, ):
2596 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2597 
    if mtype == TMessageType.EXCEPTION:
2598 
      x = TApplicationException()
2599 
      x.read(self._iprot)
2600 
      self._iprot.readMessageEnd()
2601 
      raise x
2602 
    result = createPurchaseOrder_result()
2603 
    result.read(self._iprot)
2604 
    self._iprot.readMessageEnd()
3431 rajveer 2605 
    if result.success is not None:
2819 chandransh 2606 
      return result.success
3431 rajveer 2607 
    if result.ex is not None:
2819 chandransh 2608 
      raise result.ex
2609 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2610 
 
3451 chandransh 2611 
  def updateWeight(self, orderId, weight):
2612 
    """
2613 
    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 2614 
 
3451 chandransh 2615 
    Parameters:
2616 
     - orderId
2617 
     - weight
2618 
    """
2619 
    self.send_updateWeight(orderId, weight)
2620 
    return self.recv_updateWeight()
2621 
 
2622 
  def send_updateWeight(self, orderId, weight):
2623 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2624 
    args = updateWeight_args()
2625 
    args.orderId = orderId
2626 
    args.weight = weight
2627 
    args.write(self._oprot)
2628 
    self._oprot.writeMessageEnd()
2629 
    self._oprot.trans.flush()
2630 
 
2631 
  def recv_updateWeight(self, ):
2632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2633 
    if mtype == TMessageType.EXCEPTION:
2634 
      x = TApplicationException()
2635 
      x.read(self._iprot)
2636 
      self._iprot.readMessageEnd()
2637 
      raise x
2638 
    result = updateWeight_result()
2639 
    result.read(self._iprot)
2640 
    self._iprot.readMessageEnd()
2641 
    if result.success is not None:
2642 
      return result.success
2643 
    if result.ex is not None:
2644 
      raise result.ex
2645 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2646 
 
3469 chandransh 2647 
  def changeItem(self, orderId, itemId):
2648 
    """
2649 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2650 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2651 
 
3469 chandransh 2652 
    Parameters:
2653 
     - orderId
2654 
     - itemId
2655 
    """
2656 
    self.send_changeItem(orderId, itemId)
2657 
    return self.recv_changeItem()
2658 
 
2659 
  def send_changeItem(self, orderId, itemId):
2660 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2661 
    args = changeItem_args()
2662 
    args.orderId = orderId
2663 
    args.itemId = itemId
2664 
    args.write(self._oprot)
2665 
    self._oprot.writeMessageEnd()
2666 
    self._oprot.trans.flush()
2667 
 
2668 
  def recv_changeItem(self, ):
2669 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2670 
    if mtype == TMessageType.EXCEPTION:
2671 
      x = TApplicationException()
2672 
      x.read(self._iprot)
2673 
      self._iprot.readMessageEnd()
2674 
      raise x
2675 
    result = changeItem_result()
2676 
    result.read(self._iprot)
2677 
    self._iprot.readMessageEnd()
2678 
    if result.success is not None:
2679 
      return result.success
2680 
    if result.ex is not None:
2681 
      raise result.ex
2682 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2683 
 
2684 
  def shiftToWarehouse(self, orderId, warehouseId):
2685 
    """
2686 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2687 
 
2688 
    Parameters:
2689 
     - orderId
2690 
     - warehouseId
2691 
    """
2692 
    self.send_shiftToWarehouse(orderId, warehouseId)
2693 
    return self.recv_shiftToWarehouse()
2694 
 
2695 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2696 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2697 
    args = shiftToWarehouse_args()
2698 
    args.orderId = orderId
2699 
    args.warehouseId = warehouseId
2700 
    args.write(self._oprot)
2701 
    self._oprot.writeMessageEnd()
2702 
    self._oprot.trans.flush()
2703 
 
2704 
  def recv_shiftToWarehouse(self, ):
2705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2706 
    if mtype == TMessageType.EXCEPTION:
2707 
      x = TApplicationException()
2708 
      x.read(self._iprot)
2709 
      self._iprot.readMessageEnd()
2710 
      raise x
2711 
    result = shiftToWarehouse_result()
2712 
    result.read(self._iprot)
2713 
    self._iprot.readMessageEnd()
2714 
    if result.success is not None:
2715 
      return result.success
2716 
    if result.ex is not None:
2717 
      raise result.ex
2718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
2719 
 
3986 chandransh 2720 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2721 
    """
2722 
    Adds the given delay reason to the given order.
3986 chandransh 2723 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 2724 
    Raises an exception if no order with the given id can be found.
3469 chandransh 2725 
 
3553 chandransh 2726 
    Parameters:
2727 
     - orderId
2728 
     - delayReason
3986 chandransh 2729 
     - furtherDelay
3553 chandransh 2730 
    """
3986 chandransh 2731 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 2732 
    return self.recv_addDelayReason()
2733 
 
3986 chandransh 2734 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2735 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
2736 
    args = addDelayReason_args()
2737 
    args.orderId = orderId
2738 
    args.delayReason = delayReason
3986 chandransh 2739 
    args.furtherDelay = furtherDelay
3553 chandransh 2740 
    args.write(self._oprot)
2741 
    self._oprot.writeMessageEnd()
2742 
    self._oprot.trans.flush()
2743 
 
2744 
  def recv_addDelayReason(self, ):
2745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2746 
    if mtype == TMessageType.EXCEPTION:
2747 
      x = TApplicationException()
2748 
      x.read(self._iprot)
2749 
      self._iprot.readMessageEnd()
2750 
      raise x
2751 
    result = addDelayReason_result()
2752 
    result.read(self._iprot)
2753 
    self._iprot.readMessageEnd()
2754 
    if result.success is not None:
2755 
      return result.success
2756 
    if result.ex is not None:
2757 
      raise result.ex
2758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
2759 
 
3956 chandransh 2760 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2761 
    """
2762 
    Marks the COD orders with given AWB nos. as having been processed.
2763 
    Updates the captured amount for the corresponding payment.
3553 chandransh 2764 
 
3956 chandransh 2765 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
2766 
    1. There is no order corresponding to an AWB number.
2767 
    2. The captured amount for a payment exceeds the total payment.
2768 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
2769 
 
2770 
    Parameters:
2771 
     - collectedAmountMap
2772 
     - xferBy
2773 
     - xferTxnId
2774 
     - xferDate
2775 
    """
2776 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
2777 
    return self.recv_reconcileCodCollection()
2778 
 
2779 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2780 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
2781 
    args = reconcileCodCollection_args()
2782 
    args.collectedAmountMap = collectedAmountMap
2783 
    args.xferBy = xferBy
2784 
    args.xferTxnId = xferTxnId
2785 
    args.xferDate = xferDate
2786 
    args.write(self._oprot)
2787 
    self._oprot.writeMessageEnd()
2788 
    self._oprot.trans.flush()
2789 
 
2790 
  def recv_reconcileCodCollection(self, ):
2791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2792 
    if mtype == TMessageType.EXCEPTION:
2793 
      x = TApplicationException()
2794 
      x.read(self._iprot)
2795 
      self._iprot.readMessageEnd()
2796 
      raise x
2797 
    result = reconcileCodCollection_result()
2798 
    result.read(self._iprot)
2799 
    self._iprot.readMessageEnd()
2800 
    if result.success is not None:
2801 
      return result.success
2802 
    if result.ex is not None:
2803 
      raise result.ex
2804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
2805 
 
4008 mandeep.dh 2806 
  def getTransactionsRequiringExtraProcessing(self, category):
2807 
    """
4065 mandeep.dh 2808 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 2809 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 2810 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 2811 
 
4008 mandeep.dh 2812 
    Parameters:
2813 
     - category
2814 
    """
2815 
    self.send_getTransactionsRequiringExtraProcessing(category)
2816 
    return self.recv_getTransactionsRequiringExtraProcessing()
2817 
 
2818 
  def send_getTransactionsRequiringExtraProcessing(self, category):
2819 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
2820 
    args = getTransactionsRequiringExtraProcessing_args()
2821 
    args.category = category
2822 
    args.write(self._oprot)
2823 
    self._oprot.writeMessageEnd()
2824 
    self._oprot.trans.flush()
2825 
 
2826 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
2827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2828 
    if mtype == TMessageType.EXCEPTION:
2829 
      x = TApplicationException()
2830 
      x.read(self._iprot)
2831 
      self._iprot.readMessageEnd()
2832 
      raise x
2833 
    result = getTransactionsRequiringExtraProcessing_result()
2834 
    result.read(self._iprot)
2835 
    self._iprot.readMessageEnd()
2836 
    if result.success is not None:
2837 
      return result.success
2838 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
2839 
 
2840 
  def markTransactionAsProcessed(self, transactionId, category):
2841 
    """
2842 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 2843 
    It essentially deletes the transaction id record for a particular
2844 
    processing type category (if present) from DB.
2845 
    This is currently used by CRM application.
4008 mandeep.dh 2846 
 
2847 
    Parameters:
2848 
     - transactionId
2849 
     - category
2850 
    """
2851 
    self.send_markTransactionAsProcessed(transactionId, category)
2852 
    self.recv_markTransactionAsProcessed()
2853 
 
2854 
  def send_markTransactionAsProcessed(self, transactionId, category):
2855 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
2856 
    args = markTransactionAsProcessed_args()
2857 
    args.transactionId = transactionId
2858 
    args.category = category
2859 
    args.write(self._oprot)
2860 
    self._oprot.writeMessageEnd()
2861 
    self._oprot.trans.flush()
2862 
 
2863 
  def recv_markTransactionAsProcessed(self, ):
2864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2865 
    if mtype == TMessageType.EXCEPTION:
2866 
      x = TApplicationException()
2867 
      x.read(self._iprot)
2868 
      self._iprot.readMessageEnd()
2869 
      raise x
2870 
    result = markTransactionAsProcessed_result()
2871 
    result.read(self._iprot)
2872 
    self._iprot.readMessageEnd()
2873 
    return
2874 
 
4018 chandransh 2875 
  def getItemWiseRiskyOrdersCount(self, ):
2876 
    """
2877 
    Returns a map containing the number of risky orders keyed by item id. A risky order
2878 
    is defined as one whose shipping date is about to expire.
2879 
    """
2880 
    self.send_getItemWiseRiskyOrdersCount()
2881 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 2882 
 
4018 chandransh 2883 
  def send_getItemWiseRiskyOrdersCount(self, ):
2884 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
2885 
    args = getItemWiseRiskyOrdersCount_args()
2886 
    args.write(self._oprot)
2887 
    self._oprot.writeMessageEnd()
2888 
    self._oprot.trans.flush()
2889 
 
2890 
  def recv_getItemWiseRiskyOrdersCount(self, ):
2891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2892 
    if mtype == TMessageType.EXCEPTION:
2893 
      x = TApplicationException()
2894 
      x.read(self._iprot)
2895 
      self._iprot.readMessageEnd()
2896 
      raise x
2897 
    result = getItemWiseRiskyOrdersCount_result()
2898 
    result.read(self._iprot)
2899 
    self._iprot.readMessageEnd()
2900 
    if result.success is not None:
2901 
      return result.success
2902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
2903 
 
4247 rajveer 2904 
  def markOrderCancellationRequestReceived(self, orderId):
2905 
    """
2906 
    Mark order as cancellation request received. If customer sends request of cancellation of
2907 
    a particular order, this method will be called. It will just change status of the order
2908 
    depending on its current status. It also records the previous status, so that we can move
2909 
    back to that status if cancellation request is denied.
4018 chandransh 2910 
 
4247 rajveer 2911 
    Parameters:
2912 
     - orderId
2913 
    """
2914 
    self.send_markOrderCancellationRequestReceived(orderId)
2915 
    self.recv_markOrderCancellationRequestReceived()
2916 
 
2917 
  def send_markOrderCancellationRequestReceived(self, orderId):
2918 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
2919 
    args = markOrderCancellationRequestReceived_args()
2920 
    args.orderId = orderId
2921 
    args.write(self._oprot)
2922 
    self._oprot.writeMessageEnd()
2923 
    self._oprot.trans.flush()
2924 
 
2925 
  def recv_markOrderCancellationRequestReceived(self, ):
2926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2927 
    if mtype == TMessageType.EXCEPTION:
2928 
      x = TApplicationException()
2929 
      x.read(self._iprot)
2930 
      self._iprot.readMessageEnd()
2931 
      raise x
2932 
    result = markOrderCancellationRequestReceived_result()
2933 
    result.read(self._iprot)
2934 
    self._iprot.readMessageEnd()
2935 
    if result.ex is not None:
2936 
      raise result.ex
2937 
    return
2938 
 
2939 
  def markOrderCancellationRequestConfirmed(self, orderId):
2940 
    """
2941 
    If we decide to to cancel order, CRM will call this method to move the status of order to
2942 
    cancellation request confirmed. After this OM will be able to cancel the order.
2943 
 
2944 
    Parameters:
2945 
     - orderId
2946 
    """
2947 
    self.send_markOrderCancellationRequestConfirmed(orderId)
2948 
    self.recv_markOrderCancellationRequestConfirmed()
2949 
 
2950 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
2951 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
2952 
    args = markOrderCancellationRequestConfirmed_args()
2953 
    args.orderId = orderId
2954 
    args.write(self._oprot)
2955 
    self._oprot.writeMessageEnd()
2956 
    self._oprot.trans.flush()
2957 
 
2958 
  def recv_markOrderCancellationRequestConfirmed(self, ):
2959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2960 
    if mtype == TMessageType.EXCEPTION:
2961 
      x = TApplicationException()
2962 
      x.read(self._iprot)
2963 
      self._iprot.readMessageEnd()
2964 
      raise x
2965 
    result = markOrderCancellationRequestConfirmed_result()
2966 
    result.read(self._iprot)
2967 
    self._iprot.readMessageEnd()
2968 
    if result.ex is not None:
2969 
      raise result.ex
2970 
    return
2971 
 
2972 
  def markOrderCancellationRequestDenied(self, orderId):
2973 
    """
2974 
    If we decide to not to cancel order, we will move the order ro previous status.
2975 
 
2976 
    Parameters:
2977 
     - orderId
2978 
    """
2979 
    self.send_markOrderCancellationRequestDenied(orderId)
2980 
    self.recv_markOrderCancellationRequestDenied()
2981 
 
2982 
  def send_markOrderCancellationRequestDenied(self, orderId):
2983 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
2984 
    args = markOrderCancellationRequestDenied_args()
2985 
    args.orderId = orderId
2986 
    args.write(self._oprot)
2987 
    self._oprot.writeMessageEnd()
2988 
    self._oprot.trans.flush()
2989 
 
2990 
  def recv_markOrderCancellationRequestDenied(self, ):
2991 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2992 
    if mtype == TMessageType.EXCEPTION:
2993 
      x = TApplicationException()
2994 
      x.read(self._iprot)
2995 
      self._iprot.readMessageEnd()
2996 
      raise x
2997 
    result = markOrderCancellationRequestDenied_result()
2998 
    result.read(self._iprot)
2999 
    self._iprot.readMessageEnd()
3000 
    if result.ex is not None:
3001 
      raise result.ex
3002 
    return
3003 
 
4258 rajveer 3004 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3005 
    """
4258 rajveer 3006 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3007 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3008 
 
3009 
    Parameters:
4258 rajveer 3010 
     - transactionId
4247 rajveer 3011 
    """
4258 rajveer 3012 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3013 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3014 
 
4258 rajveer 3015 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3016 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3017 
    args = markTransactionAsPaymentFlagRemoved_args()
3018 
    args.transactionId = transactionId
4247 rajveer 3019 
    args.write(self._oprot)
3020 
    self._oprot.writeMessageEnd()
3021 
    self._oprot.trans.flush()
3022 
 
4258 rajveer 3023 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3025 
    if mtype == TMessageType.EXCEPTION:
3026 
      x = TApplicationException()
3027 
      x.read(self._iprot)
3028 
      self._iprot.readMessageEnd()
3029 
      raise x
4258 rajveer 3030 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3031 
    result.read(self._iprot)
3032 
    self._iprot.readMessageEnd()
3033 
    if result.ex is not None:
3034 
      raise result.ex
3035 
    return
3036 
 
3037 
 
3376 rajveer 3038 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3039 
  def __init__(self, handler):
3376 rajveer 3040 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3041 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3042 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3043 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3044 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3045 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3046 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3047 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3048 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3049 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3050 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3051 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3052 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3053 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3054 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3055 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3056 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3057 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3058 
    self._processMap["createOrder"] = Processor.process_createOrder
3059 
    self._processMap["getOrder"] = Processor.process_getOrder
3060 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3061 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3062 
    self._processMap["getAlerts"] = Processor.process_getAlerts
3063 
    self._processMap["setAlert"] = Processor.process_setAlert
3064 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3065 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3066 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3067 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3068 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3069 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3070 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3071 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3072 
    self._processMap["billOrder"] = Processor.process_billOrder
3073 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
3074 
    self._processMap["addJacketNumber"] = Processor.process_addJacketNumber
759 chandransh 3075 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 3076 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3077 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3078 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3079 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3080 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3081 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
3082 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3083 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3084 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3085 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3086 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 3087 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3088 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3089 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3090 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3091 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3092 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3093 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3094 
    self._processMap["changeItem"] = Processor.process_changeItem
3095 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3096 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3097 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3098 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3099 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3100 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4247 rajveer 3101 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3102 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3103 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3104 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
94 ashish 3105 
 
3106 
  def process(self, iprot, oprot):
3107 
    (name, type, seqid) = iprot.readMessageBegin()
3108 
    if name not in self._processMap:
3109 
      iprot.skip(TType.STRUCT)
3110 
      iprot.readMessageEnd()
3111 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3112 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3113 
      x.write(oprot)
3114 
      oprot.writeMessageEnd()
3115 
      oprot.trans.flush()
3116 
      return
3117 
    else:
3118 
      self._processMap[name](self, seqid, iprot, oprot)
3119 
    return True
3120 
 
3121 
  def process_createTransaction(self, seqid, iprot, oprot):
3122 
    args = createTransaction_args()
3123 
    args.read(iprot)
3124 
    iprot.readMessageEnd()
3125 
    result = createTransaction_result()
3126 
    try:
132 ashish 3127 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3128 
    except TransactionServiceException, ex:
3129 
      result.ex = ex
3130 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3131 
    result.write(oprot)
3132 
    oprot.writeMessageEnd()
3133 
    oprot.trans.flush()
3134 
 
3135 
  def process_getTransaction(self, seqid, iprot, oprot):
3136 
    args = getTransaction_args()
3137 
    args.read(iprot)
3138 
    iprot.readMessageEnd()
3139 
    result = getTransaction_result()
3140 
    try:
3141 
      result.success = self._handler.getTransaction(args.id)
3142 
    except TransactionServiceException, ex:
3143 
      result.ex = ex
3144 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3145 
    result.write(oprot)
3146 
    oprot.writeMessageEnd()
3147 
    oprot.trans.flush()
3148 
 
3149 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3150 
    args = getTransactionsForCustomer_args()
3151 
    args.read(iprot)
3152 
    iprot.readMessageEnd()
3153 
    result = getTransactionsForCustomer_result()
3154 
    try:
3155 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3156 
    except TransactionServiceException, ex:
3157 
      result.ex = ex
3158 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3159 
    result.write(oprot)
3160 
    oprot.writeMessageEnd()
3161 
    oprot.trans.flush()
3162 
 
132 ashish 3163 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3164 
    args = getTransactionsForShoppingCartId_args()
3165 
    args.read(iprot)
3166 
    iprot.readMessageEnd()
3167 
    result = getTransactionsForShoppingCartId_result()
3168 
    try:
3169 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3170 
    except TransactionServiceException, ex:
3171 
      result.ex = ex
3172 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3173 
    result.write(oprot)
3174 
    oprot.writeMessageEnd()
3175 
    oprot.trans.flush()
3176 
 
94 ashish 3177 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3178 
    args = getTransactionStatus_args()
3179 
    args.read(iprot)
3180 
    iprot.readMessageEnd()
3181 
    result = getTransactionStatus_result()
3182 
    try:
3183 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3184 
    except TransactionServiceException, ex:
3185 
      result.ex = ex
3186 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3187 
    result.write(oprot)
3188 
    oprot.writeMessageEnd()
3189 
    oprot.trans.flush()
3190 
 
3191 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3192 
    args = changeTransactionStatus_args()
3193 
    args.read(iprot)
3194 
    iprot.readMessageEnd()
3195 
    result = changeTransactionStatus_result()
3196 
    try:
3197 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3198 
    except TransactionServiceException, ex:
3199 
      result.ex = ex
3200 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3201 
    result.write(oprot)
3202 
    oprot.writeMessageEnd()
3203 
    oprot.trans.flush()
3204 
 
1398 varun.gupt 3205 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3206 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3207 
    args.read(iprot)
3208 
    iprot.readMessageEnd()
1398 varun.gupt 3209 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3210 
    try:
1398 varun.gupt 3211 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3212 
    except TransactionServiceException, ex:
3213 
      result.ex = ex
1398 varun.gupt 3214 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3215 
    result.write(oprot)
3216 
    oprot.writeMessageEnd()
3217 
    oprot.trans.flush()
3218 
 
483 rajveer 3219 
  def process_getAllOrders(self, seqid, iprot, oprot):
3220 
    args = getAllOrders_args()
94 ashish 3221 
    args.read(iprot)
3222 
    iprot.readMessageEnd()
483 rajveer 3223 
    result = getAllOrders_result()
94 ashish 3224 
    try:
483 rajveer 3225 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3226 
    except TransactionServiceException, ex:
3227 
      result.ex = ex
483 rajveer 3228 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3229 
    result.write(oprot)
3230 
    oprot.writeMessageEnd()
3231 
    oprot.trans.flush()
3232 
 
4133 chandransh 3233 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3234 
    args = getOrdersInBatch_args()
3235 
    args.read(iprot)
3236 
    iprot.readMessageEnd()
3237 
    result = getOrdersInBatch_result()
3238 
    try:
3239 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3240 
    except TransactionServiceException, ex:
3241 
      result.ex = ex
3242 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3243 
    result.write(oprot)
3244 
    oprot.writeMessageEnd()
3245 
    oprot.trans.flush()
3246 
 
3247 
  def process_getOrderCount(self, seqid, iprot, oprot):
3248 
    args = getOrderCount_args()
3249 
    args.read(iprot)
3250 
    iprot.readMessageEnd()
3251 
    result = getOrderCount_result()
3252 
    try:
3253 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3254 
    except TransactionServiceException, ex:
3255 
      result.ex = ex
3256 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3257 
    result.write(oprot)
3258 
    oprot.writeMessageEnd()
3259 
    oprot.trans.flush()
3260 
 
999 varun.gupt 3261 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3262 
    args = getOrdersByBillingDate_args()
3263 
    args.read(iprot)
3264 
    iprot.readMessageEnd()
3265 
    result = getOrdersByBillingDate_result()
3266 
    try:
3267 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3268 
    except TransactionServiceException, ex:
3269 
      result.ex = ex
3270 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3271 
    result.write(oprot)
3272 
    oprot.writeMessageEnd()
3273 
    oprot.trans.flush()
3274 
 
3427 chandransh 3275 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3276 
    args = getOrdersByShippingDate_args()
3277 
    args.read(iprot)
3278 
    iprot.readMessageEnd()
3279 
    result = getOrdersByShippingDate_result()
3280 
    try:
3451 chandransh 3281 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3282 
    except TransactionServiceException, ex:
3283 
      result.ex = ex
3284 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3285 
    result.write(oprot)
3286 
    oprot.writeMessageEnd()
3287 
    oprot.trans.flush()
3288 
 
1382 varun.gupt 3289 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3290 
    args = getReturnableOrdersForCustomer_args()
3291 
    args.read(iprot)
3292 
    iprot.readMessageEnd()
3293 
    result = getReturnableOrdersForCustomer_result()
3294 
    try:
3295 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3296 
    except TransactionServiceException, ex:
3297 
      result.ex = ex
3298 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3299 
    result.write(oprot)
3300 
    oprot.writeMessageEnd()
3301 
    oprot.trans.flush()
3302 
 
3303 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3304 
    args = getCancellableOrdersForCustomer_args()
3305 
    args.read(iprot)
3306 
    iprot.readMessageEnd()
3307 
    result = getCancellableOrdersForCustomer_result()
3308 
    try:
3309 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3310 
    except TransactionServiceException, ex:
3311 
      result.ex = ex
3312 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3313 
    result.write(oprot)
3314 
    oprot.writeMessageEnd()
3315 
    oprot.trans.flush()
3316 
 
483 rajveer 3317 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3318 
    args = changeOrderStatus_args()
94 ashish 3319 
    args.read(iprot)
3320 
    iprot.readMessageEnd()
483 rajveer 3321 
    result = changeOrderStatus_result()
94 ashish 3322 
    try:
483 rajveer 3323 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3324 
    except TransactionServiceException, ex:
3325 
      result.ex = ex
483 rajveer 3326 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3327 
    result.write(oprot)
3328 
    oprot.writeMessageEnd()
3329 
    oprot.trans.flush()
3330 
 
483 rajveer 3331 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3332 
    args = getOrdersForTransaction_args()
94 ashish 3333 
    args.read(iprot)
3334 
    iprot.readMessageEnd()
483 rajveer 3335 
    result = getOrdersForTransaction_result()
94 ashish 3336 
    try:
1528 ankur.sing 3337 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 3338 
    except TransactionServiceException, ex:
3339 
      result.ex = ex
483 rajveer 3340 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 3341 
    result.write(oprot)
3342 
    oprot.writeMessageEnd()
3343 
    oprot.trans.flush()
3344 
 
483 rajveer 3345 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
3346 
    args = getOrdersForCustomer_args()
94 ashish 3347 
    args.read(iprot)
3348 
    iprot.readMessageEnd()
483 rajveer 3349 
    result = getOrdersForCustomer_result()
94 ashish 3350 
    try:
3014 chandransh 3351 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 3352 
    except TransactionServiceException, ex:
3353 
      result.ex = ex
483 rajveer 3354 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 3355 
    result.write(oprot)
3356 
    oprot.writeMessageEnd()
3357 
    oprot.trans.flush()
3358 
 
483 rajveer 3359 
  def process_createOrder(self, seqid, iprot, oprot):
3360 
    args = createOrder_args()
94 ashish 3361 
    args.read(iprot)
3362 
    iprot.readMessageEnd()
483 rajveer 3363 
    result = createOrder_result()
94 ashish 3364 
    try:
483 rajveer 3365 
      result.success = self._handler.createOrder(args.order)
94 ashish 3366 
    except TransactionServiceException, ex:
3367 
      result.ex = ex
483 rajveer 3368 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 3369 
    result.write(oprot)
3370 
    oprot.writeMessageEnd()
3371 
    oprot.trans.flush()
3372 
 
483 rajveer 3373 
  def process_getOrder(self, seqid, iprot, oprot):
3374 
    args = getOrder_args()
94 ashish 3375 
    args.read(iprot)
3376 
    iprot.readMessageEnd()
483 rajveer 3377 
    result = getOrder_result()
94 ashish 3378 
    try:
483 rajveer 3379 
      result.success = self._handler.getOrder(args.id)
94 ashish 3380 
    except TransactionServiceException, ex:
3381 
      result.ex = ex
483 rajveer 3382 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 3383 
    result.write(oprot)
3384 
    oprot.writeMessageEnd()
3385 
    oprot.trans.flush()
3386 
 
483 rajveer 3387 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
3388 
    args = getLineItemsForOrder_args()
94 ashish 3389 
    args.read(iprot)
3390 
    iprot.readMessageEnd()
483 rajveer 3391 
    result = getLineItemsForOrder_result()
94 ashish 3392 
    try:
483 rajveer 3393 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 3394 
    except TransactionServiceException, ex:
3395 
      result.ex = ex
483 rajveer 3396 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 3397 
    result.write(oprot)
3398 
    oprot.writeMessageEnd()
3399 
    oprot.trans.flush()
3400 
 
1528 ankur.sing 3401 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
3402 
    args = getOrderForCustomer_args()
3403 
    args.read(iprot)
3404 
    iprot.readMessageEnd()
3405 
    result = getOrderForCustomer_result()
3406 
    try:
3407 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
3408 
    except TransactionServiceException, ex:
3409 
      result.ex = ex
3410 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
3411 
    result.write(oprot)
3412 
    oprot.writeMessageEnd()
3413 
    oprot.trans.flush()
3414 
 
3064 chandransh 3415 
  def process_getAlerts(self, seqid, iprot, oprot):
3416 
    args = getAlerts_args()
3417 
    args.read(iprot)
3418 
    iprot.readMessageEnd()
3419 
    result = getAlerts_result()
3420 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
3421 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
3422 
    result.write(oprot)
3423 
    oprot.writeMessageEnd()
3424 
    oprot.trans.flush()
3425 
 
3426 
  def process_setAlert(self, seqid, iprot, oprot):
3427 
    args = setAlert_args()
3428 
    args.read(iprot)
3429 
    iprot.readMessageEnd()
3430 
    result = setAlert_result()
3431 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
3432 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
3433 
    result.write(oprot)
3434 
    oprot.writeMessageEnd()
3435 
    oprot.trans.flush()
3436 
 
3437 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
3438 
    args = getValidOrderCount_args()
3439 
    args.read(iprot)
3440 
    iprot.readMessageEnd()
3441 
    result = getValidOrderCount_result()
3442 
    result.success = self._handler.getValidOrderCount()
3443 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
3444 
    result.write(oprot)
3445 
    oprot.writeMessageEnd()
3446 
    oprot.trans.flush()
3447 
 
3448 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
3449 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
3450 
    args.read(iprot)
3451 
    iprot.readMessageEnd()
3452 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
3453 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
3454 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
3455 
    result.write(oprot)
3456 
    oprot.writeMessageEnd()
3457 
    oprot.trans.flush()
3458 
 
3459 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
3460 
    args = getValidOrdersAmountRange_args()
3461 
    args.read(iprot)
3462 
    iprot.readMessageEnd()
3463 
    result = getValidOrdersAmountRange_result()
3464 
    result.success = self._handler.getValidOrdersAmountRange()
3465 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
3466 
    result.write(oprot)
3467 
    oprot.writeMessageEnd()
3468 
    oprot.trans.flush()
3469 
 
3470 
  def process_getValidOrders(self, seqid, iprot, oprot):
3471 
    args = getValidOrders_args()
3472 
    args.read(iprot)
3473 
    iprot.readMessageEnd()
3474 
    result = getValidOrders_result()
3475 
    result.success = self._handler.getValidOrders(args.limit)
3476 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
3477 
    result.write(oprot)
3478 
    oprot.writeMessageEnd()
3479 
    oprot.trans.flush()
3480 
 
1220 chandransh 3481 
  def process_batchOrders(self, seqid, iprot, oprot):
3482 
    args = batchOrders_args()
3483 
    args.read(iprot)
3484 
    iprot.readMessageEnd()
3485 
    result = batchOrders_result()
3486 
    try:
3487 
      result.success = self._handler.batchOrders(args.warehouseId)
3488 
    except TransactionServiceException, ex:
3489 
      result.ex = ex
3490 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
3491 
    result.write(oprot)
3492 
    oprot.writeMessageEnd()
3493 
    oprot.trans.flush()
3494 
 
1208 chandransh 3495 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
3496 
    args = markOrderAsOutOfStock_args()
3497 
    args.read(iprot)
3498 
    iprot.readMessageEnd()
3499 
    result = markOrderAsOutOfStock_result()
3500 
    try:
3501 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
3502 
    except TransactionServiceException, ex:
3503 
      result.ex = ex
3504 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
3505 
    result.write(oprot)
3506 
    oprot.writeMessageEnd()
3507 
    oprot.trans.flush()
3508 
 
3064 chandransh 3509 
  def process_verifyOrder(self, seqid, iprot, oprot):
3510 
    args = verifyOrder_args()
759 chandransh 3511 
    args.read(iprot)
3512 
    iprot.readMessageEnd()
3064 chandransh 3513 
    result = verifyOrder_result()
759 chandransh 3514 
    try:
3064 chandransh 3515 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 3516 
    except TransactionServiceException, ex:
3517 
      result.ex = ex
3064 chandransh 3518 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 3519 
    result.write(oprot)
3520 
    oprot.writeMessageEnd()
3521 
    oprot.trans.flush()
3522 
 
3064 chandransh 3523 
  def process_acceptOrder(self, seqid, iprot, oprot):
3524 
    args = acceptOrder_args()
1113 chandransh 3525 
    args.read(iprot)
3526 
    iprot.readMessageEnd()
3064 chandransh 3527 
    result = acceptOrder_result()
1113 chandransh 3528 
    try:
3064 chandransh 3529 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 3530 
    except TransactionServiceException, ex:
3531 
      result.ex = ex
3064 chandransh 3532 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 3533 
    result.write(oprot)
3534 
    oprot.writeMessageEnd()
3535 
    oprot.trans.flush()
3536 
 
3064 chandransh 3537 
  def process_billOrder(self, seqid, iprot, oprot):
3538 
    args = billOrder_args()
1132 chandransh 3539 
    args.read(iprot)
3540 
    iprot.readMessageEnd()
3064 chandransh 3541 
    result = billOrder_result()
1132 chandransh 3542 
    try:
3064 chandransh 3543 
      result.success = self._handler.billOrder(args.orderId)
1132 chandransh 3544 
    except TransactionServiceException, ex:
3545 
      result.ex = ex
3064 chandransh 3546 
    oprot.writeMessageBegin("billOrder", TMessageType.REPLY, seqid)
1132 chandransh 3547 
    result.write(oprot)
3548 
    oprot.writeMessageEnd()
3549 
    oprot.trans.flush()
3550 
 
3064 chandransh 3551 
  def process_addBillingDetails(self, seqid, iprot, oprot):
3552 
    args = addBillingDetails_args()
1135 chandransh 3553 
    args.read(iprot)
3554 
    iprot.readMessageEnd()
3064 chandransh 3555 
    result = addBillingDetails_result()
1135 chandransh 3556 
    try:
3064 chandransh 3557 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.billed_by)
1135 chandransh 3558 
    except TransactionServiceException, ex:
3559 
      result.ex = ex
3064 chandransh 3560 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 3561 
    result.write(oprot)
3562 
    oprot.writeMessageEnd()
3563 
    oprot.trans.flush()
3564 
 
3064 chandransh 3565 
  def process_addJacketNumber(self, seqid, iprot, oprot):
3566 
    args = addJacketNumber_args()
1246 chandransh 3567 
    args.read(iprot)
3568 
    iprot.readMessageEnd()
3064 chandransh 3569 
    result = addJacketNumber_result()
1246 chandransh 3570 
    try:
3064 chandransh 3571 
      result.success = self._handler.addJacketNumber(args.orderId, args.jacketNumber, args.imeiNumber, args.itemNumber, args.billedBy, args.billingType)
1246 chandransh 3572 
    except TransactionServiceException, ex:
3573 
      result.ex = ex
3064 chandransh 3574 
    oprot.writeMessageBegin("addJacketNumber", TMessageType.REPLY, seqid)
1246 chandransh 3575 
    result.write(oprot)
3576 
    oprot.writeMessageEnd()
3577 
    oprot.trans.flush()
3578 
 
3064 chandransh 3579 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
3580 
    args = markOrdersAsManifested_args()
1408 ankur.sing 3581 
    args.read(iprot)
3582 
    iprot.readMessageEnd()
3064 chandransh 3583 
    result = markOrdersAsManifested_result()
3584 
    try:
3585 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
3586 
    except TransactionServiceException, ex:
3587 
      result.ex = ex
3588 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 3589 
    result.write(oprot)
3590 
    oprot.writeMessageEnd()
3591 
    oprot.trans.flush()
3592 
 
3064 chandransh 3593 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
3594 
    args = markOrdersAsPickedUp_args()
304 ashish 3595 
    args.read(iprot)
3596 
    iprot.readMessageEnd()
3064 chandransh 3597 
    result = markOrdersAsPickedUp_result()
3598 
    try:
3599 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3600 
    except TransactionServiceException, ex:
3601 
      result.ex = ex
3602 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 3603 
    result.write(oprot)
3604 
    oprot.writeMessageEnd()
3605 
    oprot.trans.flush()
94 ashish 3606 
 
3064 chandransh 3607 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
3608 
    args = markOrdersAsDelivered_args()
304 ashish 3609 
    args.read(iprot)
3610 
    iprot.readMessageEnd()
3064 chandransh 3611 
    result = markOrdersAsDelivered_result()
3612 
    try:
3613 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
3614 
    except TransactionServiceException, ex:
3615 
      result.ex = ex
3616 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 3617 
    result.write(oprot)
3618 
    oprot.writeMessageEnd()
3619 
    oprot.trans.flush()
3620 
 
3064 chandransh 3621 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
3622 
    args = markOrdersAsFailed_args()
1596 ankur.sing 3623 
    args.read(iprot)
3624 
    iprot.readMessageEnd()
3064 chandransh 3625 
    result = markOrdersAsFailed_result()
3626 
    try:
3627 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
3628 
    except TransactionServiceException, ex:
3629 
      result.ex = ex
3630 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 3631 
    result.write(oprot)
3632 
    oprot.writeMessageEnd()
3633 
    oprot.trans.flush()
304 ashish 3634 
 
3064 chandransh 3635 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
3636 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 3637 
    args.read(iprot)
3638 
    iprot.readMessageEnd()
3064 chandransh 3639 
    result = updateNonDeliveryReason_result()
3640 
    try:
3641 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3642 
    except TransactionServiceException, ex:
3643 
      result.ex = ex
3644 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 3645 
    result.write(oprot)
3646 
    oprot.writeMessageEnd()
3647 
    oprot.trans.flush()
1596 ankur.sing 3648 
 
3064 chandransh 3649 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
3650 
    args = getUndeliveredOrders_args()
1627 ankur.sing 3651 
    args.read(iprot)
3652 
    iprot.readMessageEnd()
3064 chandransh 3653 
    result = getUndeliveredOrders_result()
3654 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
3655 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 3656 
    result.write(oprot)
3657 
    oprot.writeMessageEnd()
3658 
    oprot.trans.flush()
3659 
 
2536 chandransh 3660 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
3661 
    args = toggleDOAFlag_args()
3662 
    args.read(iprot)
3663 
    iprot.readMessageEnd()
3664 
    result = toggleDOAFlag_result()
3665 
    try:
3666 
      result.success = self._handler.toggleDOAFlag(args.orderId)
3667 
    except TransactionServiceException, ex:
3668 
      result.ex = ex
3669 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
3670 
    result.write(oprot)
3671 
    oprot.writeMessageEnd()
3672 
    oprot.trans.flush()
1886 ankur.sing 3673 
 
2536 chandransh 3674 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
3675 
    args = requestPickupNumber_args()
3676 
    args.read(iprot)
3677 
    iprot.readMessageEnd()
3678 
    result = requestPickupNumber_result()
3679 
    try:
3680 
      result.success = self._handler.requestPickupNumber(args.orderId)
3681 
    except TransactionServiceException, ex:
3682 
      result.ex = ex
3683 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
3684 
    result.write(oprot)
3685 
    oprot.writeMessageEnd()
3686 
    oprot.trans.flush()
3687 
 
3688 
  def process_authorizePickup(self, seqid, iprot, oprot):
3689 
    args = authorizePickup_args()
3690 
    args.read(iprot)
3691 
    iprot.readMessageEnd()
3692 
    result = authorizePickup_result()
3693 
    try:
3694 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
3695 
    except TransactionServiceException, ex:
3696 
      result.ex = ex
3697 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
3698 
    result.write(oprot)
3699 
    oprot.writeMessageEnd()
3700 
    oprot.trans.flush()
3701 
 
2764 chandransh 3702 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
3703 
    args = markDoasAsPickedUp_args()
3704 
    args.read(iprot)
3705 
    iprot.readMessageEnd()
3706 
    result = markDoasAsPickedUp_result()
3707 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
3708 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
3709 
    result.write(oprot)
3710 
    oprot.writeMessageEnd()
3711 
    oprot.trans.flush()
3712 
 
2616 chandransh 3713 
  def process_receiveReturn(self, seqid, iprot, oprot):
3714 
    args = receiveReturn_args()
2591 chandransh 3715 
    args.read(iprot)
3716 
    iprot.readMessageEnd()
2616 chandransh 3717 
    result = receiveReturn_result()
2591 chandransh 3718 
    try:
2616 chandransh 3719 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 3720 
    except TransactionServiceException, ex:
3721 
      result.ex = ex
2616 chandransh 3722 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 3723 
    result.write(oprot)
3724 
    oprot.writeMessageEnd()
3725 
    oprot.trans.flush()
2536 chandransh 3726 
 
2591 chandransh 3727 
  def process_validateDoa(self, seqid, iprot, oprot):
3728 
    args = validateDoa_args()
3729 
    args.read(iprot)
3730 
    iprot.readMessageEnd()
3731 
    result = validateDoa_result()
3732 
    try:
3733 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
3734 
    except TransactionServiceException, ex:
3735 
      result.ex = ex
3736 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
3737 
    result.write(oprot)
3738 
    oprot.writeMessageEnd()
3739 
    oprot.trans.flush()
3740 
 
2616 chandransh 3741 
  def process_reshipOrder(self, seqid, iprot, oprot):
3742 
    args = reshipOrder_args()
3743 
    args.read(iprot)
3744 
    iprot.readMessageEnd()
3745 
    result = reshipOrder_result()
3746 
    try:
3747 
      result.success = self._handler.reshipOrder(args.orderId)
3748 
    except TransactionServiceException, ex:
3749 
      result.ex = ex
3750 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
3751 
    result.write(oprot)
3752 
    oprot.writeMessageEnd()
3753 
    oprot.trans.flush()
2591 chandransh 3754 
 
2616 chandransh 3755 
  def process_refundOrder(self, seqid, iprot, oprot):
3756 
    args = refundOrder_args()
3757 
    args.read(iprot)
3758 
    iprot.readMessageEnd()
3759 
    result = refundOrder_result()
3760 
    try:
3226 chandransh 3761 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 3762 
    except TransactionServiceException, ex:
3763 
      result.ex = ex
3764 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
3765 
    result.write(oprot)
3766 
    oprot.writeMessageEnd()
3767 
    oprot.trans.flush()
3768 
 
2690 chandransh 3769 
  def process_getReturnOrders(self, seqid, iprot, oprot):
3770 
    args = getReturnOrders_args()
3771 
    args.read(iprot)
3772 
    iprot.readMessageEnd()
3773 
    result = getReturnOrders_result()
3774 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
3775 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
3776 
    result.write(oprot)
3777 
    oprot.writeMessageEnd()
3778 
    oprot.trans.flush()
2616 chandransh 3779 
 
2700 chandransh 3780 
  def process_getReturnOrder(self, seqid, iprot, oprot):
3781 
    args = getReturnOrder_args()
3782 
    args.read(iprot)
3783 
    iprot.readMessageEnd()
3784 
    result = getReturnOrder_result()
3785 
    try:
3786 
      result.success = self._handler.getReturnOrder(args.id)
3787 
    except TransactionServiceException, ex:
3788 
      result.ex = ex
3789 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
3790 
    result.write(oprot)
3791 
    oprot.writeMessageEnd()
3792 
    oprot.trans.flush()
3793 
 
2690 chandransh 3794 
  def process_processReturn(self, seqid, iprot, oprot):
3795 
    args = processReturn_args()
3796 
    args.read(iprot)
3797 
    iprot.readMessageEnd()
3798 
    result = processReturn_result()
3799 
    try:
3800 
      self._handler.processReturn(args.returnOrderId)
3801 
    except TransactionServiceException, ex:
3802 
      result.ex = ex
3803 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
3804 
    result.write(oprot)
3805 
    oprot.writeMessageEnd()
3806 
    oprot.trans.flush()
3807 
 
2819 chandransh 3808 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
3809 
    args = createPurchaseOrder_args()
3810 
    args.read(iprot)
3811 
    iprot.readMessageEnd()
3812 
    result = createPurchaseOrder_result()
3813 
    try:
3814 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
3815 
    except TransactionServiceException, ex:
3816 
      result.ex = ex
3817 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
3818 
    result.write(oprot)
3819 
    oprot.writeMessageEnd()
3820 
    oprot.trans.flush()
2690 chandransh 3821 
 
3451 chandransh 3822 
  def process_updateWeight(self, seqid, iprot, oprot):
3823 
    args = updateWeight_args()
3824 
    args.read(iprot)
3825 
    iprot.readMessageEnd()
3826 
    result = updateWeight_result()
3827 
    try:
3828 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
3829 
    except TransactionServiceException, ex:
3830 
      result.ex = ex
3831 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
3832 
    result.write(oprot)
3833 
    oprot.writeMessageEnd()
3834 
    oprot.trans.flush()
2819 chandransh 3835 
 
3469 chandransh 3836 
  def process_changeItem(self, seqid, iprot, oprot):
3837 
    args = changeItem_args()
3838 
    args.read(iprot)
3839 
    iprot.readMessageEnd()
3840 
    result = changeItem_result()
3841 
    try:
3842 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
3843 
    except TransactionServiceException, ex:
3844 
      result.ex = ex
3845 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
3846 
    result.write(oprot)
3847 
    oprot.writeMessageEnd()
3848 
    oprot.trans.flush()
3451 chandransh 3849 
 
3469 chandransh 3850 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
3851 
    args = shiftToWarehouse_args()
3852 
    args.read(iprot)
3853 
    iprot.readMessageEnd()
3854 
    result = shiftToWarehouse_result()
3855 
    try:
3856 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
3857 
    except TransactionServiceException, ex:
3858 
      result.ex = ex
3859 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
3860 
    result.write(oprot)
3861 
    oprot.writeMessageEnd()
3862 
    oprot.trans.flush()
3863 
 
3553 chandransh 3864 
  def process_addDelayReason(self, seqid, iprot, oprot):
3865 
    args = addDelayReason_args()
3866 
    args.read(iprot)
3867 
    iprot.readMessageEnd()
3868 
    result = addDelayReason_result()
3869 
    try:
3986 chandransh 3870 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 3871 
    except TransactionServiceException, ex:
3872 
      result.ex = ex
3873 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
3874 
    result.write(oprot)
3875 
    oprot.writeMessageEnd()
3876 
    oprot.trans.flush()
3469 chandransh 3877 
 
3956 chandransh 3878 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
3879 
    args = reconcileCodCollection_args()
3880 
    args.read(iprot)
3881 
    iprot.readMessageEnd()
3882 
    result = reconcileCodCollection_result()
3883 
    try:
3884 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
3885 
    except TransactionServiceException, ex:
3886 
      result.ex = ex
3887 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
3888 
    result.write(oprot)
3889 
    oprot.writeMessageEnd()
3890 
    oprot.trans.flush()
3553 chandransh 3891 
 
4008 mandeep.dh 3892 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
3893 
    args = getTransactionsRequiringExtraProcessing_args()
3894 
    args.read(iprot)
3895 
    iprot.readMessageEnd()
3896 
    result = getTransactionsRequiringExtraProcessing_result()
3897 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
3898 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
3899 
    result.write(oprot)
3900 
    oprot.writeMessageEnd()
3901 
    oprot.trans.flush()
3956 chandransh 3902 
 
4008 mandeep.dh 3903 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
3904 
    args = markTransactionAsProcessed_args()
3905 
    args.read(iprot)
3906 
    iprot.readMessageEnd()
3907 
    result = markTransactionAsProcessed_result()
3908 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
3909 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
3910 
    result.write(oprot)
3911 
    oprot.writeMessageEnd()
3912 
    oprot.trans.flush()
3913 
 
4018 chandransh 3914 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
3915 
    args = getItemWiseRiskyOrdersCount_args()
3916 
    args.read(iprot)
3917 
    iprot.readMessageEnd()
3918 
    result = getItemWiseRiskyOrdersCount_result()
3919 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
3920 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
3921 
    result.write(oprot)
3922 
    oprot.writeMessageEnd()
3923 
    oprot.trans.flush()
4008 mandeep.dh 3924 
 
4247 rajveer 3925 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
3926 
    args = markOrderCancellationRequestReceived_args()
3927 
    args.read(iprot)
3928 
    iprot.readMessageEnd()
3929 
    result = markOrderCancellationRequestReceived_result()
3930 
    try:
3931 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
3932 
    except TransactionServiceException, ex:
3933 
      result.ex = ex
3934 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
3935 
    result.write(oprot)
3936 
    oprot.writeMessageEnd()
3937 
    oprot.trans.flush()
4018 chandransh 3938 
 
4247 rajveer 3939 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
3940 
    args = markOrderCancellationRequestConfirmed_args()
3941 
    args.read(iprot)
3942 
    iprot.readMessageEnd()
3943 
    result = markOrderCancellationRequestConfirmed_result()
3944 
    try:
3945 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
3946 
    except TransactionServiceException, ex:
3947 
      result.ex = ex
3948 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
3949 
    result.write(oprot)
3950 
    oprot.writeMessageEnd()
3951 
    oprot.trans.flush()
3952 
 
3953 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
3954 
    args = markOrderCancellationRequestDenied_args()
3955 
    args.read(iprot)
3956 
    iprot.readMessageEnd()
3957 
    result = markOrderCancellationRequestDenied_result()
3958 
    try:
3959 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
3960 
    except TransactionServiceException, ex:
3961 
      result.ex = ex
3962 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
3963 
    result.write(oprot)
3964 
    oprot.writeMessageEnd()
3965 
    oprot.trans.flush()
3966 
 
4258 rajveer 3967 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
3968 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 3969 
    args.read(iprot)
3970 
    iprot.readMessageEnd()
4258 rajveer 3971 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3972 
    try:
4258 rajveer 3973 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 3974 
    except TransactionServiceException, ex:
3975 
      result.ex = ex
4258 rajveer 3976 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 3977 
    result.write(oprot)
3978 
    oprot.writeMessageEnd()
3979 
    oprot.trans.flush()
3980 
 
3981 
 
94 ashish 3982 
# HELPER FUNCTIONS AND STRUCTURES
3983 
 
3984 
class createTransaction_args:
3985 
  """
3986 
  Attributes:
3987 
   - transaction
3988 
  """
3989 
 
3990 
  thrift_spec = (
3991 
    None, # 0
3992 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
3993 
  )
3994 
 
3995 
  def __init__(self, transaction=None,):
3996 
    self.transaction = transaction
3997 
 
3998 
  def read(self, iprot):
3999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4001 
      return
4002 
    iprot.readStructBegin()
4003 
    while True:
4004 
      (fname, ftype, fid) = iprot.readFieldBegin()
4005 
      if ftype == TType.STOP:
4006 
        break
4007 
      if fid == 1:
4008 
        if ftype == TType.STRUCT:
4009 
          self.transaction = Transaction()
4010 
          self.transaction.read(iprot)
4011 
        else:
4012 
          iprot.skip(ftype)
4013 
      else:
4014 
        iprot.skip(ftype)
4015 
      iprot.readFieldEnd()
4016 
    iprot.readStructEnd()
4017 
 
4018 
  def write(self, oprot):
4019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4021 
      return
4022 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4023 
    if self.transaction is not None:
94 ashish 4024 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4025 
      self.transaction.write(oprot)
4026 
      oprot.writeFieldEnd()
4027 
    oprot.writeFieldStop()
4028 
    oprot.writeStructEnd()
4029 
 
3431 rajveer 4030 
  def validate(self):
4031 
    return
4032 
 
4033 
 
94 ashish 4034 
  def __repr__(self):
4035 
    L = ['%s=%r' % (key, value)
4036 
      for key, value in self.__dict__.iteritems()]
4037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4038 
 
4039 
  def __eq__(self, other):
4040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4041 
 
4042 
  def __ne__(self, other):
4043 
    return not (self == other)
4044 
 
4045 
class createTransaction_result:
4046 
  """
4047 
  Attributes:
132 ashish 4048 
   - success
94 ashish 4049 
   - ex
4050 
  """
4051 
 
4052 
  thrift_spec = (
132 ashish 4053 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4054 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4055 
  )
4056 
 
132 ashish 4057 
  def __init__(self, success=None, ex=None,):
4058 
    self.success = success
94 ashish 4059 
    self.ex = ex
4060 
 
4061 
  def read(self, iprot):
4062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4064 
      return
4065 
    iprot.readStructBegin()
4066 
    while True:
4067 
      (fname, ftype, fid) = iprot.readFieldBegin()
4068 
      if ftype == TType.STOP:
4069 
        break
132 ashish 4070 
      if fid == 0:
4071 
        if ftype == TType.I64:
4072 
          self.success = iprot.readI64();
4073 
        else:
4074 
          iprot.skip(ftype)
4075 
      elif fid == 1:
94 ashish 4076 
        if ftype == TType.STRUCT:
4077 
          self.ex = TransactionServiceException()
4078 
          self.ex.read(iprot)
4079 
        else:
4080 
          iprot.skip(ftype)
4081 
      else:
4082 
        iprot.skip(ftype)
4083 
      iprot.readFieldEnd()
4084 
    iprot.readStructEnd()
4085 
 
4086 
  def write(self, oprot):
4087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4089 
      return
4090 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4091 
    if self.success is not None:
132 ashish 4092 
      oprot.writeFieldBegin('success', TType.I64, 0)
4093 
      oprot.writeI64(self.success)
4094 
      oprot.writeFieldEnd()
3431 rajveer 4095 
    if self.ex is not None:
94 ashish 4096 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4097 
      self.ex.write(oprot)
4098 
      oprot.writeFieldEnd()
4099 
    oprot.writeFieldStop()
4100 
    oprot.writeStructEnd()
4101 
 
3431 rajveer 4102 
  def validate(self):
4103 
    return
4104 
 
4105 
 
94 ashish 4106 
  def __repr__(self):
4107 
    L = ['%s=%r' % (key, value)
4108 
      for key, value in self.__dict__.iteritems()]
4109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4110 
 
4111 
  def __eq__(self, other):
4112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4113 
 
4114 
  def __ne__(self, other):
4115 
    return not (self == other)
4116 
 
4117 
class getTransaction_args:
4118 
  """
4119 
  Attributes:
4120 
   - id
4121 
  """
4122 
 
4123 
  thrift_spec = (
4124 
    None, # 0
4125 
    (1, TType.I64, 'id', None, None, ), # 1
4126 
  )
4127 
 
4128 
  def __init__(self, id=None,):
4129 
    self.id = id
4130 
 
4131 
  def read(self, iprot):
4132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4134 
      return
4135 
    iprot.readStructBegin()
4136 
    while True:
4137 
      (fname, ftype, fid) = iprot.readFieldBegin()
4138 
      if ftype == TType.STOP:
4139 
        break
4140 
      if fid == 1:
4141 
        if ftype == TType.I64:
4142 
          self.id = iprot.readI64();
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('getTransaction_args')
3431 rajveer 4155 
    if self.id is not None:
94 ashish 4156 
      oprot.writeFieldBegin('id', TType.I64, 1)
4157 
      oprot.writeI64(self.id)
4158 
      oprot.writeFieldEnd()
4159 
    oprot.writeFieldStop()
4160 
    oprot.writeStructEnd()
4161 
 
3431 rajveer 4162 
  def validate(self):
4163 
    return
4164 
 
4165 
 
94 ashish 4166 
  def __repr__(self):
4167 
    L = ['%s=%r' % (key, value)
4168 
      for key, value in self.__dict__.iteritems()]
4169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4170 
 
4171 
  def __eq__(self, other):
4172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4173 
 
4174 
  def __ne__(self, other):
4175 
    return not (self == other)
4176 
 
4177 
class getTransaction_result:
4178 
  """
4179 
  Attributes:
4180 
   - success
4181 
   - ex
4182 
  """
4183 
 
4184 
  thrift_spec = (
4185 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
4186 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4187 
  )
4188 
 
4189 
  def __init__(self, success=None, ex=None,):
4190 
    self.success = success
4191 
    self.ex = ex
4192 
 
4193 
  def read(self, iprot):
4194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4196 
      return
4197 
    iprot.readStructBegin()
4198 
    while True:
4199 
      (fname, ftype, fid) = iprot.readFieldBegin()
4200 
      if ftype == TType.STOP:
4201 
        break
4202 
      if fid == 0:
4203 
        if ftype == TType.STRUCT:
4204 
          self.success = Transaction()
4205 
          self.success.read(iprot)
4206 
        else:
4207 
          iprot.skip(ftype)
4208 
      elif fid == 1:
4209 
        if ftype == TType.STRUCT:
4210 
          self.ex = TransactionServiceException()
4211 
          self.ex.read(iprot)
4212 
        else:
4213 
          iprot.skip(ftype)
4214 
      else:
4215 
        iprot.skip(ftype)
4216 
      iprot.readFieldEnd()
4217 
    iprot.readStructEnd()
4218 
 
4219 
  def write(self, oprot):
4220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4222 
      return
4223 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 4224 
    if self.success is not None:
94 ashish 4225 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4226 
      self.success.write(oprot)
4227 
      oprot.writeFieldEnd()
3431 rajveer 4228 
    if self.ex is not None:
94 ashish 4229 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4230 
      self.ex.write(oprot)
4231 
      oprot.writeFieldEnd()
4232 
    oprot.writeFieldStop()
4233 
    oprot.writeStructEnd()
4234 
 
3431 rajveer 4235 
  def validate(self):
4236 
    return
4237 
 
4238 
 
94 ashish 4239 
  def __repr__(self):
4240 
    L = ['%s=%r' % (key, value)
4241 
      for key, value in self.__dict__.iteritems()]
4242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4243 
 
4244 
  def __eq__(self, other):
4245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4246 
 
4247 
  def __ne__(self, other):
4248 
    return not (self == other)
4249 
 
4250 
class getTransactionsForCustomer_args:
4251 
  """
4252 
  Attributes:
4253 
   - customerId
4254 
   - from_date
4255 
   - to_date
4256 
   - status
4257 
  """
4258 
 
4259 
  thrift_spec = (
4260 
    None, # 0
4261 
    (1, TType.I64, 'customerId', None, None, ), # 1
4262 
    (2, TType.I64, 'from_date', None, None, ), # 2
4263 
    (3, TType.I64, 'to_date', None, None, ), # 3
4264 
    (4, TType.I32, 'status', None, None, ), # 4
4265 
  )
4266 
 
4267 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
4268 
    self.customerId = customerId
4269 
    self.from_date = from_date
4270 
    self.to_date = to_date
4271 
    self.status = status
4272 
 
4273 
  def read(self, iprot):
4274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4276 
      return
4277 
    iprot.readStructBegin()
4278 
    while True:
4279 
      (fname, ftype, fid) = iprot.readFieldBegin()
4280 
      if ftype == TType.STOP:
4281 
        break
4282 
      if fid == 1:
4283 
        if ftype == TType.I64:
4284 
          self.customerId = iprot.readI64();
4285 
        else:
4286 
          iprot.skip(ftype)
4287 
      elif fid == 2:
4288 
        if ftype == TType.I64:
4289 
          self.from_date = iprot.readI64();
4290 
        else:
4291 
          iprot.skip(ftype)
4292 
      elif fid == 3:
4293 
        if ftype == TType.I64:
4294 
          self.to_date = iprot.readI64();
4295 
        else:
4296 
          iprot.skip(ftype)
4297 
      elif fid == 4:
4298 
        if ftype == TType.I32:
4299 
          self.status = iprot.readI32();
4300 
        else:
4301 
          iprot.skip(ftype)
4302 
      else:
4303 
        iprot.skip(ftype)
4304 
      iprot.readFieldEnd()
4305 
    iprot.readStructEnd()
4306 
 
4307 
  def write(self, oprot):
4308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4310 
      return
4311 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 4312 
    if self.customerId is not None:
94 ashish 4313 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
4314 
      oprot.writeI64(self.customerId)
4315 
      oprot.writeFieldEnd()
3431 rajveer 4316 
    if self.from_date is not None:
94 ashish 4317 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4318 
      oprot.writeI64(self.from_date)
4319 
      oprot.writeFieldEnd()
3431 rajveer 4320 
    if self.to_date is not None:
94 ashish 4321 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4322 
      oprot.writeI64(self.to_date)
4323 
      oprot.writeFieldEnd()
3431 rajveer 4324 
    if self.status is not None:
94 ashish 4325 
      oprot.writeFieldBegin('status', TType.I32, 4)
4326 
      oprot.writeI32(self.status)
4327 
      oprot.writeFieldEnd()
4328 
    oprot.writeFieldStop()
4329 
    oprot.writeStructEnd()
4330 
 
3431 rajveer 4331 
  def validate(self):
4332 
    return
4333 
 
4334 
 
94 ashish 4335 
  def __repr__(self):
4336 
    L = ['%s=%r' % (key, value)
4337 
      for key, value in self.__dict__.iteritems()]
4338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4339 
 
4340 
  def __eq__(self, other):
4341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4342 
 
4343 
  def __ne__(self, other):
4344 
    return not (self == other)
4345 
 
4346 
class getTransactionsForCustomer_result:
4347 
  """
4348 
  Attributes:
4349 
   - success
4350 
   - ex
4351 
  """
4352 
 
4353 
  thrift_spec = (
4354 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4355 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4356 
  )
4357 
 
4358 
  def __init__(self, success=None, ex=None,):
4359 
    self.success = success
4360 
    self.ex = ex
4361 
 
4362 
  def read(self, iprot):
4363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4365 
      return
4366 
    iprot.readStructBegin()
4367 
    while True:
4368 
      (fname, ftype, fid) = iprot.readFieldBegin()
4369 
      if ftype == TType.STOP:
4370 
        break
4371 
      if fid == 0:
4372 
        if ftype == TType.LIST:
4373 
          self.success = []
685 chandransh 4374 
          (_etype17, _size14) = iprot.readListBegin()
4375 
          for _i18 in xrange(_size14):
4376 
            _elem19 = Transaction()
4377 
            _elem19.read(iprot)
4378 
            self.success.append(_elem19)
94 ashish 4379 
          iprot.readListEnd()
4380 
        else:
4381 
          iprot.skip(ftype)
4382 
      elif fid == 1:
4383 
        if ftype == TType.STRUCT:
4384 
          self.ex = TransactionServiceException()
4385 
          self.ex.read(iprot)
4386 
        else:
4387 
          iprot.skip(ftype)
4388 
      else:
4389 
        iprot.skip(ftype)
4390 
      iprot.readFieldEnd()
4391 
    iprot.readStructEnd()
4392 
 
4393 
  def write(self, oprot):
4394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4396 
      return
4397 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 4398 
    if self.success is not None:
94 ashish 4399 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4400 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4401 
      for iter20 in self.success:
4402 
        iter20.write(oprot)
94 ashish 4403 
      oprot.writeListEnd()
4404 
      oprot.writeFieldEnd()
3431 rajveer 4405 
    if self.ex is not None:
94 ashish 4406 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4407 
      self.ex.write(oprot)
4408 
      oprot.writeFieldEnd()
4409 
    oprot.writeFieldStop()
4410 
    oprot.writeStructEnd()
4411 
 
3431 rajveer 4412 
  def validate(self):
4413 
    return
4414 
 
4415 
 
94 ashish 4416 
  def __repr__(self):
4417 
    L = ['%s=%r' % (key, value)
4418 
      for key, value in self.__dict__.iteritems()]
4419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4420 
 
4421 
  def __eq__(self, other):
4422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4423 
 
4424 
  def __ne__(self, other):
4425 
    return not (self == other)
4426 
 
132 ashish 4427 
class getTransactionsForShoppingCartId_args:
4428 
  """
4429 
  Attributes:
4430 
   - shoppingCartId
4431 
  """
4432 
 
4433 
  thrift_spec = (
4434 
    None, # 0
4435 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
4436 
  )
4437 
 
4438 
  def __init__(self, shoppingCartId=None,):
4439 
    self.shoppingCartId = shoppingCartId
4440 
 
4441 
  def read(self, iprot):
4442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4444 
      return
4445 
    iprot.readStructBegin()
4446 
    while True:
4447 
      (fname, ftype, fid) = iprot.readFieldBegin()
4448 
      if ftype == TType.STOP:
4449 
        break
4450 
      if fid == 1:
4451 
        if ftype == TType.I64:
4452 
          self.shoppingCartId = iprot.readI64();
4453 
        else:
4454 
          iprot.skip(ftype)
4455 
      else:
4456 
        iprot.skip(ftype)
4457 
      iprot.readFieldEnd()
4458 
    iprot.readStructEnd()
4459 
 
4460 
  def write(self, oprot):
4461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4463 
      return
4464 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 4465 
    if self.shoppingCartId is not None:
132 ashish 4466 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
4467 
      oprot.writeI64(self.shoppingCartId)
4468 
      oprot.writeFieldEnd()
4469 
    oprot.writeFieldStop()
4470 
    oprot.writeStructEnd()
4471 
 
3431 rajveer 4472 
  def validate(self):
4473 
    return
4474 
 
4475 
 
132 ashish 4476 
  def __repr__(self):
4477 
    L = ['%s=%r' % (key, value)
4478 
      for key, value in self.__dict__.iteritems()]
4479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4480 
 
4481 
  def __eq__(self, other):
4482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4483 
 
4484 
  def __ne__(self, other):
4485 
    return not (self == other)
4486 
 
4487 
class getTransactionsForShoppingCartId_result:
4488 
  """
4489 
  Attributes:
4490 
   - success
4491 
   - ex
4492 
  """
4493 
 
4494 
  thrift_spec = (
4495 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4496 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4497 
  )
4498 
 
4499 
  def __init__(self, success=None, ex=None,):
4500 
    self.success = success
4501 
    self.ex = ex
4502 
 
4503 
  def read(self, iprot):
4504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4506 
      return
4507 
    iprot.readStructBegin()
4508 
    while True:
4509 
      (fname, ftype, fid) = iprot.readFieldBegin()
4510 
      if ftype == TType.STOP:
4511 
        break
4512 
      if fid == 0:
4513 
        if ftype == TType.LIST:
4514 
          self.success = []
685 chandransh 4515 
          (_etype24, _size21) = iprot.readListBegin()
4516 
          for _i25 in xrange(_size21):
4517 
            _elem26 = Transaction()
4518 
            _elem26.read(iprot)
4519 
            self.success.append(_elem26)
132 ashish 4520 
          iprot.readListEnd()
4521 
        else:
4522 
          iprot.skip(ftype)
4523 
      elif fid == 1:
4524 
        if ftype == TType.STRUCT:
4525 
          self.ex = TransactionServiceException()
4526 
          self.ex.read(iprot)
4527 
        else:
4528 
          iprot.skip(ftype)
4529 
      else:
4530 
        iprot.skip(ftype)
4531 
      iprot.readFieldEnd()
4532 
    iprot.readStructEnd()
4533 
 
4534 
  def write(self, oprot):
4535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4537 
      return
4538 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 4539 
    if self.success is not None:
132 ashish 4540 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4541 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4542 
      for iter27 in self.success:
4543 
        iter27.write(oprot)
132 ashish 4544 
      oprot.writeListEnd()
4545 
      oprot.writeFieldEnd()
3431 rajveer 4546 
    if self.ex is not None:
132 ashish 4547 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4548 
      self.ex.write(oprot)
4549 
      oprot.writeFieldEnd()
4550 
    oprot.writeFieldStop()
4551 
    oprot.writeStructEnd()
4552 
 
3431 rajveer 4553 
  def validate(self):
4554 
    return
4555 
 
4556 
 
132 ashish 4557 
  def __repr__(self):
4558 
    L = ['%s=%r' % (key, value)
4559 
      for key, value in self.__dict__.iteritems()]
4560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4561 
 
4562 
  def __eq__(self, other):
4563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4564 
 
4565 
  def __ne__(self, other):
4566 
    return not (self == other)
4567 
 
94 ashish 4568 
class getTransactionStatus_args:
4569 
  """
4570 
  Attributes:
4571 
   - transactionId
4572 
  """
4573 
 
4574 
  thrift_spec = (
4575 
    None, # 0
4576 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4577 
  )
4578 
 
4579 
  def __init__(self, transactionId=None,):
4580 
    self.transactionId = transactionId
4581 
 
4582 
  def read(self, iprot):
4583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4585 
      return
4586 
    iprot.readStructBegin()
4587 
    while True:
4588 
      (fname, ftype, fid) = iprot.readFieldBegin()
4589 
      if ftype == TType.STOP:
4590 
        break
4591 
      if fid == 1:
4592 
        if ftype == TType.I64:
4593 
          self.transactionId = iprot.readI64();
4594 
        else:
4595 
          iprot.skip(ftype)
4596 
      else:
4597 
        iprot.skip(ftype)
4598 
      iprot.readFieldEnd()
4599 
    iprot.readStructEnd()
4600 
 
4601 
  def write(self, oprot):
4602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4604 
      return
4605 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 4606 
    if self.transactionId is not None:
94 ashish 4607 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4608 
      oprot.writeI64(self.transactionId)
4609 
      oprot.writeFieldEnd()
4610 
    oprot.writeFieldStop()
4611 
    oprot.writeStructEnd()
4612 
 
3431 rajveer 4613 
  def validate(self):
4614 
    return
4615 
 
4616 
 
94 ashish 4617 
  def __repr__(self):
4618 
    L = ['%s=%r' % (key, value)
4619 
      for key, value in self.__dict__.iteritems()]
4620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4621 
 
4622 
  def __eq__(self, other):
4623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4624 
 
4625 
  def __ne__(self, other):
4626 
    return not (self == other)
4627 
 
4628 
class getTransactionStatus_result:
4629 
  """
4630 
  Attributes:
4631 
   - success
4632 
   - ex
4633 
  """
4634 
 
4635 
  thrift_spec = (
4636 
    (0, TType.I32, 'success', None, None, ), # 0
4637 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4638 
  )
4639 
 
4640 
  def __init__(self, success=None, ex=None,):
4641 
    self.success = success
4642 
    self.ex = ex
4643 
 
4644 
  def read(self, iprot):
4645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4647 
      return
4648 
    iprot.readStructBegin()
4649 
    while True:
4650 
      (fname, ftype, fid) = iprot.readFieldBegin()
4651 
      if ftype == TType.STOP:
4652 
        break
4653 
      if fid == 0:
4654 
        if ftype == TType.I32:
4655 
          self.success = iprot.readI32();
4656 
        else:
4657 
          iprot.skip(ftype)
4658 
      elif fid == 1:
4659 
        if ftype == TType.STRUCT:
4660 
          self.ex = TransactionServiceException()
4661 
          self.ex.read(iprot)
4662 
        else:
4663 
          iprot.skip(ftype)
4664 
      else:
4665 
        iprot.skip(ftype)
4666 
      iprot.readFieldEnd()
4667 
    iprot.readStructEnd()
4668 
 
4669 
  def write(self, oprot):
4670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4672 
      return
4673 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 4674 
    if self.success is not None:
94 ashish 4675 
      oprot.writeFieldBegin('success', TType.I32, 0)
4676 
      oprot.writeI32(self.success)
4677 
      oprot.writeFieldEnd()
3431 rajveer 4678 
    if self.ex is not None:
94 ashish 4679 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4680 
      self.ex.write(oprot)
4681 
      oprot.writeFieldEnd()
4682 
    oprot.writeFieldStop()
4683 
    oprot.writeStructEnd()
4684 
 
3431 rajveer 4685 
  def validate(self):
4686 
    return
4687 
 
4688 
 
94 ashish 4689 
  def __repr__(self):
4690 
    L = ['%s=%r' % (key, value)
4691 
      for key, value in self.__dict__.iteritems()]
4692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4693 
 
4694 
  def __eq__(self, other):
4695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4696 
 
4697 
  def __ne__(self, other):
4698 
    return not (self == other)
4699 
 
4700 
class changeTransactionStatus_args:
4701 
  """
4702 
  Attributes:
4703 
   - transactionId
4704 
   - status
4705 
   - description
4706 
  """
4707 
 
4708 
  thrift_spec = (
4709 
    None, # 0
4710 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4711 
    (2, TType.I32, 'status', None, None, ), # 2
4712 
    (3, TType.STRING, 'description', None, None, ), # 3
4713 
  )
4714 
 
4715 
  def __init__(self, transactionId=None, status=None, description=None,):
4716 
    self.transactionId = transactionId
4717 
    self.status = status
4718 
    self.description = description
4719 
 
4720 
  def read(self, iprot):
4721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4723 
      return
4724 
    iprot.readStructBegin()
4725 
    while True:
4726 
      (fname, ftype, fid) = iprot.readFieldBegin()
4727 
      if ftype == TType.STOP:
4728 
        break
4729 
      if fid == 1:
4730 
        if ftype == TType.I64:
4731 
          self.transactionId = iprot.readI64();
4732 
        else:
4733 
          iprot.skip(ftype)
4734 
      elif fid == 2:
4735 
        if ftype == TType.I32:
4736 
          self.status = iprot.readI32();
4737 
        else:
4738 
          iprot.skip(ftype)
4739 
      elif fid == 3:
4740 
        if ftype == TType.STRING:
4741 
          self.description = iprot.readString();
4742 
        else:
4743 
          iprot.skip(ftype)
4744 
      else:
4745 
        iprot.skip(ftype)
4746 
      iprot.readFieldEnd()
4747 
    iprot.readStructEnd()
4748 
 
4749 
  def write(self, oprot):
4750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4752 
      return
4753 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 4754 
    if self.transactionId is not None:
94 ashish 4755 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4756 
      oprot.writeI64(self.transactionId)
4757 
      oprot.writeFieldEnd()
3431 rajveer 4758 
    if self.status is not None:
94 ashish 4759 
      oprot.writeFieldBegin('status', TType.I32, 2)
4760 
      oprot.writeI32(self.status)
4761 
      oprot.writeFieldEnd()
3431 rajveer 4762 
    if self.description is not None:
94 ashish 4763 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4764 
      oprot.writeString(self.description)
4765 
      oprot.writeFieldEnd()
4766 
    oprot.writeFieldStop()
4767 
    oprot.writeStructEnd()
4768 
 
3431 rajveer 4769 
  def validate(self):
4770 
    return
4771 
 
4772 
 
94 ashish 4773 
  def __repr__(self):
4774 
    L = ['%s=%r' % (key, value)
4775 
      for key, value in self.__dict__.iteritems()]
4776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4777 
 
4778 
  def __eq__(self, other):
4779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4780 
 
4781 
  def __ne__(self, other):
4782 
    return not (self == other)
4783 
 
4784 
class changeTransactionStatus_result:
4785 
  """
4786 
  Attributes:
4787 
   - success
4788 
   - ex
4789 
  """
4790 
 
4791 
  thrift_spec = (
4792 
    (0, TType.BOOL, 'success', None, None, ), # 0
4793 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4794 
  )
4795 
 
4796 
  def __init__(self, success=None, ex=None,):
4797 
    self.success = success
4798 
    self.ex = ex
4799 
 
4800 
  def read(self, iprot):
4801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4803 
      return
4804 
    iprot.readStructBegin()
4805 
    while True:
4806 
      (fname, ftype, fid) = iprot.readFieldBegin()
4807 
      if ftype == TType.STOP:
4808 
        break
4809 
      if fid == 0:
4810 
        if ftype == TType.BOOL:
4811 
          self.success = iprot.readBool();
4812 
        else:
4813 
          iprot.skip(ftype)
4814 
      elif fid == 1:
4815 
        if ftype == TType.STRUCT:
4816 
          self.ex = TransactionServiceException()
4817 
          self.ex.read(iprot)
4818 
        else:
4819 
          iprot.skip(ftype)
4820 
      else:
4821 
        iprot.skip(ftype)
4822 
      iprot.readFieldEnd()
4823 
    iprot.readStructEnd()
4824 
 
4825 
  def write(self, oprot):
4826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4828 
      return
4829 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 4830 
    if self.success is not None:
94 ashish 4831 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4832 
      oprot.writeBool(self.success)
4833 
      oprot.writeFieldEnd()
3431 rajveer 4834 
    if self.ex is not None:
94 ashish 4835 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4836 
      self.ex.write(oprot)
4837 
      oprot.writeFieldEnd()
4838 
    oprot.writeFieldStop()
4839 
    oprot.writeStructEnd()
4840 
 
3431 rajveer 4841 
  def validate(self):
4842 
    return
4843 
 
4844 
 
94 ashish 4845 
  def __repr__(self):
4846 
    L = ['%s=%r' % (key, value)
4847 
      for key, value in self.__dict__.iteritems()]
4848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4849 
 
4850 
  def __eq__(self, other):
4851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4852 
 
4853 
  def __ne__(self, other):
4854 
    return not (self == other)
4855 
 
1398 varun.gupt 4856 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 4857 
  """
4858 
  Attributes:
4859 
   - transactionId
4860 
  """
4861 
 
4862 
  thrift_spec = (
4863 
    None, # 0
4864 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4865 
  )
4866 
 
4867 
  def __init__(self, transactionId=None,):
4868 
    self.transactionId = transactionId
4869 
 
4870 
  def read(self, iprot):
4871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4873 
      return
4874 
    iprot.readStructBegin()
4875 
    while True:
4876 
      (fname, ftype, fid) = iprot.readFieldBegin()
4877 
      if ftype == TType.STOP:
4878 
        break
4879 
      if fid == 1:
4880 
        if ftype == TType.I64:
4881 
          self.transactionId = iprot.readI64();
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
1398 varun.gupt 4893 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 4894 
    if self.transactionId is not None:
1382 varun.gupt 4895 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4896 
      oprot.writeI64(self.transactionId)
4897 
      oprot.writeFieldEnd()
4898 
    oprot.writeFieldStop()
4899 
    oprot.writeStructEnd()
4900 
 
3431 rajveer 4901 
  def validate(self):
4902 
    return
4903 
 
4904 
 
1382 varun.gupt 4905 
  def __repr__(self):
4906 
    L = ['%s=%r' % (key, value)
4907 
      for key, value in self.__dict__.iteritems()]
4908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4909 
 
4910 
  def __eq__(self, other):
4911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4912 
 
4913 
  def __ne__(self, other):
4914 
    return not (self == other)
4915 
 
1398 varun.gupt 4916 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 4917 
  """
4918 
  Attributes:
4919 
   - success
4920 
   - ex
4921 
  """
4922 
 
4923 
  thrift_spec = (
4924 
    (0, TType.BOOL, 'success', None, None, ), # 0
4925 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4926 
  )
4927 
 
4928 
  def __init__(self, success=None, ex=None,):
4929 
    self.success = success
4930 
    self.ex = ex
4931 
 
4932 
  def read(self, iprot):
4933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4935 
      return
4936 
    iprot.readStructBegin()
4937 
    while True:
4938 
      (fname, ftype, fid) = iprot.readFieldBegin()
4939 
      if ftype == TType.STOP:
4940 
        break
4941 
      if fid == 0:
4942 
        if ftype == TType.BOOL:
4943 
          self.success = iprot.readBool();
4944 
        else:
4945 
          iprot.skip(ftype)
4946 
      elif fid == 1:
4947 
        if ftype == TType.STRUCT:
4948 
          self.ex = TransactionServiceException()
4949 
          self.ex.read(iprot)
4950 
        else:
4951 
          iprot.skip(ftype)
4952 
      else:
4953 
        iprot.skip(ftype)
4954 
      iprot.readFieldEnd()
4955 
    iprot.readStructEnd()
4956 
 
4957 
  def write(self, oprot):
4958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4960 
      return
1398 varun.gupt 4961 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 4962 
    if self.success is not None:
1382 varun.gupt 4963 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4964 
      oprot.writeBool(self.success)
4965 
      oprot.writeFieldEnd()
3431 rajveer 4966 
    if self.ex is not None:
1382 varun.gupt 4967 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4968 
      self.ex.write(oprot)
4969 
      oprot.writeFieldEnd()
4970 
    oprot.writeFieldStop()
4971 
    oprot.writeStructEnd()
4972 
 
3431 rajveer 4973 
  def validate(self):
4974 
    return
4975 
 
4976 
 
1382 varun.gupt 4977 
  def __repr__(self):
4978 
    L = ['%s=%r' % (key, value)
4979 
      for key, value in self.__dict__.iteritems()]
4980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4981 
 
4982 
  def __eq__(self, other):
4983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4984 
 
4985 
  def __ne__(self, other):
4986 
    return not (self == other)
4987 
 
483 rajveer 4988 
class getAllOrders_args:
94 ashish 4989 
  """
4990 
  Attributes:
483 rajveer 4991 
   - status
4992 
   - from_date
4993 
   - to_date
4994 
   - warehouse_id
94 ashish 4995 
  """
4996 
 
4997 
  thrift_spec = (
4998 
    None, # 0
483 rajveer 4999 
    (1, TType.I32, 'status', None, None, ), # 1
5000 
    (2, TType.I64, 'from_date', None, None, ), # 2
5001 
    (3, TType.I64, 'to_date', None, None, ), # 3
5002 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5003 
  )
5004 
 
483 rajveer 5005 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5006 
    self.status = status
5007 
    self.from_date = from_date
5008 
    self.to_date = to_date
5009 
    self.warehouse_id = warehouse_id
94 ashish 5010 
 
5011 
  def read(self, iprot):
5012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5014 
      return
5015 
    iprot.readStructBegin()
5016 
    while True:
5017 
      (fname, ftype, fid) = iprot.readFieldBegin()
5018 
      if ftype == TType.STOP:
5019 
        break
5020 
      if fid == 1:
483 rajveer 5021 
        if ftype == TType.I32:
5022 
          self.status = iprot.readI32();
94 ashish 5023 
        else:
5024 
          iprot.skip(ftype)
483 rajveer 5025 
      elif fid == 2:
5026 
        if ftype == TType.I64:
5027 
          self.from_date = iprot.readI64();
94 ashish 5028 
        else:
5029 
          iprot.skip(ftype)
483 rajveer 5030 
      elif fid == 3:
5031 
        if ftype == TType.I64:
5032 
          self.to_date = iprot.readI64();
94 ashish 5033 
        else:
5034 
          iprot.skip(ftype)
483 rajveer 5035 
      elif fid == 4:
94 ashish 5036 
        if ftype == TType.I64:
483 rajveer 5037 
          self.warehouse_id = iprot.readI64();
94 ashish 5038 
        else:
5039 
          iprot.skip(ftype)
5040 
      else:
5041 
        iprot.skip(ftype)
5042 
      iprot.readFieldEnd()
5043 
    iprot.readStructEnd()
5044 
 
5045 
  def write(self, oprot):
5046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5048 
      return
483 rajveer 5049 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5050 
    if self.status is not None:
483 rajveer 5051 
      oprot.writeFieldBegin('status', TType.I32, 1)
5052 
      oprot.writeI32(self.status)
94 ashish 5053 
      oprot.writeFieldEnd()
3431 rajveer 5054 
    if self.from_date is not None:
483 rajveer 5055 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5056 
      oprot.writeI64(self.from_date)
94 ashish 5057 
      oprot.writeFieldEnd()
3431 rajveer 5058 
    if self.to_date is not None:
483 rajveer 5059 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5060 
      oprot.writeI64(self.to_date)
94 ashish 5061 
      oprot.writeFieldEnd()
3431 rajveer 5062 
    if self.warehouse_id is not None:
483 rajveer 5063 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5064 
      oprot.writeI64(self.warehouse_id)
94 ashish 5065 
      oprot.writeFieldEnd()
5066 
    oprot.writeFieldStop()
5067 
    oprot.writeStructEnd()
5068 
 
3431 rajveer 5069 
  def validate(self):
5070 
    return
5071 
 
5072 
 
94 ashish 5073 
  def __repr__(self):
5074 
    L = ['%s=%r' % (key, value)
5075 
      for key, value in self.__dict__.iteritems()]
5076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5077 
 
5078 
  def __eq__(self, other):
5079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5080 
 
5081 
  def __ne__(self, other):
5082 
    return not (self == other)
5083 
 
483 rajveer 5084 
class getAllOrders_result:
94 ashish 5085 
  """
5086 
  Attributes:
5087 
   - success
5088 
   - ex
5089 
  """
5090 
 
5091 
  thrift_spec = (
483 rajveer 5092 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5093 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5094 
  )
5095 
 
5096 
  def __init__(self, success=None, ex=None,):
5097 
    self.success = success
5098 
    self.ex = ex
5099 
 
5100 
  def read(self, iprot):
5101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5103 
      return
5104 
    iprot.readStructBegin()
5105 
    while True:
5106 
      (fname, ftype, fid) = iprot.readFieldBegin()
5107 
      if ftype == TType.STOP:
5108 
        break
5109 
      if fid == 0:
483 rajveer 5110 
        if ftype == TType.LIST:
5111 
          self.success = []
685 chandransh 5112 
          (_etype31, _size28) = iprot.readListBegin()
5113 
          for _i32 in xrange(_size28):
5114 
            _elem33 = Order()
5115 
            _elem33.read(iprot)
5116 
            self.success.append(_elem33)
483 rajveer 5117 
          iprot.readListEnd()
94 ashish 5118 
        else:
5119 
          iprot.skip(ftype)
5120 
      elif fid == 1:
5121 
        if ftype == TType.STRUCT:
5122 
          self.ex = TransactionServiceException()
5123 
          self.ex.read(iprot)
5124 
        else:
5125 
          iprot.skip(ftype)
5126 
      else:
5127 
        iprot.skip(ftype)
5128 
      iprot.readFieldEnd()
5129 
    iprot.readStructEnd()
5130 
 
5131 
  def write(self, oprot):
5132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5134 
      return
483 rajveer 5135 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5136 
    if self.success is not None:
483 rajveer 5137 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5138 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5139 
      for iter34 in self.success:
5140 
        iter34.write(oprot)
483 rajveer 5141 
      oprot.writeListEnd()
94 ashish 5142 
      oprot.writeFieldEnd()
3431 rajveer 5143 
    if self.ex is not None:
94 ashish 5144 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5145 
      self.ex.write(oprot)
5146 
      oprot.writeFieldEnd()
5147 
    oprot.writeFieldStop()
5148 
    oprot.writeStructEnd()
5149 
 
3431 rajveer 5150 
  def validate(self):
5151 
    return
5152 
 
5153 
 
94 ashish 5154 
  def __repr__(self):
5155 
    L = ['%s=%r' % (key, value)
5156 
      for key, value in self.__dict__.iteritems()]
5157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5158 
 
5159 
  def __eq__(self, other):
5160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5161 
 
5162 
  def __ne__(self, other):
5163 
    return not (self == other)
5164 
 
4133 chandransh 5165 
class getOrdersInBatch_args:
5166 
  """
5167 
  Attributes:
5168 
   - statuses
5169 
   - offset
5170 
   - limit
5171 
   - warehouse_id
5172 
  """
5173 
 
5174 
  thrift_spec = (
5175 
    None, # 0
5176 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5177 
    (2, TType.I64, 'offset', None, None, ), # 2
5178 
    (3, TType.I64, 'limit', None, None, ), # 3
5179 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5180 
  )
5181 
 
5182 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
5183 
    self.statuses = statuses
5184 
    self.offset = offset
5185 
    self.limit = limit
5186 
    self.warehouse_id = warehouse_id
5187 
 
5188 
  def read(self, iprot):
5189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5191 
      return
5192 
    iprot.readStructBegin()
5193 
    while True:
5194 
      (fname, ftype, fid) = iprot.readFieldBegin()
5195 
      if ftype == TType.STOP:
5196 
        break
5197 
      if fid == 1:
5198 
        if ftype == TType.LIST:
5199 
          self.statuses = []
5200 
          (_etype38, _size35) = iprot.readListBegin()
5201 
          for _i39 in xrange(_size35):
5202 
            _elem40 = iprot.readI32();
5203 
            self.statuses.append(_elem40)
5204 
          iprot.readListEnd()
5205 
        else:
5206 
          iprot.skip(ftype)
5207 
      elif fid == 2:
5208 
        if ftype == TType.I64:
5209 
          self.offset = iprot.readI64();
5210 
        else:
5211 
          iprot.skip(ftype)
5212 
      elif fid == 3:
5213 
        if ftype == TType.I64:
5214 
          self.limit = iprot.readI64();
5215 
        else:
5216 
          iprot.skip(ftype)
5217 
      elif fid == 4:
5218 
        if ftype == TType.I64:
5219 
          self.warehouse_id = iprot.readI64();
5220 
        else:
5221 
          iprot.skip(ftype)
5222 
      else:
5223 
        iprot.skip(ftype)
5224 
      iprot.readFieldEnd()
5225 
    iprot.readStructEnd()
5226 
 
5227 
  def write(self, oprot):
5228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5230 
      return
5231 
    oprot.writeStructBegin('getOrdersInBatch_args')
5232 
    if self.statuses is not None:
5233 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5234 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5235 
      for iter41 in self.statuses:
5236 
        oprot.writeI32(iter41)
5237 
      oprot.writeListEnd()
5238 
      oprot.writeFieldEnd()
5239 
    if self.offset is not None:
5240 
      oprot.writeFieldBegin('offset', TType.I64, 2)
5241 
      oprot.writeI64(self.offset)
5242 
      oprot.writeFieldEnd()
5243 
    if self.limit is not None:
5244 
      oprot.writeFieldBegin('limit', TType.I64, 3)
5245 
      oprot.writeI64(self.limit)
5246 
      oprot.writeFieldEnd()
5247 
    if self.warehouse_id is not None:
5248 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5249 
      oprot.writeI64(self.warehouse_id)
5250 
      oprot.writeFieldEnd()
5251 
    oprot.writeFieldStop()
5252 
    oprot.writeStructEnd()
5253 
 
5254 
  def validate(self):
5255 
    return
5256 
 
5257 
 
5258 
  def __repr__(self):
5259 
    L = ['%s=%r' % (key, value)
5260 
      for key, value in self.__dict__.iteritems()]
5261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5262 
 
5263 
  def __eq__(self, other):
5264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5265 
 
5266 
  def __ne__(self, other):
5267 
    return not (self == other)
5268 
 
5269 
class getOrdersInBatch_result:
5270 
  """
5271 
  Attributes:
5272 
   - success
5273 
   - ex
5274 
  """
5275 
 
5276 
  thrift_spec = (
5277 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5278 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5279 
  )
5280 
 
5281 
  def __init__(self, success=None, ex=None,):
5282 
    self.success = success
5283 
    self.ex = ex
5284 
 
5285 
  def read(self, iprot):
5286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5288 
      return
5289 
    iprot.readStructBegin()
5290 
    while True:
5291 
      (fname, ftype, fid) = iprot.readFieldBegin()
5292 
      if ftype == TType.STOP:
5293 
        break
5294 
      if fid == 0:
5295 
        if ftype == TType.LIST:
5296 
          self.success = []
5297 
          (_etype45, _size42) = iprot.readListBegin()
5298 
          for _i46 in xrange(_size42):
5299 
            _elem47 = Order()
5300 
            _elem47.read(iprot)
5301 
            self.success.append(_elem47)
5302 
          iprot.readListEnd()
5303 
        else:
5304 
          iprot.skip(ftype)
5305 
      elif fid == 1:
5306 
        if ftype == TType.STRUCT:
5307 
          self.ex = TransactionServiceException()
5308 
          self.ex.read(iprot)
5309 
        else:
5310 
          iprot.skip(ftype)
5311 
      else:
5312 
        iprot.skip(ftype)
5313 
      iprot.readFieldEnd()
5314 
    iprot.readStructEnd()
5315 
 
5316 
  def write(self, oprot):
5317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5319 
      return
5320 
    oprot.writeStructBegin('getOrdersInBatch_result')
5321 
    if self.success is not None:
5322 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5323 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5324 
      for iter48 in self.success:
5325 
        iter48.write(oprot)
5326 
      oprot.writeListEnd()
5327 
      oprot.writeFieldEnd()
5328 
    if self.ex is not None:
5329 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5330 
      self.ex.write(oprot)
5331 
      oprot.writeFieldEnd()
5332 
    oprot.writeFieldStop()
5333 
    oprot.writeStructEnd()
5334 
 
5335 
  def validate(self):
5336 
    return
5337 
 
5338 
 
5339 
  def __repr__(self):
5340 
    L = ['%s=%r' % (key, value)
5341 
      for key, value in self.__dict__.iteritems()]
5342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5343 
 
5344 
  def __eq__(self, other):
5345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5346 
 
5347 
  def __ne__(self, other):
5348 
    return not (self == other)
5349 
 
5350 
class getOrderCount_args:
5351 
  """
5352 
  Attributes:
5353 
   - statuses
5354 
   - warehouseId
5355 
  """
5356 
 
5357 
  thrift_spec = (
5358 
    None, # 0
5359 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5360 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5361 
  )
5362 
 
5363 
  def __init__(self, statuses=None, warehouseId=None,):
5364 
    self.statuses = statuses
5365 
    self.warehouseId = warehouseId
5366 
 
5367 
  def read(self, iprot):
5368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5370 
      return
5371 
    iprot.readStructBegin()
5372 
    while True:
5373 
      (fname, ftype, fid) = iprot.readFieldBegin()
5374 
      if ftype == TType.STOP:
5375 
        break
5376 
      if fid == 1:
5377 
        if ftype == TType.LIST:
5378 
          self.statuses = []
5379 
          (_etype52, _size49) = iprot.readListBegin()
5380 
          for _i53 in xrange(_size49):
5381 
            _elem54 = iprot.readI32();
5382 
            self.statuses.append(_elem54)
5383 
          iprot.readListEnd()
5384 
        else:
5385 
          iprot.skip(ftype)
5386 
      elif fid == 2:
5387 
        if ftype == TType.I64:
5388 
          self.warehouseId = iprot.readI64();
5389 
        else:
5390 
          iprot.skip(ftype)
5391 
      else:
5392 
        iprot.skip(ftype)
5393 
      iprot.readFieldEnd()
5394 
    iprot.readStructEnd()
5395 
 
5396 
  def write(self, oprot):
5397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5399 
      return
5400 
    oprot.writeStructBegin('getOrderCount_args')
5401 
    if self.statuses is not None:
5402 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5403 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5404 
      for iter55 in self.statuses:
5405 
        oprot.writeI32(iter55)
5406 
      oprot.writeListEnd()
5407 
      oprot.writeFieldEnd()
5408 
    if self.warehouseId is not None:
5409 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5410 
      oprot.writeI64(self.warehouseId)
5411 
      oprot.writeFieldEnd()
5412 
    oprot.writeFieldStop()
5413 
    oprot.writeStructEnd()
5414 
 
5415 
  def validate(self):
5416 
    return
5417 
 
5418 
 
5419 
  def __repr__(self):
5420 
    L = ['%s=%r' % (key, value)
5421 
      for key, value in self.__dict__.iteritems()]
5422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5423 
 
5424 
  def __eq__(self, other):
5425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5426 
 
5427 
  def __ne__(self, other):
5428 
    return not (self == other)
5429 
 
5430 
class getOrderCount_result:
5431 
  """
5432 
  Attributes:
5433 
   - success
5434 
   - ex
5435 
  """
5436 
 
5437 
  thrift_spec = (
5438 
    (0, TType.I32, 'success', None, None, ), # 0
5439 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5440 
  )
5441 
 
5442 
  def __init__(self, success=None, ex=None,):
5443 
    self.success = success
5444 
    self.ex = ex
5445 
 
5446 
  def read(self, iprot):
5447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5449 
      return
5450 
    iprot.readStructBegin()
5451 
    while True:
5452 
      (fname, ftype, fid) = iprot.readFieldBegin()
5453 
      if ftype == TType.STOP:
5454 
        break
5455 
      if fid == 0:
5456 
        if ftype == TType.I32:
5457 
          self.success = iprot.readI32();
5458 
        else:
5459 
          iprot.skip(ftype)
5460 
      elif fid == 1:
5461 
        if ftype == TType.STRUCT:
5462 
          self.ex = TransactionServiceException()
5463 
          self.ex.read(iprot)
5464 
        else:
5465 
          iprot.skip(ftype)
5466 
      else:
5467 
        iprot.skip(ftype)
5468 
      iprot.readFieldEnd()
5469 
    iprot.readStructEnd()
5470 
 
5471 
  def write(self, oprot):
5472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5474 
      return
5475 
    oprot.writeStructBegin('getOrderCount_result')
5476 
    if self.success is not None:
5477 
      oprot.writeFieldBegin('success', TType.I32, 0)
5478 
      oprot.writeI32(self.success)
5479 
      oprot.writeFieldEnd()
5480 
    if self.ex is not None:
5481 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5482 
      self.ex.write(oprot)
5483 
      oprot.writeFieldEnd()
5484 
    oprot.writeFieldStop()
5485 
    oprot.writeStructEnd()
5486 
 
5487 
  def validate(self):
5488 
    return
5489 
 
5490 
 
5491 
  def __repr__(self):
5492 
    L = ['%s=%r' % (key, value)
5493 
      for key, value in self.__dict__.iteritems()]
5494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5495 
 
5496 
  def __eq__(self, other):
5497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5498 
 
5499 
  def __ne__(self, other):
5500 
    return not (self == other)
5501 
 
999 varun.gupt 5502 
class getOrdersByBillingDate_args:
5503 
  """
5504 
  Attributes:
5505 
   - status
5506 
   - start_billing_date
5507 
   - end_billing_date
5508 
   - warehouse_id
5509 
  """
5510 
 
5511 
  thrift_spec = (
5512 
    None, # 0
5513 
    (1, TType.I32, 'status', None, None, ), # 1
5514 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
5515 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
5516 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5517 
  )
5518 
 
5519 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
5520 
    self.status = status
5521 
    self.start_billing_date = start_billing_date
5522 
    self.end_billing_date = end_billing_date
5523 
    self.warehouse_id = warehouse_id
5524 
 
5525 
  def read(self, iprot):
5526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5528 
      return
5529 
    iprot.readStructBegin()
5530 
    while True:
5531 
      (fname, ftype, fid) = iprot.readFieldBegin()
5532 
      if ftype == TType.STOP:
5533 
        break
5534 
      if fid == 1:
5535 
        if ftype == TType.I32:
5536 
          self.status = iprot.readI32();
5537 
        else:
5538 
          iprot.skip(ftype)
5539 
      elif fid == 2:
5540 
        if ftype == TType.I64:
5541 
          self.start_billing_date = iprot.readI64();
5542 
        else:
5543 
          iprot.skip(ftype)
5544 
      elif fid == 3:
5545 
        if ftype == TType.I64:
5546 
          self.end_billing_date = iprot.readI64();
5547 
        else:
5548 
          iprot.skip(ftype)
5549 
      elif fid == 4:
5550 
        if ftype == TType.I64:
5551 
          self.warehouse_id = iprot.readI64();
5552 
        else:
5553 
          iprot.skip(ftype)
5554 
      else:
5555 
        iprot.skip(ftype)
5556 
      iprot.readFieldEnd()
5557 
    iprot.readStructEnd()
5558 
 
5559 
  def write(self, oprot):
5560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5562 
      return
5563 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 5564 
    if self.status is not None:
999 varun.gupt 5565 
      oprot.writeFieldBegin('status', TType.I32, 1)
5566 
      oprot.writeI32(self.status)
5567 
      oprot.writeFieldEnd()
3431 rajveer 5568 
    if self.start_billing_date is not None:
999 varun.gupt 5569 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
5570 
      oprot.writeI64(self.start_billing_date)
5571 
      oprot.writeFieldEnd()
3431 rajveer 5572 
    if self.end_billing_date is not None:
999 varun.gupt 5573 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
5574 
      oprot.writeI64(self.end_billing_date)
5575 
      oprot.writeFieldEnd()
3431 rajveer 5576 
    if self.warehouse_id is not None:
999 varun.gupt 5577 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5578 
      oprot.writeI64(self.warehouse_id)
5579 
      oprot.writeFieldEnd()
5580 
    oprot.writeFieldStop()
5581 
    oprot.writeStructEnd()
5582 
 
3431 rajveer 5583 
  def validate(self):
5584 
    return
5585 
 
5586 
 
999 varun.gupt 5587 
  def __repr__(self):
5588 
    L = ['%s=%r' % (key, value)
5589 
      for key, value in self.__dict__.iteritems()]
5590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5591 
 
5592 
  def __eq__(self, other):
5593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5594 
 
5595 
  def __ne__(self, other):
5596 
    return not (self == other)
5597 
 
5598 
class getOrdersByBillingDate_result:
5599 
  """
5600 
  Attributes:
5601 
   - success
5602 
   - ex
5603 
  """
5604 
 
5605 
  thrift_spec = (
5606 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5607 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5608 
  )
5609 
 
5610 
  def __init__(self, success=None, ex=None,):
5611 
    self.success = success
5612 
    self.ex = ex
5613 
 
5614 
  def read(self, iprot):
5615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5617 
      return
5618 
    iprot.readStructBegin()
5619 
    while True:
5620 
      (fname, ftype, fid) = iprot.readFieldBegin()
5621 
      if ftype == TType.STOP:
5622 
        break
5623 
      if fid == 0:
5624 
        if ftype == TType.LIST:
5625 
          self.success = []
4133 chandransh 5626 
          (_etype59, _size56) = iprot.readListBegin()
5627 
          for _i60 in xrange(_size56):
5628 
            _elem61 = Order()
5629 
            _elem61.read(iprot)
5630 
            self.success.append(_elem61)
999 varun.gupt 5631 
          iprot.readListEnd()
5632 
        else:
5633 
          iprot.skip(ftype)
5634 
      elif fid == 1:
5635 
        if ftype == TType.STRUCT:
5636 
          self.ex = TransactionServiceException()
5637 
          self.ex.read(iprot)
5638 
        else:
5639 
          iprot.skip(ftype)
5640 
      else:
5641 
        iprot.skip(ftype)
5642 
      iprot.readFieldEnd()
5643 
    iprot.readStructEnd()
5644 
 
5645 
  def write(self, oprot):
5646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5648 
      return
5649 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 5650 
    if self.success is not None:
999 varun.gupt 5651 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5652 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 5653 
      for iter62 in self.success:
5654 
        iter62.write(oprot)
999 varun.gupt 5655 
      oprot.writeListEnd()
5656 
      oprot.writeFieldEnd()
3431 rajveer 5657 
    if self.ex is not None:
999 varun.gupt 5658 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5659 
      self.ex.write(oprot)
5660 
      oprot.writeFieldEnd()
5661 
    oprot.writeFieldStop()
5662 
    oprot.writeStructEnd()
5663 
 
3431 rajveer 5664 
  def validate(self):
5665 
    return
5666 
 
5667 
 
999 varun.gupt 5668 
  def __repr__(self):
5669 
    L = ['%s=%r' % (key, value)
5670 
      for key, value in self.__dict__.iteritems()]
5671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5672 
 
5673 
  def __eq__(self, other):
5674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5675 
 
5676 
  def __ne__(self, other):
5677 
    return not (self == other)
5678 
 
3427 chandransh 5679 
class getOrdersByShippingDate_args:
5680 
  """
5681 
  Attributes:
5682 
   - fromShippingDate
5683 
   - toShippingDate
5684 
   - providerId
5685 
   - warehouseId
3451 chandransh 5686 
   - cod
3427 chandransh 5687 
  """
5688 
 
5689 
  thrift_spec = (
5690 
    None, # 0
5691 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
5692 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
5693 
    (3, TType.I64, 'providerId', None, None, ), # 3
5694 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 5695 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 5696 
  )
5697 
 
3451 chandransh 5698 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 5699 
    self.fromShippingDate = fromShippingDate
5700 
    self.toShippingDate = toShippingDate
5701 
    self.providerId = providerId
5702 
    self.warehouseId = warehouseId
3451 chandransh 5703 
    self.cod = cod
3427 chandransh 5704 
 
5705 
  def read(self, iprot):
5706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5708 
      return
5709 
    iprot.readStructBegin()
5710 
    while True:
5711 
      (fname, ftype, fid) = iprot.readFieldBegin()
5712 
      if ftype == TType.STOP:
5713 
        break
5714 
      if fid == 1:
5715 
        if ftype == TType.I64:
5716 
          self.fromShippingDate = iprot.readI64();
5717 
        else:
5718 
          iprot.skip(ftype)
5719 
      elif fid == 2:
5720 
        if ftype == TType.I64:
5721 
          self.toShippingDate = iprot.readI64();
5722 
        else:
5723 
          iprot.skip(ftype)
5724 
      elif fid == 3:
5725 
        if ftype == TType.I64:
5726 
          self.providerId = iprot.readI64();
5727 
        else:
5728 
          iprot.skip(ftype)
5729 
      elif fid == 4:
5730 
        if ftype == TType.I64:
5731 
          self.warehouseId = iprot.readI64();
5732 
        else:
5733 
          iprot.skip(ftype)
3451 chandransh 5734 
      elif fid == 5:
5735 
        if ftype == TType.BOOL:
5736 
          self.cod = iprot.readBool();
5737 
        else:
5738 
          iprot.skip(ftype)
3427 chandransh 5739 
      else:
5740 
        iprot.skip(ftype)
5741 
      iprot.readFieldEnd()
5742 
    iprot.readStructEnd()
5743 
 
5744 
  def write(self, oprot):
5745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5747 
      return
5748 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 5749 
    if self.fromShippingDate is not None:
3427 chandransh 5750 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
5751 
      oprot.writeI64(self.fromShippingDate)
5752 
      oprot.writeFieldEnd()
3431 rajveer 5753 
    if self.toShippingDate is not None:
3427 chandransh 5754 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
5755 
      oprot.writeI64(self.toShippingDate)
5756 
      oprot.writeFieldEnd()
3431 rajveer 5757 
    if self.providerId is not None:
3427 chandransh 5758 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
5759 
      oprot.writeI64(self.providerId)
5760 
      oprot.writeFieldEnd()
3431 rajveer 5761 
    if self.warehouseId is not None:
3427 chandransh 5762 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
5763 
      oprot.writeI64(self.warehouseId)
5764 
      oprot.writeFieldEnd()
3451 chandransh 5765 
    if self.cod is not None:
5766 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
5767 
      oprot.writeBool(self.cod)
5768 
      oprot.writeFieldEnd()
3427 chandransh 5769 
    oprot.writeFieldStop()
5770 
    oprot.writeStructEnd()
5771 
 
3431 rajveer 5772 
  def validate(self):
5773 
    return
5774 
 
5775 
 
3427 chandransh 5776 
  def __repr__(self):
5777 
    L = ['%s=%r' % (key, value)
5778 
      for key, value in self.__dict__.iteritems()]
5779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5780 
 
5781 
  def __eq__(self, other):
5782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5783 
 
5784 
  def __ne__(self, other):
5785 
    return not (self == other)
5786 
 
5787 
class getOrdersByShippingDate_result:
5788 
  """
5789 
  Attributes:
5790 
   - success
5791 
   - ex
5792 
  """
5793 
 
5794 
  thrift_spec = (
5795 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5796 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5797 
  )
5798 
 
5799 
  def __init__(self, success=None, ex=None,):
5800 
    self.success = success
5801 
    self.ex = ex
5802 
 
5803 
  def read(self, iprot):
5804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5806 
      return
5807 
    iprot.readStructBegin()
5808 
    while True:
5809 
      (fname, ftype, fid) = iprot.readFieldBegin()
5810 
      if ftype == TType.STOP:
5811 
        break
5812 
      if fid == 0:
5813 
        if ftype == TType.LIST:
5814 
          self.success = []
4133 chandransh 5815 
          (_etype66, _size63) = iprot.readListBegin()
5816 
          for _i67 in xrange(_size63):
5817 
            _elem68 = Order()
5818 
            _elem68.read(iprot)
5819 
            self.success.append(_elem68)
3427 chandransh 5820 
          iprot.readListEnd()
5821 
        else:
5822 
          iprot.skip(ftype)
5823 
      elif fid == 1:
5824 
        if ftype == TType.STRUCT:
5825 
          self.ex = TransactionServiceException()
5826 
          self.ex.read(iprot)
5827 
        else:
5828 
          iprot.skip(ftype)
5829 
      else:
5830 
        iprot.skip(ftype)
5831 
      iprot.readFieldEnd()
5832 
    iprot.readStructEnd()
5833 
 
5834 
  def write(self, oprot):
5835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5837 
      return
5838 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 5839 
    if self.success is not None:
3427 chandransh 5840 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5841 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 5842 
      for iter69 in self.success:
5843 
        iter69.write(oprot)
3427 chandransh 5844 
      oprot.writeListEnd()
5845 
      oprot.writeFieldEnd()
3431 rajveer 5846 
    if self.ex is not None:
3427 chandransh 5847 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5848 
      self.ex.write(oprot)
5849 
      oprot.writeFieldEnd()
5850 
    oprot.writeFieldStop()
5851 
    oprot.writeStructEnd()
5852 
 
3431 rajveer 5853 
  def validate(self):
5854 
    return
5855 
 
5856 
 
3427 chandransh 5857 
  def __repr__(self):
5858 
    L = ['%s=%r' % (key, value)
5859 
      for key, value in self.__dict__.iteritems()]
5860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5861 
 
5862 
  def __eq__(self, other):
5863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5864 
 
5865 
  def __ne__(self, other):
5866 
    return not (self == other)
5867 
 
1382 varun.gupt 5868 
class getReturnableOrdersForCustomer_args:
5869 
  """
5870 
  Attributes:
5871 
   - customer_id
5872 
   - limit
5873 
  """
5874 
 
5875 
  thrift_spec = (
5876 
    None, # 0
5877 
    (1, TType.I64, 'customer_id', None, None, ), # 1
5878 
    (2, TType.I64, 'limit', None, None, ), # 2
5879 
  )
5880 
 
5881 
  def __init__(self, customer_id=None, limit=None,):
5882 
    self.customer_id = customer_id
5883 
    self.limit = limit
5884 
 
5885 
  def read(self, iprot):
5886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5888 
      return
5889 
    iprot.readStructBegin()
5890 
    while True:
5891 
      (fname, ftype, fid) = iprot.readFieldBegin()
5892 
      if ftype == TType.STOP:
5893 
        break
5894 
      if fid == 1:
5895 
        if ftype == TType.I64:
5896 
          self.customer_id = iprot.readI64();
5897 
        else:
5898 
          iprot.skip(ftype)
5899 
      elif fid == 2:
5900 
        if ftype == TType.I64:
5901 
          self.limit = iprot.readI64();
5902 
        else:
5903 
          iprot.skip(ftype)
5904 
      else:
5905 
        iprot.skip(ftype)
5906 
      iprot.readFieldEnd()
5907 
    iprot.readStructEnd()
5908 
 
5909 
  def write(self, oprot):
5910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5912 
      return
5913 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 5914 
    if self.customer_id is not None:
1382 varun.gupt 5915 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
5916 
      oprot.writeI64(self.customer_id)
5917 
      oprot.writeFieldEnd()
3431 rajveer 5918 
    if self.limit is not None:
1382 varun.gupt 5919 
      oprot.writeFieldBegin('limit', TType.I64, 2)
5920 
      oprot.writeI64(self.limit)
5921 
      oprot.writeFieldEnd()
5922 
    oprot.writeFieldStop()
5923 
    oprot.writeStructEnd()
5924 
 
3431 rajveer 5925 
  def validate(self):
5926 
    return
5927 
 
5928 
 
1382 varun.gupt 5929 
  def __repr__(self):
5930 
    L = ['%s=%r' % (key, value)
5931 
      for key, value in self.__dict__.iteritems()]
5932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5933 
 
5934 
  def __eq__(self, other):
5935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5936 
 
5937 
  def __ne__(self, other):
5938 
    return not (self == other)
5939 
 
5940 
class getReturnableOrdersForCustomer_result:
5941 
  """
5942 
  Attributes:
5943 
   - success
5944 
   - ex
5945 
  """
5946 
 
5947 
  thrift_spec = (
5948 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
5949 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5950 
  )
5951 
 
5952 
  def __init__(self, success=None, ex=None,):
5953 
    self.success = success
5954 
    self.ex = ex
5955 
 
5956 
  def read(self, iprot):
5957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5959 
      return
5960 
    iprot.readStructBegin()
5961 
    while True:
5962 
      (fname, ftype, fid) = iprot.readFieldBegin()
5963 
      if ftype == TType.STOP:
5964 
        break
5965 
      if fid == 0:
5966 
        if ftype == TType.LIST:
5967 
          self.success = []
4133 chandransh 5968 
          (_etype73, _size70) = iprot.readListBegin()
5969 
          for _i74 in xrange(_size70):
5970 
            _elem75 = iprot.readI64();
5971 
            self.success.append(_elem75)
1382 varun.gupt 5972 
          iprot.readListEnd()
5973 
        else:
5974 
          iprot.skip(ftype)
5975 
      elif fid == 1:
5976 
        if ftype == TType.STRUCT:
5977 
          self.ex = TransactionServiceException()
5978 
          self.ex.read(iprot)
5979 
        else:
5980 
          iprot.skip(ftype)
5981 
      else:
5982 
        iprot.skip(ftype)
5983 
      iprot.readFieldEnd()
5984 
    iprot.readStructEnd()
5985 
 
5986 
  def write(self, oprot):
5987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5989 
      return
5990 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 5991 
    if self.success is not None:
1382 varun.gupt 5992 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5993 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 5994 
      for iter76 in self.success:
5995 
        oprot.writeI64(iter76)
1382 varun.gupt 5996 
      oprot.writeListEnd()
5997 
      oprot.writeFieldEnd()
3431 rajveer 5998 
    if self.ex is not None:
1382 varun.gupt 5999 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6000 
      self.ex.write(oprot)
6001 
      oprot.writeFieldEnd()
6002 
    oprot.writeFieldStop()
6003 
    oprot.writeStructEnd()
6004 
 
3431 rajveer 6005 
  def validate(self):
6006 
    return
6007 
 
6008 
 
1382 varun.gupt 6009 
  def __repr__(self):
6010 
    L = ['%s=%r' % (key, value)
6011 
      for key, value in self.__dict__.iteritems()]
6012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6013 
 
6014 
  def __eq__(self, other):
6015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6016 
 
6017 
  def __ne__(self, other):
6018 
    return not (self == other)
6019 
 
6020 
class getCancellableOrdersForCustomer_args:
6021 
  """
6022 
  Attributes:
6023 
   - customer_id
6024 
   - limit
6025 
  """
6026 
 
6027 
  thrift_spec = (
6028 
    None, # 0
6029 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6030 
    (2, TType.I64, 'limit', None, None, ), # 2
6031 
  )
6032 
 
6033 
  def __init__(self, customer_id=None, limit=None,):
6034 
    self.customer_id = customer_id
6035 
    self.limit = limit
6036 
 
6037 
  def read(self, iprot):
6038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6040 
      return
6041 
    iprot.readStructBegin()
6042 
    while True:
6043 
      (fname, ftype, fid) = iprot.readFieldBegin()
6044 
      if ftype == TType.STOP:
6045 
        break
6046 
      if fid == 1:
6047 
        if ftype == TType.I64:
6048 
          self.customer_id = iprot.readI64();
6049 
        else:
6050 
          iprot.skip(ftype)
6051 
      elif fid == 2:
6052 
        if ftype == TType.I64:
6053 
          self.limit = iprot.readI64();
6054 
        else:
6055 
          iprot.skip(ftype)
6056 
      else:
6057 
        iprot.skip(ftype)
6058 
      iprot.readFieldEnd()
6059 
    iprot.readStructEnd()
6060 
 
6061 
  def write(self, oprot):
6062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6064 
      return
6065 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6066 
    if self.customer_id is not None:
1382 varun.gupt 6067 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6068 
      oprot.writeI64(self.customer_id)
6069 
      oprot.writeFieldEnd()
3431 rajveer 6070 
    if self.limit is not None:
1382 varun.gupt 6071 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6072 
      oprot.writeI64(self.limit)
6073 
      oprot.writeFieldEnd()
6074 
    oprot.writeFieldStop()
6075 
    oprot.writeStructEnd()
6076 
 
3431 rajveer 6077 
  def validate(self):
6078 
    return
6079 
 
6080 
 
1382 varun.gupt 6081 
  def __repr__(self):
6082 
    L = ['%s=%r' % (key, value)
6083 
      for key, value in self.__dict__.iteritems()]
6084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6085 
 
6086 
  def __eq__(self, other):
6087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6088 
 
6089 
  def __ne__(self, other):
6090 
    return not (self == other)
6091 
 
6092 
class getCancellableOrdersForCustomer_result:
6093 
  """
6094 
  Attributes:
6095 
   - success
6096 
   - ex
6097 
  """
6098 
 
6099 
  thrift_spec = (
6100 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6101 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6102 
  )
6103 
 
6104 
  def __init__(self, success=None, ex=None,):
6105 
    self.success = success
6106 
    self.ex = ex
6107 
 
6108 
  def read(self, iprot):
6109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6111 
      return
6112 
    iprot.readStructBegin()
6113 
    while True:
6114 
      (fname, ftype, fid) = iprot.readFieldBegin()
6115 
      if ftype == TType.STOP:
6116 
        break
6117 
      if fid == 0:
6118 
        if ftype == TType.LIST:
6119 
          self.success = []
4133 chandransh 6120 
          (_etype80, _size77) = iprot.readListBegin()
6121 
          for _i81 in xrange(_size77):
6122 
            _elem82 = iprot.readI64();
6123 
            self.success.append(_elem82)
1382 varun.gupt 6124 
          iprot.readListEnd()
6125 
        else:
6126 
          iprot.skip(ftype)
6127 
      elif fid == 1:
6128 
        if ftype == TType.STRUCT:
6129 
          self.ex = TransactionServiceException()
6130 
          self.ex.read(iprot)
6131 
        else:
6132 
          iprot.skip(ftype)
6133 
      else:
6134 
        iprot.skip(ftype)
6135 
      iprot.readFieldEnd()
6136 
    iprot.readStructEnd()
6137 
 
6138 
  def write(self, oprot):
6139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6141 
      return
6142 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6143 
    if self.success is not None:
1382 varun.gupt 6144 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6145 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6146 
      for iter83 in self.success:
6147 
        oprot.writeI64(iter83)
1382 varun.gupt 6148 
      oprot.writeListEnd()
6149 
      oprot.writeFieldEnd()
3431 rajveer 6150 
    if self.ex is not None:
1382 varun.gupt 6151 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6152 
      self.ex.write(oprot)
6153 
      oprot.writeFieldEnd()
6154 
    oprot.writeFieldStop()
6155 
    oprot.writeStructEnd()
6156 
 
3431 rajveer 6157 
  def validate(self):
6158 
    return
6159 
 
6160 
 
1382 varun.gupt 6161 
  def __repr__(self):
6162 
    L = ['%s=%r' % (key, value)
6163 
      for key, value in self.__dict__.iteritems()]
6164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6165 
 
6166 
  def __eq__(self, other):
6167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6168 
 
6169 
  def __ne__(self, other):
6170 
    return not (self == other)
6171 
 
483 rajveer 6172 
class changeOrderStatus_args:
94 ashish 6173 
  """
6174 
  Attributes:
483 rajveer 6175 
   - orderId
6176 
   - status
6177 
   - description
94 ashish 6178 
  """
6179 
 
6180 
  thrift_spec = (
6181 
    None, # 0
483 rajveer 6182 
    (1, TType.I64, 'orderId', None, None, ), # 1
6183 
    (2, TType.I32, 'status', None, None, ), # 2
6184 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 6185 
  )
6186 
 
483 rajveer 6187 
  def __init__(self, orderId=None, status=None, description=None,):
6188 
    self.orderId = orderId
6189 
    self.status = status
6190 
    self.description = description
94 ashish 6191 
 
6192 
  def read(self, iprot):
6193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6195 
      return
6196 
    iprot.readStructBegin()
6197 
    while True:
6198 
      (fname, ftype, fid) = iprot.readFieldBegin()
6199 
      if ftype == TType.STOP:
6200 
        break
6201 
      if fid == 1:
6202 
        if ftype == TType.I64:
483 rajveer 6203 
          self.orderId = iprot.readI64();
94 ashish 6204 
        else:
6205 
          iprot.skip(ftype)
6206 
      elif fid == 2:
483 rajveer 6207 
        if ftype == TType.I32:
6208 
          self.status = iprot.readI32();
94 ashish 6209 
        else:
6210 
          iprot.skip(ftype)
483 rajveer 6211 
      elif fid == 3:
6212 
        if ftype == TType.STRING:
6213 
          self.description = iprot.readString();
6214 
        else:
6215 
          iprot.skip(ftype)
94 ashish 6216 
      else:
6217 
        iprot.skip(ftype)
6218 
      iprot.readFieldEnd()
6219 
    iprot.readStructEnd()
6220 
 
6221 
  def write(self, oprot):
6222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6224 
      return
483 rajveer 6225 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 6226 
    if self.orderId is not None:
483 rajveer 6227 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6228 
      oprot.writeI64(self.orderId)
94 ashish 6229 
      oprot.writeFieldEnd()
3431 rajveer 6230 
    if self.status is not None:
483 rajveer 6231 
      oprot.writeFieldBegin('status', TType.I32, 2)
6232 
      oprot.writeI32(self.status)
94 ashish 6233 
      oprot.writeFieldEnd()
3431 rajveer 6234 
    if self.description is not None:
483 rajveer 6235 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6236 
      oprot.writeString(self.description)
6237 
      oprot.writeFieldEnd()
94 ashish 6238 
    oprot.writeFieldStop()
6239 
    oprot.writeStructEnd()
6240 
 
3431 rajveer 6241 
  def validate(self):
6242 
    return
6243 
 
6244 
 
94 ashish 6245 
  def __repr__(self):
6246 
    L = ['%s=%r' % (key, value)
6247 
      for key, value in self.__dict__.iteritems()]
6248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6249 
 
6250 
  def __eq__(self, other):
6251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6252 
 
6253 
  def __ne__(self, other):
6254 
    return not (self == other)
6255 
 
483 rajveer 6256 
class changeOrderStatus_result:
94 ashish 6257 
  """
6258 
  Attributes:
6259 
   - success
6260 
   - ex
6261 
  """
6262 
 
6263 
  thrift_spec = (
6264 
    (0, TType.BOOL, 'success', None, None, ), # 0
6265 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6266 
  )
6267 
 
6268 
  def __init__(self, success=None, ex=None,):
6269 
    self.success = success
6270 
    self.ex = ex
6271 
 
6272 
  def read(self, iprot):
6273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6275 
      return
6276 
    iprot.readStructBegin()
6277 
    while True:
6278 
      (fname, ftype, fid) = iprot.readFieldBegin()
6279 
      if ftype == TType.STOP:
6280 
        break
6281 
      if fid == 0:
6282 
        if ftype == TType.BOOL:
6283 
          self.success = iprot.readBool();
6284 
        else:
6285 
          iprot.skip(ftype)
6286 
      elif fid == 1:
6287 
        if ftype == TType.STRUCT:
6288 
          self.ex = TransactionServiceException()
6289 
          self.ex.read(iprot)
6290 
        else:
6291 
          iprot.skip(ftype)
6292 
      else:
6293 
        iprot.skip(ftype)
6294 
      iprot.readFieldEnd()
6295 
    iprot.readStructEnd()
6296 
 
6297 
  def write(self, oprot):
6298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6300 
      return
483 rajveer 6301 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 6302 
    if self.success is not None:
94 ashish 6303 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6304 
      oprot.writeBool(self.success)
6305 
      oprot.writeFieldEnd()
3431 rajveer 6306 
    if self.ex is not None:
94 ashish 6307 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6308 
      self.ex.write(oprot)
6309 
      oprot.writeFieldEnd()
6310 
    oprot.writeFieldStop()
6311 
    oprot.writeStructEnd()
6312 
 
3431 rajveer 6313 
  def validate(self):
6314 
    return
6315 
 
6316 
 
94 ashish 6317 
  def __repr__(self):
6318 
    L = ['%s=%r' % (key, value)
6319 
      for key, value in self.__dict__.iteritems()]
6320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6321 
 
6322 
  def __eq__(self, other):
6323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6324 
 
6325 
  def __ne__(self, other):
6326 
    return not (self == other)
6327 
 
3064 chandransh 6328 
class getOrdersForTransaction_args:
494 rajveer 6329 
  """
6330 
  Attributes:
3064 chandransh 6331 
   - transactionId
6332 
   - customerId
494 rajveer 6333 
  """
6334 
 
6335 
  thrift_spec = (
6336 
    None, # 0
3064 chandransh 6337 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6338 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 6339 
  )
6340 
 
3064 chandransh 6341 
  def __init__(self, transactionId=None, customerId=None,):
6342 
    self.transactionId = transactionId
6343 
    self.customerId = customerId
494 rajveer 6344 
 
6345 
  def read(self, iprot):
6346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6348 
      return
6349 
    iprot.readStructBegin()
6350 
    while True:
6351 
      (fname, ftype, fid) = iprot.readFieldBegin()
6352 
      if ftype == TType.STOP:
6353 
        break
6354 
      if fid == 1:
6355 
        if ftype == TType.I64:
3064 chandransh 6356 
          self.transactionId = iprot.readI64();
494 rajveer 6357 
        else:
6358 
          iprot.skip(ftype)
6359 
      elif fid == 2:
3064 chandransh 6360 
        if ftype == TType.I64:
6361 
          self.customerId = iprot.readI64();
494 rajveer 6362 
        else:
6363 
          iprot.skip(ftype)
6364 
      else:
6365 
        iprot.skip(ftype)
6366 
      iprot.readFieldEnd()
6367 
    iprot.readStructEnd()
6368 
 
6369 
  def write(self, oprot):
6370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6372 
      return
3064 chandransh 6373 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 6374 
    if self.transactionId is not None:
3064 chandransh 6375 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6376 
      oprot.writeI64(self.transactionId)
494 rajveer 6377 
      oprot.writeFieldEnd()
3431 rajveer 6378 
    if self.customerId is not None:
3064 chandransh 6379 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
6380 
      oprot.writeI64(self.customerId)
494 rajveer 6381 
      oprot.writeFieldEnd()
6382 
    oprot.writeFieldStop()
6383 
    oprot.writeStructEnd()
6384 
 
3431 rajveer 6385 
  def validate(self):
6386 
    return
6387 
 
6388 
 
494 rajveer 6389 
  def __repr__(self):
6390 
    L = ['%s=%r' % (key, value)
6391 
      for key, value in self.__dict__.iteritems()]
6392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6393 
 
6394 
  def __eq__(self, other):
6395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6396 
 
6397 
  def __ne__(self, other):
6398 
    return not (self == other)
6399 
 
3064 chandransh 6400 
class getOrdersForTransaction_result:
494 rajveer 6401 
  """
6402 
  Attributes:
6403 
   - success
6404 
   - ex
6405 
  """
6406 
 
6407 
  thrift_spec = (
3064 chandransh 6408 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 6409 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6410 
  )
6411 
 
6412 
  def __init__(self, success=None, ex=None,):
6413 
    self.success = success
6414 
    self.ex = ex
6415 
 
6416 
  def read(self, iprot):
6417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6419 
      return
6420 
    iprot.readStructBegin()
6421 
    while True:
6422 
      (fname, ftype, fid) = iprot.readFieldBegin()
6423 
      if ftype == TType.STOP:
6424 
        break
6425 
      if fid == 0:
3064 chandransh 6426 
        if ftype == TType.LIST:
6427 
          self.success = []
4133 chandransh 6428 
          (_etype87, _size84) = iprot.readListBegin()
6429 
          for _i88 in xrange(_size84):
6430 
            _elem89 = Order()
6431 
            _elem89.read(iprot)
6432 
            self.success.append(_elem89)
3064 chandransh 6433 
          iprot.readListEnd()
494 rajveer 6434 
        else:
6435 
          iprot.skip(ftype)
6436 
      elif fid == 1:
6437 
        if ftype == TType.STRUCT:
6438 
          self.ex = TransactionServiceException()
6439 
          self.ex.read(iprot)
6440 
        else:
6441 
          iprot.skip(ftype)
6442 
      else:
6443 
        iprot.skip(ftype)
6444 
      iprot.readFieldEnd()
6445 
    iprot.readStructEnd()
6446 
 
6447 
  def write(self, oprot):
6448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6450 
      return
3064 chandransh 6451 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 6452 
    if self.success is not None:
3064 chandransh 6453 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6454 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6455 
      for iter90 in self.success:
6456 
        iter90.write(oprot)
3064 chandransh 6457 
      oprot.writeListEnd()
494 rajveer 6458 
      oprot.writeFieldEnd()
3431 rajveer 6459 
    if self.ex is not None:
494 rajveer 6460 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6461 
      self.ex.write(oprot)
6462 
      oprot.writeFieldEnd()
6463 
    oprot.writeFieldStop()
6464 
    oprot.writeStructEnd()
6465 
 
3431 rajveer 6466 
  def validate(self):
6467 
    return
6468 
 
6469 
 
494 rajveer 6470 
  def __repr__(self):
6471 
    L = ['%s=%r' % (key, value)
6472 
      for key, value in self.__dict__.iteritems()]
6473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6474 
 
6475 
  def __eq__(self, other):
6476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6477 
 
6478 
  def __ne__(self, other):
6479 
    return not (self == other)
6480 
 
3064 chandransh 6481 
class getOrdersForCustomer_args:
1149 chandransh 6482 
  """
6483 
  Attributes:
3064 chandransh 6484 
   - customerId
6485 
   - from_date
6486 
   - to_date
6487 
   - statuses
1149 chandransh 6488 
  """
6489 
 
6490 
  thrift_spec = (
6491 
    None, # 0
3064 chandransh 6492 
    (1, TType.I64, 'customerId', None, None, ), # 1
6493 
    (2, TType.I64, 'from_date', None, None, ), # 2
6494 
    (3, TType.I64, 'to_date', None, None, ), # 3
6495 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 6496 
  )
6497 
 
3064 chandransh 6498 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
6499 
    self.customerId = customerId
6500 
    self.from_date = from_date
6501 
    self.to_date = to_date
6502 
    self.statuses = statuses
1149 chandransh 6503 
 
6504 
  def read(self, iprot):
6505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6507 
      return
6508 
    iprot.readStructBegin()
6509 
    while True:
6510 
      (fname, ftype, fid) = iprot.readFieldBegin()
6511 
      if ftype == TType.STOP:
6512 
        break
6513 
      if fid == 1:
6514 
        if ftype == TType.I64:
3064 chandransh 6515 
          self.customerId = iprot.readI64();
1149 chandransh 6516 
        else:
6517 
          iprot.skip(ftype)
6518 
      elif fid == 2:
6519 
        if ftype == TType.I64:
3064 chandransh 6520 
          self.from_date = iprot.readI64();
1149 chandransh 6521 
        else:
6522 
          iprot.skip(ftype)
2783 chandransh 6523 
      elif fid == 3:
6524 
        if ftype == TType.I64:
3064 chandransh 6525 
          self.to_date = iprot.readI64();
2783 chandransh 6526 
        else:
6527 
          iprot.skip(ftype)
6528 
      elif fid == 4:
3064 chandransh 6529 
        if ftype == TType.LIST:
6530 
          self.statuses = []
4133 chandransh 6531 
          (_etype94, _size91) = iprot.readListBegin()
6532 
          for _i95 in xrange(_size91):
6533 
            _elem96 = iprot.readI32();
6534 
            self.statuses.append(_elem96)
3064 chandransh 6535 
          iprot.readListEnd()
2783 chandransh 6536 
        else:
6537 
          iprot.skip(ftype)
1149 chandransh 6538 
      else:
6539 
        iprot.skip(ftype)
6540 
      iprot.readFieldEnd()
6541 
    iprot.readStructEnd()
6542 
 
6543 
  def write(self, oprot):
6544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6546 
      return
3064 chandransh 6547 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 6548 
    if self.customerId is not None:
3064 chandransh 6549 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6550 
      oprot.writeI64(self.customerId)
1149 chandransh 6551 
      oprot.writeFieldEnd()
3431 rajveer 6552 
    if self.from_date is not None:
3064 chandransh 6553 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6554 
      oprot.writeI64(self.from_date)
1149 chandransh 6555 
      oprot.writeFieldEnd()
3431 rajveer 6556 
    if self.to_date is not None:
3064 chandransh 6557 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6558 
      oprot.writeI64(self.to_date)
2783 chandransh 6559 
      oprot.writeFieldEnd()
3431 rajveer 6560 
    if self.statuses is not None:
3064 chandransh 6561 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
6562 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 6563 
      for iter97 in self.statuses:
6564 
        oprot.writeI32(iter97)
3064 chandransh 6565 
      oprot.writeListEnd()
2783 chandransh 6566 
      oprot.writeFieldEnd()
1149 chandransh 6567 
    oprot.writeFieldStop()
6568 
    oprot.writeStructEnd()
6569 
 
3431 rajveer 6570 
  def validate(self):
6571 
    return
6572 
 
6573 
 
1149 chandransh 6574 
  def __repr__(self):
6575 
    L = ['%s=%r' % (key, value)
6576 
      for key, value in self.__dict__.iteritems()]
6577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6578 
 
6579 
  def __eq__(self, other):
6580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6581 
 
6582 
  def __ne__(self, other):
6583 
    return not (self == other)
6584 
 
3064 chandransh 6585 
class getOrdersForCustomer_result:
1149 chandransh 6586 
  """
6587 
  Attributes:
6588 
   - success
6589 
   - ex
6590 
  """
6591 
 
6592 
  thrift_spec = (
3064 chandransh 6593 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 6594 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6595 
  )
6596 
 
6597 
  def __init__(self, success=None, ex=None,):
6598 
    self.success = success
6599 
    self.ex = ex
6600 
 
6601 
  def read(self, iprot):
6602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6604 
      return
6605 
    iprot.readStructBegin()
6606 
    while True:
6607 
      (fname, ftype, fid) = iprot.readFieldBegin()
6608 
      if ftype == TType.STOP:
6609 
        break
6610 
      if fid == 0:
3064 chandransh 6611 
        if ftype == TType.LIST:
6612 
          self.success = []
4133 chandransh 6613 
          (_etype101, _size98) = iprot.readListBegin()
6614 
          for _i102 in xrange(_size98):
6615 
            _elem103 = Order()
6616 
            _elem103.read(iprot)
6617 
            self.success.append(_elem103)
3064 chandransh 6618 
          iprot.readListEnd()
1149 chandransh 6619 
        else:
6620 
          iprot.skip(ftype)
6621 
      elif fid == 1:
6622 
        if ftype == TType.STRUCT:
6623 
          self.ex = TransactionServiceException()
6624 
          self.ex.read(iprot)
6625 
        else:
6626 
          iprot.skip(ftype)
6627 
      else:
6628 
        iprot.skip(ftype)
6629 
      iprot.readFieldEnd()
6630 
    iprot.readStructEnd()
6631 
 
6632 
  def write(self, oprot):
6633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6635 
      return
3064 chandransh 6636 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 6637 
    if self.success is not None:
3064 chandransh 6638 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6639 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6640 
      for iter104 in self.success:
6641 
        iter104.write(oprot)
3064 chandransh 6642 
      oprot.writeListEnd()
1149 chandransh 6643 
      oprot.writeFieldEnd()
3431 rajveer 6644 
    if self.ex is not None:
1149 chandransh 6645 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6646 
      self.ex.write(oprot)
6647 
      oprot.writeFieldEnd()
6648 
    oprot.writeFieldStop()
6649 
    oprot.writeStructEnd()
6650 
 
3431 rajveer 6651 
  def validate(self):
6652 
    return
6653 
 
6654 
 
1149 chandransh 6655 
  def __repr__(self):
6656 
    L = ['%s=%r' % (key, value)
6657 
      for key, value in self.__dict__.iteritems()]
6658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6659 
 
6660 
  def __eq__(self, other):
6661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6662 
 
6663 
  def __ne__(self, other):
6664 
    return not (self == other)
6665 
 
3064 chandransh 6666 
class createOrder_args:
921 rajveer 6667 
  """
6668 
  Attributes:
3064 chandransh 6669 
   - order
921 rajveer 6670 
  """
6671 
 
6672 
  thrift_spec = (
6673 
    None, # 0
3064 chandransh 6674 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 6675 
  )
6676 
 
3064 chandransh 6677 
  def __init__(self, order=None,):
6678 
    self.order = order
921 rajveer 6679 
 
6680 
  def read(self, iprot):
6681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6683 
      return
6684 
    iprot.readStructBegin()
6685 
    while True:
6686 
      (fname, ftype, fid) = iprot.readFieldBegin()
6687 
      if ftype == TType.STOP:
6688 
        break
6689 
      if fid == 1:
3064 chandransh 6690 
        if ftype == TType.STRUCT:
6691 
          self.order = Order()
6692 
          self.order.read(iprot)
921 rajveer 6693 
        else:
6694 
          iprot.skip(ftype)
6695 
      else:
6696 
        iprot.skip(ftype)
6697 
      iprot.readFieldEnd()
6698 
    iprot.readStructEnd()
6699 
 
6700 
  def write(self, oprot):
6701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6703 
      return
3064 chandransh 6704 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 6705 
    if self.order is not None:
3064 chandransh 6706 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
6707 
      self.order.write(oprot)
921 rajveer 6708 
      oprot.writeFieldEnd()
6709 
    oprot.writeFieldStop()
6710 
    oprot.writeStructEnd()
6711 
 
3431 rajveer 6712 
  def validate(self):
6713 
    return
6714 
 
6715 
 
921 rajveer 6716 
  def __repr__(self):
6717 
    L = ['%s=%r' % (key, value)
6718 
      for key, value in self.__dict__.iteritems()]
6719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6720 
 
6721 
  def __eq__(self, other):
6722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6723 
 
6724 
  def __ne__(self, other):
6725 
    return not (self == other)
6726 
 
3064 chandransh 6727 
class createOrder_result:
921 rajveer 6728 
  """
6729 
  Attributes:
6730 
   - success
6731 
   - ex
6732 
  """
6733 
 
6734 
  thrift_spec = (
3064 chandransh 6735 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 6736 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6737 
  )
6738 
 
6739 
  def __init__(self, success=None, ex=None,):
6740 
    self.success = success
6741 
    self.ex = ex
6742 
 
6743 
  def read(self, iprot):
6744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6746 
      return
6747 
    iprot.readStructBegin()
6748 
    while True:
6749 
      (fname, ftype, fid) = iprot.readFieldBegin()
6750 
      if ftype == TType.STOP:
6751 
        break
6752 
      if fid == 0:
3064 chandransh 6753 
        if ftype == TType.I64:
6754 
          self.success = iprot.readI64();
921 rajveer 6755 
        else:
6756 
          iprot.skip(ftype)
6757 
      elif fid == 1:
6758 
        if ftype == TType.STRUCT:
6759 
          self.ex = TransactionServiceException()
6760 
          self.ex.read(iprot)
6761 
        else:
6762 
          iprot.skip(ftype)
6763 
      else:
6764 
        iprot.skip(ftype)
6765 
      iprot.readFieldEnd()
6766 
    iprot.readStructEnd()
6767 
 
6768 
  def write(self, oprot):
6769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6771 
      return
3064 chandransh 6772 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 6773 
    if self.success is not None:
3064 chandransh 6774 
      oprot.writeFieldBegin('success', TType.I64, 0)
6775 
      oprot.writeI64(self.success)
921 rajveer 6776 
      oprot.writeFieldEnd()
3431 rajveer 6777 
    if self.ex is not None:
921 rajveer 6778 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6779 
      self.ex.write(oprot)
6780 
      oprot.writeFieldEnd()
6781 
    oprot.writeFieldStop()
6782 
    oprot.writeStructEnd()
6783 
 
3431 rajveer 6784 
  def validate(self):
6785 
    return
6786 
 
6787 
 
921 rajveer 6788 
  def __repr__(self):
6789 
    L = ['%s=%r' % (key, value)
6790 
      for key, value in self.__dict__.iteritems()]
6791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6792 
 
6793 
  def __eq__(self, other):
6794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6795 
 
6796 
  def __ne__(self, other):
6797 
    return not (self == other)
6798 
 
3064 chandransh 6799 
class getOrder_args:
921 rajveer 6800 
  """
6801 
  Attributes:
3064 chandransh 6802 
   - id
921 rajveer 6803 
  """
6804 
 
6805 
  thrift_spec = (
6806 
    None, # 0
3064 chandransh 6807 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 6808 
  )
6809 
 
3064 chandransh 6810 
  def __init__(self, id=None,):
6811 
    self.id = id
921 rajveer 6812 
 
6813 
  def read(self, iprot):
6814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6816 
      return
6817 
    iprot.readStructBegin()
6818 
    while True:
6819 
      (fname, ftype, fid) = iprot.readFieldBegin()
6820 
      if ftype == TType.STOP:
6821 
        break
6822 
      if fid == 1:
6823 
        if ftype == TType.I64:
3064 chandransh 6824 
          self.id = iprot.readI64();
921 rajveer 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('getOrder_args')
3431 rajveer 6837 
    if self.id is not None:
3064 chandransh 6838 
      oprot.writeFieldBegin('id', TType.I64, 1)
6839 
      oprot.writeI64(self.id)
921 rajveer 6840 
      oprot.writeFieldEnd()
6841 
    oprot.writeFieldStop()
6842 
    oprot.writeStructEnd()
6843 
 
3431 rajveer 6844 
  def validate(self):
6845 
    return
6846 
 
6847 
 
921 rajveer 6848 
  def __repr__(self):
6849 
    L = ['%s=%r' % (key, value)
6850 
      for key, value in self.__dict__.iteritems()]
6851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6852 
 
6853 
  def __eq__(self, other):
6854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6855 
 
6856 
  def __ne__(self, other):
6857 
    return not (self == other)
6858 
 
3064 chandransh 6859 
class getOrder_result:
921 rajveer 6860 
  """
6861 
  Attributes:
6862 
   - success
6863 
   - ex
6864 
  """
6865 
 
6866 
  thrift_spec = (
3064 chandransh 6867 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 6868 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6869 
  )
6870 
 
6871 
  def __init__(self, success=None, ex=None,):
6872 
    self.success = success
6873 
    self.ex = ex
6874 
 
6875 
  def read(self, iprot):
6876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6878 
      return
6879 
    iprot.readStructBegin()
6880 
    while True:
6881 
      (fname, ftype, fid) = iprot.readFieldBegin()
6882 
      if ftype == TType.STOP:
6883 
        break
6884 
      if fid == 0:
3064 chandransh 6885 
        if ftype == TType.STRUCT:
6886 
          self.success = Order()
6887 
          self.success.read(iprot)
921 rajveer 6888 
        else:
6889 
          iprot.skip(ftype)
6890 
      elif fid == 1:
6891 
        if ftype == TType.STRUCT:
6892 
          self.ex = TransactionServiceException()
6893 
          self.ex.read(iprot)
6894 
        else:
6895 
          iprot.skip(ftype)
6896 
      else:
6897 
        iprot.skip(ftype)
6898 
      iprot.readFieldEnd()
6899 
    iprot.readStructEnd()
6900 
 
6901 
  def write(self, oprot):
6902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6904 
      return
3064 chandransh 6905 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 6906 
    if self.success is not None:
3064 chandransh 6907 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6908 
      self.success.write(oprot)
921 rajveer 6909 
      oprot.writeFieldEnd()
3431 rajveer 6910 
    if self.ex is not None:
921 rajveer 6911 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6912 
      self.ex.write(oprot)
6913 
      oprot.writeFieldEnd()
6914 
    oprot.writeFieldStop()
6915 
    oprot.writeStructEnd()
6916 
 
3431 rajveer 6917 
  def validate(self):
6918 
    return
6919 
 
6920 
 
921 rajveer 6921 
  def __repr__(self):
6922 
    L = ['%s=%r' % (key, value)
6923 
      for key, value in self.__dict__.iteritems()]
6924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6925 
 
6926 
  def __eq__(self, other):
6927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6928 
 
6929 
  def __ne__(self, other):
6930 
    return not (self == other)
6931 
 
3064 chandransh 6932 
class getLineItemsForOrder_args:
94 ashish 6933 
  """
6934 
  Attributes:
3064 chandransh 6935 
   - orderId
94 ashish 6936 
  """
6937 
 
6938 
  thrift_spec = (
6939 
    None, # 0
3064 chandransh 6940 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 6941 
  )
6942 
 
3064 chandransh 6943 
  def __init__(self, orderId=None,):
6944 
    self.orderId = orderId
94 ashish 6945 
 
6946 
  def read(self, iprot):
6947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6949 
      return
6950 
    iprot.readStructBegin()
6951 
    while True:
6952 
      (fname, ftype, fid) = iprot.readFieldBegin()
6953 
      if ftype == TType.STOP:
6954 
        break
6955 
      if fid == 1:
6956 
        if ftype == TType.I64:
3064 chandransh 6957 
          self.orderId = iprot.readI64();
94 ashish 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('getLineItemsForOrder_args')
3431 rajveer 6970 
    if self.orderId is not None:
3064 chandransh 6971 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6972 
      oprot.writeI64(self.orderId)
94 ashish 6973 
      oprot.writeFieldEnd()
6974 
    oprot.writeFieldStop()
6975 
    oprot.writeStructEnd()
6976 
 
3431 rajveer 6977 
  def validate(self):
6978 
    return
6979 
 
6980 
 
94 ashish 6981 
  def __repr__(self):
6982 
    L = ['%s=%r' % (key, value)
6983 
      for key, value in self.__dict__.iteritems()]
6984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6985 
 
6986 
  def __eq__(self, other):
6987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6988 
 
6989 
  def __ne__(self, other):
6990 
    return not (self == other)
6991 
 
3064 chandransh 6992 
class getLineItemsForOrder_result:
94 ashish 6993 
  """
6994 
  Attributes:
6995 
   - success
6996 
   - ex
6997 
  """
6998 
 
6999 
  thrift_spec = (
3064 chandransh 7000 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7001 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7002 
  )
7003 
 
7004 
  def __init__(self, success=None, ex=None,):
7005 
    self.success = success
7006 
    self.ex = ex
7007 
 
7008 
  def read(self, iprot):
7009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7011 
      return
7012 
    iprot.readStructBegin()
7013 
    while True:
7014 
      (fname, ftype, fid) = iprot.readFieldBegin()
7015 
      if ftype == TType.STOP:
7016 
        break
7017 
      if fid == 0:
483 rajveer 7018 
        if ftype == TType.LIST:
7019 
          self.success = []
4133 chandransh 7020 
          (_etype108, _size105) = iprot.readListBegin()
7021 
          for _i109 in xrange(_size105):
7022 
            _elem110 = LineItem()
7023 
            _elem110.read(iprot)
7024 
            self.success.append(_elem110)
483 rajveer 7025 
          iprot.readListEnd()
94 ashish 7026 
        else:
7027 
          iprot.skip(ftype)
7028 
      elif fid == 1:
7029 
        if ftype == TType.STRUCT:
7030 
          self.ex = TransactionServiceException()
7031 
          self.ex.read(iprot)
7032 
        else:
7033 
          iprot.skip(ftype)
7034 
      else:
7035 
        iprot.skip(ftype)
7036 
      iprot.readFieldEnd()
7037 
    iprot.readStructEnd()
7038 
 
7039 
  def write(self, oprot):
7040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7042 
      return
3064 chandransh 7043 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7044 
    if self.success is not None:
483 rajveer 7045 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7046 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7047 
      for iter111 in self.success:
7048 
        iter111.write(oprot)
483 rajveer 7049 
      oprot.writeListEnd()
94 ashish 7050 
      oprot.writeFieldEnd()
3431 rajveer 7051 
    if self.ex is not None:
94 ashish 7052 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7053 
      self.ex.write(oprot)
7054 
      oprot.writeFieldEnd()
7055 
    oprot.writeFieldStop()
7056 
    oprot.writeStructEnd()
7057 
 
3431 rajveer 7058 
  def validate(self):
7059 
    return
7060 
 
7061 
 
94 ashish 7062 
  def __repr__(self):
7063 
    L = ['%s=%r' % (key, value)
7064 
      for key, value in self.__dict__.iteritems()]
7065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7066 
 
7067 
  def __eq__(self, other):
7068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7069 
 
7070 
  def __ne__(self, other):
7071 
    return not (self == other)
7072 
 
3064 chandransh 7073 
class getOrderForCustomer_args:
94 ashish 7074 
  """
7075 
  Attributes:
3064 chandransh 7076 
   - orderId
483 rajveer 7077 
   - customerId
94 ashish 7078 
  """
7079 
 
7080 
  thrift_spec = (
7081 
    None, # 0
3064 chandransh 7082 
    (1, TType.I64, 'orderId', None, None, ), # 1
7083 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7084 
  )
7085 
 
3064 chandransh 7086 
  def __init__(self, orderId=None, customerId=None,):
7087 
    self.orderId = orderId
483 rajveer 7088 
    self.customerId = customerId
94 ashish 7089 
 
7090 
  def read(self, iprot):
7091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7093 
      return
7094 
    iprot.readStructBegin()
7095 
    while True:
7096 
      (fname, ftype, fid) = iprot.readFieldBegin()
7097 
      if ftype == TType.STOP:
7098 
        break
7099 
      if fid == 1:
7100 
        if ftype == TType.I64:
3064 chandransh 7101 
          self.orderId = iprot.readI64();
94 ashish 7102 
        else:
7103 
          iprot.skip(ftype)
7104 
      elif fid == 2:
7105 
        if ftype == TType.I64:
3064 chandransh 7106 
          self.customerId = iprot.readI64();
94 ashish 7107 
        else:
7108 
          iprot.skip(ftype)
7109 
      else:
7110 
        iprot.skip(ftype)
7111 
      iprot.readFieldEnd()
7112 
    iprot.readStructEnd()
7113 
 
7114 
  def write(self, oprot):
7115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7117 
      return
3064 chandransh 7118 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 7119 
    if self.orderId is not None:
3064 chandransh 7120 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7121 
      oprot.writeI64(self.orderId)
7122 
      oprot.writeFieldEnd()
3431 rajveer 7123 
    if self.customerId is not None:
3064 chandransh 7124 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7125 
      oprot.writeI64(self.customerId)
94 ashish 7126 
      oprot.writeFieldEnd()
7127 
    oprot.writeFieldStop()
7128 
    oprot.writeStructEnd()
7129 
 
3431 rajveer 7130 
  def validate(self):
7131 
    return
7132 
 
7133 
 
94 ashish 7134 
  def __repr__(self):
7135 
    L = ['%s=%r' % (key, value)
7136 
      for key, value in self.__dict__.iteritems()]
7137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7138 
 
7139 
  def __eq__(self, other):
7140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7141 
 
7142 
  def __ne__(self, other):
7143 
    return not (self == other)
7144 
 
3064 chandransh 7145 
class getOrderForCustomer_result:
94 ashish 7146 
  """
7147 
  Attributes:
7148 
   - success
7149 
   - ex
7150 
  """
7151 
 
7152 
  thrift_spec = (
3064 chandransh 7153 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 7154 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7155 
  )
7156 
 
7157 
  def __init__(self, success=None, ex=None,):
7158 
    self.success = success
7159 
    self.ex = ex
7160 
 
7161 
  def read(self, iprot):
7162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7164 
      return
7165 
    iprot.readStructBegin()
7166 
    while True:
7167 
      (fname, ftype, fid) = iprot.readFieldBegin()
7168 
      if ftype == TType.STOP:
7169 
        break
7170 
      if fid == 0:
3064 chandransh 7171 
        if ftype == TType.STRUCT:
7172 
          self.success = Order()
7173 
          self.success.read(iprot)
94 ashish 7174 
        else:
7175 
          iprot.skip(ftype)
7176 
      elif fid == 1:
7177 
        if ftype == TType.STRUCT:
7178 
          self.ex = TransactionServiceException()
7179 
          self.ex.read(iprot)
7180 
        else:
7181 
          iprot.skip(ftype)
7182 
      else:
7183 
        iprot.skip(ftype)
7184 
      iprot.readFieldEnd()
7185 
    iprot.readStructEnd()
7186 
 
7187 
  def write(self, oprot):
7188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7190 
      return
3064 chandransh 7191 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 7192 
    if self.success is not None:
3064 chandransh 7193 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7194 
      self.success.write(oprot)
94 ashish 7195 
      oprot.writeFieldEnd()
3431 rajveer 7196 
    if self.ex is not None:
94 ashish 7197 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7198 
      self.ex.write(oprot)
7199 
      oprot.writeFieldEnd()
7200 
    oprot.writeFieldStop()
7201 
    oprot.writeStructEnd()
7202 
 
3431 rajveer 7203 
  def validate(self):
7204 
    return
7205 
 
7206 
 
94 ashish 7207 
  def __repr__(self):
7208 
    L = ['%s=%r' % (key, value)
7209 
      for key, value in self.__dict__.iteritems()]
7210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7211 
 
7212 
  def __eq__(self, other):
7213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7214 
 
7215 
  def __ne__(self, other):
7216 
    return not (self == other)
7217 
 
3064 chandransh 7218 
class getAlerts_args:
94 ashish 7219 
  """
7220 
  Attributes:
3064 chandransh 7221 
   - orderId
7222 
   - valid
94 ashish 7223 
  """
7224 
 
7225 
  thrift_spec = (
7226 
    None, # 0
3064 chandransh 7227 
    (1, TType.I64, 'orderId', None, None, ), # 1
7228 
    (2, TType.BOOL, 'valid', None, None, ), # 2
94 ashish 7229 
  )
7230 
 
3064 chandransh 7231 
  def __init__(self, orderId=None, valid=None,):
7232 
    self.orderId = orderId
7233 
    self.valid = valid
94 ashish 7234 
 
7235 
  def read(self, iprot):
7236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7238 
      return
7239 
    iprot.readStructBegin()
7240 
    while True:
7241 
      (fname, ftype, fid) = iprot.readFieldBegin()
7242 
      if ftype == TType.STOP:
7243 
        break
7244 
      if fid == 1:
3064 chandransh 7245 
        if ftype == TType.I64:
7246 
          self.orderId = iprot.readI64();
94 ashish 7247 
        else:
7248 
          iprot.skip(ftype)
3064 chandransh 7249 
      elif fid == 2:
7250 
        if ftype == TType.BOOL:
7251 
          self.valid = iprot.readBool();
7252 
        else:
7253 
          iprot.skip(ftype)
94 ashish 7254 
      else:
7255 
        iprot.skip(ftype)
7256 
      iprot.readFieldEnd()
7257 
    iprot.readStructEnd()
7258 
 
7259 
  def write(self, oprot):
7260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7262 
      return
3064 chandransh 7263 
    oprot.writeStructBegin('getAlerts_args')
3431 rajveer 7264 
    if self.orderId is not None:
3064 chandransh 7265 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7266 
      oprot.writeI64(self.orderId)
94 ashish 7267 
      oprot.writeFieldEnd()
3431 rajveer 7268 
    if self.valid is not None:
3064 chandransh 7269 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
7270 
      oprot.writeBool(self.valid)
7271 
      oprot.writeFieldEnd()
94 ashish 7272 
    oprot.writeFieldStop()
7273 
    oprot.writeStructEnd()
7274 
 
3431 rajveer 7275 
  def validate(self):
7276 
    return
7277 
 
7278 
 
94 ashish 7279 
  def __repr__(self):
7280 
    L = ['%s=%r' % (key, value)
7281 
      for key, value in self.__dict__.iteritems()]
7282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7283 
 
7284 
  def __eq__(self, other):
7285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7286 
 
7287 
  def __ne__(self, other):
7288 
    return not (self == other)
7289 
 
3064 chandransh 7290 
class getAlerts_result:
94 ashish 7291 
  """
7292 
  Attributes:
7293 
   - success
7294 
  """
7295 
 
7296 
  thrift_spec = (
3064 chandransh 7297 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 7298 
  )
7299 
 
3064 chandransh 7300 
  def __init__(self, success=None,):
94 ashish 7301 
    self.success = success
7302 
 
7303 
  def read(self, iprot):
7304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7306 
      return
7307 
    iprot.readStructBegin()
7308 
    while True:
7309 
      (fname, ftype, fid) = iprot.readFieldBegin()
7310 
      if ftype == TType.STOP:
7311 
        break
7312 
      if fid == 0:
3064 chandransh 7313 
        if ftype == TType.LIST:
7314 
          self.success = []
4133 chandransh 7315 
          (_etype115, _size112) = iprot.readListBegin()
7316 
          for _i116 in xrange(_size112):
7317 
            _elem117 = Alert()
7318 
            _elem117.read(iprot)
7319 
            self.success.append(_elem117)
3064 chandransh 7320 
          iprot.readListEnd()
94 ashish 7321 
        else:
7322 
          iprot.skip(ftype)
7323 
      else:
7324 
        iprot.skip(ftype)
7325 
      iprot.readFieldEnd()
7326 
    iprot.readStructEnd()
7327 
 
7328 
  def write(self, oprot):
7329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7331 
      return
3064 chandransh 7332 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 7333 
    if self.success is not None:
3064 chandransh 7334 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7335 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7336 
      for iter118 in self.success:
7337 
        iter118.write(oprot)
3064 chandransh 7338 
      oprot.writeListEnd()
94 ashish 7339 
      oprot.writeFieldEnd()
7340 
    oprot.writeFieldStop()
7341 
    oprot.writeStructEnd()
7342 
 
3431 rajveer 7343 
  def validate(self):
7344 
    return
7345 
 
7346 
 
94 ashish 7347 
  def __repr__(self):
7348 
    L = ['%s=%r' % (key, value)
7349 
      for key, value in self.__dict__.iteritems()]
7350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7351 
 
7352 
  def __eq__(self, other):
7353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7354 
 
7355 
  def __ne__(self, other):
7356 
    return not (self == other)
7357 
 
3064 chandransh 7358 
class setAlert_args:
94 ashish 7359 
  """
7360 
  Attributes:
3064 chandransh 7361 
   - orderId
7362 
   - unset
7363 
   - type
7364 
   - comment
94 ashish 7365 
  """
7366 
 
7367 
  thrift_spec = (
7368 
    None, # 0
3064 chandransh 7369 
    (1, TType.I64, 'orderId', None, None, ), # 1
7370 
    (2, TType.BOOL, 'unset', None, None, ), # 2
7371 
    (3, TType.I64, 'type', None, None, ), # 3
7372 
    (4, TType.STRING, 'comment', None, None, ), # 4
94 ashish 7373 
  )
7374 
 
3064 chandransh 7375 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
7376 
    self.orderId = orderId
7377 
    self.unset = unset
7378 
    self.type = type
7379 
    self.comment = comment
94 ashish 7380 
 
7381 
  def read(self, iprot):
7382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7384 
      return
7385 
    iprot.readStructBegin()
7386 
    while True:
7387 
      (fname, ftype, fid) = iprot.readFieldBegin()
7388 
      if ftype == TType.STOP:
7389 
        break
7390 
      if fid == 1:
7391 
        if ftype == TType.I64:
3064 chandransh 7392 
          self.orderId = iprot.readI64();
94 ashish 7393 
        else:
7394 
          iprot.skip(ftype)
3064 chandransh 7395 
      elif fid == 2:
7396 
        if ftype == TType.BOOL:
7397 
          self.unset = iprot.readBool();
7398 
        else:
7399 
          iprot.skip(ftype)
7400 
      elif fid == 3:
7401 
        if ftype == TType.I64:
7402 
          self.type = iprot.readI64();
7403 
        else:
7404 
          iprot.skip(ftype)
7405 
      elif fid == 4:
7406 
        if ftype == TType.STRING:
7407 
          self.comment = iprot.readString();
7408 
        else:
7409 
          iprot.skip(ftype)
94 ashish 7410 
      else:
7411 
        iprot.skip(ftype)
7412 
      iprot.readFieldEnd()
7413 
    iprot.readStructEnd()
7414 
 
7415 
  def write(self, oprot):
7416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7418 
      return
3064 chandransh 7419 
    oprot.writeStructBegin('setAlert_args')
3431 rajveer 7420 
    if self.orderId is not None:
3064 chandransh 7421 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7422 
      oprot.writeI64(self.orderId)
94 ashish 7423 
      oprot.writeFieldEnd()
3431 rajveer 7424 
    if self.unset is not None:
3064 chandransh 7425 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
7426 
      oprot.writeBool(self.unset)
7427 
      oprot.writeFieldEnd()
3431 rajveer 7428 
    if self.type is not None:
3064 chandransh 7429 
      oprot.writeFieldBegin('type', TType.I64, 3)
7430 
      oprot.writeI64(self.type)
7431 
      oprot.writeFieldEnd()
3431 rajveer 7432 
    if self.comment is not None:
3064 chandransh 7433 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
7434 
      oprot.writeString(self.comment)
7435 
      oprot.writeFieldEnd()
94 ashish 7436 
    oprot.writeFieldStop()
7437 
    oprot.writeStructEnd()
7438 
 
3431 rajveer 7439 
  def validate(self):
7440 
    return
7441 
 
7442 
 
94 ashish 7443 
  def __repr__(self):
7444 
    L = ['%s=%r' % (key, value)
7445 
      for key, value in self.__dict__.iteritems()]
7446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7447 
 
7448 
  def __eq__(self, other):
7449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7450 
 
7451 
  def __ne__(self, other):
7452 
    return not (self == other)
7453 
 
3064 chandransh 7454 
class setAlert_result:
7455 
 
7456 
  thrift_spec = (
7457 
  )
7458 
 
7459 
  def read(self, iprot):
7460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7462 
      return
7463 
    iprot.readStructBegin()
7464 
    while True:
7465 
      (fname, ftype, fid) = iprot.readFieldBegin()
7466 
      if ftype == TType.STOP:
7467 
        break
7468 
      else:
7469 
        iprot.skip(ftype)
7470 
      iprot.readFieldEnd()
7471 
    iprot.readStructEnd()
7472 
 
7473 
  def write(self, oprot):
7474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7476 
      return
7477 
    oprot.writeStructBegin('setAlert_result')
7478 
    oprot.writeFieldStop()
7479 
    oprot.writeStructEnd()
7480 
 
3431 rajveer 7481 
  def validate(self):
7482 
    return
7483 
 
7484 
 
3064 chandransh 7485 
  def __repr__(self):
7486 
    L = ['%s=%r' % (key, value)
7487 
      for key, value in self.__dict__.iteritems()]
7488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7489 
 
7490 
  def __eq__(self, other):
7491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7492 
 
7493 
  def __ne__(self, other):
7494 
    return not (self == other)
7495 
 
7496 
class getValidOrderCount_args:
7497 
 
7498 
  thrift_spec = (
7499 
  )
7500 
 
7501 
  def read(self, iprot):
7502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7504 
      return
7505 
    iprot.readStructBegin()
7506 
    while True:
7507 
      (fname, ftype, fid) = iprot.readFieldBegin()
7508 
      if ftype == TType.STOP:
7509 
        break
7510 
      else:
7511 
        iprot.skip(ftype)
7512 
      iprot.readFieldEnd()
7513 
    iprot.readStructEnd()
7514 
 
7515 
  def write(self, oprot):
7516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7518 
      return
7519 
    oprot.writeStructBegin('getValidOrderCount_args')
7520 
    oprot.writeFieldStop()
7521 
    oprot.writeStructEnd()
7522 
 
3431 rajveer 7523 
  def validate(self):
7524 
    return
7525 
 
7526 
 
3064 chandransh 7527 
  def __repr__(self):
7528 
    L = ['%s=%r' % (key, value)
7529 
      for key, value in self.__dict__.iteritems()]
7530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7531 
 
7532 
  def __eq__(self, other):
7533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7534 
 
7535 
  def __ne__(self, other):
7536 
    return not (self == other)
7537 
 
7538 
class getValidOrderCount_result:
94 ashish 7539 
  """
7540 
  Attributes:
7541 
   - success
7542 
  """
7543 
 
7544 
  thrift_spec = (
3064 chandransh 7545 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7546 
  )
7547 
 
3064 chandransh 7548 
  def __init__(self, success=None,):
94 ashish 7549 
    self.success = success
7550 
 
7551 
  def read(self, iprot):
7552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7554 
      return
7555 
    iprot.readStructBegin()
7556 
    while True:
7557 
      (fname, ftype, fid) = iprot.readFieldBegin()
7558 
      if ftype == TType.STOP:
7559 
        break
7560 
      if fid == 0:
3064 chandransh 7561 
        if ftype == TType.I64:
7562 
          self.success = iprot.readI64();
94 ashish 7563 
        else:
7564 
          iprot.skip(ftype)
7565 
      else:
7566 
        iprot.skip(ftype)
7567 
      iprot.readFieldEnd()
7568 
    iprot.readStructEnd()
7569 
 
7570 
  def write(self, oprot):
7571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7573 
      return
3064 chandransh 7574 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 7575 
    if self.success is not None:
3064 chandransh 7576 
      oprot.writeFieldBegin('success', TType.I64, 0)
7577 
      oprot.writeI64(self.success)
94 ashish 7578 
      oprot.writeFieldEnd()
7579 
    oprot.writeFieldStop()
7580 
    oprot.writeStructEnd()
7581 
 
3431 rajveer 7582 
  def validate(self):
7583 
    return
7584 
 
7585 
 
94 ashish 7586 
  def __repr__(self):
7587 
    L = ['%s=%r' % (key, value)
7588 
      for key, value in self.__dict__.iteritems()]
7589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7590 
 
7591 
  def __eq__(self, other):
7592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7593 
 
7594 
  def __ne__(self, other):
7595 
    return not (self == other)
7596 
 
3064 chandransh 7597 
class getNoOfCustomersWithSuccessfulTransaction_args:
7598 
 
7599 
  thrift_spec = (
7600 
  )
7601 
 
7602 
  def read(self, iprot):
7603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7605 
      return
7606 
    iprot.readStructBegin()
7607 
    while True:
7608 
      (fname, ftype, fid) = iprot.readFieldBegin()
7609 
      if ftype == TType.STOP:
7610 
        break
7611 
      else:
7612 
        iprot.skip(ftype)
7613 
      iprot.readFieldEnd()
7614 
    iprot.readStructEnd()
7615 
 
7616 
  def write(self, oprot):
7617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7619 
      return
7620 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
7621 
    oprot.writeFieldStop()
7622 
    oprot.writeStructEnd()
7623 
 
3431 rajveer 7624 
  def validate(self):
7625 
    return
7626 
 
7627 
 
3064 chandransh 7628 
  def __repr__(self):
7629 
    L = ['%s=%r' % (key, value)
7630 
      for key, value in self.__dict__.iteritems()]
7631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7632 
 
7633 
  def __eq__(self, other):
7634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7635 
 
7636 
  def __ne__(self, other):
7637 
    return not (self == other)
7638 
 
7639 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 7640 
  """
7641 
  Attributes:
3064 chandransh 7642 
   - success
94 ashish 7643 
  """
7644 
 
7645 
  thrift_spec = (
3064 chandransh 7646 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7647 
  )
7648 
 
3064 chandransh 7649 
  def __init__(self, success=None,):
7650 
    self.success = success
94 ashish 7651 
 
7652 
  def read(self, iprot):
7653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7655 
      return
7656 
    iprot.readStructBegin()
7657 
    while True:
7658 
      (fname, ftype, fid) = iprot.readFieldBegin()
7659 
      if ftype == TType.STOP:
7660 
        break
3064 chandransh 7661 
      if fid == 0:
94 ashish 7662 
        if ftype == TType.I64:
3064 chandransh 7663 
          self.success = iprot.readI64();
94 ashish 7664 
        else:
7665 
          iprot.skip(ftype)
7666 
      else:
7667 
        iprot.skip(ftype)
7668 
      iprot.readFieldEnd()
7669 
    iprot.readStructEnd()
7670 
 
7671 
  def write(self, oprot):
7672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7674 
      return
3064 chandransh 7675 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 7676 
    if self.success is not None:
3064 chandransh 7677 
      oprot.writeFieldBegin('success', TType.I64, 0)
7678 
      oprot.writeI64(self.success)
94 ashish 7679 
      oprot.writeFieldEnd()
7680 
    oprot.writeFieldStop()
7681 
    oprot.writeStructEnd()
7682 
 
3431 rajveer 7683 
  def validate(self):
7684 
    return
7685 
 
7686 
 
94 ashish 7687 
  def __repr__(self):
7688 
    L = ['%s=%r' % (key, value)
7689 
      for key, value in self.__dict__.iteritems()]
7690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7691 
 
7692 
  def __eq__(self, other):
7693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7694 
 
7695 
  def __ne__(self, other):
7696 
    return not (self == other)
7697 
 
3064 chandransh 7698 
class getValidOrdersAmountRange_args:
7699 
 
7700 
  thrift_spec = (
7701 
  )
7702 
 
7703 
  def read(self, iprot):
7704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7706 
      return
7707 
    iprot.readStructBegin()
7708 
    while True:
7709 
      (fname, ftype, fid) = iprot.readFieldBegin()
7710 
      if ftype == TType.STOP:
7711 
        break
7712 
      else:
7713 
        iprot.skip(ftype)
7714 
      iprot.readFieldEnd()
7715 
    iprot.readStructEnd()
7716 
 
7717 
  def write(self, oprot):
7718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7720 
      return
7721 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
7722 
    oprot.writeFieldStop()
7723 
    oprot.writeStructEnd()
7724 
 
3431 rajveer 7725 
  def validate(self):
7726 
    return
7727 
 
7728 
 
3064 chandransh 7729 
  def __repr__(self):
7730 
    L = ['%s=%r' % (key, value)
7731 
      for key, value in self.__dict__.iteritems()]
7732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7733 
 
7734 
  def __eq__(self, other):
7735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7736 
 
7737 
  def __ne__(self, other):
7738 
    return not (self == other)
7739 
 
7740 
class getValidOrdersAmountRange_result:
94 ashish 7741 
  """
7742 
  Attributes:
7743 
   - success
7744 
  """
7745 
 
7746 
  thrift_spec = (
3064 chandransh 7747 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 7748 
  )
7749 
 
3064 chandransh 7750 
  def __init__(self, success=None,):
94 ashish 7751 
    self.success = success
7752 
 
7753 
  def read(self, iprot):
7754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7756 
      return
7757 
    iprot.readStructBegin()
7758 
    while True:
7759 
      (fname, ftype, fid) = iprot.readFieldBegin()
7760 
      if ftype == TType.STOP:
7761 
        break
7762 
      if fid == 0:
483 rajveer 7763 
        if ftype == TType.LIST:
7764 
          self.success = []
4133 chandransh 7765 
          (_etype122, _size119) = iprot.readListBegin()
7766 
          for _i123 in xrange(_size119):
7767 
            _elem124 = iprot.readDouble();
7768 
            self.success.append(_elem124)
483 rajveer 7769 
          iprot.readListEnd()
94 ashish 7770 
        else:
7771 
          iprot.skip(ftype)
7772 
      else:
7773 
        iprot.skip(ftype)
7774 
      iprot.readFieldEnd()
7775 
    iprot.readStructEnd()
7776 
 
7777 
  def write(self, oprot):
7778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7780 
      return
3064 chandransh 7781 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 7782 
    if self.success is not None:
483 rajveer 7783 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 7784 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 7785 
      for iter125 in self.success:
7786 
        oprot.writeDouble(iter125)
483 rajveer 7787 
      oprot.writeListEnd()
94 ashish 7788 
      oprot.writeFieldEnd()
7789 
    oprot.writeFieldStop()
7790 
    oprot.writeStructEnd()
7791 
 
3431 rajveer 7792 
  def validate(self):
7793 
    return
7794 
 
7795 
 
94 ashish 7796 
  def __repr__(self):
7797 
    L = ['%s=%r' % (key, value)
7798 
      for key, value in self.__dict__.iteritems()]
7799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7800 
 
7801 
  def __eq__(self, other):
7802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7803 
 
7804 
  def __ne__(self, other):
7805 
    return not (self == other)
7806 
 
3064 chandransh 7807 
class getValidOrders_args:
1528 ankur.sing 7808 
  """
7809 
  Attributes:
3064 chandransh 7810 
   - limit
1528 ankur.sing 7811 
  """
7812 
 
7813 
  thrift_spec = (
7814 
    None, # 0
3064 chandransh 7815 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 7816 
  )
7817 
 
3064 chandransh 7818 
  def __init__(self, limit=None,):
7819 
    self.limit = limit
1528 ankur.sing 7820 
 
7821 
  def read(self, iprot):
7822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7824 
      return
7825 
    iprot.readStructBegin()
7826 
    while True:
7827 
      (fname, ftype, fid) = iprot.readFieldBegin()
7828 
      if ftype == TType.STOP:
7829 
        break
7830 
      if fid == 1:
7831 
        if ftype == TType.I64:
3064 chandransh 7832 
          self.limit = iprot.readI64();
1528 ankur.sing 7833 
        else:
7834 
          iprot.skip(ftype)
7835 
      else:
7836 
        iprot.skip(ftype)
7837 
      iprot.readFieldEnd()
7838 
    iprot.readStructEnd()
7839 
 
7840 
  def write(self, oprot):
7841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7843 
      return
3064 chandransh 7844 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 7845 
    if self.limit is not None:
3064 chandransh 7846 
      oprot.writeFieldBegin('limit', TType.I64, 1)
7847 
      oprot.writeI64(self.limit)
1528 ankur.sing 7848 
      oprot.writeFieldEnd()
7849 
    oprot.writeFieldStop()
7850 
    oprot.writeStructEnd()
7851 
 
3431 rajveer 7852 
  def validate(self):
7853 
    return
7854 
 
7855 
 
1528 ankur.sing 7856 
  def __repr__(self):
7857 
    L = ['%s=%r' % (key, value)
7858 
      for key, value in self.__dict__.iteritems()]
7859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7860 
 
7861 
  def __eq__(self, other):
7862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7863 
 
7864 
  def __ne__(self, other):
7865 
    return not (self == other)
7866 
 
3064 chandransh 7867 
class getValidOrders_result:
1528 ankur.sing 7868 
  """
7869 
  Attributes:
7870 
   - success
7871 
  """
7872 
 
7873 
  thrift_spec = (
3064 chandransh 7874 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 7875 
  )
7876 
 
3064 chandransh 7877 
  def __init__(self, success=None,):
1528 ankur.sing 7878 
    self.success = success
7879 
 
7880 
  def read(self, iprot):
7881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7883 
      return
7884 
    iprot.readStructBegin()
7885 
    while True:
7886 
      (fname, ftype, fid) = iprot.readFieldBegin()
7887 
      if ftype == TType.STOP:
7888 
        break
7889 
      if fid == 0:
3064 chandransh 7890 
        if ftype == TType.LIST:
7891 
          self.success = []
4133 chandransh 7892 
          (_etype129, _size126) = iprot.readListBegin()
7893 
          for _i130 in xrange(_size126):
7894 
            _elem131 = Order()
7895 
            _elem131.read(iprot)
7896 
            self.success.append(_elem131)
3064 chandransh 7897 
          iprot.readListEnd()
1528 ankur.sing 7898 
        else:
7899 
          iprot.skip(ftype)
7900 
      else:
7901 
        iprot.skip(ftype)
7902 
      iprot.readFieldEnd()
7903 
    iprot.readStructEnd()
7904 
 
7905 
  def write(self, oprot):
7906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7908 
      return
3064 chandransh 7909 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 7910 
    if self.success is not None:
3064 chandransh 7911 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7912 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7913 
      for iter132 in self.success:
7914 
        iter132.write(oprot)
3064 chandransh 7915 
      oprot.writeListEnd()
1528 ankur.sing 7916 
      oprot.writeFieldEnd()
7917 
    oprot.writeFieldStop()
7918 
    oprot.writeStructEnd()
7919 
 
3431 rajveer 7920 
  def validate(self):
7921 
    return
7922 
 
7923 
 
1528 ankur.sing 7924 
  def __repr__(self):
7925 
    L = ['%s=%r' % (key, value)
7926 
      for key, value in self.__dict__.iteritems()]
7927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7928 
 
7929 
  def __eq__(self, other):
7930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7931 
 
7932 
  def __ne__(self, other):
7933 
    return not (self == other)
7934 
 
1220 chandransh 7935 
class batchOrders_args:
7936 
  """
7937 
  Attributes:
7938 
   - warehouseId
7939 
  """
7940 
 
7941 
  thrift_spec = (
7942 
    None, # 0
7943 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
7944 
  )
7945 
 
7946 
  def __init__(self, warehouseId=None,):
7947 
    self.warehouseId = warehouseId
7948 
 
7949 
  def read(self, iprot):
7950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7952 
      return
7953 
    iprot.readStructBegin()
7954 
    while True:
7955 
      (fname, ftype, fid) = iprot.readFieldBegin()
7956 
      if ftype == TType.STOP:
7957 
        break
7958 
      if fid == 1:
7959 
        if ftype == TType.I64:
7960 
          self.warehouseId = iprot.readI64();
7961 
        else:
7962 
          iprot.skip(ftype)
7963 
      else:
7964 
        iprot.skip(ftype)
7965 
      iprot.readFieldEnd()
7966 
    iprot.readStructEnd()
7967 
 
7968 
  def write(self, oprot):
7969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7971 
      return
7972 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 7973 
    if self.warehouseId is not None:
1220 chandransh 7974 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
7975 
      oprot.writeI64(self.warehouseId)
7976 
      oprot.writeFieldEnd()
7977 
    oprot.writeFieldStop()
7978 
    oprot.writeStructEnd()
7979 
 
3431 rajveer 7980 
  def validate(self):
7981 
    return
7982 
 
7983 
 
1220 chandransh 7984 
  def __repr__(self):
7985 
    L = ['%s=%r' % (key, value)
7986 
      for key, value in self.__dict__.iteritems()]
7987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7988 
 
7989 
  def __eq__(self, other):
7990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7991 
 
7992 
  def __ne__(self, other):
7993 
    return not (self == other)
7994 
 
7995 
class batchOrders_result:
7996 
  """
7997 
  Attributes:
7998 
   - success
7999 
   - ex
8000 
  """
8001 
 
8002 
  thrift_spec = (
8003 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8004 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8005 
  )
8006 
 
8007 
  def __init__(self, success=None, ex=None,):
8008 
    self.success = success
8009 
    self.ex = ex
8010 
 
8011 
  def read(self, iprot):
8012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8014 
      return
8015 
    iprot.readStructBegin()
8016 
    while True:
8017 
      (fname, ftype, fid) = iprot.readFieldBegin()
8018 
      if ftype == TType.STOP:
8019 
        break
8020 
      if fid == 0:
8021 
        if ftype == TType.LIST:
8022 
          self.success = []
4133 chandransh 8023 
          (_etype136, _size133) = iprot.readListBegin()
8024 
          for _i137 in xrange(_size133):
8025 
            _elem138 = Order()
8026 
            _elem138.read(iprot)
8027 
            self.success.append(_elem138)
1220 chandransh 8028 
          iprot.readListEnd()
8029 
        else:
8030 
          iprot.skip(ftype)
8031 
      elif fid == 1:
8032 
        if ftype == TType.STRUCT:
8033 
          self.ex = TransactionServiceException()
8034 
          self.ex.read(iprot)
8035 
        else:
8036 
          iprot.skip(ftype)
8037 
      else:
8038 
        iprot.skip(ftype)
8039 
      iprot.readFieldEnd()
8040 
    iprot.readStructEnd()
8041 
 
8042 
  def write(self, oprot):
8043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8045 
      return
8046 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 8047 
    if self.success is not None:
1220 chandransh 8048 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8049 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8050 
      for iter139 in self.success:
8051 
        iter139.write(oprot)
1220 chandransh 8052 
      oprot.writeListEnd()
8053 
      oprot.writeFieldEnd()
3431 rajveer 8054 
    if self.ex is not None:
1220 chandransh 8055 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8056 
      self.ex.write(oprot)
8057 
      oprot.writeFieldEnd()
8058 
    oprot.writeFieldStop()
8059 
    oprot.writeStructEnd()
8060 
 
3431 rajveer 8061 
  def validate(self):
8062 
    return
8063 
 
8064 
 
1220 chandransh 8065 
  def __repr__(self):
8066 
    L = ['%s=%r' % (key, value)
8067 
      for key, value in self.__dict__.iteritems()]
8068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8069 
 
8070 
  def __eq__(self, other):
8071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8072 
 
8073 
  def __ne__(self, other):
8074 
    return not (self == other)
8075 
 
1208 chandransh 8076 
class markOrderAsOutOfStock_args:
8077 
  """
8078 
  Attributes:
8079 
   - orderId
8080 
  """
8081 
 
8082 
  thrift_spec = (
8083 
    None, # 0
8084 
    (1, TType.I64, 'orderId', None, None, ), # 1
8085 
  )
8086 
 
8087 
  def __init__(self, orderId=None,):
8088 
    self.orderId = orderId
8089 
 
8090 
  def read(self, iprot):
8091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8093 
      return
8094 
    iprot.readStructBegin()
8095 
    while True:
8096 
      (fname, ftype, fid) = iprot.readFieldBegin()
8097 
      if ftype == TType.STOP:
8098 
        break
8099 
      if fid == 1:
8100 
        if ftype == TType.I64:
8101 
          self.orderId = iprot.readI64();
8102 
        else:
8103 
          iprot.skip(ftype)
8104 
      else:
8105 
        iprot.skip(ftype)
8106 
      iprot.readFieldEnd()
8107 
    iprot.readStructEnd()
8108 
 
8109 
  def write(self, oprot):
8110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8112 
      return
8113 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 8114 
    if self.orderId is not None:
1208 chandransh 8115 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8116 
      oprot.writeI64(self.orderId)
8117 
      oprot.writeFieldEnd()
8118 
    oprot.writeFieldStop()
8119 
    oprot.writeStructEnd()
8120 
 
3431 rajveer 8121 
  def validate(self):
8122 
    return
8123 
 
8124 
 
1208 chandransh 8125 
  def __repr__(self):
8126 
    L = ['%s=%r' % (key, value)
8127 
      for key, value in self.__dict__.iteritems()]
8128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8129 
 
8130 
  def __eq__(self, other):
8131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8132 
 
8133 
  def __ne__(self, other):
8134 
    return not (self == other)
8135 
 
8136 
class markOrderAsOutOfStock_result:
8137 
  """
8138 
  Attributes:
8139 
   - success
8140 
   - ex
8141 
  """
8142 
 
8143 
  thrift_spec = (
8144 
    (0, TType.BOOL, 'success', None, None, ), # 0
8145 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8146 
  )
8147 
 
8148 
  def __init__(self, success=None, ex=None,):
8149 
    self.success = success
8150 
    self.ex = ex
8151 
 
8152 
  def read(self, iprot):
8153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8155 
      return
8156 
    iprot.readStructBegin()
8157 
    while True:
8158 
      (fname, ftype, fid) = iprot.readFieldBegin()
8159 
      if ftype == TType.STOP:
8160 
        break
8161 
      if fid == 0:
8162 
        if ftype == TType.BOOL:
8163 
          self.success = iprot.readBool();
8164 
        else:
8165 
          iprot.skip(ftype)
8166 
      elif fid == 1:
8167 
        if ftype == TType.STRUCT:
8168 
          self.ex = TransactionServiceException()
8169 
          self.ex.read(iprot)
8170 
        else:
8171 
          iprot.skip(ftype)
8172 
      else:
8173 
        iprot.skip(ftype)
8174 
      iprot.readFieldEnd()
8175 
    iprot.readStructEnd()
8176 
 
8177 
  def write(self, oprot):
8178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8180 
      return
8181 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 8182 
    if self.success is not None:
1208 chandransh 8183 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8184 
      oprot.writeBool(self.success)
8185 
      oprot.writeFieldEnd()
3431 rajveer 8186 
    if self.ex is not None:
1208 chandransh 8187 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8188 
      self.ex.write(oprot)
8189 
      oprot.writeFieldEnd()
8190 
    oprot.writeFieldStop()
8191 
    oprot.writeStructEnd()
8192 
 
3431 rajveer 8193 
  def validate(self):
8194 
    return
8195 
 
8196 
 
1208 chandransh 8197 
  def __repr__(self):
8198 
    L = ['%s=%r' % (key, value)
8199 
      for key, value in self.__dict__.iteritems()]
8200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8201 
 
8202 
  def __eq__(self, other):
8203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8204 
 
8205 
  def __ne__(self, other):
8206 
    return not (self == other)
8207 
 
3064 chandransh 8208 
class verifyOrder_args:
759 chandransh 8209 
  """
8210 
  Attributes:
3064 chandransh 8211 
   - orderId
759 chandransh 8212 
  """
8213 
 
8214 
  thrift_spec = (
8215 
    None, # 0
3064 chandransh 8216 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 8217 
  )
8218 
 
3064 chandransh 8219 
  def __init__(self, orderId=None,):
8220 
    self.orderId = orderId
759 chandransh 8221 
 
8222 
  def read(self, iprot):
8223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8225 
      return
8226 
    iprot.readStructBegin()
8227 
    while True:
8228 
      (fname, ftype, fid) = iprot.readFieldBegin()
8229 
      if ftype == TType.STOP:
8230 
        break
8231 
      if fid == 1:
8232 
        if ftype == TType.I64:
3064 chandransh 8233 
          self.orderId = iprot.readI64();
759 chandransh 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
3064 chandransh 8245 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 8246 
    if self.orderId is not None:
3064 chandransh 8247 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8248 
      oprot.writeI64(self.orderId)
759 chandransh 8249 
      oprot.writeFieldEnd()
8250 
    oprot.writeFieldStop()
8251 
    oprot.writeStructEnd()
8252 
 
3431 rajveer 8253 
  def validate(self):
8254 
    return
8255 
 
8256 
 
759 chandransh 8257 
  def __repr__(self):
8258 
    L = ['%s=%r' % (key, value)
8259 
      for key, value in self.__dict__.iteritems()]
8260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8261 
 
8262 
  def __eq__(self, other):
8263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8264 
 
8265 
  def __ne__(self, other):
8266 
    return not (self == other)
8267 
 
3064 chandransh 8268 
class verifyOrder_result:
759 chandransh 8269 
  """
8270 
  Attributes:
8271 
   - success
8272 
   - ex
8273 
  """
8274 
 
8275 
  thrift_spec = (
8276 
    (0, TType.BOOL, 'success', None, None, ), # 0
8277 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8278 
  )
8279 
 
8280 
  def __init__(self, success=None, ex=None,):
8281 
    self.success = success
8282 
    self.ex = ex
8283 
 
8284 
  def read(self, iprot):
8285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8287 
      return
8288 
    iprot.readStructBegin()
8289 
    while True:
8290 
      (fname, ftype, fid) = iprot.readFieldBegin()
8291 
      if ftype == TType.STOP:
8292 
        break
8293 
      if fid == 0:
8294 
        if ftype == TType.BOOL:
8295 
          self.success = iprot.readBool();
8296 
        else:
8297 
          iprot.skip(ftype)
8298 
      elif fid == 1:
8299 
        if ftype == TType.STRUCT:
8300 
          self.ex = TransactionServiceException()
8301 
          self.ex.read(iprot)
8302 
        else:
8303 
          iprot.skip(ftype)
8304 
      else:
8305 
        iprot.skip(ftype)
8306 
      iprot.readFieldEnd()
8307 
    iprot.readStructEnd()
8308 
 
8309 
  def write(self, oprot):
8310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8312 
      return
3064 chandransh 8313 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 8314 
    if self.success is not None:
759 chandransh 8315 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8316 
      oprot.writeBool(self.success)
8317 
      oprot.writeFieldEnd()
3431 rajveer 8318 
    if self.ex is not None:
759 chandransh 8319 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8320 
      self.ex.write(oprot)
8321 
      oprot.writeFieldEnd()
8322 
    oprot.writeFieldStop()
8323 
    oprot.writeStructEnd()
8324 
 
3431 rajveer 8325 
  def validate(self):
8326 
    return
8327 
 
8328 
 
759 chandransh 8329 
  def __repr__(self):
8330 
    L = ['%s=%r' % (key, value)
8331 
      for key, value in self.__dict__.iteritems()]
8332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8333 
 
8334 
  def __eq__(self, other):
8335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8336 
 
8337 
  def __ne__(self, other):
8338 
    return not (self == other)
8339 
 
3064 chandransh 8340 
class acceptOrder_args:
1113 chandransh 8341 
  """
8342 
  Attributes:
3064 chandransh 8343 
   - orderId
1113 chandransh 8344 
  """
8345 
 
8346 
  thrift_spec = (
8347 
    None, # 0
3064 chandransh 8348 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 8349 
  )
8350 
 
3064 chandransh 8351 
  def __init__(self, orderId=None,):
8352 
    self.orderId = orderId
1113 chandransh 8353 
 
8354 
  def read(self, iprot):
8355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8357 
      return
8358 
    iprot.readStructBegin()
8359 
    while True:
8360 
      (fname, ftype, fid) = iprot.readFieldBegin()
8361 
      if ftype == TType.STOP:
8362 
        break
8363 
      if fid == 1:
8364 
        if ftype == TType.I64:
3064 chandransh 8365 
          self.orderId = iprot.readI64();
1113 chandransh 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('acceptOrder_args')
3431 rajveer 8378 
    if self.orderId is not None:
3064 chandransh 8379 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8380 
      oprot.writeI64(self.orderId)
1113 chandransh 8381 
      oprot.writeFieldEnd()
8382 
    oprot.writeFieldStop()
8383 
    oprot.writeStructEnd()
8384 
 
3431 rajveer 8385 
  def validate(self):
8386 
    return
8387 
 
8388 
 
1113 chandransh 8389 
  def __repr__(self):
8390 
    L = ['%s=%r' % (key, value)
8391 
      for key, value in self.__dict__.iteritems()]
8392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8393 
 
8394 
  def __eq__(self, other):
8395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8396 
 
8397 
  def __ne__(self, other):
8398 
    return not (self == other)
8399 
 
3064 chandransh 8400 
class acceptOrder_result:
1113 chandransh 8401 
  """
8402 
  Attributes:
8403 
   - success
8404 
   - ex
8405 
  """
8406 
 
8407 
  thrift_spec = (
3064 chandransh 8408 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 8409 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8410 
  )
8411 
 
8412 
  def __init__(self, success=None, ex=None,):
8413 
    self.success = success
8414 
    self.ex = ex
8415 
 
8416 
  def read(self, iprot):
8417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8419 
      return
8420 
    iprot.readStructBegin()
8421 
    while True:
8422 
      (fname, ftype, fid) = iprot.readFieldBegin()
8423 
      if ftype == TType.STOP:
8424 
        break
8425 
      if fid == 0:
3064 chandransh 8426 
        if ftype == TType.BOOL:
8427 
          self.success = iprot.readBool();
1113 chandransh 8428 
        else:
8429 
          iprot.skip(ftype)
8430 
      elif fid == 1:
8431 
        if ftype == TType.STRUCT:
8432 
          self.ex = TransactionServiceException()
8433 
          self.ex.read(iprot)
8434 
        else:
8435 
          iprot.skip(ftype)
8436 
      else:
8437 
        iprot.skip(ftype)
8438 
      iprot.readFieldEnd()
8439 
    iprot.readStructEnd()
8440 
 
8441 
  def write(self, oprot):
8442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8444 
      return
3064 chandransh 8445 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 8446 
    if self.success is not None:
3064 chandransh 8447 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8448 
      oprot.writeBool(self.success)
1113 chandransh 8449 
      oprot.writeFieldEnd()
3431 rajveer 8450 
    if self.ex is not None:
1113 chandransh 8451 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8452 
      self.ex.write(oprot)
8453 
      oprot.writeFieldEnd()
8454 
    oprot.writeFieldStop()
8455 
    oprot.writeStructEnd()
8456 
 
3431 rajveer 8457 
  def validate(self):
8458 
    return
8459 
 
8460 
 
1113 chandransh 8461 
  def __repr__(self):
8462 
    L = ['%s=%r' % (key, value)
8463 
      for key, value in self.__dict__.iteritems()]
8464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8465 
 
8466 
  def __eq__(self, other):
8467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8468 
 
8469 
  def __ne__(self, other):
8470 
    return not (self == other)
8471 
 
3064 chandransh 8472 
class billOrder_args:
1132 chandransh 8473 
  """
8474 
  Attributes:
3064 chandransh 8475 
   - orderId
1132 chandransh 8476 
  """
8477 
 
8478 
  thrift_spec = (
8479 
    None, # 0
3064 chandransh 8480 
    (1, TType.I64, 'orderId', None, None, ), # 1
1132 chandransh 8481 
  )
8482 
 
3064 chandransh 8483 
  def __init__(self, orderId=None,):
8484 
    self.orderId = orderId
1132 chandransh 8485 
 
8486 
  def read(self, iprot):
8487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8489 
      return
8490 
    iprot.readStructBegin()
8491 
    while True:
8492 
      (fname, ftype, fid) = iprot.readFieldBegin()
8493 
      if ftype == TType.STOP:
8494 
        break
8495 
      if fid == 1:
8496 
        if ftype == TType.I64:
3064 chandransh 8497 
          self.orderId = iprot.readI64();
1132 chandransh 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('billOrder_args')
3431 rajveer 8510 
    if self.orderId is not None:
3064 chandransh 8511 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8512 
      oprot.writeI64(self.orderId)
1132 chandransh 8513 
      oprot.writeFieldEnd()
8514 
    oprot.writeFieldStop()
8515 
    oprot.writeStructEnd()
8516 
 
3431 rajveer 8517 
  def validate(self):
8518 
    return
8519 
 
8520 
 
1132 chandransh 8521 
  def __repr__(self):
8522 
    L = ['%s=%r' % (key, value)
8523 
      for key, value in self.__dict__.iteritems()]
8524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8525 
 
8526 
  def __eq__(self, other):
8527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8528 
 
8529 
  def __ne__(self, other):
8530 
    return not (self == other)
8531 
 
3064 chandransh 8532 
class billOrder_result:
1132 chandransh 8533 
  """
8534 
  Attributes:
3064 chandransh 8535 
   - success
1132 chandransh 8536 
   - ex
8537 
  """
8538 
 
8539 
  thrift_spec = (
3064 chandransh 8540 
    (0, TType.BOOL, 'success', None, None, ), # 0
1132 chandransh 8541 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8542 
  )
8543 
 
3064 chandransh 8544 
  def __init__(self, success=None, ex=None,):
8545 
    self.success = success
1132 chandransh 8546 
    self.ex = ex
8547 
 
8548 
  def read(self, iprot):
8549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8551 
      return
8552 
    iprot.readStructBegin()
8553 
    while True:
8554 
      (fname, ftype, fid) = iprot.readFieldBegin()
8555 
      if ftype == TType.STOP:
8556 
        break
3064 chandransh 8557 
      if fid == 0:
8558 
        if ftype == TType.BOOL:
8559 
          self.success = iprot.readBool();
8560 
        else:
8561 
          iprot.skip(ftype)
8562 
      elif fid == 1:
1132 chandransh 8563 
        if ftype == TType.STRUCT:
8564 
          self.ex = TransactionServiceException()
8565 
          self.ex.read(iprot)
8566 
        else:
8567 
          iprot.skip(ftype)
8568 
      else:
8569 
        iprot.skip(ftype)
8570 
      iprot.readFieldEnd()
8571 
    iprot.readStructEnd()
8572 
 
8573 
  def write(self, oprot):
8574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8576 
      return
3064 chandransh 8577 
    oprot.writeStructBegin('billOrder_result')
3431 rajveer 8578 
    if self.success is not None:
3064 chandransh 8579 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8580 
      oprot.writeBool(self.success)
8581 
      oprot.writeFieldEnd()
3431 rajveer 8582 
    if self.ex is not None:
1132 chandransh 8583 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8584 
      self.ex.write(oprot)
8585 
      oprot.writeFieldEnd()
8586 
    oprot.writeFieldStop()
8587 
    oprot.writeStructEnd()
8588 
 
3431 rajveer 8589 
  def validate(self):
8590 
    return
8591 
 
8592 
 
1132 chandransh 8593 
  def __repr__(self):
8594 
    L = ['%s=%r' % (key, value)
8595 
      for key, value in self.__dict__.iteritems()]
8596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8597 
 
8598 
  def __eq__(self, other):
8599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8600 
 
8601 
  def __ne__(self, other):
8602 
    return not (self == other)
8603 
 
3064 chandransh 8604 
class addBillingDetails_args:
1135 chandransh 8605 
  """
8606 
  Attributes:
3064 chandransh 8607 
   - orderId
8608 
   - invoice_number
8609 
   - billed_by
1135 chandransh 8610 
  """
8611 
 
8612 
  thrift_spec = (
8613 
    None, # 0
3064 chandransh 8614 
    (1, TType.I64, 'orderId', None, None, ), # 1
8615 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
8616 
    (3, TType.STRING, 'billed_by', None, None, ), # 3
1135 chandransh 8617 
  )
8618 
 
3064 chandransh 8619 
  def __init__(self, orderId=None, invoice_number=None, billed_by=None,):
8620 
    self.orderId = orderId
8621 
    self.invoice_number = invoice_number
8622 
    self.billed_by = billed_by
1135 chandransh 8623 
 
8624 
  def read(self, iprot):
8625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8627 
      return
8628 
    iprot.readStructBegin()
8629 
    while True:
8630 
      (fname, ftype, fid) = iprot.readFieldBegin()
8631 
      if ftype == TType.STOP:
8632 
        break
8633 
      if fid == 1:
8634 
        if ftype == TType.I64:
3064 chandransh 8635 
          self.orderId = iprot.readI64();
1135 chandransh 8636 
        else:
8637 
          iprot.skip(ftype)
8638 
      elif fid == 2:
3064 chandransh 8639 
        if ftype == TType.STRING:
8640 
          self.invoice_number = iprot.readString();
1135 chandransh 8641 
        else:
8642 
          iprot.skip(ftype)
3064 chandransh 8643 
      elif fid == 3:
8644 
        if ftype == TType.STRING:
8645 
          self.billed_by = iprot.readString();
8646 
        else:
8647 
          iprot.skip(ftype)
1135 chandransh 8648 
      else:
8649 
        iprot.skip(ftype)
8650 
      iprot.readFieldEnd()
8651 
    iprot.readStructEnd()
8652 
 
8653 
  def write(self, oprot):
8654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8656 
      return
3064 chandransh 8657 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 8658 
    if self.orderId is not None:
3064 chandransh 8659 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8660 
      oprot.writeI64(self.orderId)
1135 chandransh 8661 
      oprot.writeFieldEnd()
3431 rajveer 8662 
    if self.invoice_number is not None:
3064 chandransh 8663 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
8664 
      oprot.writeString(self.invoice_number)
1135 chandransh 8665 
      oprot.writeFieldEnd()
3431 rajveer 8666 
    if self.billed_by is not None:
3064 chandransh 8667 
      oprot.writeFieldBegin('billed_by', TType.STRING, 3)
8668 
      oprot.writeString(self.billed_by)
8669 
      oprot.writeFieldEnd()
1135 chandransh 8670 
    oprot.writeFieldStop()
8671 
    oprot.writeStructEnd()
8672 
 
3431 rajveer 8673 
  def validate(self):
8674 
    return
8675 
 
8676 
 
1135 chandransh 8677 
  def __repr__(self):
8678 
    L = ['%s=%r' % (key, value)
8679 
      for key, value in self.__dict__.iteritems()]
8680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8681 
 
8682 
  def __eq__(self, other):
8683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8684 
 
8685 
  def __ne__(self, other):
8686 
    return not (self == other)
8687 
 
3064 chandransh 8688 
class addBillingDetails_result:
1135 chandransh 8689 
  """
8690 
  Attributes:
3064 chandransh 8691 
   - success
1135 chandransh 8692 
   - ex
8693 
  """
8694 
 
8695 
  thrift_spec = (
3064 chandransh 8696 
    (0, TType.BOOL, 'success', None, None, ), # 0
1135 chandransh 8697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8698 
  )
8699 
 
3064 chandransh 8700 
  def __init__(self, success=None, ex=None,):
8701 
    self.success = success
1135 chandransh 8702 
    self.ex = ex
8703 
 
8704 
  def read(self, iprot):
8705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8707 
      return
8708 
    iprot.readStructBegin()
8709 
    while True:
8710 
      (fname, ftype, fid) = iprot.readFieldBegin()
8711 
      if ftype == TType.STOP:
8712 
        break
3064 chandransh 8713 
      if fid == 0:
8714 
        if ftype == TType.BOOL:
8715 
          self.success = iprot.readBool();
8716 
        else:
8717 
          iprot.skip(ftype)
8718 
      elif fid == 1:
1135 chandransh 8719 
        if ftype == TType.STRUCT:
8720 
          self.ex = TransactionServiceException()
8721 
          self.ex.read(iprot)
8722 
        else:
8723 
          iprot.skip(ftype)
8724 
      else:
8725 
        iprot.skip(ftype)
8726 
      iprot.readFieldEnd()
8727 
    iprot.readStructEnd()
8728 
 
8729 
  def write(self, oprot):
8730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8732 
      return
3064 chandransh 8733 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 8734 
    if self.success is not None:
3064 chandransh 8735 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8736 
      oprot.writeBool(self.success)
8737 
      oprot.writeFieldEnd()
3431 rajveer 8738 
    if self.ex is not None:
1135 chandransh 8739 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8740 
      self.ex.write(oprot)
8741 
      oprot.writeFieldEnd()
8742 
    oprot.writeFieldStop()
8743 
    oprot.writeStructEnd()
8744 
 
3431 rajveer 8745 
  def validate(self):
8746 
    return
8747 
 
8748 
 
1135 chandransh 8749 
  def __repr__(self):
8750 
    L = ['%s=%r' % (key, value)
8751 
      for key, value in self.__dict__.iteritems()]
8752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8753 
 
8754 
  def __eq__(self, other):
8755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8756 
 
8757 
  def __ne__(self, other):
8758 
    return not (self == other)
8759 
 
3064 chandransh 8760 
class addJacketNumber_args:
1246 chandransh 8761 
  """
8762 
  Attributes:
3064 chandransh 8763 
   - orderId
8764 
   - jacketNumber
8765 
   - imeiNumber
8766 
   - itemNumber
8767 
   - billedBy
8768 
   - billingType
1246 chandransh 8769 
  """
8770 
 
8771 
  thrift_spec = (
8772 
    None, # 0
3064 chandransh 8773 
    (1, TType.I64, 'orderId', None, None, ), # 1
8774 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
8775 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
8776 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
8777 
    (5, TType.STRING, 'billedBy', None, None, ), # 5
8778 
    (6, TType.I64, 'billingType', None, None, ), # 6
1246 chandransh 8779 
  )
8780 
 
3064 chandransh 8781 
  def __init__(self, orderId=None, jacketNumber=None, imeiNumber=None, itemNumber=None, billedBy=None, billingType=None,):
8782 
    self.orderId = orderId
8783 
    self.jacketNumber = jacketNumber
8784 
    self.imeiNumber = imeiNumber
8785 
    self.itemNumber = itemNumber
8786 
    self.billedBy = billedBy
8787 
    self.billingType = billingType
1246 chandransh 8788 
 
8789 
  def read(self, iprot):
8790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8792 
      return
8793 
    iprot.readStructBegin()
8794 
    while True:
8795 
      (fname, ftype, fid) = iprot.readFieldBegin()
8796 
      if ftype == TType.STOP:
8797 
        break
8798 
      if fid == 1:
8799 
        if ftype == TType.I64:
3064 chandransh 8800 
          self.orderId = iprot.readI64();
1246 chandransh 8801 
        else:
8802 
          iprot.skip(ftype)
8803 
      elif fid == 2:
3064 chandransh 8804 
        if ftype == TType.I64:
8805 
          self.jacketNumber = iprot.readI64();
1246 chandransh 8806 
        else:
8807 
          iprot.skip(ftype)
3064 chandransh 8808 
      elif fid == 3:
8809 
        if ftype == TType.I64:
8810 
          self.imeiNumber = iprot.readI64();
8811 
        else:
8812 
          iprot.skip(ftype)
8813 
      elif fid == 4:
8814 
        if ftype == TType.STRING:
8815 
          self.itemNumber = iprot.readString();
8816 
        else:
8817 
          iprot.skip(ftype)
8818 
      elif fid == 5:
8819 
        if ftype == TType.STRING:
8820 
          self.billedBy = iprot.readString();
8821 
        else:
8822 
          iprot.skip(ftype)
8823 
      elif fid == 6:
8824 
        if ftype == TType.I64:
8825 
          self.billingType = iprot.readI64();
8826 
        else:
8827 
          iprot.skip(ftype)
1246 chandransh 8828 
      else:
8829 
        iprot.skip(ftype)
8830 
      iprot.readFieldEnd()
8831 
    iprot.readStructEnd()
8832 
 
8833 
  def write(self, oprot):
8834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8836 
      return
3064 chandransh 8837 
    oprot.writeStructBegin('addJacketNumber_args')
3431 rajveer 8838 
    if self.orderId is not None:
3064 chandransh 8839 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8840 
      oprot.writeI64(self.orderId)
1246 chandransh 8841 
      oprot.writeFieldEnd()
3431 rajveer 8842 
    if self.jacketNumber is not None:
3064 chandransh 8843 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
8844 
      oprot.writeI64(self.jacketNumber)
1246 chandransh 8845 
      oprot.writeFieldEnd()
3431 rajveer 8846 
    if self.imeiNumber is not None:
3064 chandransh 8847 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
8848 
      oprot.writeI64(self.imeiNumber)
8849 
      oprot.writeFieldEnd()
3431 rajveer 8850 
    if self.itemNumber is not None:
3064 chandransh 8851 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
8852 
      oprot.writeString(self.itemNumber)
8853 
      oprot.writeFieldEnd()
3431 rajveer 8854 
    if self.billedBy is not None:
3064 chandransh 8855 
      oprot.writeFieldBegin('billedBy', TType.STRING, 5)
8856 
      oprot.writeString(self.billedBy)
8857 
      oprot.writeFieldEnd()
3431 rajveer 8858 
    if self.billingType is not None:
3064 chandransh 8859 
      oprot.writeFieldBegin('billingType', TType.I64, 6)
8860 
      oprot.writeI64(self.billingType)
8861 
      oprot.writeFieldEnd()
1246 chandransh 8862 
    oprot.writeFieldStop()
8863 
    oprot.writeStructEnd()
8864 
 
3431 rajveer 8865 
  def validate(self):
8866 
    return
8867 
 
8868 
 
1246 chandransh 8869 
  def __repr__(self):
8870 
    L = ['%s=%r' % (key, value)
8871 
      for key, value in self.__dict__.iteritems()]
8872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8873 
 
8874 
  def __eq__(self, other):
8875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8876 
 
8877 
  def __ne__(self, other):
8878 
    return not (self == other)
8879 
 
3064 chandransh 8880 
class addJacketNumber_result:
1246 chandransh 8881 
  """
8882 
  Attributes:
3064 chandransh 8883 
   - success
1246 chandransh 8884 
   - ex
8885 
  """
8886 
 
8887 
  thrift_spec = (
3064 chandransh 8888 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 8889 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8890 
  )
8891 
 
3064 chandransh 8892 
  def __init__(self, success=None, ex=None,):
8893 
    self.success = success
1246 chandransh 8894 
    self.ex = ex
8895 
 
8896 
  def read(self, iprot):
8897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8899 
      return
8900 
    iprot.readStructBegin()
8901 
    while True:
8902 
      (fname, ftype, fid) = iprot.readFieldBegin()
8903 
      if ftype == TType.STOP:
8904 
        break
3064 chandransh 8905 
      if fid == 0:
8906 
        if ftype == TType.BOOL:
8907 
          self.success = iprot.readBool();
8908 
        else:
8909 
          iprot.skip(ftype)
8910 
      elif fid == 1:
1246 chandransh 8911 
        if ftype == TType.STRUCT:
8912 
          self.ex = TransactionServiceException()
8913 
          self.ex.read(iprot)
8914 
        else:
8915 
          iprot.skip(ftype)
8916 
      else:
8917 
        iprot.skip(ftype)
8918 
      iprot.readFieldEnd()
8919 
    iprot.readStructEnd()
8920 
 
8921 
  def write(self, oprot):
8922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8924 
      return
3064 chandransh 8925 
    oprot.writeStructBegin('addJacketNumber_result')
3431 rajveer 8926 
    if self.success is not None:
3064 chandransh 8927 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8928 
      oprot.writeBool(self.success)
8929 
      oprot.writeFieldEnd()
3431 rajveer 8930 
    if self.ex is not None:
1246 chandransh 8931 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8932 
      self.ex.write(oprot)
8933 
      oprot.writeFieldEnd()
8934 
    oprot.writeFieldStop()
8935 
    oprot.writeStructEnd()
8936 
 
3431 rajveer 8937 
  def validate(self):
8938 
    return
8939 
 
8940 
 
1246 chandransh 8941 
  def __repr__(self):
8942 
    L = ['%s=%r' % (key, value)
8943 
      for key, value in self.__dict__.iteritems()]
8944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8945 
 
8946 
  def __eq__(self, other):
8947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8948 
 
8949 
  def __ne__(self, other):
8950 
    return not (self == other)
8951 
 
3064 chandransh 8952 
class markOrdersAsManifested_args:
1408 ankur.sing 8953 
  """
8954 
  Attributes:
3064 chandransh 8955 
   - warehouseId
1408 ankur.sing 8956 
   - providerId
3064 chandransh 8957 
   - cod
1408 ankur.sing 8958 
  """
8959 
 
8960 
  thrift_spec = (
8961 
    None, # 0
3064 chandransh 8962 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8963 
    (2, TType.I64, 'providerId', None, None, ), # 2
8964 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 8965 
  )
8966 
 
3064 chandransh 8967 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
8968 
    self.warehouseId = warehouseId
1408 ankur.sing 8969 
    self.providerId = providerId
3064 chandransh 8970 
    self.cod = cod
1408 ankur.sing 8971 
 
8972 
  def read(self, iprot):
8973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8975 
      return
8976 
    iprot.readStructBegin()
8977 
    while True:
8978 
      (fname, ftype, fid) = iprot.readFieldBegin()
8979 
      if ftype == TType.STOP:
8980 
        break
8981 
      if fid == 1:
8982 
        if ftype == TType.I64:
3064 chandransh 8983 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 8984 
        else:
8985 
          iprot.skip(ftype)
8986 
      elif fid == 2:
8987 
        if ftype == TType.I64:
3064 chandransh 8988 
          self.providerId = iprot.readI64();
1408 ankur.sing 8989 
        else:
8990 
          iprot.skip(ftype)
3064 chandransh 8991 
      elif fid == 3:
8992 
        if ftype == TType.BOOL:
8993 
          self.cod = iprot.readBool();
8994 
        else:
8995 
          iprot.skip(ftype)
1408 ankur.sing 8996 
      else:
8997 
        iprot.skip(ftype)
8998 
      iprot.readFieldEnd()
8999 
    iprot.readStructEnd()
9000 
 
9001 
  def write(self, oprot):
9002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9004 
      return
3064 chandransh 9005 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 9006 
    if self.warehouseId is not None:
3064 chandransh 9007 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9008 
      oprot.writeI64(self.warehouseId)
9009 
      oprot.writeFieldEnd()
3431 rajveer 9010 
    if self.providerId is not None:
3064 chandransh 9011 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9012 
      oprot.writeI64(self.providerId)
9013 
      oprot.writeFieldEnd()
3431 rajveer 9014 
    if self.cod is not None:
3064 chandransh 9015 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9016 
      oprot.writeBool(self.cod)
1408 ankur.sing 9017 
      oprot.writeFieldEnd()
9018 
    oprot.writeFieldStop()
9019 
    oprot.writeStructEnd()
9020 
 
3431 rajveer 9021 
  def validate(self):
9022 
    return
9023 
 
9024 
 
1408 ankur.sing 9025 
  def __repr__(self):
9026 
    L = ['%s=%r' % (key, value)
9027 
      for key, value in self.__dict__.iteritems()]
9028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9029 
 
9030 
  def __eq__(self, other):
9031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9032 
 
9033 
  def __ne__(self, other):
9034 
    return not (self == other)
9035 
 
3064 chandransh 9036 
class markOrdersAsManifested_result:
1408 ankur.sing 9037 
  """
9038 
  Attributes:
9039 
   - success
3064 chandransh 9040 
   - ex
1408 ankur.sing 9041 
  """
9042 
 
9043 
  thrift_spec = (
3064 chandransh 9044 
    (0, TType.BOOL, 'success', None, None, ), # 0
9045 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 9046 
  )
9047 
 
3064 chandransh 9048 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 9049 
    self.success = success
3064 chandransh 9050 
    self.ex = ex
1408 ankur.sing 9051 
 
9052 
  def read(self, iprot):
9053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9055 
      return
9056 
    iprot.readStructBegin()
9057 
    while True:
9058 
      (fname, ftype, fid) = iprot.readFieldBegin()
9059 
      if ftype == TType.STOP:
9060 
        break
9061 
      if fid == 0:
3064 chandransh 9062 
        if ftype == TType.BOOL:
9063 
          self.success = iprot.readBool();
1408 ankur.sing 9064 
        else:
9065 
          iprot.skip(ftype)
3064 chandransh 9066 
      elif fid == 1:
9067 
        if ftype == TType.STRUCT:
9068 
          self.ex = TransactionServiceException()
9069 
          self.ex.read(iprot)
9070 
        else:
9071 
          iprot.skip(ftype)
1408 ankur.sing 9072 
      else:
9073 
        iprot.skip(ftype)
9074 
      iprot.readFieldEnd()
9075 
    iprot.readStructEnd()
9076 
 
9077 
  def write(self, oprot):
9078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9080 
      return
3064 chandransh 9081 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 9082 
    if self.success is not None:
3064 chandransh 9083 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9084 
      oprot.writeBool(self.success)
1408 ankur.sing 9085 
      oprot.writeFieldEnd()
3431 rajveer 9086 
    if self.ex is not None:
3064 chandransh 9087 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9088 
      self.ex.write(oprot)
9089 
      oprot.writeFieldEnd()
1408 ankur.sing 9090 
    oprot.writeFieldStop()
9091 
    oprot.writeStructEnd()
9092 
 
3431 rajveer 9093 
  def validate(self):
9094 
    return
9095 
 
9096 
 
1408 ankur.sing 9097 
  def __repr__(self):
9098 
    L = ['%s=%r' % (key, value)
9099 
      for key, value in self.__dict__.iteritems()]
9100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9101 
 
9102 
  def __eq__(self, other):
9103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9104 
 
9105 
  def __ne__(self, other):
9106 
    return not (self == other)
9107 
 
3064 chandransh 9108 
class markOrdersAsPickedUp_args:
304 ashish 9109 
  """
9110 
  Attributes:
3064 chandransh 9111 
   - providerId
9112 
   - pickupDetails
304 ashish 9113 
  """
94 ashish 9114 
 
304 ashish 9115 
  thrift_spec = (
9116 
    None, # 0
3064 chandransh 9117 
    (1, TType.I64, 'providerId', None, None, ), # 1
9118 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9119 
  )
9120 
 
3064 chandransh 9121 
  def __init__(self, providerId=None, pickupDetails=None,):
9122 
    self.providerId = providerId
9123 
    self.pickupDetails = pickupDetails
304 ashish 9124 
 
9125 
  def read(self, iprot):
9126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9128 
      return
9129 
    iprot.readStructBegin()
9130 
    while True:
9131 
      (fname, ftype, fid) = iprot.readFieldBegin()
9132 
      if ftype == TType.STOP:
9133 
        break
9134 
      if fid == 1:
9135 
        if ftype == TType.I64:
3064 chandransh 9136 
          self.providerId = iprot.readI64();
304 ashish 9137 
        else:
9138 
          iprot.skip(ftype)
9139 
      elif fid == 2:
3064 chandransh 9140 
        if ftype == TType.MAP:
9141 
          self.pickupDetails = {}
4133 chandransh 9142 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
9143 
          for _i144 in xrange(_size140):
9144 
            _key145 = iprot.readString();
9145 
            _val146 = iprot.readString();
9146 
            self.pickupDetails[_key145] = _val146
3064 chandransh 9147 
          iprot.readMapEnd()
304 ashish 9148 
        else:
9149 
          iprot.skip(ftype)
9150 
      else:
9151 
        iprot.skip(ftype)
9152 
      iprot.readFieldEnd()
9153 
    iprot.readStructEnd()
9154 
 
9155 
  def write(self, oprot):
9156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9158 
      return
3064 chandransh 9159 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 9160 
    if self.providerId is not None:
3064 chandransh 9161 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9162 
      oprot.writeI64(self.providerId)
304 ashish 9163 
      oprot.writeFieldEnd()
3431 rajveer 9164 
    if self.pickupDetails is not None:
3064 chandransh 9165 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
9166 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 9167 
      for kiter147,viter148 in self.pickupDetails.items():
9168 
        oprot.writeString(kiter147)
9169 
        oprot.writeString(viter148)
3064 chandransh 9170 
      oprot.writeMapEnd()
304 ashish 9171 
      oprot.writeFieldEnd()
9172 
    oprot.writeFieldStop()
9173 
    oprot.writeStructEnd()
9174 
 
3431 rajveer 9175 
  def validate(self):
9176 
    return
9177 
 
9178 
 
304 ashish 9179 
  def __repr__(self):
9180 
    L = ['%s=%r' % (key, value)
9181 
      for key, value in self.__dict__.iteritems()]
9182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9183 
 
9184 
  def __eq__(self, other):
9185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9186 
 
9187 
  def __ne__(self, other):
9188 
    return not (self == other)
9189 
 
3064 chandransh 9190 
class markOrdersAsPickedUp_result:
304 ashish 9191 
  """
9192 
  Attributes:
9193 
   - success
3064 chandransh 9194 
   - ex
304 ashish 9195 
  """
9196 
 
9197 
  thrift_spec = (
3064 chandransh 9198 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9199 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9200 
  )
9201 
 
3064 chandransh 9202 
  def __init__(self, success=None, ex=None,):
304 ashish 9203 
    self.success = success
3064 chandransh 9204 
    self.ex = ex
304 ashish 9205 
 
9206 
  def read(self, iprot):
9207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9209 
      return
9210 
    iprot.readStructBegin()
9211 
    while True:
9212 
      (fname, ftype, fid) = iprot.readFieldBegin()
9213 
      if ftype == TType.STOP:
9214 
        break
9215 
      if fid == 0:
9216 
        if ftype == TType.LIST:
9217 
          self.success = []
4133 chandransh 9218 
          (_etype152, _size149) = iprot.readListBegin()
9219 
          for _i153 in xrange(_size149):
9220 
            _elem154 = Order()
9221 
            _elem154.read(iprot)
9222 
            self.success.append(_elem154)
304 ashish 9223 
          iprot.readListEnd()
9224 
        else:
9225 
          iprot.skip(ftype)
3064 chandransh 9226 
      elif fid == 1:
9227 
        if ftype == TType.STRUCT:
9228 
          self.ex = TransactionServiceException()
9229 
          self.ex.read(iprot)
9230 
        else:
9231 
          iprot.skip(ftype)
304 ashish 9232 
      else:
9233 
        iprot.skip(ftype)
9234 
      iprot.readFieldEnd()
9235 
    iprot.readStructEnd()
9236 
 
9237 
  def write(self, oprot):
9238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9240 
      return
3064 chandransh 9241 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 9242 
    if self.success is not None:
304 ashish 9243 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9244 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9245 
      for iter155 in self.success:
9246 
        iter155.write(oprot)
304 ashish 9247 
      oprot.writeListEnd()
9248 
      oprot.writeFieldEnd()
3431 rajveer 9249 
    if self.ex is not None:
3064 chandransh 9250 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9251 
      self.ex.write(oprot)
9252 
      oprot.writeFieldEnd()
304 ashish 9253 
    oprot.writeFieldStop()
9254 
    oprot.writeStructEnd()
9255 
 
3431 rajveer 9256 
  def validate(self):
9257 
    return
9258 
 
9259 
 
304 ashish 9260 
  def __repr__(self):
9261 
    L = ['%s=%r' % (key, value)
9262 
      for key, value in self.__dict__.iteritems()]
9263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9264 
 
9265 
  def __eq__(self, other):
9266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9267 
 
9268 
  def __ne__(self, other):
9269 
    return not (self == other)
9270 
 
3064 chandransh 9271 
class markOrdersAsDelivered_args:
304 ashish 9272 
  """
9273 
  Attributes:
3064 chandransh 9274 
   - providerId
9275 
   - deliveredOrders
304 ashish 9276 
  """
9277 
 
9278 
  thrift_spec = (
9279 
    None, # 0
3064 chandransh 9280 
    (1, TType.I64, 'providerId', None, None, ), # 1
9281 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9282 
  )
9283 
 
3064 chandransh 9284 
  def __init__(self, providerId=None, deliveredOrders=None,):
9285 
    self.providerId = providerId
9286 
    self.deliveredOrders = deliveredOrders
304 ashish 9287 
 
9288 
  def read(self, iprot):
9289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9291 
      return
9292 
    iprot.readStructBegin()
9293 
    while True:
9294 
      (fname, ftype, fid) = iprot.readFieldBegin()
9295 
      if ftype == TType.STOP:
9296 
        break
9297 
      if fid == 1:
9298 
        if ftype == TType.I64:
3064 chandransh 9299 
          self.providerId = iprot.readI64();
304 ashish 9300 
        else:
9301 
          iprot.skip(ftype)
9302 
      elif fid == 2:
3064 chandransh 9303 
        if ftype == TType.MAP:
9304 
          self.deliveredOrders = {}
4133 chandransh 9305 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9306 
          for _i160 in xrange(_size156):
9307 
            _key161 = iprot.readString();
9308 
            _val162 = iprot.readString();
9309 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 9310 
          iprot.readMapEnd()
304 ashish 9311 
        else:
9312 
          iprot.skip(ftype)
9313 
      else:
9314 
        iprot.skip(ftype)
9315 
      iprot.readFieldEnd()
9316 
    iprot.readStructEnd()
9317 
 
9318 
  def write(self, oprot):
9319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9321 
      return
3064 chandransh 9322 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 9323 
    if self.providerId is not None:
3064 chandransh 9324 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9325 
      oprot.writeI64(self.providerId)
304 ashish 9326 
      oprot.writeFieldEnd()
3431 rajveer 9327 
    if self.deliveredOrders is not None:
3064 chandransh 9328 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
9329 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 9330 
      for kiter163,viter164 in self.deliveredOrders.items():
9331 
        oprot.writeString(kiter163)
9332 
        oprot.writeString(viter164)
3064 chandransh 9333 
      oprot.writeMapEnd()
304 ashish 9334 
      oprot.writeFieldEnd()
9335 
    oprot.writeFieldStop()
9336 
    oprot.writeStructEnd()
9337 
 
3431 rajveer 9338 
  def validate(self):
9339 
    return
9340 
 
9341 
 
304 ashish 9342 
  def __repr__(self):
9343 
    L = ['%s=%r' % (key, value)
9344 
      for key, value in self.__dict__.iteritems()]
9345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9346 
 
9347 
  def __eq__(self, other):
9348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9349 
 
9350 
  def __ne__(self, other):
9351 
    return not (self == other)
9352 
 
3064 chandransh 9353 
class markOrdersAsDelivered_result:
9354 
  """
9355 
  Attributes:
9356 
   - ex
9357 
  """
304 ashish 9358 
 
9359 
  thrift_spec = (
3064 chandransh 9360 
    None, # 0
9361 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9362 
  )
9363 
 
3064 chandransh 9364 
  def __init__(self, ex=None,):
9365 
    self.ex = ex
304 ashish 9366 
 
1596 ankur.sing 9367 
  def read(self, iprot):
9368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9370 
      return
9371 
    iprot.readStructBegin()
9372 
    while True:
9373 
      (fname, ftype, fid) = iprot.readFieldBegin()
9374 
      if ftype == TType.STOP:
9375 
        break
3064 chandransh 9376 
      if fid == 1:
9377 
        if ftype == TType.STRUCT:
9378 
          self.ex = TransactionServiceException()
9379 
          self.ex.read(iprot)
9380 
        else:
9381 
          iprot.skip(ftype)
1596 ankur.sing 9382 
      else:
9383 
        iprot.skip(ftype)
9384 
      iprot.readFieldEnd()
9385 
    iprot.readStructEnd()
9386 
 
9387 
  def write(self, oprot):
9388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9390 
      return
3064 chandransh 9391 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 9392 
    if self.ex is not None:
3064 chandransh 9393 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9394 
      self.ex.write(oprot)
9395 
      oprot.writeFieldEnd()
1596 ankur.sing 9396 
    oprot.writeFieldStop()
9397 
    oprot.writeStructEnd()
9398 
 
3431 rajveer 9399 
  def validate(self):
9400 
    return
9401 
 
9402 
 
1596 ankur.sing 9403 
  def __repr__(self):
9404 
    L = ['%s=%r' % (key, value)
9405 
      for key, value in self.__dict__.iteritems()]
9406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9407 
 
9408 
  def __eq__(self, other):
9409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9410 
 
9411 
  def __ne__(self, other):
9412 
    return not (self == other)
9413 
 
3064 chandransh 9414 
class markOrdersAsFailed_args:
1596 ankur.sing 9415 
  """
9416 
  Attributes:
3064 chandransh 9417 
   - providerId
9418 
   - returnedOrders
1596 ankur.sing 9419 
  """
9420 
 
9421 
  thrift_spec = (
3064 chandransh 9422 
    None, # 0
9423 
    (1, TType.I64, 'providerId', None, None, ), # 1
9424 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 9425 
  )
9426 
 
3064 chandransh 9427 
  def __init__(self, providerId=None, returnedOrders=None,):
9428 
    self.providerId = providerId
9429 
    self.returnedOrders = returnedOrders
1596 ankur.sing 9430 
 
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:
1596 ankur.sing 9441 
        if ftype == TType.I64:
3064 chandransh 9442 
          self.providerId = iprot.readI64();
1596 ankur.sing 9443 
        else:
9444 
          iprot.skip(ftype)
3064 chandransh 9445 
      elif fid == 2:
9446 
        if ftype == TType.MAP:
9447 
          self.returnedOrders = {}
4133 chandransh 9448 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
9449 
          for _i169 in xrange(_size165):
9450 
            _key170 = iprot.readString();
9451 
            _val171 = iprot.readString();
9452 
            self.returnedOrders[_key170] = _val171
3064 chandransh 9453 
          iprot.readMapEnd()
9454 
        else:
9455 
          iprot.skip(ftype)
1596 ankur.sing 9456 
      else:
9457 
        iprot.skip(ftype)
9458 
      iprot.readFieldEnd()
9459 
    iprot.readStructEnd()
9460 
 
9461 
  def write(self, oprot):
9462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9464 
      return
3064 chandransh 9465 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 9466 
    if self.providerId is not None:
3064 chandransh 9467 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9468 
      oprot.writeI64(self.providerId)
1596 ankur.sing 9469 
      oprot.writeFieldEnd()
3431 rajveer 9470 
    if self.returnedOrders is not None:
3064 chandransh 9471 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
9472 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 9473 
      for kiter172,viter173 in self.returnedOrders.items():
9474 
        oprot.writeString(kiter172)
9475 
        oprot.writeString(viter173)
3064 chandransh 9476 
      oprot.writeMapEnd()
9477 
      oprot.writeFieldEnd()
1596 ankur.sing 9478 
    oprot.writeFieldStop()
9479 
    oprot.writeStructEnd()
9480 
 
3431 rajveer 9481 
  def validate(self):
9482 
    return
9483 
 
9484 
 
1596 ankur.sing 9485 
  def __repr__(self):
9486 
    L = ['%s=%r' % (key, value)
9487 
      for key, value in self.__dict__.iteritems()]
9488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9489 
 
9490 
  def __eq__(self, other):
9491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9492 
 
9493 
  def __ne__(self, other):
9494 
    return not (self == other)
9495 
 
3064 chandransh 9496 
class markOrdersAsFailed_result:
9497 
  """
9498 
  Attributes:
9499 
   - ex
9500 
  """
1596 ankur.sing 9501 
 
1627 ankur.sing 9502 
  thrift_spec = (
3064 chandransh 9503 
    None, # 0
9504 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9505 
  )
9506 
 
3064 chandransh 9507 
  def __init__(self, ex=None,):
9508 
    self.ex = ex
9509 
 
1627 ankur.sing 9510 
  def read(self, iprot):
9511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9513 
      return
9514 
    iprot.readStructBegin()
9515 
    while True:
9516 
      (fname, ftype, fid) = iprot.readFieldBegin()
9517 
      if ftype == TType.STOP:
9518 
        break
3064 chandransh 9519 
      if fid == 1:
9520 
        if ftype == TType.STRUCT:
9521 
          self.ex = TransactionServiceException()
9522 
          self.ex.read(iprot)
9523 
        else:
9524 
          iprot.skip(ftype)
1627 ankur.sing 9525 
      else:
9526 
        iprot.skip(ftype)
9527 
      iprot.readFieldEnd()
9528 
    iprot.readStructEnd()
9529 
 
9530 
  def write(self, oprot):
9531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9533 
      return
3064 chandransh 9534 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 9535 
    if self.ex is not None:
3064 chandransh 9536 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9537 
      self.ex.write(oprot)
9538 
      oprot.writeFieldEnd()
1627 ankur.sing 9539 
    oprot.writeFieldStop()
9540 
    oprot.writeStructEnd()
9541 
 
3431 rajveer 9542 
  def validate(self):
9543 
    return
9544 
 
9545 
 
1627 ankur.sing 9546 
  def __repr__(self):
9547 
    L = ['%s=%r' % (key, value)
9548 
      for key, value in self.__dict__.iteritems()]
9549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9550 
 
9551 
  def __eq__(self, other):
9552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9553 
 
9554 
  def __ne__(self, other):
9555 
    return not (self == other)
9556 
 
3064 chandransh 9557 
class updateNonDeliveryReason_args:
1627 ankur.sing 9558 
  """
9559 
  Attributes:
3064 chandransh 9560 
   - providerId
9561 
   - undeliveredOrders
1627 ankur.sing 9562 
  """
9563 
 
9564 
  thrift_spec = (
3064 chandransh 9565 
    None, # 0
9566 
    (1, TType.I64, 'providerId', None, None, ), # 1
9567 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 9568 
  )
9569 
 
3064 chandransh 9570 
  def __init__(self, providerId=None, undeliveredOrders=None,):
9571 
    self.providerId = providerId
9572 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 9573 
 
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:
1627 ankur.sing 9584 
        if ftype == TType.I64:
3064 chandransh 9585 
          self.providerId = iprot.readI64();
1627 ankur.sing 9586 
        else:
9587 
          iprot.skip(ftype)
3064 chandransh 9588 
      elif fid == 2:
9589 
        if ftype == TType.MAP:
9590 
          self.undeliveredOrders = {}
4133 chandransh 9591 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
9592 
          for _i178 in xrange(_size174):
9593 
            _key179 = iprot.readString();
9594 
            _val180 = iprot.readString();
9595 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 9596 
          iprot.readMapEnd()
9597 
        else:
9598 
          iprot.skip(ftype)
1627 ankur.sing 9599 
      else:
9600 
        iprot.skip(ftype)
9601 
      iprot.readFieldEnd()
9602 
    iprot.readStructEnd()
9603 
 
9604 
  def write(self, oprot):
9605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9607 
      return
3064 chandransh 9608 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 9609 
    if self.providerId is not None:
3064 chandransh 9610 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9611 
      oprot.writeI64(self.providerId)
1627 ankur.sing 9612 
      oprot.writeFieldEnd()
3431 rajveer 9613 
    if self.undeliveredOrders is not None:
3064 chandransh 9614 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
9615 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 9616 
      for kiter181,viter182 in self.undeliveredOrders.items():
9617 
        oprot.writeString(kiter181)
9618 
        oprot.writeString(viter182)
3064 chandransh 9619 
      oprot.writeMapEnd()
9620 
      oprot.writeFieldEnd()
1627 ankur.sing 9621 
    oprot.writeFieldStop()
9622 
    oprot.writeStructEnd()
9623 
 
3431 rajveer 9624 
  def validate(self):
9625 
    return
9626 
 
9627 
 
1627 ankur.sing 9628 
  def __repr__(self):
9629 
    L = ['%s=%r' % (key, value)
9630 
      for key, value in self.__dict__.iteritems()]
9631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9632 
 
9633 
  def __eq__(self, other):
9634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9635 
 
9636 
  def __ne__(self, other):
9637 
    return not (self == other)
9638 
 
3064 chandransh 9639 
class updateNonDeliveryReason_result:
1627 ankur.sing 9640 
  """
9641 
  Attributes:
3064 chandransh 9642 
   - ex
1627 ankur.sing 9643 
  """
9644 
 
9645 
  thrift_spec = (
3064 chandransh 9646 
    None, # 0
9647 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9648 
  )
9649 
 
3064 chandransh 9650 
  def __init__(self, ex=None,):
9651 
    self.ex = ex
1627 ankur.sing 9652 
 
9653 
  def read(self, iprot):
9654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9656 
      return
9657 
    iprot.readStructBegin()
9658 
    while True:
9659 
      (fname, ftype, fid) = iprot.readFieldBegin()
9660 
      if ftype == TType.STOP:
9661 
        break
3064 chandransh 9662 
      if fid == 1:
9663 
        if ftype == TType.STRUCT:
9664 
          self.ex = TransactionServiceException()
9665 
          self.ex.read(iprot)
1627 ankur.sing 9666 
        else:
9667 
          iprot.skip(ftype)
9668 
      else:
9669 
        iprot.skip(ftype)
9670 
      iprot.readFieldEnd()
9671 
    iprot.readStructEnd()
9672 
 
9673 
  def write(self, oprot):
9674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9676 
      return
3064 chandransh 9677 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 9678 
    if self.ex is not None:
3064 chandransh 9679 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9680 
      self.ex.write(oprot)
1627 ankur.sing 9681 
      oprot.writeFieldEnd()
9682 
    oprot.writeFieldStop()
9683 
    oprot.writeStructEnd()
9684 
 
3431 rajveer 9685 
  def validate(self):
9686 
    return
9687 
 
9688 
 
1627 ankur.sing 9689 
  def __repr__(self):
9690 
    L = ['%s=%r' % (key, value)
9691 
      for key, value in self.__dict__.iteritems()]
9692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9693 
 
9694 
  def __eq__(self, other):
9695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9696 
 
9697 
  def __ne__(self, other):
9698 
    return not (self == other)
9699 
 
3064 chandransh 9700 
class getUndeliveredOrders_args:
1886 ankur.sing 9701 
  """
9702 
  Attributes:
3064 chandransh 9703 
   - providerId
9704 
   - warehouseId
1886 ankur.sing 9705 
  """
1627 ankur.sing 9706 
 
1886 ankur.sing 9707 
  thrift_spec = (
9708 
    None, # 0
3064 chandransh 9709 
    (1, TType.I64, 'providerId', None, None, ), # 1
9710 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 9711 
  )
9712 
 
3064 chandransh 9713 
  def __init__(self, providerId=None, warehouseId=None,):
9714 
    self.providerId = providerId
9715 
    self.warehouseId = warehouseId
1886 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
9726 
      if fid == 1:
9727 
        if ftype == TType.I64:
3064 chandransh 9728 
          self.providerId = iprot.readI64();
1886 ankur.sing 9729 
        else:
9730 
          iprot.skip(ftype)
3064 chandransh 9731 
      elif fid == 2:
9732 
        if ftype == TType.I64:
9733 
          self.warehouseId = iprot.readI64();
9734 
        else:
9735 
          iprot.skip(ftype)
1886 ankur.sing 9736 
      else:
9737 
        iprot.skip(ftype)
9738 
      iprot.readFieldEnd()
9739 
    iprot.readStructEnd()
9740 
 
9741 
  def write(self, oprot):
9742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9744 
      return
3064 chandransh 9745 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 9746 
    if self.providerId is not None:
3064 chandransh 9747 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9748 
      oprot.writeI64(self.providerId)
1886 ankur.sing 9749 
      oprot.writeFieldEnd()
3431 rajveer 9750 
    if self.warehouseId is not None:
3064 chandransh 9751 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9752 
      oprot.writeI64(self.warehouseId)
9753 
      oprot.writeFieldEnd()
1886 ankur.sing 9754 
    oprot.writeFieldStop()
9755 
    oprot.writeStructEnd()
9756 
 
3431 rajveer 9757 
  def validate(self):
9758 
    return
9759 
 
9760 
 
1886 ankur.sing 9761 
  def __repr__(self):
9762 
    L = ['%s=%r' % (key, value)
9763 
      for key, value in self.__dict__.iteritems()]
9764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9765 
 
9766 
  def __eq__(self, other):
9767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9768 
 
9769 
  def __ne__(self, other):
9770 
    return not (self == other)
9771 
 
3064 chandransh 9772 
class getUndeliveredOrders_result:
1886 ankur.sing 9773 
  """
9774 
  Attributes:
9775 
   - success
9776 
  """
9777 
 
9778 
  thrift_spec = (
9779 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9780 
  )
9781 
 
9782 
  def __init__(self, success=None,):
9783 
    self.success = success
9784 
 
9785 
  def read(self, iprot):
9786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9788 
      return
9789 
    iprot.readStructBegin()
9790 
    while True:
9791 
      (fname, ftype, fid) = iprot.readFieldBegin()
9792 
      if ftype == TType.STOP:
9793 
        break
9794 
      if fid == 0:
9795 
        if ftype == TType.LIST:
9796 
          self.success = []
4133 chandransh 9797 
          (_etype186, _size183) = iprot.readListBegin()
9798 
          for _i187 in xrange(_size183):
9799 
            _elem188 = Order()
9800 
            _elem188.read(iprot)
9801 
            self.success.append(_elem188)
1886 ankur.sing 9802 
          iprot.readListEnd()
9803 
        else:
9804 
          iprot.skip(ftype)
9805 
      else:
9806 
        iprot.skip(ftype)
9807 
      iprot.readFieldEnd()
9808 
    iprot.readStructEnd()
9809 
 
9810 
  def write(self, oprot):
9811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9813 
      return
3064 chandransh 9814 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 9815 
    if self.success is not None:
1886 ankur.sing 9816 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9817 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9818 
      for iter189 in self.success:
9819 
        iter189.write(oprot)
1886 ankur.sing 9820 
      oprot.writeListEnd()
9821 
      oprot.writeFieldEnd()
9822 
    oprot.writeFieldStop()
9823 
    oprot.writeStructEnd()
9824 
 
3431 rajveer 9825 
  def validate(self):
9826 
    return
9827 
 
9828 
 
1886 ankur.sing 9829 
  def __repr__(self):
9830 
    L = ['%s=%r' % (key, value)
9831 
      for key, value in self.__dict__.iteritems()]
9832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9833 
 
9834 
  def __eq__(self, other):
9835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9836 
 
9837 
  def __ne__(self, other):
9838 
    return not (self == other)
9839 
 
2536 chandransh 9840 
class toggleDOAFlag_args:
9841 
  """
9842 
  Attributes:
9843 
   - orderId
9844 
  """
1886 ankur.sing 9845 
 
2536 chandransh 9846 
  thrift_spec = (
9847 
    None, # 0
9848 
    (1, TType.I64, 'orderId', None, None, ), # 1
9849 
  )
9850 
 
9851 
  def __init__(self, orderId=None,):
9852 
    self.orderId = orderId
9853 
 
9854 
  def read(self, iprot):
9855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9857 
      return
9858 
    iprot.readStructBegin()
9859 
    while True:
9860 
      (fname, ftype, fid) = iprot.readFieldBegin()
9861 
      if ftype == TType.STOP:
9862 
        break
9863 
      if fid == 1:
9864 
        if ftype == TType.I64:
9865 
          self.orderId = iprot.readI64();
9866 
        else:
9867 
          iprot.skip(ftype)
9868 
      else:
9869 
        iprot.skip(ftype)
9870 
      iprot.readFieldEnd()
9871 
    iprot.readStructEnd()
9872 
 
9873 
  def write(self, oprot):
9874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9876 
      return
9877 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 9878 
    if self.orderId is not None:
2536 chandransh 9879 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9880 
      oprot.writeI64(self.orderId)
9881 
      oprot.writeFieldEnd()
9882 
    oprot.writeFieldStop()
9883 
    oprot.writeStructEnd()
9884 
 
3431 rajveer 9885 
  def validate(self):
9886 
    return
9887 
 
9888 
 
2536 chandransh 9889 
  def __repr__(self):
9890 
    L = ['%s=%r' % (key, value)
9891 
      for key, value in self.__dict__.iteritems()]
9892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9893 
 
9894 
  def __eq__(self, other):
9895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9896 
 
9897 
  def __ne__(self, other):
9898 
    return not (self == other)
9899 
 
9900 
class toggleDOAFlag_result:
9901 
  """
9902 
  Attributes:
9903 
   - success
9904 
   - ex
9905 
  """
9906 
 
9907 
  thrift_spec = (
9908 
    (0, TType.BOOL, 'success', None, None, ), # 0
9909 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9910 
  )
9911 
 
9912 
  def __init__(self, success=None, ex=None,):
9913 
    self.success = success
9914 
    self.ex = ex
9915 
 
9916 
  def read(self, iprot):
9917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9919 
      return
9920 
    iprot.readStructBegin()
9921 
    while True:
9922 
      (fname, ftype, fid) = iprot.readFieldBegin()
9923 
      if ftype == TType.STOP:
9924 
        break
9925 
      if fid == 0:
9926 
        if ftype == TType.BOOL:
9927 
          self.success = iprot.readBool();
9928 
        else:
9929 
          iprot.skip(ftype)
9930 
      elif fid == 1:
9931 
        if ftype == TType.STRUCT:
9932 
          self.ex = TransactionServiceException()
9933 
          self.ex.read(iprot)
9934 
        else:
9935 
          iprot.skip(ftype)
9936 
      else:
9937 
        iprot.skip(ftype)
9938 
      iprot.readFieldEnd()
9939 
    iprot.readStructEnd()
9940 
 
9941 
  def write(self, oprot):
9942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9944 
      return
9945 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 9946 
    if self.success is not None:
2536 chandransh 9947 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9948 
      oprot.writeBool(self.success)
9949 
      oprot.writeFieldEnd()
3431 rajveer 9950 
    if self.ex is not None:
2536 chandransh 9951 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9952 
      self.ex.write(oprot)
9953 
      oprot.writeFieldEnd()
9954 
    oprot.writeFieldStop()
9955 
    oprot.writeStructEnd()
9956 
 
3431 rajveer 9957 
  def validate(self):
9958 
    return
9959 
 
9960 
 
2536 chandransh 9961 
  def __repr__(self):
9962 
    L = ['%s=%r' % (key, value)
9963 
      for key, value in self.__dict__.iteritems()]
9964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9965 
 
9966 
  def __eq__(self, other):
9967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9968 
 
9969 
  def __ne__(self, other):
9970 
    return not (self == other)
9971 
 
9972 
class requestPickupNumber_args:
9973 
  """
9974 
  Attributes:
9975 
   - orderId
9976 
  """
9977 
 
9978 
  thrift_spec = (
9979 
    None, # 0
9980 
    (1, TType.I64, 'orderId', None, None, ), # 1
9981 
  )
9982 
 
9983 
  def __init__(self, orderId=None,):
9984 
    self.orderId = orderId
9985 
 
9986 
  def read(self, iprot):
9987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9989 
      return
9990 
    iprot.readStructBegin()
9991 
    while True:
9992 
      (fname, ftype, fid) = iprot.readFieldBegin()
9993 
      if ftype == TType.STOP:
9994 
        break
9995 
      if fid == 1:
9996 
        if ftype == TType.I64:
9997 
          self.orderId = iprot.readI64();
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('requestPickupNumber_args')
3431 rajveer 10010 
    if self.orderId is not None:
2536 chandransh 10011 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10012 
      oprot.writeI64(self.orderId)
10013 
      oprot.writeFieldEnd()
10014 
    oprot.writeFieldStop()
10015 
    oprot.writeStructEnd()
10016 
 
3431 rajveer 10017 
  def validate(self):
10018 
    return
10019 
 
10020 
 
2536 chandransh 10021 
  def __repr__(self):
10022 
    L = ['%s=%r' % (key, value)
10023 
      for key, value in self.__dict__.iteritems()]
10024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10025 
 
10026 
  def __eq__(self, other):
10027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10028 
 
10029 
  def __ne__(self, other):
10030 
    return not (self == other)
10031 
 
10032 
class requestPickupNumber_result:
10033 
  """
10034 
  Attributes:
10035 
   - success
10036 
   - ex
10037 
  """
10038 
 
10039 
  thrift_spec = (
10040 
    (0, TType.BOOL, 'success', None, None, ), # 0
10041 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10042 
  )
10043 
 
10044 
  def __init__(self, success=None, ex=None,):
10045 
    self.success = success
10046 
    self.ex = ex
10047 
 
10048 
  def read(self, iprot):
10049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10051 
      return
10052 
    iprot.readStructBegin()
10053 
    while True:
10054 
      (fname, ftype, fid) = iprot.readFieldBegin()
10055 
      if ftype == TType.STOP:
10056 
        break
10057 
      if fid == 0:
10058 
        if ftype == TType.BOOL:
10059 
          self.success = iprot.readBool();
10060 
        else:
10061 
          iprot.skip(ftype)
10062 
      elif fid == 1:
10063 
        if ftype == TType.STRUCT:
10064 
          self.ex = TransactionServiceException()
10065 
          self.ex.read(iprot)
10066 
        else:
10067 
          iprot.skip(ftype)
10068 
      else:
10069 
        iprot.skip(ftype)
10070 
      iprot.readFieldEnd()
10071 
    iprot.readStructEnd()
10072 
 
10073 
  def write(self, oprot):
10074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10076 
      return
10077 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 10078 
    if self.success is not None:
2536 chandransh 10079 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10080 
      oprot.writeBool(self.success)
10081 
      oprot.writeFieldEnd()
3431 rajveer 10082 
    if self.ex is not None:
2536 chandransh 10083 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10084 
      self.ex.write(oprot)
10085 
      oprot.writeFieldEnd()
10086 
    oprot.writeFieldStop()
10087 
    oprot.writeStructEnd()
10088 
 
3431 rajveer 10089 
  def validate(self):
10090 
    return
10091 
 
10092 
 
2536 chandransh 10093 
  def __repr__(self):
10094 
    L = ['%s=%r' % (key, value)
10095 
      for key, value in self.__dict__.iteritems()]
10096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10097 
 
10098 
  def __eq__(self, other):
10099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10100 
 
10101 
  def __ne__(self, other):
10102 
    return not (self == other)
10103 
 
10104 
class authorizePickup_args:
10105 
  """
10106 
  Attributes:
10107 
   - orderId
10108 
   - pickupNumber
10109 
  """
10110 
 
10111 
  thrift_spec = (
10112 
    None, # 0
10113 
    (1, TType.I64, 'orderId', None, None, ), # 1
10114 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
10115 
  )
10116 
 
10117 
  def __init__(self, orderId=None, pickupNumber=None,):
10118 
    self.orderId = orderId
10119 
    self.pickupNumber = pickupNumber
10120 
 
10121 
  def read(self, iprot):
10122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10124 
      return
10125 
    iprot.readStructBegin()
10126 
    while True:
10127 
      (fname, ftype, fid) = iprot.readFieldBegin()
10128 
      if ftype == TType.STOP:
10129 
        break
10130 
      if fid == 1:
10131 
        if ftype == TType.I64:
10132 
          self.orderId = iprot.readI64();
10133 
        else:
10134 
          iprot.skip(ftype)
10135 
      elif fid == 2:
10136 
        if ftype == TType.STRING:
10137 
          self.pickupNumber = iprot.readString();
10138 
        else:
10139 
          iprot.skip(ftype)
10140 
      else:
10141 
        iprot.skip(ftype)
10142 
      iprot.readFieldEnd()
10143 
    iprot.readStructEnd()
10144 
 
10145 
  def write(self, oprot):
10146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10148 
      return
10149 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 10150 
    if self.orderId is not None:
2536 chandransh 10151 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10152 
      oprot.writeI64(self.orderId)
10153 
      oprot.writeFieldEnd()
3431 rajveer 10154 
    if self.pickupNumber is not None:
2536 chandransh 10155 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
10156 
      oprot.writeString(self.pickupNumber)
10157 
      oprot.writeFieldEnd()
10158 
    oprot.writeFieldStop()
10159 
    oprot.writeStructEnd()
10160 
 
3431 rajveer 10161 
  def validate(self):
10162 
    return
10163 
 
10164 
 
2536 chandransh 10165 
  def __repr__(self):
10166 
    L = ['%s=%r' % (key, value)
10167 
      for key, value in self.__dict__.iteritems()]
10168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10169 
 
10170 
  def __eq__(self, other):
10171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10172 
 
10173 
  def __ne__(self, other):
10174 
    return not (self == other)
10175 
 
10176 
class authorizePickup_result:
10177 
  """
10178 
  Attributes:
10179 
   - success
10180 
   - ex
10181 
  """
10182 
 
10183 
  thrift_spec = (
10184 
    (0, TType.BOOL, 'success', None, None, ), # 0
10185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10186 
  )
10187 
 
10188 
  def __init__(self, success=None, ex=None,):
10189 
    self.success = success
10190 
    self.ex = ex
10191 
 
10192 
  def read(self, iprot):
10193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10195 
      return
10196 
    iprot.readStructBegin()
10197 
    while True:
10198 
      (fname, ftype, fid) = iprot.readFieldBegin()
10199 
      if ftype == TType.STOP:
10200 
        break
10201 
      if fid == 0:
10202 
        if ftype == TType.BOOL:
10203 
          self.success = iprot.readBool();
10204 
        else:
10205 
          iprot.skip(ftype)
10206 
      elif fid == 1:
10207 
        if ftype == TType.STRUCT:
10208 
          self.ex = TransactionServiceException()
10209 
          self.ex.read(iprot)
10210 
        else:
10211 
          iprot.skip(ftype)
10212 
      else:
10213 
        iprot.skip(ftype)
10214 
      iprot.readFieldEnd()
10215 
    iprot.readStructEnd()
10216 
 
10217 
  def write(self, oprot):
10218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10220 
      return
10221 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 10222 
    if self.success is not None:
2536 chandransh 10223 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10224 
      oprot.writeBool(self.success)
10225 
      oprot.writeFieldEnd()
3431 rajveer 10226 
    if self.ex is not None:
2536 chandransh 10227 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10228 
      self.ex.write(oprot)
10229 
      oprot.writeFieldEnd()
10230 
    oprot.writeFieldStop()
10231 
    oprot.writeStructEnd()
10232 
 
3431 rajveer 10233 
  def validate(self):
10234 
    return
10235 
 
10236 
 
2536 chandransh 10237 
  def __repr__(self):
10238 
    L = ['%s=%r' % (key, value)
10239 
      for key, value in self.__dict__.iteritems()]
10240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10241 
 
10242 
  def __eq__(self, other):
10243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10244 
 
10245 
  def __ne__(self, other):
10246 
    return not (self == other)
10247 
 
2764 chandransh 10248 
class markDoasAsPickedUp_args:
10249 
  """
10250 
  Attributes:
10251 
   - providerId
10252 
   - pickupDetails
10253 
  """
10254 
 
10255 
  thrift_spec = (
10256 
    None, # 0
10257 
    (1, TType.I64, 'providerId', None, None, ), # 1
10258 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
10259 
  )
10260 
 
10261 
  def __init__(self, providerId=None, pickupDetails=None,):
10262 
    self.providerId = providerId
10263 
    self.pickupDetails = pickupDetails
10264 
 
10265 
  def read(self, iprot):
10266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10268 
      return
10269 
    iprot.readStructBegin()
10270 
    while True:
10271 
      (fname, ftype, fid) = iprot.readFieldBegin()
10272 
      if ftype == TType.STOP:
10273 
        break
10274 
      if fid == 1:
10275 
        if ftype == TType.I64:
10276 
          self.providerId = iprot.readI64();
10277 
        else:
10278 
          iprot.skip(ftype)
10279 
      elif fid == 2:
10280 
        if ftype == TType.MAP:
10281 
          self.pickupDetails = {}
4133 chandransh 10282 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
10283 
          for _i194 in xrange(_size190):
10284 
            _key195 = iprot.readString();
10285 
            _val196 = iprot.readString();
10286 
            self.pickupDetails[_key195] = _val196
2764 chandransh 10287 
          iprot.readMapEnd()
10288 
        else:
10289 
          iprot.skip(ftype)
10290 
      else:
10291 
        iprot.skip(ftype)
10292 
      iprot.readFieldEnd()
10293 
    iprot.readStructEnd()
10294 
 
10295 
  def write(self, oprot):
10296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10298 
      return
10299 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 10300 
    if self.providerId is not None:
2764 chandransh 10301 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10302 
      oprot.writeI64(self.providerId)
10303 
      oprot.writeFieldEnd()
3431 rajveer 10304 
    if self.pickupDetails is not None:
2764 chandransh 10305 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10306 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10307 
      for kiter197,viter198 in self.pickupDetails.items():
10308 
        oprot.writeString(kiter197)
10309 
        oprot.writeString(viter198)
2764 chandransh 10310 
      oprot.writeMapEnd()
10311 
      oprot.writeFieldEnd()
10312 
    oprot.writeFieldStop()
10313 
    oprot.writeStructEnd()
10314 
 
3431 rajveer 10315 
  def validate(self):
10316 
    return
10317 
 
10318 
 
2764 chandransh 10319 
  def __repr__(self):
10320 
    L = ['%s=%r' % (key, value)
10321 
      for key, value in self.__dict__.iteritems()]
10322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10323 
 
10324 
  def __eq__(self, other):
10325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10326 
 
10327 
  def __ne__(self, other):
10328 
    return not (self == other)
10329 
 
10330 
class markDoasAsPickedUp_result:
10331 
  """
10332 
  Attributes:
10333 
   - success
10334 
  """
10335 
 
10336 
  thrift_spec = (
10337 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10338 
  )
10339 
 
10340 
  def __init__(self, success=None,):
10341 
    self.success = success
10342 
 
10343 
  def read(self, iprot):
10344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10346 
      return
10347 
    iprot.readStructBegin()
10348 
    while True:
10349 
      (fname, ftype, fid) = iprot.readFieldBegin()
10350 
      if ftype == TType.STOP:
10351 
        break
10352 
      if fid == 0:
10353 
        if ftype == TType.LIST:
10354 
          self.success = []
4133 chandransh 10355 
          (_etype202, _size199) = iprot.readListBegin()
10356 
          for _i203 in xrange(_size199):
10357 
            _elem204 = Order()
10358 
            _elem204.read(iprot)
10359 
            self.success.append(_elem204)
2764 chandransh 10360 
          iprot.readListEnd()
10361 
        else:
10362 
          iprot.skip(ftype)
10363 
      else:
10364 
        iprot.skip(ftype)
10365 
      iprot.readFieldEnd()
10366 
    iprot.readStructEnd()
10367 
 
10368 
  def write(self, oprot):
10369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10371 
      return
10372 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 10373 
    if self.success is not None:
2764 chandransh 10374 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10375 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10376 
      for iter205 in self.success:
10377 
        iter205.write(oprot)
2764 chandransh 10378 
      oprot.writeListEnd()
10379 
      oprot.writeFieldEnd()
10380 
    oprot.writeFieldStop()
10381 
    oprot.writeStructEnd()
10382 
 
3431 rajveer 10383 
  def validate(self):
10384 
    return
10385 
 
10386 
 
2764 chandransh 10387 
  def __repr__(self):
10388 
    L = ['%s=%r' % (key, value)
10389 
      for key, value in self.__dict__.iteritems()]
10390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10391 
 
10392 
  def __eq__(self, other):
10393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10394 
 
10395 
  def __ne__(self, other):
10396 
    return not (self == other)
10397 
 
2616 chandransh 10398 
class receiveReturn_args:
2591 chandransh 10399 
  """
10400 
  Attributes:
10401 
   - orderId
10402 
  """
2536 chandransh 10403 
 
2591 chandransh 10404 
  thrift_spec = (
10405 
    None, # 0
10406 
    (1, TType.I64, 'orderId', None, None, ), # 1
10407 
  )
10408 
 
10409 
  def __init__(self, orderId=None,):
10410 
    self.orderId = orderId
10411 
 
10412 
  def read(self, iprot):
10413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10415 
      return
10416 
    iprot.readStructBegin()
10417 
    while True:
10418 
      (fname, ftype, fid) = iprot.readFieldBegin()
10419 
      if ftype == TType.STOP:
10420 
        break
10421 
      if fid == 1:
10422 
        if ftype == TType.I64:
10423 
          self.orderId = iprot.readI64();
10424 
        else:
10425 
          iprot.skip(ftype)
10426 
      else:
10427 
        iprot.skip(ftype)
10428 
      iprot.readFieldEnd()
10429 
    iprot.readStructEnd()
10430 
 
10431 
  def write(self, oprot):
10432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10434 
      return
2616 chandransh 10435 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 10436 
    if self.orderId is not None:
2591 chandransh 10437 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10438 
      oprot.writeI64(self.orderId)
10439 
      oprot.writeFieldEnd()
10440 
    oprot.writeFieldStop()
10441 
    oprot.writeStructEnd()
10442 
 
3431 rajveer 10443 
  def validate(self):
10444 
    return
10445 
 
10446 
 
2591 chandransh 10447 
  def __repr__(self):
10448 
    L = ['%s=%r' % (key, value)
10449 
      for key, value in self.__dict__.iteritems()]
10450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10451 
 
10452 
  def __eq__(self, other):
10453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10454 
 
10455 
  def __ne__(self, other):
10456 
    return not (self == other)
10457 
 
2616 chandransh 10458 
class receiveReturn_result:
2591 chandransh 10459 
  """
10460 
  Attributes:
10461 
   - success
10462 
   - ex
10463 
  """
10464 
 
10465 
  thrift_spec = (
10466 
    (0, TType.BOOL, 'success', None, None, ), # 0
10467 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10468 
  )
10469 
 
10470 
  def __init__(self, success=None, ex=None,):
10471 
    self.success = success
10472 
    self.ex = ex
10473 
 
10474 
  def read(self, iprot):
10475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10477 
      return
10478 
    iprot.readStructBegin()
10479 
    while True:
10480 
      (fname, ftype, fid) = iprot.readFieldBegin()
10481 
      if ftype == TType.STOP:
10482 
        break
10483 
      if fid == 0:
10484 
        if ftype == TType.BOOL:
10485 
          self.success = iprot.readBool();
10486 
        else:
10487 
          iprot.skip(ftype)
10488 
      elif fid == 1:
10489 
        if ftype == TType.STRUCT:
10490 
          self.ex = TransactionServiceException()
10491 
          self.ex.read(iprot)
10492 
        else:
10493 
          iprot.skip(ftype)
10494 
      else:
10495 
        iprot.skip(ftype)
10496 
      iprot.readFieldEnd()
10497 
    iprot.readStructEnd()
10498 
 
10499 
  def write(self, oprot):
10500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10502 
      return
2616 chandransh 10503 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 10504 
    if self.success is not None:
2591 chandransh 10505 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10506 
      oprot.writeBool(self.success)
10507 
      oprot.writeFieldEnd()
3431 rajveer 10508 
    if self.ex is not None:
2591 chandransh 10509 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10510 
      self.ex.write(oprot)
10511 
      oprot.writeFieldEnd()
10512 
    oprot.writeFieldStop()
10513 
    oprot.writeStructEnd()
10514 
 
3431 rajveer 10515 
  def validate(self):
10516 
    return
10517 
 
10518 
 
2591 chandransh 10519 
  def __repr__(self):
10520 
    L = ['%s=%r' % (key, value)
10521 
      for key, value in self.__dict__.iteritems()]
10522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10523 
 
10524 
  def __eq__(self, other):
10525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10526 
 
10527 
  def __ne__(self, other):
10528 
    return not (self == other)
10529 
 
10530 
class validateDoa_args:
10531 
  """
10532 
  Attributes:
10533 
   - orderId
10534 
   - isValid
10535 
  """
10536 
 
10537 
  thrift_spec = (
10538 
    None, # 0
10539 
    (1, TType.I64, 'orderId', None, None, ), # 1
10540 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
10541 
  )
10542 
 
10543 
  def __init__(self, orderId=None, isValid=None,):
10544 
    self.orderId = orderId
10545 
    self.isValid = isValid
10546 
 
10547 
  def read(self, iprot):
10548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10550 
      return
10551 
    iprot.readStructBegin()
10552 
    while True:
10553 
      (fname, ftype, fid) = iprot.readFieldBegin()
10554 
      if ftype == TType.STOP:
10555 
        break
10556 
      if fid == 1:
10557 
        if ftype == TType.I64:
10558 
          self.orderId = iprot.readI64();
10559 
        else:
10560 
          iprot.skip(ftype)
10561 
      elif fid == 2:
10562 
        if ftype == TType.BOOL:
10563 
          self.isValid = iprot.readBool();
10564 
        else:
10565 
          iprot.skip(ftype)
10566 
      else:
10567 
        iprot.skip(ftype)
10568 
      iprot.readFieldEnd()
10569 
    iprot.readStructEnd()
10570 
 
10571 
  def write(self, oprot):
10572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10574 
      return
10575 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 10576 
    if self.orderId is not None:
2591 chandransh 10577 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10578 
      oprot.writeI64(self.orderId)
10579 
      oprot.writeFieldEnd()
3431 rajveer 10580 
    if self.isValid is not None:
2591 chandransh 10581 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
10582 
      oprot.writeBool(self.isValid)
10583 
      oprot.writeFieldEnd()
10584 
    oprot.writeFieldStop()
10585 
    oprot.writeStructEnd()
10586 
 
3431 rajveer 10587 
  def validate(self):
10588 
    return
10589 
 
10590 
 
2591 chandransh 10591 
  def __repr__(self):
10592 
    L = ['%s=%r' % (key, value)
10593 
      for key, value in self.__dict__.iteritems()]
10594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10595 
 
10596 
  def __eq__(self, other):
10597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10598 
 
10599 
  def __ne__(self, other):
10600 
    return not (self == other)
10601 
 
10602 
class validateDoa_result:
10603 
  """
10604 
  Attributes:
10605 
   - success
10606 
   - ex
10607 
  """
10608 
 
10609 
  thrift_spec = (
10610 
    (0, TType.BOOL, 'success', None, None, ), # 0
10611 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10612 
  )
10613 
 
10614 
  def __init__(self, success=None, ex=None,):
10615 
    self.success = success
10616 
    self.ex = ex
10617 
 
10618 
  def read(self, iprot):
10619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10621 
      return
10622 
    iprot.readStructBegin()
10623 
    while True:
10624 
      (fname, ftype, fid) = iprot.readFieldBegin()
10625 
      if ftype == TType.STOP:
10626 
        break
10627 
      if fid == 0:
10628 
        if ftype == TType.BOOL:
10629 
          self.success = iprot.readBool();
10630 
        else:
10631 
          iprot.skip(ftype)
10632 
      elif fid == 1:
10633 
        if ftype == TType.STRUCT:
10634 
          self.ex = TransactionServiceException()
10635 
          self.ex.read(iprot)
10636 
        else:
10637 
          iprot.skip(ftype)
10638 
      else:
10639 
        iprot.skip(ftype)
10640 
      iprot.readFieldEnd()
10641 
    iprot.readStructEnd()
10642 
 
10643 
  def write(self, oprot):
10644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10646 
      return
10647 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 10648 
    if self.success is not None:
2591 chandransh 10649 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10650 
      oprot.writeBool(self.success)
10651 
      oprot.writeFieldEnd()
3431 rajveer 10652 
    if self.ex is not None:
2591 chandransh 10653 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10654 
      self.ex.write(oprot)
10655 
      oprot.writeFieldEnd()
10656 
    oprot.writeFieldStop()
10657 
    oprot.writeStructEnd()
10658 
 
3431 rajveer 10659 
  def validate(self):
10660 
    return
10661 
 
10662 
 
2591 chandransh 10663 
  def __repr__(self):
10664 
    L = ['%s=%r' % (key, value)
10665 
      for key, value in self.__dict__.iteritems()]
10666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10667 
 
10668 
  def __eq__(self, other):
10669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10670 
 
10671 
  def __ne__(self, other):
10672 
    return not (self == other)
10673 
 
2616 chandransh 10674 
class reshipOrder_args:
10675 
  """
10676 
  Attributes:
10677 
   - orderId
10678 
  """
2591 chandransh 10679 
 
2616 chandransh 10680 
  thrift_spec = (
10681 
    None, # 0
10682 
    (1, TType.I64, 'orderId', None, None, ), # 1
10683 
  )
10684 
 
10685 
  def __init__(self, orderId=None,):
10686 
    self.orderId = orderId
10687 
 
10688 
  def read(self, iprot):
10689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10691 
      return
10692 
    iprot.readStructBegin()
10693 
    while True:
10694 
      (fname, ftype, fid) = iprot.readFieldBegin()
10695 
      if ftype == TType.STOP:
10696 
        break
10697 
      if fid == 1:
10698 
        if ftype == TType.I64:
10699 
          self.orderId = iprot.readI64();
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('reshipOrder_args')
3431 rajveer 10712 
    if self.orderId is not None:
2616 chandransh 10713 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10714 
      oprot.writeI64(self.orderId)
10715 
      oprot.writeFieldEnd()
10716 
    oprot.writeFieldStop()
10717 
    oprot.writeStructEnd()
10718 
 
3431 rajveer 10719 
  def validate(self):
10720 
    return
10721 
 
10722 
 
2616 chandransh 10723 
  def __repr__(self):
10724 
    L = ['%s=%r' % (key, value)
10725 
      for key, value in self.__dict__.iteritems()]
10726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10727 
 
10728 
  def __eq__(self, other):
10729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10730 
 
10731 
  def __ne__(self, other):
10732 
    return not (self == other)
10733 
 
10734 
class reshipOrder_result:
10735 
  """
10736 
  Attributes:
10737 
   - success
10738 
   - ex
10739 
  """
10740 
 
10741 
  thrift_spec = (
10742 
    (0, TType.I64, 'success', None, None, ), # 0
10743 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10744 
  )
10745 
 
10746 
  def __init__(self, success=None, ex=None,):
10747 
    self.success = success
10748 
    self.ex = ex
10749 
 
10750 
  def read(self, iprot):
10751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10753 
      return
10754 
    iprot.readStructBegin()
10755 
    while True:
10756 
      (fname, ftype, fid) = iprot.readFieldBegin()
10757 
      if ftype == TType.STOP:
10758 
        break
10759 
      if fid == 0:
10760 
        if ftype == TType.I64:
10761 
          self.success = iprot.readI64();
10762 
        else:
10763 
          iprot.skip(ftype)
10764 
      elif fid == 1:
10765 
        if ftype == TType.STRUCT:
10766 
          self.ex = TransactionServiceException()
10767 
          self.ex.read(iprot)
10768 
        else:
10769 
          iprot.skip(ftype)
10770 
      else:
10771 
        iprot.skip(ftype)
10772 
      iprot.readFieldEnd()
10773 
    iprot.readStructEnd()
10774 
 
10775 
  def write(self, oprot):
10776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10778 
      return
10779 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 10780 
    if self.success is not None:
2616 chandransh 10781 
      oprot.writeFieldBegin('success', TType.I64, 0)
10782 
      oprot.writeI64(self.success)
10783 
      oprot.writeFieldEnd()
3431 rajveer 10784 
    if self.ex is not None:
2616 chandransh 10785 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10786 
      self.ex.write(oprot)
10787 
      oprot.writeFieldEnd()
10788 
    oprot.writeFieldStop()
10789 
    oprot.writeStructEnd()
10790 
 
3431 rajveer 10791 
  def validate(self):
10792 
    return
10793 
 
10794 
 
2616 chandransh 10795 
  def __repr__(self):
10796 
    L = ['%s=%r' % (key, value)
10797 
      for key, value in self.__dict__.iteritems()]
10798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10799 
 
10800 
  def __eq__(self, other):
10801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10802 
 
10803 
  def __ne__(self, other):
10804 
    return not (self == other)
10805 
 
10806 
class refundOrder_args:
10807 
  """
10808 
  Attributes:
10809 
   - orderId
3226 chandransh 10810 
   - refundedBy
10811 
   - reason
2616 chandransh 10812 
  """
10813 
 
10814 
  thrift_spec = (
10815 
    None, # 0
10816 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 10817 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
10818 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 10819 
  )
10820 
 
3226 chandransh 10821 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 10822 
    self.orderId = orderId
3226 chandransh 10823 
    self.refundedBy = refundedBy
10824 
    self.reason = reason
2616 chandransh 10825 
 
10826 
  def read(self, iprot):
10827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10829 
      return
10830 
    iprot.readStructBegin()
10831 
    while True:
10832 
      (fname, ftype, fid) = iprot.readFieldBegin()
10833 
      if ftype == TType.STOP:
10834 
        break
10835 
      if fid == 1:
10836 
        if ftype == TType.I64:
10837 
          self.orderId = iprot.readI64();
10838 
        else:
10839 
          iprot.skip(ftype)
3226 chandransh 10840 
      elif fid == 2:
10841 
        if ftype == TType.STRING:
10842 
          self.refundedBy = iprot.readString();
10843 
        else:
10844 
          iprot.skip(ftype)
10845 
      elif fid == 3:
10846 
        if ftype == TType.STRING:
10847 
          self.reason = iprot.readString();
10848 
        else:
10849 
          iprot.skip(ftype)
2616 chandransh 10850 
      else:
10851 
        iprot.skip(ftype)
10852 
      iprot.readFieldEnd()
10853 
    iprot.readStructEnd()
10854 
 
10855 
  def write(self, oprot):
10856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10858 
      return
10859 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 10860 
    if self.orderId is not None:
2616 chandransh 10861 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10862 
      oprot.writeI64(self.orderId)
10863 
      oprot.writeFieldEnd()
3431 rajveer 10864 
    if self.refundedBy is not None:
3226 chandransh 10865 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
10866 
      oprot.writeString(self.refundedBy)
10867 
      oprot.writeFieldEnd()
3431 rajveer 10868 
    if self.reason is not None:
3226 chandransh 10869 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
10870 
      oprot.writeString(self.reason)
10871 
      oprot.writeFieldEnd()
2616 chandransh 10872 
    oprot.writeFieldStop()
10873 
    oprot.writeStructEnd()
10874 
 
3431 rajveer 10875 
  def validate(self):
10876 
    return
10877 
 
10878 
 
2616 chandransh 10879 
  def __repr__(self):
10880 
    L = ['%s=%r' % (key, value)
10881 
      for key, value in self.__dict__.iteritems()]
10882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10883 
 
10884 
  def __eq__(self, other):
10885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10886 
 
10887 
  def __ne__(self, other):
10888 
    return not (self == other)
10889 
 
10890 
class refundOrder_result:
10891 
  """
10892 
  Attributes:
10893 
   - success
10894 
   - ex
10895 
  """
10896 
 
10897 
  thrift_spec = (
10898 
    (0, TType.BOOL, 'success', None, None, ), # 0
10899 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10900 
  )
10901 
 
10902 
  def __init__(self, success=None, ex=None,):
10903 
    self.success = success
10904 
    self.ex = ex
10905 
 
10906 
  def read(self, iprot):
10907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10909 
      return
10910 
    iprot.readStructBegin()
10911 
    while True:
10912 
      (fname, ftype, fid) = iprot.readFieldBegin()
10913 
      if ftype == TType.STOP:
10914 
        break
10915 
      if fid == 0:
10916 
        if ftype == TType.BOOL:
10917 
          self.success = iprot.readBool();
10918 
        else:
10919 
          iprot.skip(ftype)
10920 
      elif fid == 1:
10921 
        if ftype == TType.STRUCT:
10922 
          self.ex = TransactionServiceException()
10923 
          self.ex.read(iprot)
10924 
        else:
10925 
          iprot.skip(ftype)
10926 
      else:
10927 
        iprot.skip(ftype)
10928 
      iprot.readFieldEnd()
10929 
    iprot.readStructEnd()
10930 
 
10931 
  def write(self, oprot):
10932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10934 
      return
10935 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 10936 
    if self.success is not None:
2616 chandransh 10937 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10938 
      oprot.writeBool(self.success)
10939 
      oprot.writeFieldEnd()
3431 rajveer 10940 
    if self.ex is not None:
2616 chandransh 10941 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10942 
      self.ex.write(oprot)
10943 
      oprot.writeFieldEnd()
10944 
    oprot.writeFieldStop()
10945 
    oprot.writeStructEnd()
10946 
 
3431 rajveer 10947 
  def validate(self):
10948 
    return
10949 
 
10950 
 
2616 chandransh 10951 
  def __repr__(self):
10952 
    L = ['%s=%r' % (key, value)
10953 
      for key, value in self.__dict__.iteritems()]
10954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10955 
 
10956 
  def __eq__(self, other):
10957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10958 
 
10959 
  def __ne__(self, other):
10960 
    return not (self == other)
10961 
 
2690 chandransh 10962 
class getReturnOrders_args:
10963 
  """
10964 
  Attributes:
10965 
   - warehouseId
10966 
   - fromDate
10967 
   - toDate
10968 
  """
2616 chandransh 10969 
 
2690 chandransh 10970 
  thrift_spec = (
10971 
    None, # 0
10972 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10973 
    (2, TType.I64, 'fromDate', None, None, ), # 2
10974 
    (3, TType.I64, 'toDate', None, None, ), # 3
10975 
  )
10976 
 
10977 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
10978 
    self.warehouseId = warehouseId
10979 
    self.fromDate = fromDate
10980 
    self.toDate = toDate
10981 
 
10982 
  def read(self, iprot):
10983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10985 
      return
10986 
    iprot.readStructBegin()
10987 
    while True:
10988 
      (fname, ftype, fid) = iprot.readFieldBegin()
10989 
      if ftype == TType.STOP:
10990 
        break
10991 
      if fid == 1:
10992 
        if ftype == TType.I64:
10993 
          self.warehouseId = iprot.readI64();
10994 
        else:
10995 
          iprot.skip(ftype)
10996 
      elif fid == 2:
10997 
        if ftype == TType.I64:
10998 
          self.fromDate = iprot.readI64();
10999 
        else:
11000 
          iprot.skip(ftype)
11001 
      elif fid == 3:
11002 
        if ftype == TType.I64:
11003 
          self.toDate = iprot.readI64();
11004 
        else:
11005 
          iprot.skip(ftype)
11006 
      else:
11007 
        iprot.skip(ftype)
11008 
      iprot.readFieldEnd()
11009 
    iprot.readStructEnd()
11010 
 
11011 
  def write(self, oprot):
11012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11014 
      return
11015 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 11016 
    if self.warehouseId is not None:
2690 chandransh 11017 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11018 
      oprot.writeI64(self.warehouseId)
11019 
      oprot.writeFieldEnd()
3431 rajveer 11020 
    if self.fromDate is not None:
2690 chandransh 11021 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
11022 
      oprot.writeI64(self.fromDate)
11023 
      oprot.writeFieldEnd()
3431 rajveer 11024 
    if self.toDate is not None:
2690 chandransh 11025 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
11026 
      oprot.writeI64(self.toDate)
11027 
      oprot.writeFieldEnd()
11028 
    oprot.writeFieldStop()
11029 
    oprot.writeStructEnd()
11030 
 
3431 rajveer 11031 
  def validate(self):
11032 
    return
11033 
 
11034 
 
2690 chandransh 11035 
  def __repr__(self):
11036 
    L = ['%s=%r' % (key, value)
11037 
      for key, value in self.__dict__.iteritems()]
11038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11039 
 
11040 
  def __eq__(self, other):
11041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11042 
 
11043 
  def __ne__(self, other):
11044 
    return not (self == other)
11045 
 
11046 
class getReturnOrders_result:
11047 
  """
11048 
  Attributes:
11049 
   - success
11050 
  """
11051 
 
11052 
  thrift_spec = (
11053 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
11054 
  )
11055 
 
11056 
  def __init__(self, success=None,):
11057 
    self.success = success
11058 
 
11059 
  def read(self, iprot):
11060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11062 
      return
11063 
    iprot.readStructBegin()
11064 
    while True:
11065 
      (fname, ftype, fid) = iprot.readFieldBegin()
11066 
      if ftype == TType.STOP:
11067 
        break
11068 
      if fid == 0:
11069 
        if ftype == TType.LIST:
11070 
          self.success = []
4133 chandransh 11071 
          (_etype209, _size206) = iprot.readListBegin()
11072 
          for _i210 in xrange(_size206):
11073 
            _elem211 = ReturnOrder()
11074 
            _elem211.read(iprot)
11075 
            self.success.append(_elem211)
2690 chandransh 11076 
          iprot.readListEnd()
11077 
        else:
11078 
          iprot.skip(ftype)
11079 
      else:
11080 
        iprot.skip(ftype)
11081 
      iprot.readFieldEnd()
11082 
    iprot.readStructEnd()
11083 
 
11084 
  def write(self, oprot):
11085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11087 
      return
11088 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 11089 
    if self.success is not None:
2690 chandransh 11090 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11091 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11092 
      for iter212 in self.success:
11093 
        iter212.write(oprot)
2690 chandransh 11094 
      oprot.writeListEnd()
11095 
      oprot.writeFieldEnd()
11096 
    oprot.writeFieldStop()
11097 
    oprot.writeStructEnd()
11098 
 
3431 rajveer 11099 
  def validate(self):
11100 
    return
11101 
 
11102 
 
2690 chandransh 11103 
  def __repr__(self):
11104 
    L = ['%s=%r' % (key, value)
11105 
      for key, value in self.__dict__.iteritems()]
11106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11107 
 
11108 
  def __eq__(self, other):
11109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11110 
 
11111 
  def __ne__(self, other):
11112 
    return not (self == other)
11113 
 
2700 chandransh 11114 
class getReturnOrder_args:
11115 
  """
11116 
  Attributes:
11117 
   - id
11118 
  """
11119 
 
11120 
  thrift_spec = (
11121 
    None, # 0
11122 
    (1, TType.I64, 'id', None, None, ), # 1
11123 
  )
11124 
 
11125 
  def __init__(self, id=None,):
11126 
    self.id = id
11127 
 
11128 
  def read(self, iprot):
11129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11131 
      return
11132 
    iprot.readStructBegin()
11133 
    while True:
11134 
      (fname, ftype, fid) = iprot.readFieldBegin()
11135 
      if ftype == TType.STOP:
11136 
        break
11137 
      if fid == 1:
11138 
        if ftype == TType.I64:
11139 
          self.id = iprot.readI64();
11140 
        else:
11141 
          iprot.skip(ftype)
11142 
      else:
11143 
        iprot.skip(ftype)
11144 
      iprot.readFieldEnd()
11145 
    iprot.readStructEnd()
11146 
 
11147 
  def write(self, oprot):
11148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11150 
      return
11151 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 11152 
    if self.id is not None:
2700 chandransh 11153 
      oprot.writeFieldBegin('id', TType.I64, 1)
11154 
      oprot.writeI64(self.id)
11155 
      oprot.writeFieldEnd()
11156 
    oprot.writeFieldStop()
11157 
    oprot.writeStructEnd()
11158 
 
3431 rajveer 11159 
  def validate(self):
11160 
    return
11161 
 
11162 
 
2700 chandransh 11163 
  def __repr__(self):
11164 
    L = ['%s=%r' % (key, value)
11165 
      for key, value in self.__dict__.iteritems()]
11166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11167 
 
11168 
  def __eq__(self, other):
11169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11170 
 
11171 
  def __ne__(self, other):
11172 
    return not (self == other)
11173 
 
11174 
class getReturnOrder_result:
11175 
  """
11176 
  Attributes:
11177 
   - success
11178 
   - ex
11179 
  """
11180 
 
11181 
  thrift_spec = (
11182 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
11183 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11184 
  )
11185 
 
11186 
  def __init__(self, success=None, ex=None,):
11187 
    self.success = success
11188 
    self.ex = ex
11189 
 
11190 
  def read(self, iprot):
11191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11193 
      return
11194 
    iprot.readStructBegin()
11195 
    while True:
11196 
      (fname, ftype, fid) = iprot.readFieldBegin()
11197 
      if ftype == TType.STOP:
11198 
        break
11199 
      if fid == 0:
11200 
        if ftype == TType.STRUCT:
11201 
          self.success = ReturnOrder()
11202 
          self.success.read(iprot)
11203 
        else:
11204 
          iprot.skip(ftype)
11205 
      elif fid == 1:
11206 
        if ftype == TType.STRUCT:
11207 
          self.ex = TransactionServiceException()
11208 
          self.ex.read(iprot)
11209 
        else:
11210 
          iprot.skip(ftype)
11211 
      else:
11212 
        iprot.skip(ftype)
11213 
      iprot.readFieldEnd()
11214 
    iprot.readStructEnd()
11215 
 
11216 
  def write(self, oprot):
11217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11219 
      return
11220 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 11221 
    if self.success is not None:
2700 chandransh 11222 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11223 
      self.success.write(oprot)
11224 
      oprot.writeFieldEnd()
3431 rajveer 11225 
    if self.ex is not None:
2700 chandransh 11226 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11227 
      self.ex.write(oprot)
11228 
      oprot.writeFieldEnd()
11229 
    oprot.writeFieldStop()
11230 
    oprot.writeStructEnd()
11231 
 
3431 rajveer 11232 
  def validate(self):
11233 
    return
11234 
 
11235 
 
2700 chandransh 11236 
  def __repr__(self):
11237 
    L = ['%s=%r' % (key, value)
11238 
      for key, value in self.__dict__.iteritems()]
11239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11240 
 
11241 
  def __eq__(self, other):
11242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11243 
 
11244 
  def __ne__(self, other):
11245 
    return not (self == other)
11246 
 
2690 chandransh 11247 
class processReturn_args:
11248 
  """
11249 
  Attributes:
11250 
   - returnOrderId
11251 
  """
11252 
 
11253 
  thrift_spec = (
11254 
    None, # 0
11255 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
11256 
  )
11257 
 
11258 
  def __init__(self, returnOrderId=None,):
11259 
    self.returnOrderId = returnOrderId
11260 
 
11261 
  def read(self, iprot):
11262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11264 
      return
11265 
    iprot.readStructBegin()
11266 
    while True:
11267 
      (fname, ftype, fid) = iprot.readFieldBegin()
11268 
      if ftype == TType.STOP:
11269 
        break
11270 
      if fid == 1:
11271 
        if ftype == TType.I64:
11272 
          self.returnOrderId = iprot.readI64();
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('processReturn_args')
3431 rajveer 11285 
    if self.returnOrderId is not None:
2690 chandransh 11286 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
11287 
      oprot.writeI64(self.returnOrderId)
11288 
      oprot.writeFieldEnd()
11289 
    oprot.writeFieldStop()
11290 
    oprot.writeStructEnd()
11291 
 
3431 rajveer 11292 
  def validate(self):
11293 
    return
11294 
 
11295 
 
2690 chandransh 11296 
  def __repr__(self):
11297 
    L = ['%s=%r' % (key, value)
11298 
      for key, value in self.__dict__.iteritems()]
11299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11300 
 
11301 
  def __eq__(self, other):
11302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11303 
 
11304 
  def __ne__(self, other):
11305 
    return not (self == other)
11306 
 
11307 
class processReturn_result:
11308 
  """
11309 
  Attributes:
11310 
   - ex
11311 
  """
11312 
 
11313 
  thrift_spec = (
11314 
    None, # 0
11315 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11316 
  )
11317 
 
11318 
  def __init__(self, ex=None,):
11319 
    self.ex = ex
11320 
 
11321 
  def read(self, iprot):
11322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11324 
      return
11325 
    iprot.readStructBegin()
11326 
    while True:
11327 
      (fname, ftype, fid) = iprot.readFieldBegin()
11328 
      if ftype == TType.STOP:
11329 
        break
11330 
      if fid == 1:
11331 
        if ftype == TType.STRUCT:
11332 
          self.ex = TransactionServiceException()
11333 
          self.ex.read(iprot)
11334 
        else:
11335 
          iprot.skip(ftype)
11336 
      else:
11337 
        iprot.skip(ftype)
11338 
      iprot.readFieldEnd()
11339 
    iprot.readStructEnd()
11340 
 
11341 
  def write(self, oprot):
11342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11344 
      return
11345 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 11346 
    if self.ex is not None:
2690 chandransh 11347 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11348 
      self.ex.write(oprot)
11349 
      oprot.writeFieldEnd()
11350 
    oprot.writeFieldStop()
11351 
    oprot.writeStructEnd()
11352 
 
3431 rajveer 11353 
  def validate(self):
11354 
    return
11355 
 
11356 
 
2690 chandransh 11357 
  def __repr__(self):
11358 
    L = ['%s=%r' % (key, value)
11359 
      for key, value in self.__dict__.iteritems()]
11360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11361 
 
11362 
  def __eq__(self, other):
11363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11364 
 
11365 
  def __ne__(self, other):
11366 
    return not (self == other)
11367 
 
2819 chandransh 11368 
class createPurchaseOrder_args:
11369 
  """
11370 
  Attributes:
11371 
   - warehouseId
11372 
  """
2690 chandransh 11373 
 
2819 chandransh 11374 
  thrift_spec = (
11375 
    None, # 0
11376 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11377 
  )
11378 
 
11379 
  def __init__(self, warehouseId=None,):
11380 
    self.warehouseId = warehouseId
11381 
 
11382 
  def read(self, iprot):
11383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11385 
      return
11386 
    iprot.readStructBegin()
11387 
    while True:
11388 
      (fname, ftype, fid) = iprot.readFieldBegin()
11389 
      if ftype == TType.STOP:
11390 
        break
11391 
      if fid == 1:
11392 
        if ftype == TType.I64:
11393 
          self.warehouseId = iprot.readI64();
11394 
        else:
11395 
          iprot.skip(ftype)
11396 
      else:
11397 
        iprot.skip(ftype)
11398 
      iprot.readFieldEnd()
11399 
    iprot.readStructEnd()
11400 
 
11401 
  def write(self, oprot):
11402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11404 
      return
11405 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 11406 
    if self.warehouseId is not None:
2819 chandransh 11407 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11408 
      oprot.writeI64(self.warehouseId)
11409 
      oprot.writeFieldEnd()
11410 
    oprot.writeFieldStop()
11411 
    oprot.writeStructEnd()
11412 
 
3431 rajveer 11413 
  def validate(self):
11414 
    return
11415 
 
11416 
 
2819 chandransh 11417 
  def __repr__(self):
11418 
    L = ['%s=%r' % (key, value)
11419 
      for key, value in self.__dict__.iteritems()]
11420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11421 
 
11422 
  def __eq__(self, other):
11423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11424 
 
11425 
  def __ne__(self, other):
11426 
    return not (self == other)
11427 
 
11428 
class createPurchaseOrder_result:
11429 
  """
11430 
  Attributes:
11431 
   - success
11432 
   - ex
11433 
  """
11434 
 
11435 
  thrift_spec = (
11436 
    (0, TType.I64, 'success', None, None, ), # 0
11437 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11438 
  )
11439 
 
11440 
  def __init__(self, success=None, ex=None,):
11441 
    self.success = success
11442 
    self.ex = ex
11443 
 
11444 
  def read(self, iprot):
11445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11447 
      return
11448 
    iprot.readStructBegin()
11449 
    while True:
11450 
      (fname, ftype, fid) = iprot.readFieldBegin()
11451 
      if ftype == TType.STOP:
11452 
        break
11453 
      if fid == 0:
11454 
        if ftype == TType.I64:
11455 
          self.success = iprot.readI64();
11456 
        else:
11457 
          iprot.skip(ftype)
11458 
      elif fid == 1:
11459 
        if ftype == TType.STRUCT:
11460 
          self.ex = TransactionServiceException()
11461 
          self.ex.read(iprot)
11462 
        else:
11463 
          iprot.skip(ftype)
11464 
      else:
11465 
        iprot.skip(ftype)
11466 
      iprot.readFieldEnd()
11467 
    iprot.readStructEnd()
11468 
 
11469 
  def write(self, oprot):
11470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11472 
      return
11473 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 11474 
    if self.success is not None:
2819 chandransh 11475 
      oprot.writeFieldBegin('success', TType.I64, 0)
11476 
      oprot.writeI64(self.success)
11477 
      oprot.writeFieldEnd()
3431 rajveer 11478 
    if self.ex is not None:
2819 chandransh 11479 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11480 
      self.ex.write(oprot)
11481 
      oprot.writeFieldEnd()
11482 
    oprot.writeFieldStop()
11483 
    oprot.writeStructEnd()
11484 
 
3431 rajveer 11485 
  def validate(self):
11486 
    return
11487 
 
11488 
 
2819 chandransh 11489 
  def __repr__(self):
11490 
    L = ['%s=%r' % (key, value)
11491 
      for key, value in self.__dict__.iteritems()]
11492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11493 
 
11494 
  def __eq__(self, other):
11495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11496 
 
11497 
  def __ne__(self, other):
11498 
    return not (self == other)
3451 chandransh 11499 
 
11500 
class updateWeight_args:
11501 
  """
11502 
  Attributes:
11503 
   - orderId
11504 
   - weight
11505 
  """
11506 
 
11507 
  thrift_spec = (
11508 
    None, # 0
11509 
    (1, TType.I64, 'orderId', None, None, ), # 1
11510 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
11511 
  )
11512 
 
11513 
  def __init__(self, orderId=None, weight=None,):
11514 
    self.orderId = orderId
11515 
    self.weight = weight
11516 
 
11517 
  def read(self, iprot):
11518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11520 
      return
11521 
    iprot.readStructBegin()
11522 
    while True:
11523 
      (fname, ftype, fid) = iprot.readFieldBegin()
11524 
      if ftype == TType.STOP:
11525 
        break
11526 
      if fid == 1:
11527 
        if ftype == TType.I64:
11528 
          self.orderId = iprot.readI64();
11529 
        else:
11530 
          iprot.skip(ftype)
11531 
      elif fid == 2:
11532 
        if ftype == TType.DOUBLE:
11533 
          self.weight = iprot.readDouble();
11534 
        else:
11535 
          iprot.skip(ftype)
11536 
      else:
11537 
        iprot.skip(ftype)
11538 
      iprot.readFieldEnd()
11539 
    iprot.readStructEnd()
11540 
 
11541 
  def write(self, oprot):
11542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11544 
      return
11545 
    oprot.writeStructBegin('updateWeight_args')
11546 
    if self.orderId is not None:
11547 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11548 
      oprot.writeI64(self.orderId)
11549 
      oprot.writeFieldEnd()
11550 
    if self.weight is not None:
11551 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
11552 
      oprot.writeDouble(self.weight)
11553 
      oprot.writeFieldEnd()
11554 
    oprot.writeFieldStop()
11555 
    oprot.writeStructEnd()
11556 
 
11557 
  def validate(self):
11558 
    return
11559 
 
11560 
 
11561 
  def __repr__(self):
11562 
    L = ['%s=%r' % (key, value)
11563 
      for key, value in self.__dict__.iteritems()]
11564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11565 
 
11566 
  def __eq__(self, other):
11567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11568 
 
11569 
  def __ne__(self, other):
11570 
    return not (self == other)
11571 
 
11572 
class updateWeight_result:
11573 
  """
11574 
  Attributes:
11575 
   - success
11576 
   - ex
11577 
  """
11578 
 
11579 
  thrift_spec = (
11580 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11581 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11582 
  )
11583 
 
11584 
  def __init__(self, success=None, ex=None,):
11585 
    self.success = success
11586 
    self.ex = ex
11587 
 
11588 
  def read(self, iprot):
11589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11591 
      return
11592 
    iprot.readStructBegin()
11593 
    while True:
11594 
      (fname, ftype, fid) = iprot.readFieldBegin()
11595 
      if ftype == TType.STOP:
11596 
        break
11597 
      if fid == 0:
11598 
        if ftype == TType.STRUCT:
11599 
          self.success = Order()
11600 
          self.success.read(iprot)
11601 
        else:
11602 
          iprot.skip(ftype)
11603 
      elif fid == 1:
11604 
        if ftype == TType.STRUCT:
11605 
          self.ex = TransactionServiceException()
11606 
          self.ex.read(iprot)
11607 
        else:
11608 
          iprot.skip(ftype)
11609 
      else:
11610 
        iprot.skip(ftype)
11611 
      iprot.readFieldEnd()
11612 
    iprot.readStructEnd()
11613 
 
11614 
  def write(self, oprot):
11615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11617 
      return
11618 
    oprot.writeStructBegin('updateWeight_result')
11619 
    if self.success is not None:
11620 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11621 
      self.success.write(oprot)
11622 
      oprot.writeFieldEnd()
11623 
    if self.ex is not None:
11624 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11625 
      self.ex.write(oprot)
11626 
      oprot.writeFieldEnd()
11627 
    oprot.writeFieldStop()
11628 
    oprot.writeStructEnd()
11629 
 
11630 
  def validate(self):
11631 
    return
11632 
 
11633 
 
11634 
  def __repr__(self):
11635 
    L = ['%s=%r' % (key, value)
11636 
      for key, value in self.__dict__.iteritems()]
11637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11638 
 
11639 
  def __eq__(self, other):
11640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11641 
 
11642 
  def __ne__(self, other):
11643 
    return not (self == other)
3469 chandransh 11644 
 
11645 
class changeItem_args:
11646 
  """
11647 
  Attributes:
11648 
   - orderId
11649 
   - itemId
11650 
  """
11651 
 
11652 
  thrift_spec = (
11653 
    None, # 0
11654 
    (1, TType.I64, 'orderId', None, None, ), # 1
11655 
    (2, TType.I64, 'itemId', None, None, ), # 2
11656 
  )
11657 
 
11658 
  def __init__(self, orderId=None, itemId=None,):
11659 
    self.orderId = orderId
11660 
    self.itemId = itemId
11661 
 
11662 
  def read(self, iprot):
11663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11665 
      return
11666 
    iprot.readStructBegin()
11667 
    while True:
11668 
      (fname, ftype, fid) = iprot.readFieldBegin()
11669 
      if ftype == TType.STOP:
11670 
        break
11671 
      if fid == 1:
11672 
        if ftype == TType.I64:
11673 
          self.orderId = iprot.readI64();
11674 
        else:
11675 
          iprot.skip(ftype)
11676 
      elif fid == 2:
11677 
        if ftype == TType.I64:
11678 
          self.itemId = iprot.readI64();
11679 
        else:
11680 
          iprot.skip(ftype)
11681 
      else:
11682 
        iprot.skip(ftype)
11683 
      iprot.readFieldEnd()
11684 
    iprot.readStructEnd()
11685 
 
11686 
  def write(self, oprot):
11687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11689 
      return
11690 
    oprot.writeStructBegin('changeItem_args')
11691 
    if self.orderId is not None:
11692 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11693 
      oprot.writeI64(self.orderId)
11694 
      oprot.writeFieldEnd()
11695 
    if self.itemId is not None:
11696 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11697 
      oprot.writeI64(self.itemId)
11698 
      oprot.writeFieldEnd()
11699 
    oprot.writeFieldStop()
11700 
    oprot.writeStructEnd()
11701 
 
11702 
  def validate(self):
11703 
    return
11704 
 
11705 
 
11706 
  def __repr__(self):
11707 
    L = ['%s=%r' % (key, value)
11708 
      for key, value in self.__dict__.iteritems()]
11709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11710 
 
11711 
  def __eq__(self, other):
11712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11713 
 
11714 
  def __ne__(self, other):
11715 
    return not (self == other)
11716 
 
11717 
class changeItem_result:
11718 
  """
11719 
  Attributes:
11720 
   - success
11721 
   - ex
11722 
  """
11723 
 
11724 
  thrift_spec = (
11725 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11726 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11727 
  )
11728 
 
11729 
  def __init__(self, success=None, ex=None,):
11730 
    self.success = success
11731 
    self.ex = ex
11732 
 
11733 
  def read(self, iprot):
11734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11736 
      return
11737 
    iprot.readStructBegin()
11738 
    while True:
11739 
      (fname, ftype, fid) = iprot.readFieldBegin()
11740 
      if ftype == TType.STOP:
11741 
        break
11742 
      if fid == 0:
11743 
        if ftype == TType.STRUCT:
11744 
          self.success = Order()
11745 
          self.success.read(iprot)
11746 
        else:
11747 
          iprot.skip(ftype)
11748 
      elif fid == 1:
11749 
        if ftype == TType.STRUCT:
11750 
          self.ex = TransactionServiceException()
11751 
          self.ex.read(iprot)
11752 
        else:
11753 
          iprot.skip(ftype)
11754 
      else:
11755 
        iprot.skip(ftype)
11756 
      iprot.readFieldEnd()
11757 
    iprot.readStructEnd()
11758 
 
11759 
  def write(self, oprot):
11760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11762 
      return
11763 
    oprot.writeStructBegin('changeItem_result')
11764 
    if self.success is not None:
11765 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11766 
      self.success.write(oprot)
11767 
      oprot.writeFieldEnd()
11768 
    if self.ex is not None:
11769 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11770 
      self.ex.write(oprot)
11771 
      oprot.writeFieldEnd()
11772 
    oprot.writeFieldStop()
11773 
    oprot.writeStructEnd()
11774 
 
11775 
  def validate(self):
11776 
    return
11777 
 
11778 
 
11779 
  def __repr__(self):
11780 
    L = ['%s=%r' % (key, value)
11781 
      for key, value in self.__dict__.iteritems()]
11782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11783 
 
11784 
  def __eq__(self, other):
11785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11786 
 
11787 
  def __ne__(self, other):
11788 
    return not (self == other)
11789 
 
11790 
class shiftToWarehouse_args:
11791 
  """
11792 
  Attributes:
11793 
   - orderId
11794 
   - warehouseId
11795 
  """
11796 
 
11797 
  thrift_spec = (
11798 
    None, # 0
11799 
    (1, TType.I64, 'orderId', None, None, ), # 1
11800 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11801 
  )
11802 
 
11803 
  def __init__(self, orderId=None, warehouseId=None,):
11804 
    self.orderId = orderId
11805 
    self.warehouseId = warehouseId
11806 
 
11807 
  def read(self, iprot):
11808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11810 
      return
11811 
    iprot.readStructBegin()
11812 
    while True:
11813 
      (fname, ftype, fid) = iprot.readFieldBegin()
11814 
      if ftype == TType.STOP:
11815 
        break
11816 
      if fid == 1:
11817 
        if ftype == TType.I64:
11818 
          self.orderId = iprot.readI64();
11819 
        else:
11820 
          iprot.skip(ftype)
11821 
      elif fid == 2:
11822 
        if ftype == TType.I64:
11823 
          self.warehouseId = iprot.readI64();
11824 
        else:
11825 
          iprot.skip(ftype)
11826 
      else:
11827 
        iprot.skip(ftype)
11828 
      iprot.readFieldEnd()
11829 
    iprot.readStructEnd()
11830 
 
11831 
  def write(self, oprot):
11832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11834 
      return
11835 
    oprot.writeStructBegin('shiftToWarehouse_args')
11836 
    if self.orderId is not None:
11837 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11838 
      oprot.writeI64(self.orderId)
11839 
      oprot.writeFieldEnd()
11840 
    if self.warehouseId is not None:
11841 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11842 
      oprot.writeI64(self.warehouseId)
11843 
      oprot.writeFieldEnd()
11844 
    oprot.writeFieldStop()
11845 
    oprot.writeStructEnd()
11846 
 
11847 
  def validate(self):
11848 
    return
11849 
 
11850 
 
11851 
  def __repr__(self):
11852 
    L = ['%s=%r' % (key, value)
11853 
      for key, value in self.__dict__.iteritems()]
11854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11855 
 
11856 
  def __eq__(self, other):
11857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11858 
 
11859 
  def __ne__(self, other):
11860 
    return not (self == other)
11861 
 
11862 
class shiftToWarehouse_result:
11863 
  """
11864 
  Attributes:
11865 
   - success
11866 
   - ex
11867 
  """
11868 
 
11869 
  thrift_spec = (
11870 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11871 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11872 
  )
11873 
 
11874 
  def __init__(self, success=None, ex=None,):
11875 
    self.success = success
11876 
    self.ex = ex
11877 
 
11878 
  def read(self, iprot):
11879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11881 
      return
11882 
    iprot.readStructBegin()
11883 
    while True:
11884 
      (fname, ftype, fid) = iprot.readFieldBegin()
11885 
      if ftype == TType.STOP:
11886 
        break
11887 
      if fid == 0:
11888 
        if ftype == TType.STRUCT:
11889 
          self.success = Order()
11890 
          self.success.read(iprot)
11891 
        else:
11892 
          iprot.skip(ftype)
11893 
      elif fid == 1:
11894 
        if ftype == TType.STRUCT:
11895 
          self.ex = TransactionServiceException()
11896 
          self.ex.read(iprot)
11897 
        else:
11898 
          iprot.skip(ftype)
11899 
      else:
11900 
        iprot.skip(ftype)
11901 
      iprot.readFieldEnd()
11902 
    iprot.readStructEnd()
11903 
 
11904 
  def write(self, oprot):
11905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11907 
      return
11908 
    oprot.writeStructBegin('shiftToWarehouse_result')
11909 
    if self.success is not None:
11910 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11911 
      self.success.write(oprot)
11912 
      oprot.writeFieldEnd()
11913 
    if self.ex is not None:
11914 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11915 
      self.ex.write(oprot)
11916 
      oprot.writeFieldEnd()
11917 
    oprot.writeFieldStop()
11918 
    oprot.writeStructEnd()
11919 
 
11920 
  def validate(self):
11921 
    return
11922 
 
11923 
 
11924 
  def __repr__(self):
11925 
    L = ['%s=%r' % (key, value)
11926 
      for key, value in self.__dict__.iteritems()]
11927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11928 
 
11929 
  def __eq__(self, other):
11930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11931 
 
11932 
  def __ne__(self, other):
11933 
    return not (self == other)
3553 chandransh 11934 
 
11935 
class addDelayReason_args:
11936 
  """
11937 
  Attributes:
11938 
   - orderId
11939 
   - delayReason
3986 chandransh 11940 
   - furtherDelay
3553 chandransh 11941 
  """
11942 
 
11943 
  thrift_spec = (
11944 
    None, # 0
11945 
    (1, TType.I64, 'orderId', None, None, ), # 1
11946 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 11947 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 11948 
  )
11949 
 
3986 chandransh 11950 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 11951 
    self.orderId = orderId
11952 
    self.delayReason = delayReason
3986 chandransh 11953 
    self.furtherDelay = furtherDelay
3553 chandransh 11954 
 
11955 
  def read(self, iprot):
11956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11958 
      return
11959 
    iprot.readStructBegin()
11960 
    while True:
11961 
      (fname, ftype, fid) = iprot.readFieldBegin()
11962 
      if ftype == TType.STOP:
11963 
        break
11964 
      if fid == 1:
11965 
        if ftype == TType.I64:
11966 
          self.orderId = iprot.readI64();
11967 
        else:
11968 
          iprot.skip(ftype)
11969 
      elif fid == 2:
11970 
        if ftype == TType.I32:
11971 
          self.delayReason = iprot.readI32();
11972 
        else:
11973 
          iprot.skip(ftype)
3986 chandransh 11974 
      elif fid == 3:
11975 
        if ftype == TType.I64:
11976 
          self.furtherDelay = iprot.readI64();
11977 
        else:
11978 
          iprot.skip(ftype)
3553 chandransh 11979 
      else:
11980 
        iprot.skip(ftype)
11981 
      iprot.readFieldEnd()
11982 
    iprot.readStructEnd()
11983 
 
11984 
  def write(self, oprot):
11985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11987 
      return
11988 
    oprot.writeStructBegin('addDelayReason_args')
11989 
    if self.orderId is not None:
11990 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11991 
      oprot.writeI64(self.orderId)
11992 
      oprot.writeFieldEnd()
11993 
    if self.delayReason is not None:
11994 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
11995 
      oprot.writeI32(self.delayReason)
11996 
      oprot.writeFieldEnd()
3986 chandransh 11997 
    if self.furtherDelay is not None:
11998 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
11999 
      oprot.writeI64(self.furtherDelay)
12000 
      oprot.writeFieldEnd()
3553 chandransh 12001 
    oprot.writeFieldStop()
12002 
    oprot.writeStructEnd()
12003 
 
12004 
  def validate(self):
12005 
    return
12006 
 
12007 
 
12008 
  def __repr__(self):
12009 
    L = ['%s=%r' % (key, value)
12010 
      for key, value in self.__dict__.iteritems()]
12011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12012 
 
12013 
  def __eq__(self, other):
12014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12015 
 
12016 
  def __ne__(self, other):
12017 
    return not (self == other)
12018 
 
12019 
class addDelayReason_result:
12020 
  """
12021 
  Attributes:
12022 
   - success
12023 
   - ex
12024 
  """
12025 
 
12026 
  thrift_spec = (
12027 
    (0, TType.BOOL, 'success', None, None, ), # 0
12028 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12029 
  )
12030 
 
12031 
  def __init__(self, success=None, ex=None,):
12032 
    self.success = success
12033 
    self.ex = ex
12034 
 
12035 
  def read(self, iprot):
12036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12038 
      return
12039 
    iprot.readStructBegin()
12040 
    while True:
12041 
      (fname, ftype, fid) = iprot.readFieldBegin()
12042 
      if ftype == TType.STOP:
12043 
        break
12044 
      if fid == 0:
12045 
        if ftype == TType.BOOL:
12046 
          self.success = iprot.readBool();
12047 
        else:
12048 
          iprot.skip(ftype)
12049 
      elif fid == 1:
12050 
        if ftype == TType.STRUCT:
12051 
          self.ex = TransactionServiceException()
12052 
          self.ex.read(iprot)
12053 
        else:
12054 
          iprot.skip(ftype)
12055 
      else:
12056 
        iprot.skip(ftype)
12057 
      iprot.readFieldEnd()
12058 
    iprot.readStructEnd()
12059 
 
12060 
  def write(self, oprot):
12061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12063 
      return
12064 
    oprot.writeStructBegin('addDelayReason_result')
12065 
    if self.success is not None:
12066 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12067 
      oprot.writeBool(self.success)
12068 
      oprot.writeFieldEnd()
12069 
    if self.ex is not None:
12070 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12071 
      self.ex.write(oprot)
12072 
      oprot.writeFieldEnd()
12073 
    oprot.writeFieldStop()
12074 
    oprot.writeStructEnd()
12075 
 
12076 
  def validate(self):
12077 
    return
12078 
 
12079 
 
12080 
  def __repr__(self):
12081 
    L = ['%s=%r' % (key, value)
12082 
      for key, value in self.__dict__.iteritems()]
12083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12084 
 
12085 
  def __eq__(self, other):
12086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12087 
 
12088 
  def __ne__(self, other):
12089 
    return not (self == other)
3956 chandransh 12090 
 
12091 
class reconcileCodCollection_args:
12092 
  """
12093 
  Attributes:
12094 
   - collectedAmountMap
12095 
   - xferBy
12096 
   - xferTxnId
12097 
   - xferDate
12098 
  """
12099 
 
12100 
  thrift_spec = (
12101 
    None, # 0
12102 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
12103 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
12104 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
12105 
    (4, TType.I64, 'xferDate', None, None, ), # 4
12106 
  )
12107 
 
12108 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
12109 
    self.collectedAmountMap = collectedAmountMap
12110 
    self.xferBy = xferBy
12111 
    self.xferTxnId = xferTxnId
12112 
    self.xferDate = xferDate
12113 
 
12114 
  def read(self, iprot):
12115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12117 
      return
12118 
    iprot.readStructBegin()
12119 
    while True:
12120 
      (fname, ftype, fid) = iprot.readFieldBegin()
12121 
      if ftype == TType.STOP:
12122 
        break
12123 
      if fid == 1:
12124 
        if ftype == TType.MAP:
12125 
          self.collectedAmountMap = {}
4133 chandransh 12126 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
12127 
          for _i217 in xrange(_size213):
12128 
            _key218 = iprot.readString();
12129 
            _val219 = iprot.readDouble();
12130 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 12131 
          iprot.readMapEnd()
12132 
        else:
12133 
          iprot.skip(ftype)
12134 
      elif fid == 2:
12135 
        if ftype == TType.STRING:
12136 
          self.xferBy = iprot.readString();
12137 
        else:
12138 
          iprot.skip(ftype)
12139 
      elif fid == 3:
12140 
        if ftype == TType.STRING:
12141 
          self.xferTxnId = iprot.readString();
12142 
        else:
12143 
          iprot.skip(ftype)
12144 
      elif fid == 4:
12145 
        if ftype == TType.I64:
12146 
          self.xferDate = iprot.readI64();
12147 
        else:
12148 
          iprot.skip(ftype)
12149 
      else:
12150 
        iprot.skip(ftype)
12151 
      iprot.readFieldEnd()
12152 
    iprot.readStructEnd()
12153 
 
12154 
  def write(self, oprot):
12155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12157 
      return
12158 
    oprot.writeStructBegin('reconcileCodCollection_args')
12159 
    if self.collectedAmountMap is not None:
12160 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
12161 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 12162 
      for kiter220,viter221 in self.collectedAmountMap.items():
12163 
        oprot.writeString(kiter220)
12164 
        oprot.writeDouble(viter221)
3956 chandransh 12165 
      oprot.writeMapEnd()
12166 
      oprot.writeFieldEnd()
12167 
    if self.xferBy is not None:
12168 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
12169 
      oprot.writeString(self.xferBy)
12170 
      oprot.writeFieldEnd()
12171 
    if self.xferTxnId is not None:
12172 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
12173 
      oprot.writeString(self.xferTxnId)
12174 
      oprot.writeFieldEnd()
12175 
    if self.xferDate is not None:
12176 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
12177 
      oprot.writeI64(self.xferDate)
12178 
      oprot.writeFieldEnd()
12179 
    oprot.writeFieldStop()
12180 
    oprot.writeStructEnd()
12181 
 
12182 
  def validate(self):
12183 
    return
12184 
 
12185 
 
12186 
  def __repr__(self):
12187 
    L = ['%s=%r' % (key, value)
12188 
      for key, value in self.__dict__.iteritems()]
12189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12190 
 
12191 
  def __eq__(self, other):
12192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12193 
 
12194 
  def __ne__(self, other):
12195 
    return not (self == other)
12196 
 
12197 
class reconcileCodCollection_result:
12198 
  """
12199 
  Attributes:
12200 
   - success
12201 
   - ex
12202 
  """
12203 
 
12204 
  thrift_spec = (
12205 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
12206 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12207 
  )
12208 
 
12209 
  def __init__(self, success=None, ex=None,):
12210 
    self.success = success
12211 
    self.ex = ex
12212 
 
12213 
  def read(self, iprot):
12214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12216 
      return
12217 
    iprot.readStructBegin()
12218 
    while True:
12219 
      (fname, ftype, fid) = iprot.readFieldBegin()
12220 
      if ftype == TType.STOP:
12221 
        break
12222 
      if fid == 0:
12223 
        if ftype == TType.MAP:
12224 
          self.success = {}
4133 chandransh 12225 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
12226 
          for _i226 in xrange(_size222):
12227 
            _key227 = iprot.readString();
12228 
            _val228 = iprot.readString();
12229 
            self.success[_key227] = _val228
3956 chandransh 12230 
          iprot.readMapEnd()
12231 
        else:
12232 
          iprot.skip(ftype)
12233 
      elif fid == 1:
12234 
        if ftype == TType.STRUCT:
12235 
          self.ex = TransactionServiceException()
12236 
          self.ex.read(iprot)
12237 
        else:
12238 
          iprot.skip(ftype)
12239 
      else:
12240 
        iprot.skip(ftype)
12241 
      iprot.readFieldEnd()
12242 
    iprot.readStructEnd()
12243 
 
12244 
  def write(self, oprot):
12245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12247 
      return
12248 
    oprot.writeStructBegin('reconcileCodCollection_result')
12249 
    if self.success is not None:
12250 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12251 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 12252 
      for kiter229,viter230 in self.success.items():
12253 
        oprot.writeString(kiter229)
12254 
        oprot.writeString(viter230)
3956 chandransh 12255 
      oprot.writeMapEnd()
12256 
      oprot.writeFieldEnd()
12257 
    if self.ex is not None:
12258 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12259 
      self.ex.write(oprot)
12260 
      oprot.writeFieldEnd()
12261 
    oprot.writeFieldStop()
12262 
    oprot.writeStructEnd()
12263 
 
12264 
  def validate(self):
12265 
    return
12266 
 
12267 
 
12268 
  def __repr__(self):
12269 
    L = ['%s=%r' % (key, value)
12270 
      for key, value in self.__dict__.iteritems()]
12271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12272 
 
12273 
  def __eq__(self, other):
12274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12275 
 
12276 
  def __ne__(self, other):
12277 
    return not (self == other)
4008 mandeep.dh 12278 
 
12279 
class getTransactionsRequiringExtraProcessing_args:
12280 
  """
12281 
  Attributes:
12282 
   - category
12283 
  """
12284 
 
12285 
  thrift_spec = (
12286 
    None, # 0
12287 
    (1, TType.I32, 'category', None, None, ), # 1
12288 
  )
12289 
 
12290 
  def __init__(self, category=None,):
12291 
    self.category = category
12292 
 
12293 
  def read(self, iprot):
12294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12296 
      return
12297 
    iprot.readStructBegin()
12298 
    while True:
12299 
      (fname, ftype, fid) = iprot.readFieldBegin()
12300 
      if ftype == TType.STOP:
12301 
        break
12302 
      if fid == 1:
12303 
        if ftype == TType.I32:
12304 
          self.category = iprot.readI32();
12305 
        else:
12306 
          iprot.skip(ftype)
12307 
      else:
12308 
        iprot.skip(ftype)
12309 
      iprot.readFieldEnd()
12310 
    iprot.readStructEnd()
12311 
 
12312 
  def write(self, oprot):
12313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12315 
      return
12316 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
12317 
    if self.category is not None:
12318 
      oprot.writeFieldBegin('category', TType.I32, 1)
12319 
      oprot.writeI32(self.category)
12320 
      oprot.writeFieldEnd()
12321 
    oprot.writeFieldStop()
12322 
    oprot.writeStructEnd()
12323 
 
12324 
  def validate(self):
12325 
    return
12326 
 
12327 
 
12328 
  def __repr__(self):
12329 
    L = ['%s=%r' % (key, value)
12330 
      for key, value in self.__dict__.iteritems()]
12331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12332 
 
12333 
  def __eq__(self, other):
12334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12335 
 
12336 
  def __ne__(self, other):
12337 
    return not (self == other)
12338 
 
12339 
class getTransactionsRequiringExtraProcessing_result:
12340 
  """
12341 
  Attributes:
12342 
   - success
12343 
  """
12344 
 
12345 
  thrift_spec = (
12346 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12347 
  )
12348 
 
12349 
  def __init__(self, success=None,):
12350 
    self.success = success
12351 
 
12352 
  def read(self, iprot):
12353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12355 
      return
12356 
    iprot.readStructBegin()
12357 
    while True:
12358 
      (fname, ftype, fid) = iprot.readFieldBegin()
12359 
      if ftype == TType.STOP:
12360 
        break
12361 
      if fid == 0:
12362 
        if ftype == TType.LIST:
12363 
          self.success = []
4133 chandransh 12364 
          (_etype234, _size231) = iprot.readListBegin()
12365 
          for _i235 in xrange(_size231):
12366 
            _elem236 = iprot.readI64();
12367 
            self.success.append(_elem236)
4008 mandeep.dh 12368 
          iprot.readListEnd()
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_result')
12381 
    if self.success is not None:
12382 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12383 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 12384 
      for iter237 in self.success:
12385 
        oprot.writeI64(iter237)
4008 mandeep.dh 12386 
      oprot.writeListEnd()
12387 
      oprot.writeFieldEnd()
12388 
    oprot.writeFieldStop()
12389 
    oprot.writeStructEnd()
12390 
 
12391 
  def validate(self):
12392 
    return
12393 
 
12394 
 
12395 
  def __repr__(self):
12396 
    L = ['%s=%r' % (key, value)
12397 
      for key, value in self.__dict__.iteritems()]
12398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12399 
 
12400 
  def __eq__(self, other):
12401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12402 
 
12403 
  def __ne__(self, other):
12404 
    return not (self == other)
12405 
 
12406 
class markTransactionAsProcessed_args:
12407 
  """
12408 
  Attributes:
12409 
   - transactionId
12410 
   - category
12411 
  """
12412 
 
12413 
  thrift_spec = (
12414 
    None, # 0
12415 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12416 
    (2, TType.I32, 'category', None, None, ), # 2
12417 
  )
12418 
 
12419 
  def __init__(self, transactionId=None, category=None,):
12420 
    self.transactionId = transactionId
12421 
    self.category = category
12422 
 
12423 
  def read(self, iprot):
12424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12426 
      return
12427 
    iprot.readStructBegin()
12428 
    while True:
12429 
      (fname, ftype, fid) = iprot.readFieldBegin()
12430 
      if ftype == TType.STOP:
12431 
        break
12432 
      if fid == 1:
12433 
        if ftype == TType.I64:
12434 
          self.transactionId = iprot.readI64();
12435 
        else:
12436 
          iprot.skip(ftype)
12437 
      elif fid == 2:
12438 
        if ftype == TType.I32:
12439 
          self.category = iprot.readI32();
12440 
        else:
12441 
          iprot.skip(ftype)
12442 
      else:
12443 
        iprot.skip(ftype)
12444 
      iprot.readFieldEnd()
12445 
    iprot.readStructEnd()
12446 
 
12447 
  def write(self, oprot):
12448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12450 
      return
12451 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
12452 
    if self.transactionId is not None:
12453 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12454 
      oprot.writeI64(self.transactionId)
12455 
      oprot.writeFieldEnd()
12456 
    if self.category is not None:
12457 
      oprot.writeFieldBegin('category', TType.I32, 2)
12458 
      oprot.writeI32(self.category)
12459 
      oprot.writeFieldEnd()
12460 
    oprot.writeFieldStop()
12461 
    oprot.writeStructEnd()
12462 
 
12463 
  def validate(self):
12464 
    return
12465 
 
12466 
 
12467 
  def __repr__(self):
12468 
    L = ['%s=%r' % (key, value)
12469 
      for key, value in self.__dict__.iteritems()]
12470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12471 
 
12472 
  def __eq__(self, other):
12473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12474 
 
12475 
  def __ne__(self, other):
12476 
    return not (self == other)
12477 
 
12478 
class markTransactionAsProcessed_result:
12479 
 
12480 
  thrift_spec = (
12481 
  )
12482 
 
12483 
  def read(self, iprot):
12484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12486 
      return
12487 
    iprot.readStructBegin()
12488 
    while True:
12489 
      (fname, ftype, fid) = iprot.readFieldBegin()
12490 
      if ftype == TType.STOP:
12491 
        break
12492 
      else:
12493 
        iprot.skip(ftype)
12494 
      iprot.readFieldEnd()
12495 
    iprot.readStructEnd()
12496 
 
12497 
  def write(self, oprot):
12498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12500 
      return
12501 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
12502 
    oprot.writeFieldStop()
12503 
    oprot.writeStructEnd()
12504 
 
12505 
  def validate(self):
12506 
    return
12507 
 
12508 
 
12509 
  def __repr__(self):
12510 
    L = ['%s=%r' % (key, value)
12511 
      for key, value in self.__dict__.iteritems()]
12512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12513 
 
12514 
  def __eq__(self, other):
12515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12516 
 
12517 
  def __ne__(self, other):
12518 
    return not (self == other)
4018 chandransh 12519 
 
12520 
class getItemWiseRiskyOrdersCount_args:
12521 
 
12522 
  thrift_spec = (
12523 
  )
12524 
 
12525 
  def read(self, iprot):
12526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12528 
      return
12529 
    iprot.readStructBegin()
12530 
    while True:
12531 
      (fname, ftype, fid) = iprot.readFieldBegin()
12532 
      if ftype == TType.STOP:
12533 
        break
12534 
      else:
12535 
        iprot.skip(ftype)
12536 
      iprot.readFieldEnd()
12537 
    iprot.readStructEnd()
12538 
 
12539 
  def write(self, oprot):
12540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12542 
      return
12543 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
12544 
    oprot.writeFieldStop()
12545 
    oprot.writeStructEnd()
12546 
 
12547 
  def validate(self):
12548 
    return
12549 
 
12550 
 
12551 
  def __repr__(self):
12552 
    L = ['%s=%r' % (key, value)
12553 
      for key, value in self.__dict__.iteritems()]
12554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12555 
 
12556 
  def __eq__(self, other):
12557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12558 
 
12559 
  def __ne__(self, other):
12560 
    return not (self == other)
12561 
 
12562 
class getItemWiseRiskyOrdersCount_result:
12563 
  """
12564 
  Attributes:
12565 
   - success
12566 
  """
12567 
 
12568 
  thrift_spec = (
12569 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
12570 
  )
12571 
 
12572 
  def __init__(self, success=None,):
12573 
    self.success = success
12574 
 
12575 
  def read(self, iprot):
12576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12578 
      return
12579 
    iprot.readStructBegin()
12580 
    while True:
12581 
      (fname, ftype, fid) = iprot.readFieldBegin()
12582 
      if ftype == TType.STOP:
12583 
        break
12584 
      if fid == 0:
12585 
        if ftype == TType.MAP:
12586 
          self.success = {}
4133 chandransh 12587 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
12588 
          for _i242 in xrange(_size238):
12589 
            _key243 = iprot.readI64();
12590 
            _val244 = iprot.readI64();
12591 
            self.success[_key243] = _val244
4018 chandransh 12592 
          iprot.readMapEnd()
12593 
        else:
12594 
          iprot.skip(ftype)
12595 
      else:
12596 
        iprot.skip(ftype)
12597 
      iprot.readFieldEnd()
12598 
    iprot.readStructEnd()
12599 
 
12600 
  def write(self, oprot):
12601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12603 
      return
12604 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
12605 
    if self.success is not None:
12606 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12607 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 12608 
      for kiter245,viter246 in self.success.items():
12609 
        oprot.writeI64(kiter245)
12610 
        oprot.writeI64(viter246)
4018 chandransh 12611 
      oprot.writeMapEnd()
12612 
      oprot.writeFieldEnd()
12613 
    oprot.writeFieldStop()
12614 
    oprot.writeStructEnd()
12615 
 
12616 
  def validate(self):
12617 
    return
12618 
 
12619 
 
12620 
  def __repr__(self):
12621 
    L = ['%s=%r' % (key, value)
12622 
      for key, value in self.__dict__.iteritems()]
12623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12624 
 
12625 
  def __eq__(self, other):
12626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12627 
 
12628 
  def __ne__(self, other):
12629 
    return not (self == other)
4247 rajveer 12630 
 
12631 
class markOrderCancellationRequestReceived_args:
12632 
  """
12633 
  Attributes:
12634 
   - orderId
12635 
  """
12636 
 
12637 
  thrift_spec = (
12638 
    None, # 0
12639 
    (1, TType.I64, 'orderId', None, None, ), # 1
12640 
  )
12641 
 
12642 
  def __init__(self, orderId=None,):
12643 
    self.orderId = orderId
12644 
 
12645 
  def read(self, iprot):
12646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12648 
      return
12649 
    iprot.readStructBegin()
12650 
    while True:
12651 
      (fname, ftype, fid) = iprot.readFieldBegin()
12652 
      if ftype == TType.STOP:
12653 
        break
12654 
      if fid == 1:
12655 
        if ftype == TType.I64:
12656 
          self.orderId = iprot.readI64();
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('markOrderCancellationRequestReceived_args')
12669 
    if self.orderId is not None:
12670 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12671 
      oprot.writeI64(self.orderId)
12672 
      oprot.writeFieldEnd()
12673 
    oprot.writeFieldStop()
12674 
    oprot.writeStructEnd()
12675 
 
12676 
  def validate(self):
12677 
    return
12678 
 
12679 
 
12680 
  def __repr__(self):
12681 
    L = ['%s=%r' % (key, value)
12682 
      for key, value in self.__dict__.iteritems()]
12683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12684 
 
12685 
  def __eq__(self, other):
12686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12687 
 
12688 
  def __ne__(self, other):
12689 
    return not (self == other)
12690 
 
12691 
class markOrderCancellationRequestReceived_result:
12692 
  """
12693 
  Attributes:
12694 
   - ex
12695 
  """
12696 
 
12697 
  thrift_spec = (
12698 
    None, # 0
12699 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12700 
  )
12701 
 
12702 
  def __init__(self, ex=None,):
12703 
    self.ex = ex
12704 
 
12705 
  def read(self, iprot):
12706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12708 
      return
12709 
    iprot.readStructBegin()
12710 
    while True:
12711 
      (fname, ftype, fid) = iprot.readFieldBegin()
12712 
      if ftype == TType.STOP:
12713 
        break
12714 
      if fid == 1:
12715 
        if ftype == TType.STRUCT:
12716 
          self.ex = TransactionServiceException()
12717 
          self.ex.read(iprot)
12718 
        else:
12719 
          iprot.skip(ftype)
12720 
      else:
12721 
        iprot.skip(ftype)
12722 
      iprot.readFieldEnd()
12723 
    iprot.readStructEnd()
12724 
 
12725 
  def write(self, oprot):
12726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12728 
      return
12729 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
12730 
    if self.ex is not None:
12731 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12732 
      self.ex.write(oprot)
12733 
      oprot.writeFieldEnd()
12734 
    oprot.writeFieldStop()
12735 
    oprot.writeStructEnd()
12736 
 
12737 
  def validate(self):
12738 
    return
12739 
 
12740 
 
12741 
  def __repr__(self):
12742 
    L = ['%s=%r' % (key, value)
12743 
      for key, value in self.__dict__.iteritems()]
12744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12745 
 
12746 
  def __eq__(self, other):
12747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12748 
 
12749 
  def __ne__(self, other):
12750 
    return not (self == other)
12751 
 
12752 
class markOrderCancellationRequestConfirmed_args:
12753 
  """
12754 
  Attributes:
12755 
   - orderId
12756 
  """
12757 
 
12758 
  thrift_spec = (
12759 
    None, # 0
12760 
    (1, TType.I64, 'orderId', None, None, ), # 1
12761 
  )
12762 
 
12763 
  def __init__(self, orderId=None,):
12764 
    self.orderId = orderId
12765 
 
12766 
  def read(self, iprot):
12767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12769 
      return
12770 
    iprot.readStructBegin()
12771 
    while True:
12772 
      (fname, ftype, fid) = iprot.readFieldBegin()
12773 
      if ftype == TType.STOP:
12774 
        break
12775 
      if fid == 1:
12776 
        if ftype == TType.I64:
12777 
          self.orderId = iprot.readI64();
12778 
        else:
12779 
          iprot.skip(ftype)
12780 
      else:
12781 
        iprot.skip(ftype)
12782 
      iprot.readFieldEnd()
12783 
    iprot.readStructEnd()
12784 
 
12785 
  def write(self, oprot):
12786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12788 
      return
12789 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
12790 
    if self.orderId is not None:
12791 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12792 
      oprot.writeI64(self.orderId)
12793 
      oprot.writeFieldEnd()
12794 
    oprot.writeFieldStop()
12795 
    oprot.writeStructEnd()
12796 
 
12797 
  def validate(self):
12798 
    return
12799 
 
12800 
 
12801 
  def __repr__(self):
12802 
    L = ['%s=%r' % (key, value)
12803 
      for key, value in self.__dict__.iteritems()]
12804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12805 
 
12806 
  def __eq__(self, other):
12807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12808 
 
12809 
  def __ne__(self, other):
12810 
    return not (self == other)
12811 
 
12812 
class markOrderCancellationRequestConfirmed_result:
12813 
  """
12814 
  Attributes:
12815 
   - ex
12816 
  """
12817 
 
12818 
  thrift_spec = (
12819 
    None, # 0
12820 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12821 
  )
12822 
 
12823 
  def __init__(self, ex=None,):
12824 
    self.ex = ex
12825 
 
12826 
  def read(self, iprot):
12827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12829 
      return
12830 
    iprot.readStructBegin()
12831 
    while True:
12832 
      (fname, ftype, fid) = iprot.readFieldBegin()
12833 
      if ftype == TType.STOP:
12834 
        break
12835 
      if fid == 1:
12836 
        if ftype == TType.STRUCT:
12837 
          self.ex = TransactionServiceException()
12838 
          self.ex.read(iprot)
12839 
        else:
12840 
          iprot.skip(ftype)
12841 
      else:
12842 
        iprot.skip(ftype)
12843 
      iprot.readFieldEnd()
12844 
    iprot.readStructEnd()
12845 
 
12846 
  def write(self, oprot):
12847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12849 
      return
12850 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
12851 
    if self.ex is not None:
12852 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12853 
      self.ex.write(oprot)
12854 
      oprot.writeFieldEnd()
12855 
    oprot.writeFieldStop()
12856 
    oprot.writeStructEnd()
12857 
 
12858 
  def validate(self):
12859 
    return
12860 
 
12861 
 
12862 
  def __repr__(self):
12863 
    L = ['%s=%r' % (key, value)
12864 
      for key, value in self.__dict__.iteritems()]
12865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12866 
 
12867 
  def __eq__(self, other):
12868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12869 
 
12870 
  def __ne__(self, other):
12871 
    return not (self == other)
12872 
 
12873 
class markOrderCancellationRequestDenied_args:
12874 
  """
12875 
  Attributes:
12876 
   - orderId
12877 
  """
12878 
 
12879 
  thrift_spec = (
12880 
    None, # 0
12881 
    (1, TType.I64, 'orderId', None, None, ), # 1
12882 
  )
12883 
 
12884 
  def __init__(self, orderId=None,):
12885 
    self.orderId = orderId
12886 
 
12887 
  def read(self, iprot):
12888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12890 
      return
12891 
    iprot.readStructBegin()
12892 
    while True:
12893 
      (fname, ftype, fid) = iprot.readFieldBegin()
12894 
      if ftype == TType.STOP:
12895 
        break
12896 
      if fid == 1:
12897 
        if ftype == TType.I64:
12898 
          self.orderId = iprot.readI64();
12899 
        else:
12900 
          iprot.skip(ftype)
12901 
      else:
12902 
        iprot.skip(ftype)
12903 
      iprot.readFieldEnd()
12904 
    iprot.readStructEnd()
12905 
 
12906 
  def write(self, oprot):
12907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12909 
      return
12910 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
12911 
    if self.orderId is not None:
12912 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12913 
      oprot.writeI64(self.orderId)
12914 
      oprot.writeFieldEnd()
12915 
    oprot.writeFieldStop()
12916 
    oprot.writeStructEnd()
12917 
 
12918 
  def validate(self):
12919 
    return
12920 
 
12921 
 
12922 
  def __repr__(self):
12923 
    L = ['%s=%r' % (key, value)
12924 
      for key, value in self.__dict__.iteritems()]
12925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12926 
 
12927 
  def __eq__(self, other):
12928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12929 
 
12930 
  def __ne__(self, other):
12931 
    return not (self == other)
12932 
 
12933 
class markOrderCancellationRequestDenied_result:
12934 
  """
12935 
  Attributes:
12936 
   - ex
12937 
  """
12938 
 
12939 
  thrift_spec = (
12940 
    None, # 0
12941 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12942 
  )
12943 
 
12944 
  def __init__(self, ex=None,):
12945 
    self.ex = ex
12946 
 
12947 
  def read(self, iprot):
12948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12950 
      return
12951 
    iprot.readStructBegin()
12952 
    while True:
12953 
      (fname, ftype, fid) = iprot.readFieldBegin()
12954 
      if ftype == TType.STOP:
12955 
        break
12956 
      if fid == 1:
12957 
        if ftype == TType.STRUCT:
12958 
          self.ex = TransactionServiceException()
12959 
          self.ex.read(iprot)
12960 
        else:
12961 
          iprot.skip(ftype)
12962 
      else:
12963 
        iprot.skip(ftype)
12964 
      iprot.readFieldEnd()
12965 
    iprot.readStructEnd()
12966 
 
12967 
  def write(self, oprot):
12968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12970 
      return
12971 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
12972 
    if self.ex is not None:
12973 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12974 
      self.ex.write(oprot)
12975 
      oprot.writeFieldEnd()
12976 
    oprot.writeFieldStop()
12977 
    oprot.writeStructEnd()
12978 
 
12979 
  def validate(self):
12980 
    return
12981 
 
12982 
 
12983 
  def __repr__(self):
12984 
    L = ['%s=%r' % (key, value)
12985 
      for key, value in self.__dict__.iteritems()]
12986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12987 
 
12988 
  def __eq__(self, other):
12989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12990 
 
12991 
  def __ne__(self, other):
12992 
    return not (self == other)
12993 
 
4258 rajveer 12994 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 12995 
  """
12996 
  Attributes:
4258 rajveer 12997 
   - transactionId
4247 rajveer 12998 
  """
12999 
 
13000 
  thrift_spec = (
13001 
    None, # 0
4258 rajveer 13002 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 13003 
  )
13004 
 
4258 rajveer 13005 
  def __init__(self, transactionId=None,):
13006 
    self.transactionId = transactionId
4247 rajveer 13007 
 
13008 
  def read(self, iprot):
13009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13011 
      return
13012 
    iprot.readStructBegin()
13013 
    while True:
13014 
      (fname, ftype, fid) = iprot.readFieldBegin()
13015 
      if ftype == TType.STOP:
13016 
        break
13017 
      if fid == 1:
13018 
        if ftype == TType.I64:
4258 rajveer 13019 
          self.transactionId = iprot.readI64();
4247 rajveer 13020 
        else:
13021 
          iprot.skip(ftype)
13022 
      else:
13023 
        iprot.skip(ftype)
13024 
      iprot.readFieldEnd()
13025 
    iprot.readStructEnd()
13026 
 
13027 
  def write(self, oprot):
13028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13030 
      return
4258 rajveer 13031 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
13032 
    if self.transactionId is not None:
13033 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13034 
      oprot.writeI64(self.transactionId)
4247 rajveer 13035 
      oprot.writeFieldEnd()
13036 
    oprot.writeFieldStop()
13037 
    oprot.writeStructEnd()
13038 
 
13039 
  def validate(self):
13040 
    return
13041 
 
13042 
 
13043 
  def __repr__(self):
13044 
    L = ['%s=%r' % (key, value)
13045 
      for key, value in self.__dict__.iteritems()]
13046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13047 
 
13048 
  def __eq__(self, other):
13049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13050 
 
13051 
  def __ne__(self, other):
13052 
    return not (self == other)
13053 
 
4258 rajveer 13054 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 13055 
  """
13056 
  Attributes:
13057 
   - ex
13058 
  """
13059 
 
13060 
  thrift_spec = (
13061 
    None, # 0
13062 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13063 
  )
13064 
 
13065 
  def __init__(self, ex=None,):
13066 
    self.ex = ex
13067 
 
13068 
  def read(self, iprot):
13069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13071 
      return
13072 
    iprot.readStructBegin()
13073 
    while True:
13074 
      (fname, ftype, fid) = iprot.readFieldBegin()
13075 
      if ftype == TType.STOP:
13076 
        break
13077 
      if fid == 1:
13078 
        if ftype == TType.STRUCT:
13079 
          self.ex = TransactionServiceException()
13080 
          self.ex.read(iprot)
13081 
        else:
13082 
          iprot.skip(ftype)
13083 
      else:
13084 
        iprot.skip(ftype)
13085 
      iprot.readFieldEnd()
13086 
    iprot.readStructEnd()
13087 
 
13088 
  def write(self, oprot):
13089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13091 
      return
4258 rajveer 13092 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 13093 
    if self.ex is not None:
13094 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13095 
      self.ex.write(oprot)
13096 
      oprot.writeFieldEnd()
13097 
    oprot.writeFieldStop()
13098 
    oprot.writeStructEnd()
13099 
 
13100 
  def validate(self):
13101 
    return
13102 
 
13103 
 
13104 
  def __repr__(self):
13105 
    L = ['%s=%r' % (key, value)
13106 
      for key, value in self.__dict__.iteritems()]
13107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13108 
 
13109 
  def __eq__(self, other):
13110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13111 
 
13112 
  def __ne__(self, other):
13113 
    return not (self == other)