Subversion Repositories SmartDukaan

Rev

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