Subversion Repositories SmartDukaan

Rev

Rev 4259 | Rev 4283 | 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 
 
4264 rajveer 317 
  def addBillingDetails(self, orderId, invoice_number, billed_by, jacketNumber):
3064 chandransh 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
4264 rajveer 327 
     - jacketNumber
3064 chandransh 328 
    """
329 
    pass
330 
 
331 
  def addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
332 
    """
333 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
334 
    the IMEI no. if a -1 is supplied.
335 
    Also, it generates an invoice number for the order, marks the order as
336 
    BILLED and sets the billing timestamp.
337 
    It should be used when we are billing the orders ourselves.
3431 rajveer 338 
 
3064 chandransh 339 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 340 
 
3064 chandransh 341 
    Parameters:
342 
     - orderId
343 
     - jacketNumber
344 
     - imeiNumber
345 
     - itemNumber
346 
     - billedBy
347 
     - billingType
348 
    """
349 
    pass
350 
 
351 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
352 
    """
353 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
354 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 355 
 
3064 chandransh 356 
    Parameters:
759 chandransh 357 
     - warehouseId
358 
     - providerId
3064 chandransh 359 
     - cod
759 chandransh 360 
    """
361 
    pass
362 
 
1113 chandransh 363 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
364 
    """
365 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
366 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
367 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 368 
 
1113 chandransh 369 
    Parameters:
370 
     - providerId
371 
     - pickupDetails
372 
    """
373 
    pass
374 
 
1132 chandransh 375 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
376 
    """
377 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
378 
    the name of the receiver.
379 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 380 
 
1132 chandransh 381 
    Parameters:
382 
     - providerId
383 
     - deliveredOrders
384 
    """
385 
    pass
386 
 
1135 chandransh 387 
  def markOrdersAsFailed(self, providerId, returnedOrders):
388 
    """
389 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
390 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 391 
 
1135 chandransh 392 
    Parameters:
393 
     - providerId
394 
     - returnedOrders
395 
    """
396 
    pass
397 
 
1246 chandransh 398 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
399 
    """
400 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 401 
 
1246 chandransh 402 
    Parameters:
403 
     - providerId
404 
     - undeliveredOrders
405 
    """
406 
    pass
407 
 
1408 ankur.sing 408 
  def getUndeliveredOrders(self, providerId, warehouseId):
409 
    """
410 
    Returns the list of orders whose delivery time has passed but have not been
411 
    delivered yet for the given provider and warehouse. To get a complete list of
412 
    undelivered orders, pass them as -1.
413 
    Returns an empty list if no such orders exist.
3431 rajveer 414 
 
1408 ankur.sing 415 
    Parameters:
416 
     - providerId
417 
     - warehouseId
418 
    """
419 
    pass
420 
 
2536 chandransh 421 
  def toggleDOAFlag(self, orderId):
422 
    """
423 
    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.
424 
    Returns the final flag status.
425 
    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 426 
 
2536 chandransh 427 
    Parameters:
428 
     - orderId
429 
    """
430 
    pass
1886 ankur.sing 431 
 
2536 chandransh 432 
  def requestPickupNumber(self, orderId):
433 
    """
434 
    Sends out an email to the account manager of the original courier provider used to ship the order.
435 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
436 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
437 
    For any other status, it returns false.
438 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 439 
 
2536 chandransh 440 
    Parameters:
441 
     - orderId
442 
    """
443 
    pass
444 
 
445 
  def authorizePickup(self, orderId, pickupNumber):
446 
    """
447 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
448 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
449 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
450 
    	3. Returns true
2591 chandransh 451 
    If the order is in any other status, it returns false.
2536 chandransh 452 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 453 
 
2536 chandransh 454 
    Parameters:
455 
     - orderId
456 
     - pickupNumber
457 
    """
458 
    pass
459 
 
2764 chandransh 460 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
461 
    """
462 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
463 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 464 
 
2764 chandransh 465 
    Parameters:
466 
     - providerId
467 
     - pickupDetails
468 
    """
469 
    pass
470 
 
2616 chandransh 471 
  def receiveReturn(self, orderId):
2591 chandransh 472 
    """
2599 chandransh 473 
    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 474 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 475 
    If the order is in any other state, it returns false.
476 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 477 
 
2591 chandransh 478 
    Parameters:
479 
     - orderId
480 
    """
481 
    pass
2536 chandransh 482 
 
2591 chandransh 483 
  def validateDoa(self, orderId, isValid):
484 
    """
2599 chandransh 485 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 486 
    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 487 
    If the order is in any other state, it returns false.
488 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 489 
 
2591 chandransh 490 
    Parameters:
491 
     - orderId
492 
     - isValid
493 
    """
494 
    pass
495 
 
2616 chandransh 496 
  def reshipOrder(self, orderId):
497 
    """
498 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
499 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
500 
    	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.
501 
 
502 
    If the order is in DOA_CERT_VALID state, it does the following:
503 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
504 
    	2. Creates a return order for the warehouse executive to return the DOA material.
505 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 506 
 
2616 chandransh 507 
    Returns the id of the newly created order.
3431 rajveer 508 
 
2616 chandransh 509 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 510 
 
2616 chandransh 511 
    Parameters:
512 
     - orderId
513 
    """
514 
    pass
2591 chandransh 515 
 
3226 chandransh 516 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 517 
    """
518 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
519 
    	1. Creates a refund request for batch processing.
520 
    	2. Creates a return order for the warehouse executive to return the shipped material.
521 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 522 
 
2616 chandransh 523 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
524 
    	1. Creates a refund request for batch processing.
3226 chandransh 525 
    	2. Cancels the reservation of the item in the warehouse.
526 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 527 
 
3226 chandransh 528 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
529 
    	1. Cancels the reservation of the item in the warehouse.
530 
    	2. Marks the current order as CANCELED.
531 
 
532 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
533 
 
2616 chandransh 534 
    Returns True if it is successful, False otherwise.
3431 rajveer 535 
 
2616 chandransh 536 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 537 
 
2616 chandransh 538 
    Parameters:
539 
     - orderId
3226 chandransh 540 
     - refundedBy
541 
     - reason
2616 chandransh 542 
    """
543 
    pass
544 
 
2690 chandransh 545 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
546 
    """
547 
    Get all return orders created between the from and to dates for the given warehouse.
548 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 549 
 
2690 chandransh 550 
    Parameters:
551 
     - warehouseId
552 
     - fromDate
553 
     - toDate
554 
    """
555 
    pass
2616 chandransh 556 
 
2700 chandransh 557 
  def getReturnOrder(self, id):
558 
    """
559 
    Returns the ReturnOrder corresponding to the given id.
560 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 561 
 
2700 chandransh 562 
    Parameters:
563 
     - id
564 
    """
565 
    pass
566 
 
2690 chandransh 567 
  def processReturn(self, returnOrderId):
568 
    """
569 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 570 
 
2690 chandransh 571 
    Parameters:
572 
     - returnOrderId
573 
    """
574 
    pass
575 
 
2819 chandransh 576 
  def createPurchaseOrder(self, warehouseId):
577 
    """
578 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 579 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 580 
 
2819 chandransh 581 
    Parameters:
582 
     - warehouseId
583 
    """
584 
    pass
2690 chandransh 585 
 
3451 chandransh 586 
  def updateWeight(self, orderId, weight):
587 
    """
588 
    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 589 
 
3451 chandransh 590 
    Parameters:
591 
     - orderId
592 
     - weight
593 
    """
594 
    pass
595 
 
3469 chandransh 596 
  def changeItem(self, orderId, itemId):
597 
    """
598 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
599 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 600 
 
3469 chandransh 601 
    Parameters:
602 
     - orderId
603 
     - itemId
604 
    """
605 
    pass
606 
 
607 
  def shiftToWarehouse(self, orderId, warehouseId):
608 
    """
609 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
610 
 
611 
    Parameters:
612 
     - orderId
613 
     - warehouseId
614 
    """
615 
    pass
616 
 
3986 chandransh 617 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 618 
    """
619 
    Adds the given delay reason to the given order.
3986 chandransh 620 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 621 
    Raises an exception if no order with the given id can be found.
3469 chandransh 622 
 
3553 chandransh 623 
    Parameters:
624 
     - orderId
625 
     - delayReason
3986 chandransh 626 
     - furtherDelay
3553 chandransh 627 
    """
628 
    pass
629 
 
3956 chandransh 630 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
631 
    """
632 
    Marks the COD orders with given AWB nos. as having been processed.
633 
    Updates the captured amount for the corresponding payment.
3553 chandransh 634 
 
3956 chandransh 635 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
636 
    1. There is no order corresponding to an AWB number.
637 
    2. The captured amount for a payment exceeds the total payment.
638 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
639 
 
640 
    Parameters:
641 
     - collectedAmountMap
642 
     - xferBy
643 
     - xferTxnId
644 
     - xferDate
645 
    """
646 
    pass
647 
 
4008 mandeep.dh 648 
  def getTransactionsRequiringExtraProcessing(self, category):
649 
    """
4065 mandeep.dh 650 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 651 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 652 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 653 
 
4008 mandeep.dh 654 
    Parameters:
655 
     - category
656 
    """
657 
    pass
658 
 
659 
  def markTransactionAsProcessed(self, transactionId, category):
660 
    """
661 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 662 
    It essentially deletes the transaction id record for a particular
663 
    processing type category (if present) from DB.
664 
    This is currently used by CRM application.
4008 mandeep.dh 665 
 
666 
    Parameters:
667 
     - transactionId
668 
     - category
669 
    """
670 
    pass
671 
 
4018 chandransh 672 
  def getItemWiseRiskyOrdersCount(self, ):
673 
    """
674 
    Returns a map containing the number of risky orders keyed by item id. A risky order
675 
    is defined as one whose shipping date is about to expire.
676 
    """
677 
    pass
4008 mandeep.dh 678 
 
4247 rajveer 679 
  def markOrderCancellationRequestReceived(self, orderId):
680 
    """
681 
    Mark order as cancellation request received. If customer sends request of cancellation of
682 
    a particular order, this method will be called. It will just change status of the order
683 
    depending on its current status. It also records the previous status, so that we can move
684 
    back to that status if cancellation request is denied.
4018 chandransh 685 
 
4247 rajveer 686 
    Parameters:
687 
     - orderId
688 
    """
689 
    pass
690 
 
691 
  def markOrderCancellationRequestConfirmed(self, orderId):
692 
    """
693 
    If we decide to to cancel order, CRM will call this method to move the status of order to
694 
    cancellation request confirmed. After this OM will be able to cancel the order.
695 
 
696 
    Parameters:
697 
     - orderId
698 
    """
699 
    pass
700 
 
701 
  def markOrderCancellationRequestDenied(self, orderId):
702 
    """
703 
    If we decide to not to cancel order, we will move the order ro previous status.
704 
 
705 
    Parameters:
706 
     - orderId
707 
    """
708 
    pass
709 
 
4258 rajveer 710 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 711 
    """
4258 rajveer 712 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
713 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 714 
 
715 
    Parameters:
4258 rajveer 716 
     - transactionId
4247 rajveer 717 
    """
718 
    pass
719 
 
4259 anupam.sin 720 
  def refundTransaction(self, transactionId, refundedBy, reason):
721 
    """
722 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
723 
    need to be cancelled
4247 rajveer 724 
 
4259 anupam.sin 725 
    Parameters:
726 
     - transactionId
727 
     - refundedBy
728 
     - reason
729 
    """
730 
    pass
731 
 
732 
 
3376 rajveer 733 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 734 
  def __init__(self, iprot, oprot=None):
3376 rajveer 735 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 736 
 
737 
  def createTransaction(self, transaction):
738 
    """
739 
    Parameters:
740 
     - transaction
741 
    """
742 
    self.send_createTransaction(transaction)
132 ashish 743 
    return self.recv_createTransaction()
94 ashish 744 
 
745 
  def send_createTransaction(self, transaction):
746 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
747 
    args = createTransaction_args()
748 
    args.transaction = transaction
749 
    args.write(self._oprot)
750 
    self._oprot.writeMessageEnd()
751 
    self._oprot.trans.flush()
752 
 
753 
  def recv_createTransaction(self, ):
754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
755 
    if mtype == TMessageType.EXCEPTION:
756 
      x = TApplicationException()
757 
      x.read(self._iprot)
758 
      self._iprot.readMessageEnd()
759 
      raise x
760 
    result = createTransaction_result()
761 
    result.read(self._iprot)
762 
    self._iprot.readMessageEnd()
3431 rajveer 763 
    if result.success is not None:
132 ashish 764 
      return result.success
3431 rajveer 765 
    if result.ex is not None:
94 ashish 766 
      raise result.ex
132 ashish 767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 768 
 
769 
  def getTransaction(self, id):
770 
    """
771 
    Parameters:
772 
     - id
773 
    """
774 
    self.send_getTransaction(id)
775 
    return self.recv_getTransaction()
776 
 
777 
  def send_getTransaction(self, id):
778 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
779 
    args = getTransaction_args()
780 
    args.id = id
781 
    args.write(self._oprot)
782 
    self._oprot.writeMessageEnd()
783 
    self._oprot.trans.flush()
784 
 
785 
  def recv_getTransaction(self, ):
786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
787 
    if mtype == TMessageType.EXCEPTION:
788 
      x = TApplicationException()
789 
      x.read(self._iprot)
790 
      self._iprot.readMessageEnd()
791 
      raise x
792 
    result = getTransaction_result()
793 
    result.read(self._iprot)
794 
    self._iprot.readMessageEnd()
3431 rajveer 795 
    if result.success is not None:
94 ashish 796 
      return result.success
3431 rajveer 797 
    if result.ex is not None:
94 ashish 798 
      raise result.ex
799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
800 
 
801 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
802 
    """
803 
    Parameters:
804 
     - customerId
805 
     - from_date
806 
     - to_date
807 
     - status
808 
    """
809 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
810 
    return self.recv_getTransactionsForCustomer()
811 
 
812 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
813 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
814 
    args = getTransactionsForCustomer_args()
815 
    args.customerId = customerId
816 
    args.from_date = from_date
817 
    args.to_date = to_date
818 
    args.status = status
819 
    args.write(self._oprot)
820 
    self._oprot.writeMessageEnd()
821 
    self._oprot.trans.flush()
822 
 
823 
  def recv_getTransactionsForCustomer(self, ):
824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
825 
    if mtype == TMessageType.EXCEPTION:
826 
      x = TApplicationException()
827 
      x.read(self._iprot)
828 
      self._iprot.readMessageEnd()
829 
      raise x
830 
    result = getTransactionsForCustomer_result()
831 
    result.read(self._iprot)
832 
    self._iprot.readMessageEnd()
3431 rajveer 833 
    if result.success is not None:
94 ashish 834 
      return result.success
3431 rajveer 835 
    if result.ex is not None:
94 ashish 836 
      raise result.ex
837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
838 
 
132 ashish 839 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
840 
    """
841 
    Parameters:
842 
     - shoppingCartId
843 
    """
844 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
845 
    return self.recv_getTransactionsForShoppingCartId()
846 
 
847 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
848 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
849 
    args = getTransactionsForShoppingCartId_args()
850 
    args.shoppingCartId = shoppingCartId
851 
    args.write(self._oprot)
852 
    self._oprot.writeMessageEnd()
853 
    self._oprot.trans.flush()
854 
 
855 
  def recv_getTransactionsForShoppingCartId(self, ):
856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
857 
    if mtype == TMessageType.EXCEPTION:
858 
      x = TApplicationException()
859 
      x.read(self._iprot)
860 
      self._iprot.readMessageEnd()
861 
      raise x
862 
    result = getTransactionsForShoppingCartId_result()
863 
    result.read(self._iprot)
864 
    self._iprot.readMessageEnd()
3431 rajveer 865 
    if result.success is not None:
132 ashish 866 
      return result.success
3431 rajveer 867 
    if result.ex is not None:
132 ashish 868 
      raise result.ex
869 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
870 
 
94 ashish 871 
  def getTransactionStatus(self, transactionId):
872 
    """
873 
    Parameters:
874 
     - transactionId
875 
    """
876 
    self.send_getTransactionStatus(transactionId)
877 
    return self.recv_getTransactionStatus()
878 
 
879 
  def send_getTransactionStatus(self, transactionId):
880 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
881 
    args = getTransactionStatus_args()
882 
    args.transactionId = transactionId
883 
    args.write(self._oprot)
884 
    self._oprot.writeMessageEnd()
885 
    self._oprot.trans.flush()
886 
 
887 
  def recv_getTransactionStatus(self, ):
888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
889 
    if mtype == TMessageType.EXCEPTION:
890 
      x = TApplicationException()
891 
      x.read(self._iprot)
892 
      self._iprot.readMessageEnd()
893 
      raise x
894 
    result = getTransactionStatus_result()
895 
    result.read(self._iprot)
896 
    self._iprot.readMessageEnd()
3431 rajveer 897 
    if result.success is not None:
94 ashish 898 
      return result.success
3431 rajveer 899 
    if result.ex is not None:
94 ashish 900 
      raise result.ex
901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
902 
 
903 
  def changeTransactionStatus(self, transactionId, status, description):
904 
    """
905 
    Parameters:
906 
     - transactionId
907 
     - status
908 
     - description
909 
    """
910 
    self.send_changeTransactionStatus(transactionId, status, description)
911 
    return self.recv_changeTransactionStatus()
912 
 
913 
  def send_changeTransactionStatus(self, transactionId, status, description):
914 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
915 
    args = changeTransactionStatus_args()
916 
    args.transactionId = transactionId
917 
    args.status = status
918 
    args.description = description
919 
    args.write(self._oprot)
920 
    self._oprot.writeMessageEnd()
921 
    self._oprot.trans.flush()
922 
 
923 
  def recv_changeTransactionStatus(self, ):
924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
925 
    if mtype == TMessageType.EXCEPTION:
926 
      x = TApplicationException()
927 
      x.read(self._iprot)
928 
      self._iprot.readMessageEnd()
929 
      raise x
930 
    result = changeTransactionStatus_result()
931 
    result.read(self._iprot)
932 
    self._iprot.readMessageEnd()
3431 rajveer 933 
    if result.success is not None:
94 ashish 934 
      return result.success
3431 rajveer 935 
    if result.ex is not None:
94 ashish 936 
      raise result.ex
937 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
938 
 
1398 varun.gupt 939 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 940 
    """
941 
    Parameters:
942 
     - transactionId
943 
    """
1398 varun.gupt 944 
    self.send_enqueueTransactionInfoEmail(transactionId)
945 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 946 
 
1398 varun.gupt 947 
  def send_enqueueTransactionInfoEmail(self, transactionId):
948 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
949 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 950 
    args.transactionId = transactionId
951 
    args.write(self._oprot)
952 
    self._oprot.writeMessageEnd()
953 
    self._oprot.trans.flush()
954 
 
1398 varun.gupt 955 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
957 
    if mtype == TMessageType.EXCEPTION:
958 
      x = TApplicationException()
959 
      x.read(self._iprot)
960 
      self._iprot.readMessageEnd()
961 
      raise x
1398 varun.gupt 962 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 963 
    result.read(self._iprot)
964 
    self._iprot.readMessageEnd()
3431 rajveer 965 
    if result.success is not None:
1382 varun.gupt 966 
      return result.success
3431 rajveer 967 
    if result.ex is not None:
1382 varun.gupt 968 
      raise result.ex
1398 varun.gupt 969 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 970 
 
483 rajveer 971 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 972 
    """
973 
    Parameters:
483 rajveer 974 
     - status
975 
     - from_date
976 
     - to_date
977 
     - warehouse_id
94 ashish 978 
    """
483 rajveer 979 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
980 
    return self.recv_getAllOrders()
94 ashish 981 
 
483 rajveer 982 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
983 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
984 
    args = getAllOrders_args()
985 
    args.status = status
986 
    args.from_date = from_date
987 
    args.to_date = to_date
988 
    args.warehouse_id = warehouse_id
94 ashish 989 
    args.write(self._oprot)
990 
    self._oprot.writeMessageEnd()
991 
    self._oprot.trans.flush()
992 
 
483 rajveer 993 
  def recv_getAllOrders(self, ):
94 ashish 994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
995 
    if mtype == TMessageType.EXCEPTION:
996 
      x = TApplicationException()
997 
      x.read(self._iprot)
998 
      self._iprot.readMessageEnd()
999 
      raise x
483 rajveer 1000 
    result = getAllOrders_result()
94 ashish 1001 
    result.read(self._iprot)
1002 
    self._iprot.readMessageEnd()
3431 rajveer 1003 
    if result.success is not None:
94 ashish 1004 
      return result.success
3431 rajveer 1005 
    if result.ex is not None:
94 ashish 1006 
      raise result.ex
483 rajveer 1007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1008 
 
4133 chandransh 1009 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1010 
    """
1011 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1012 
    Pass the status as null and the limit as 0 to ignore them.
1013 
 
1014 
    Parameters:
1015 
     - statuses
1016 
     - offset
1017 
     - limit
1018 
     - warehouse_id
1019 
    """
1020 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1021 
    return self.recv_getOrdersInBatch()
1022 
 
1023 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1024 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1025 
    args = getOrdersInBatch_args()
1026 
    args.statuses = statuses
1027 
    args.offset = offset
1028 
    args.limit = limit
1029 
    args.warehouse_id = warehouse_id
1030 
    args.write(self._oprot)
1031 
    self._oprot.writeMessageEnd()
1032 
    self._oprot.trans.flush()
1033 
 
1034 
  def recv_getOrdersInBatch(self, ):
1035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1036 
    if mtype == TMessageType.EXCEPTION:
1037 
      x = TApplicationException()
1038 
      x.read(self._iprot)
1039 
      self._iprot.readMessageEnd()
1040 
      raise x
1041 
    result = getOrdersInBatch_result()
1042 
    result.read(self._iprot)
1043 
    self._iprot.readMessageEnd()
1044 
    if result.success is not None:
1045 
      return result.success
1046 
    if result.ex is not None:
1047 
      raise result.ex
1048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1049 
 
1050 
  def getOrderCount(self, statuses, warehouseId):
1051 
    """
1052 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1053 
 
1054 
    Parameters:
1055 
     - statuses
1056 
     - warehouseId
1057 
    """
1058 
    self.send_getOrderCount(statuses, warehouseId)
1059 
    return self.recv_getOrderCount()
1060 
 
1061 
  def send_getOrderCount(self, statuses, warehouseId):
1062 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1063 
    args = getOrderCount_args()
1064 
    args.statuses = statuses
1065 
    args.warehouseId = warehouseId
1066 
    args.write(self._oprot)
1067 
    self._oprot.writeMessageEnd()
1068 
    self._oprot.trans.flush()
1069 
 
1070 
  def recv_getOrderCount(self, ):
1071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1072 
    if mtype == TMessageType.EXCEPTION:
1073 
      x = TApplicationException()
1074 
      x.read(self._iprot)
1075 
      self._iprot.readMessageEnd()
1076 
      raise x
1077 
    result = getOrderCount_result()
1078 
    result.read(self._iprot)
1079 
    self._iprot.readMessageEnd()
1080 
    if result.success is not None:
1081 
      return result.success
1082 
    if result.ex is not None:
1083 
      raise result.ex
1084 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1085 
 
999 varun.gupt 1086 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1087 
    """
1132 chandransh 1088 
    Returns orders within a range of their billing dates
3431 rajveer 1089 
 
999 varun.gupt 1090 
    Parameters:
1091 
     - status
1092 
     - start_billing_date
1093 
     - end_billing_date
1094 
     - warehouse_id
1095 
    """
1096 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1097 
    return self.recv_getOrdersByBillingDate()
1098 
 
1099 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1100 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1101 
    args = getOrdersByBillingDate_args()
1102 
    args.status = status
1103 
    args.start_billing_date = start_billing_date
1104 
    args.end_billing_date = end_billing_date
1105 
    args.warehouse_id = warehouse_id
1106 
    args.write(self._oprot)
1107 
    self._oprot.writeMessageEnd()
1108 
    self._oprot.trans.flush()
1109 
 
1110 
  def recv_getOrdersByBillingDate(self, ):
1111 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1112 
    if mtype == TMessageType.EXCEPTION:
1113 
      x = TApplicationException()
1114 
      x.read(self._iprot)
1115 
      self._iprot.readMessageEnd()
1116 
      raise x
1117 
    result = getOrdersByBillingDate_result()
1118 
    result.read(self._iprot)
1119 
    self._iprot.readMessageEnd()
3431 rajveer 1120 
    if result.success is not None:
999 varun.gupt 1121 
      return result.success
3431 rajveer 1122 
    if result.ex is not None:
999 varun.gupt 1123 
      raise result.ex
1124 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1125 
 
3451 chandransh 1126 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1127 
    """
1128 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1129 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1130 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1131 
 
3427 chandransh 1132 
    Parameters:
1133 
     - fromShippingDate
1134 
     - toShippingDate
1135 
     - providerId
1136 
     - warehouseId
3451 chandransh 1137 
     - cod
3427 chandransh 1138 
    """
3451 chandransh 1139 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1140 
    return self.recv_getOrdersByShippingDate()
1141 
 
3451 chandransh 1142 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1143 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1144 
    args = getOrdersByShippingDate_args()
1145 
    args.fromShippingDate = fromShippingDate
1146 
    args.toShippingDate = toShippingDate
1147 
    args.providerId = providerId
1148 
    args.warehouseId = warehouseId
3451 chandransh 1149 
    args.cod = cod
3427 chandransh 1150 
    args.write(self._oprot)
1151 
    self._oprot.writeMessageEnd()
1152 
    self._oprot.trans.flush()
1153 
 
1154 
  def recv_getOrdersByShippingDate(self, ):
1155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1156 
    if mtype == TMessageType.EXCEPTION:
1157 
      x = TApplicationException()
1158 
      x.read(self._iprot)
1159 
      self._iprot.readMessageEnd()
1160 
      raise x
1161 
    result = getOrdersByShippingDate_result()
1162 
    result.read(self._iprot)
1163 
    self._iprot.readMessageEnd()
3431 rajveer 1164 
    if result.success is not None:
3427 chandransh 1165 
      return result.success
3431 rajveer 1166 
    if result.ex is not None:
3427 chandransh 1167 
      raise result.ex
1168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1169 
 
1382 varun.gupt 1170 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1171 
    """
1172 
    Returns order ids for orders which can be returned
3431 rajveer 1173 
 
1382 varun.gupt 1174 
    Parameters:
1175 
     - customer_id
1176 
     - limit
1177 
    """
1178 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1179 
    return self.recv_getReturnableOrdersForCustomer()
1180 
 
1181 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1182 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1183 
    args = getReturnableOrdersForCustomer_args()
1184 
    args.customer_id = customer_id
1185 
    args.limit = limit
1186 
    args.write(self._oprot)
1187 
    self._oprot.writeMessageEnd()
1188 
    self._oprot.trans.flush()
1189 
 
1190 
  def recv_getReturnableOrdersForCustomer(self, ):
1191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1192 
    if mtype == TMessageType.EXCEPTION:
1193 
      x = TApplicationException()
1194 
      x.read(self._iprot)
1195 
      self._iprot.readMessageEnd()
1196 
      raise x
1197 
    result = getReturnableOrdersForCustomer_result()
1198 
    result.read(self._iprot)
1199 
    self._iprot.readMessageEnd()
3431 rajveer 1200 
    if result.success is not None:
1382 varun.gupt 1201 
      return result.success
3431 rajveer 1202 
    if result.ex is not None:
1382 varun.gupt 1203 
      raise result.ex
1204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1205 
 
1206 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1207 
    """
1208 
    Returns order ids for orders which can be cancelled
3431 rajveer 1209 
 
1382 varun.gupt 1210 
    Parameters:
1211 
     - customer_id
1212 
     - limit
1213 
    """
1214 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1215 
    return self.recv_getCancellableOrdersForCustomer()
1216 
 
1217 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1218 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1219 
    args = getCancellableOrdersForCustomer_args()
1220 
    args.customer_id = customer_id
1221 
    args.limit = limit
1222 
    args.write(self._oprot)
1223 
    self._oprot.writeMessageEnd()
1224 
    self._oprot.trans.flush()
1225 
 
1226 
  def recv_getCancellableOrdersForCustomer(self, ):
1227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1228 
    if mtype == TMessageType.EXCEPTION:
1229 
      x = TApplicationException()
1230 
      x.read(self._iprot)
1231 
      self._iprot.readMessageEnd()
1232 
      raise x
1233 
    result = getCancellableOrdersForCustomer_result()
1234 
    result.read(self._iprot)
1235 
    self._iprot.readMessageEnd()
3431 rajveer 1236 
    if result.success is not None:
1382 varun.gupt 1237 
      return result.success
3431 rajveer 1238 
    if result.ex is not None:
1382 varun.gupt 1239 
      raise result.ex
1240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1241 
 
483 rajveer 1242 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1243 
    """
1244 
    Parameters:
483 rajveer 1245 
     - orderId
1246 
     - status
1247 
     - description
94 ashish 1248 
    """
483 rajveer 1249 
    self.send_changeOrderStatus(orderId, status, description)
1250 
    return self.recv_changeOrderStatus()
94 ashish 1251 
 
483 rajveer 1252 
  def send_changeOrderStatus(self, orderId, status, description):
1253 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1254 
    args = changeOrderStatus_args()
1255 
    args.orderId = orderId
1256 
    args.status = status
1257 
    args.description = description
94 ashish 1258 
    args.write(self._oprot)
1259 
    self._oprot.writeMessageEnd()
1260 
    self._oprot.trans.flush()
1261 
 
483 rajveer 1262 
  def recv_changeOrderStatus(self, ):
94 ashish 1263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1264 
    if mtype == TMessageType.EXCEPTION:
1265 
      x = TApplicationException()
1266 
      x.read(self._iprot)
1267 
      self._iprot.readMessageEnd()
1268 
      raise x
483 rajveer 1269 
    result = changeOrderStatus_result()
94 ashish 1270 
    result.read(self._iprot)
1271 
    self._iprot.readMessageEnd()
3431 rajveer 1272 
    if result.success is not None:
94 ashish 1273 
      return result.success
3431 rajveer 1274 
    if result.ex is not None:
94 ashish 1275 
      raise result.ex
483 rajveer 1276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1277 
 
1528 ankur.sing 1278 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1279 
    """
1528 ankur.sing 1280 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1281 
    only user who owns the transaction can view its order details.
3431 rajveer 1282 
 
94 ashish 1283 
    Parameters:
1284 
     - transactionId
1528 ankur.sing 1285 
     - customerId
94 ashish 1286 
    """
1528 ankur.sing 1287 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1288 
    return self.recv_getOrdersForTransaction()
94 ashish 1289 
 
1528 ankur.sing 1290 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1291 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1292 
    args = getOrdersForTransaction_args()
94 ashish 1293 
    args.transactionId = transactionId
1528 ankur.sing 1294 
    args.customerId = customerId
94 ashish 1295 
    args.write(self._oprot)
1296 
    self._oprot.writeMessageEnd()
1297 
    self._oprot.trans.flush()
1298 
 
483 rajveer 1299 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1301 
    if mtype == TMessageType.EXCEPTION:
1302 
      x = TApplicationException()
1303 
      x.read(self._iprot)
1304 
      self._iprot.readMessageEnd()
1305 
      raise x
483 rajveer 1306 
    result = getOrdersForTransaction_result()
94 ashish 1307 
    result.read(self._iprot)
1308 
    self._iprot.readMessageEnd()
3431 rajveer 1309 
    if result.success is not None:
94 ashish 1310 
      return result.success
3431 rajveer 1311 
    if result.ex is not None:
94 ashish 1312 
      raise result.ex
483 rajveer 1313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1314 
 
3014 chandransh 1315 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1316 
    """
3014 chandransh 1317 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1318 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1319 
 
94 ashish 1320 
    Parameters:
483 rajveer 1321 
     - customerId
1322 
     - from_date
1323 
     - to_date
3014 chandransh 1324 
     - statuses
94 ashish 1325 
    """
3014 chandransh 1326 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1327 
    return self.recv_getOrdersForCustomer()
94 ashish 1328 
 
3014 chandransh 1329 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1330 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1331 
    args = getOrdersForCustomer_args()
1332 
    args.customerId = customerId
1333 
    args.from_date = from_date
1334 
    args.to_date = to_date
3014 chandransh 1335 
    args.statuses = statuses
94 ashish 1336 
    args.write(self._oprot)
1337 
    self._oprot.writeMessageEnd()
1338 
    self._oprot.trans.flush()
1339 
 
483 rajveer 1340 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1342 
    if mtype == TMessageType.EXCEPTION:
1343 
      x = TApplicationException()
1344 
      x.read(self._iprot)
1345 
      self._iprot.readMessageEnd()
1346 
      raise x
483 rajveer 1347 
    result = getOrdersForCustomer_result()
94 ashish 1348 
    result.read(self._iprot)
1349 
    self._iprot.readMessageEnd()
3431 rajveer 1350 
    if result.success is not None:
94 ashish 1351 
      return result.success
3431 rajveer 1352 
    if result.ex is not None:
94 ashish 1353 
      raise result.ex
483 rajveer 1354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1355 
 
483 rajveer 1356 
  def createOrder(self, order):
94 ashish 1357 
    """
1358 
    Parameters:
483 rajveer 1359 
     - order
94 ashish 1360 
    """
483 rajveer 1361 
    self.send_createOrder(order)
1362 
    return self.recv_createOrder()
94 ashish 1363 
 
483 rajveer 1364 
  def send_createOrder(self, order):
1365 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1366 
    args = createOrder_args()
1367 
    args.order = order
94 ashish 1368 
    args.write(self._oprot)
1369 
    self._oprot.writeMessageEnd()
1370 
    self._oprot.trans.flush()
1371 
 
483 rajveer 1372 
  def recv_createOrder(self, ):
94 ashish 1373 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1374 
    if mtype == TMessageType.EXCEPTION:
1375 
      x = TApplicationException()
1376 
      x.read(self._iprot)
1377 
      self._iprot.readMessageEnd()
1378 
      raise x
483 rajveer 1379 
    result = createOrder_result()
94 ashish 1380 
    result.read(self._iprot)
1381 
    self._iprot.readMessageEnd()
3431 rajveer 1382 
    if result.success is not None:
94 ashish 1383 
      return result.success
3431 rajveer 1384 
    if result.ex is not None:
94 ashish 1385 
      raise result.ex
483 rajveer 1386 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1387 
 
483 rajveer 1388 
  def getOrder(self, id):
94 ashish 1389 
    """
1390 
    Parameters:
483 rajveer 1391 
     - id
94 ashish 1392 
    """
483 rajveer 1393 
    self.send_getOrder(id)
1394 
    return self.recv_getOrder()
94 ashish 1395 
 
483 rajveer 1396 
  def send_getOrder(self, id):
1397 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1398 
    args = getOrder_args()
1399 
    args.id = id
94 ashish 1400 
    args.write(self._oprot)
1401 
    self._oprot.writeMessageEnd()
1402 
    self._oprot.trans.flush()
1403 
 
483 rajveer 1404 
  def recv_getOrder(self, ):
94 ashish 1405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1406 
    if mtype == TMessageType.EXCEPTION:
1407 
      x = TApplicationException()
1408 
      x.read(self._iprot)
1409 
      self._iprot.readMessageEnd()
1410 
      raise x
483 rajveer 1411 
    result = getOrder_result()
94 ashish 1412 
    result.read(self._iprot)
1413 
    self._iprot.readMessageEnd()
3431 rajveer 1414 
    if result.success is not None:
94 ashish 1415 
      return result.success
3431 rajveer 1416 
    if result.ex is not None:
94 ashish 1417 
      raise result.ex
483 rajveer 1418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1419 
 
483 rajveer 1420 
  def getLineItemsForOrder(self, orderId):
94 ashish 1421 
    """
1422 
    Parameters:
483 rajveer 1423 
     - orderId
94 ashish 1424 
    """
483 rajveer 1425 
    self.send_getLineItemsForOrder(orderId)
1426 
    return self.recv_getLineItemsForOrder()
94 ashish 1427 
 
483 rajveer 1428 
  def send_getLineItemsForOrder(self, orderId):
1429 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1430 
    args = getLineItemsForOrder_args()
1431 
    args.orderId = orderId
94 ashish 1432 
    args.write(self._oprot)
1433 
    self._oprot.writeMessageEnd()
1434 
    self._oprot.trans.flush()
1435 
 
483 rajveer 1436 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1438 
    if mtype == TMessageType.EXCEPTION:
1439 
      x = TApplicationException()
1440 
      x.read(self._iprot)
1441 
      self._iprot.readMessageEnd()
1442 
      raise x
483 rajveer 1443 
    result = getLineItemsForOrder_result()
94 ashish 1444 
    result.read(self._iprot)
1445 
    self._iprot.readMessageEnd()
3431 rajveer 1446 
    if result.success is not None:
94 ashish 1447 
      return result.success
3431 rajveer 1448 
    if result.ex is not None:
94 ashish 1449 
      raise result.ex
483 rajveer 1450 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1451 
 
1528 ankur.sing 1452 
  def getOrderForCustomer(self, orderId, customerId):
1453 
    """
1454 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1455 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1456 
 
1528 ankur.sing 1457 
    Parameters:
1458 
     - orderId
1459 
     - customerId
1460 
    """
1461 
    self.send_getOrderForCustomer(orderId, customerId)
1462 
    return self.recv_getOrderForCustomer()
1463 
 
1464 
  def send_getOrderForCustomer(self, orderId, customerId):
1465 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1466 
    args = getOrderForCustomer_args()
1467 
    args.orderId = orderId
1468 
    args.customerId = customerId
1469 
    args.write(self._oprot)
1470 
    self._oprot.writeMessageEnd()
1471 
    self._oprot.trans.flush()
1472 
 
1473 
  def recv_getOrderForCustomer(self, ):
1474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1475 
    if mtype == TMessageType.EXCEPTION:
1476 
      x = TApplicationException()
1477 
      x.read(self._iprot)
1478 
      self._iprot.readMessageEnd()
1479 
      raise x
1480 
    result = getOrderForCustomer_result()
1481 
    result.read(self._iprot)
1482 
    self._iprot.readMessageEnd()
3431 rajveer 1483 
    if result.success is not None:
1528 ankur.sing 1484 
      return result.success
3431 rajveer 1485 
    if result.ex is not None:
1528 ankur.sing 1486 
      raise result.ex
1487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1488 
 
3064 chandransh 1489 
  def getAlerts(self, orderId, valid):
1490 
    """
1491 
    Parameters:
1492 
     - orderId
1493 
     - valid
1494 
    """
1495 
    self.send_getAlerts(orderId, valid)
1496 
    return self.recv_getAlerts()
1497 
 
1498 
  def send_getAlerts(self, orderId, valid):
1499 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1500 
    args = getAlerts_args()
1501 
    args.orderId = orderId
1502 
    args.valid = valid
1503 
    args.write(self._oprot)
1504 
    self._oprot.writeMessageEnd()
1505 
    self._oprot.trans.flush()
1506 
 
1507 
  def recv_getAlerts(self, ):
1508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1509 
    if mtype == TMessageType.EXCEPTION:
1510 
      x = TApplicationException()
1511 
      x.read(self._iprot)
1512 
      self._iprot.readMessageEnd()
1513 
      raise x
1514 
    result = getAlerts_result()
1515 
    result.read(self._iprot)
1516 
    self._iprot.readMessageEnd()
3431 rajveer 1517 
    if result.success is not None:
3064 chandransh 1518 
      return result.success
1519 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1520 
 
1521 
  def setAlert(self, orderId, unset, type, comment):
1522 
    """
1523 
    Parameters:
1524 
     - orderId
1525 
     - unset
1526 
     - type
1527 
     - comment
1528 
    """
1529 
    self.send_setAlert(orderId, unset, type, comment)
1530 
    self.recv_setAlert()
1531 
 
1532 
  def send_setAlert(self, orderId, unset, type, comment):
1533 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
1534 
    args = setAlert_args()
1535 
    args.orderId = orderId
1536 
    args.unset = unset
1537 
    args.type = type
1538 
    args.comment = comment
1539 
    args.write(self._oprot)
1540 
    self._oprot.writeMessageEnd()
1541 
    self._oprot.trans.flush()
1542 
 
1543 
  def recv_setAlert(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 = setAlert_result()
1551 
    result.read(self._iprot)
1552 
    self._iprot.readMessageEnd()
1553 
    return
1554 
 
1555 
  def getValidOrderCount(self, ):
1556 
    """
1557 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1558 
    """
1559 
    self.send_getValidOrderCount()
1560 
    return self.recv_getValidOrderCount()
1561 
 
1562 
  def send_getValidOrderCount(self, ):
1563 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1564 
    args = getValidOrderCount_args()
1565 
    args.write(self._oprot)
1566 
    self._oprot.writeMessageEnd()
1567 
    self._oprot.trans.flush()
1568 
 
1569 
  def recv_getValidOrderCount(self, ):
1570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1571 
    if mtype == TMessageType.EXCEPTION:
1572 
      x = TApplicationException()
1573 
      x.read(self._iprot)
1574 
      self._iprot.readMessageEnd()
1575 
      raise x
1576 
    result = getValidOrderCount_result()
1577 
    result.read(self._iprot)
1578 
    self._iprot.readMessageEnd()
3431 rajveer 1579 
    if result.success is not None:
3064 chandransh 1580 
      return result.success
1581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1582 
 
1583 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1584 
    """
1585 
    Returns the number of distinct customers who have done successful transactions
1586 
    """
1587 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1588 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1589 
 
1590 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1591 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1592 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1593 
    args.write(self._oprot)
1594 
    self._oprot.writeMessageEnd()
1595 
    self._oprot.trans.flush()
1596 
 
1597 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1598 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1599 
    if mtype == TMessageType.EXCEPTION:
1600 
      x = TApplicationException()
1601 
      x.read(self._iprot)
1602 
      self._iprot.readMessageEnd()
1603 
      raise x
1604 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1605 
    result.read(self._iprot)
1606 
    self._iprot.readMessageEnd()
3431 rajveer 1607 
    if result.success is not None:
3064 chandransh 1608 
      return result.success
1609 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1610 
 
1611 
  def getValidOrdersAmountRange(self, ):
1612 
    """
1613 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1614 
    List contains two values, first minimum amount and second maximum amount.
1615 
    """
1616 
    self.send_getValidOrdersAmountRange()
1617 
    return self.recv_getValidOrdersAmountRange()
1618 
 
1619 
  def send_getValidOrdersAmountRange(self, ):
1620 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1621 
    args = getValidOrdersAmountRange_args()
1622 
    args.write(self._oprot)
1623 
    self._oprot.writeMessageEnd()
1624 
    self._oprot.trans.flush()
1625 
 
1626 
  def recv_getValidOrdersAmountRange(self, ):
1627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1628 
    if mtype == TMessageType.EXCEPTION:
1629 
      x = TApplicationException()
1630 
      x.read(self._iprot)
1631 
      self._iprot.readMessageEnd()
1632 
      raise x
1633 
    result = getValidOrdersAmountRange_result()
1634 
    result.read(self._iprot)
1635 
    self._iprot.readMessageEnd()
3431 rajveer 1636 
    if result.success is not None:
3064 chandransh 1637 
      return result.success
1638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1639 
 
1640 
  def getValidOrders(self, limit):
1641 
    """
1642 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1643 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1644 
 
3064 chandransh 1645 
    Parameters:
1646 
     - limit
1647 
    """
1648 
    self.send_getValidOrders(limit)
1649 
    return self.recv_getValidOrders()
1650 
 
1651 
  def send_getValidOrders(self, limit):
1652 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1653 
    args = getValidOrders_args()
1654 
    args.limit = limit
1655 
    args.write(self._oprot)
1656 
    self._oprot.writeMessageEnd()
1657 
    self._oprot.trans.flush()
1658 
 
1659 
  def recv_getValidOrders(self, ):
1660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1661 
    if mtype == TMessageType.EXCEPTION:
1662 
      x = TApplicationException()
1663 
      x.read(self._iprot)
1664 
      self._iprot.readMessageEnd()
1665 
      raise x
1666 
    result = getValidOrders_result()
1667 
    result.read(self._iprot)
1668 
    self._iprot.readMessageEnd()
3431 rajveer 1669 
    if result.success is not None:
3064 chandransh 1670 
      return result.success
1671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1672 
 
1220 chandransh 1673 
  def batchOrders(self, warehouseId):
1674 
    """
1675 
    Create a batch of all the pending orders for the given warehouse.
1676 
    The returned list is orderd by created_timestamp.
1677 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1678 
 
1220 chandransh 1679 
    Parameters:
1680 
     - warehouseId
1681 
    """
1682 
    self.send_batchOrders(warehouseId)
1683 
    return self.recv_batchOrders()
1684 
 
1685 
  def send_batchOrders(self, warehouseId):
1686 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1687 
    args = batchOrders_args()
1688 
    args.warehouseId = warehouseId
1689 
    args.write(self._oprot)
1690 
    self._oprot.writeMessageEnd()
1691 
    self._oprot.trans.flush()
1692 
 
1693 
  def recv_batchOrders(self, ):
1694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1695 
    if mtype == TMessageType.EXCEPTION:
1696 
      x = TApplicationException()
1697 
      x.read(self._iprot)
1698 
      self._iprot.readMessageEnd()
1699 
      raise x
1700 
    result = batchOrders_result()
1701 
    result.read(self._iprot)
1702 
    self._iprot.readMessageEnd()
3431 rajveer 1703 
    if result.success is not None:
1220 chandransh 1704 
      return result.success
3431 rajveer 1705 
    if result.ex is not None:
1220 chandransh 1706 
      raise result.ex
1707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1708 
 
1208 chandransh 1709 
  def markOrderAsOutOfStock(self, orderId):
1710 
    """
1711 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1712 
 
1208 chandransh 1713 
    Parameters:
1714 
     - orderId
1715 
    """
1716 
    self.send_markOrderAsOutOfStock(orderId)
1717 
    return self.recv_markOrderAsOutOfStock()
1718 
 
1719 
  def send_markOrderAsOutOfStock(self, orderId):
1720 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1721 
    args = markOrderAsOutOfStock_args()
1722 
    args.orderId = orderId
1723 
    args.write(self._oprot)
1724 
    self._oprot.writeMessageEnd()
1725 
    self._oprot.trans.flush()
1726 
 
1727 
  def recv_markOrderAsOutOfStock(self, ):
1728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1729 
    if mtype == TMessageType.EXCEPTION:
1730 
      x = TApplicationException()
1731 
      x.read(self._iprot)
1732 
      self._iprot.readMessageEnd()
1733 
      raise x
1734 
    result = markOrderAsOutOfStock_result()
1735 
    result.read(self._iprot)
1736 
    self._iprot.readMessageEnd()
3431 rajveer 1737 
    if result.success is not None:
1208 chandransh 1738 
      return result.success
3431 rajveer 1739 
    if result.ex is not None:
1208 chandransh 1740 
      raise result.ex
1741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1742 
 
3064 chandransh 1743 
  def verifyOrder(self, orderId):
759 chandransh 1744 
    """
3064 chandransh 1745 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1746 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1747 
    used for all other orders as well.
1748 
    Throws an exception if no such order exists.
3431 rajveer 1749 
 
759 chandransh 1750 
    Parameters:
3064 chandransh 1751 
     - orderId
759 chandransh 1752 
    """
3064 chandransh 1753 
    self.send_verifyOrder(orderId)
1754 
    return self.recv_verifyOrder()
759 chandransh 1755 
 
3064 chandransh 1756 
  def send_verifyOrder(self, orderId):
1757 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1758 
    args = verifyOrder_args()
1759 
    args.orderId = orderId
759 chandransh 1760 
    args.write(self._oprot)
1761 
    self._oprot.writeMessageEnd()
1762 
    self._oprot.trans.flush()
1763 
 
3064 chandransh 1764 
  def recv_verifyOrder(self, ):
759 chandransh 1765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1766 
    if mtype == TMessageType.EXCEPTION:
1767 
      x = TApplicationException()
1768 
      x.read(self._iprot)
1769 
      self._iprot.readMessageEnd()
1770 
      raise x
3064 chandransh 1771 
    result = verifyOrder_result()
759 chandransh 1772 
    result.read(self._iprot)
1773 
    self._iprot.readMessageEnd()
3431 rajveer 1774 
    if result.success is not None:
759 chandransh 1775 
      return result.success
3431 rajveer 1776 
    if result.ex is not None:
759 chandransh 1777 
      raise result.ex
3064 chandransh 1778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1779 
 
3064 chandransh 1780 
  def acceptOrder(self, orderId):
1113 chandransh 1781 
    """
3064 chandransh 1782 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1783 
    given order is not a COD order, it also captures the payment if the same has
1784 
    not been captured.
1785 
    Throws an exception if no such order exists.
3431 rajveer 1786 
 
1113 chandransh 1787 
    Parameters:
3064 chandransh 1788 
     - orderId
1113 chandransh 1789 
    """
3064 chandransh 1790 
    self.send_acceptOrder(orderId)
1791 
    return self.recv_acceptOrder()
1113 chandransh 1792 
 
3064 chandransh 1793 
  def send_acceptOrder(self, orderId):
1794 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1795 
    args = acceptOrder_args()
1796 
    args.orderId = orderId
1113 chandransh 1797 
    args.write(self._oprot)
1798 
    self._oprot.writeMessageEnd()
1799 
    self._oprot.trans.flush()
1800 
 
3064 chandransh 1801 
  def recv_acceptOrder(self, ):
1113 chandransh 1802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1803 
    if mtype == TMessageType.EXCEPTION:
1804 
      x = TApplicationException()
1805 
      x.read(self._iprot)
1806 
      self._iprot.readMessageEnd()
1807 
      raise x
3064 chandransh 1808 
    result = acceptOrder_result()
1113 chandransh 1809 
    result.read(self._iprot)
1810 
    self._iprot.readMessageEnd()
3431 rajveer 1811 
    if result.success is not None:
1113 chandransh 1812 
      return result.success
3431 rajveer 1813 
    if result.ex is not None:
1113 chandransh 1814 
      raise result.ex
3064 chandransh 1815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1816 
 
3064 chandransh 1817 
  def billOrder(self, orderId):
1132 chandransh 1818 
    """
1819 
    Parameters:
3064 chandransh 1820 
     - orderId
1132 chandransh 1821 
    """
3064 chandransh 1822 
    self.send_billOrder(orderId)
1823 
    return self.recv_billOrder()
1132 chandransh 1824 
 
3064 chandransh 1825 
  def send_billOrder(self, orderId):
1826 
    self._oprot.writeMessageBegin('billOrder', TMessageType.CALL, self._seqid)
1827 
    args = billOrder_args()
1828 
    args.orderId = orderId
1132 chandransh 1829 
    args.write(self._oprot)
1830 
    self._oprot.writeMessageEnd()
1831 
    self._oprot.trans.flush()
1832 
 
3064 chandransh 1833 
  def recv_billOrder(self, ):
1132 chandransh 1834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1835 
    if mtype == TMessageType.EXCEPTION:
1836 
      x = TApplicationException()
1837 
      x.read(self._iprot)
1838 
      self._iprot.readMessageEnd()
1839 
      raise x
3064 chandransh 1840 
    result = billOrder_result()
1132 chandransh 1841 
    result.read(self._iprot)
1842 
    self._iprot.readMessageEnd()
3431 rajveer 1843 
    if result.success is not None:
3064 chandransh 1844 
      return result.success
3431 rajveer 1845 
    if result.ex is not None:
1132 chandransh 1846 
      raise result.ex
3064 chandransh 1847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "billOrder failed: unknown result");
1132 chandransh 1848 
 
4264 rajveer 1849 
  def addBillingDetails(self, orderId, invoice_number, billed_by, jacketNumber):
1135 chandransh 1850 
    """
3064 chandransh 1851 
    Add billing details such as the bill number and the biller to the Order.
1852 
    Should be used when the bill is issued by a 3rd party and we've to feed
1853 
    the information into our system.
3431 rajveer 1854 
 
1135 chandransh 1855 
    Parameters:
3064 chandransh 1856 
     - orderId
1857 
     - invoice_number
1858 
     - billed_by
4264 rajveer 1859 
     - jacketNumber
1135 chandransh 1860 
    """
4264 rajveer 1861 
    self.send_addBillingDetails(orderId, invoice_number, billed_by, jacketNumber)
3064 chandransh 1862 
    return self.recv_addBillingDetails()
1135 chandransh 1863 
 
4264 rajveer 1864 
  def send_addBillingDetails(self, orderId, invoice_number, billed_by, jacketNumber):
3064 chandransh 1865 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1866 
    args = addBillingDetails_args()
1867 
    args.orderId = orderId
1868 
    args.invoice_number = invoice_number
1869 
    args.billed_by = billed_by
4264 rajveer 1870 
    args.jacketNumber = jacketNumber
1135 chandransh 1871 
    args.write(self._oprot)
1872 
    self._oprot.writeMessageEnd()
1873 
    self._oprot.trans.flush()
1874 
 
3064 chandransh 1875 
  def recv_addBillingDetails(self, ):
1135 chandransh 1876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1877 
    if mtype == TMessageType.EXCEPTION:
1878 
      x = TApplicationException()
1879 
      x.read(self._iprot)
1880 
      self._iprot.readMessageEnd()
1881 
      raise x
3064 chandransh 1882 
    result = addBillingDetails_result()
1135 chandransh 1883 
    result.read(self._iprot)
1884 
    self._iprot.readMessageEnd()
3431 rajveer 1885 
    if result.success is not None:
3064 chandransh 1886 
      return result.success
3431 rajveer 1887 
    if result.ex is not None:
1135 chandransh 1888 
      raise result.ex
3064 chandransh 1889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 1890 
 
3064 chandransh 1891 
  def addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
1246 chandransh 1892 
    """
3064 chandransh 1893 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1894 
    the IMEI no. if a -1 is supplied.
1895 
    Also, it generates an invoice number for the order, marks the order as
1896 
    BILLED and sets the billing timestamp.
1897 
    It should be used when we are billing the orders ourselves.
3431 rajveer 1898 
 
3064 chandransh 1899 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1900 
 
1246 chandransh 1901 
    Parameters:
3064 chandransh 1902 
     - orderId
1903 
     - jacketNumber
1904 
     - imeiNumber
1905 
     - itemNumber
1906 
     - billedBy
1907 
     - billingType
1246 chandransh 1908 
    """
3064 chandransh 1909 
    self.send_addJacketNumber(orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType)
1910 
    return self.recv_addJacketNumber()
1246 chandransh 1911 
 
3064 chandransh 1912 
  def send_addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
1913 
    self._oprot.writeMessageBegin('addJacketNumber', TMessageType.CALL, self._seqid)
1914 
    args = addJacketNumber_args()
1915 
    args.orderId = orderId
1916 
    args.jacketNumber = jacketNumber
1917 
    args.imeiNumber = imeiNumber
1918 
    args.itemNumber = itemNumber
1919 
    args.billedBy = billedBy
1920 
    args.billingType = billingType
1246 chandransh 1921 
    args.write(self._oprot)
1922 
    self._oprot.writeMessageEnd()
1923 
    self._oprot.trans.flush()
1924 
 
3064 chandransh 1925 
  def recv_addJacketNumber(self, ):
1246 chandransh 1926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1927 
    if mtype == TMessageType.EXCEPTION:
1928 
      x = TApplicationException()
1929 
      x.read(self._iprot)
1930 
      self._iprot.readMessageEnd()
1931 
      raise x
3064 chandransh 1932 
    result = addJacketNumber_result()
1246 chandransh 1933 
    result.read(self._iprot)
1934 
    self._iprot.readMessageEnd()
3431 rajveer 1935 
    if result.success is not None:
3064 chandransh 1936 
      return result.success
3431 rajveer 1937 
    if result.ex is not None:
1246 chandransh 1938 
      raise result.ex
3064 chandransh 1939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addJacketNumber failed: unknown result");
1246 chandransh 1940 
 
3064 chandransh 1941 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 1942 
    """
3064 chandransh 1943 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
1944 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 1945 
 
1408 ankur.sing 1946 
    Parameters:
3064 chandransh 1947 
     - warehouseId
1408 ankur.sing 1948 
     - providerId
3064 chandransh 1949 
     - cod
1408 ankur.sing 1950 
    """
3064 chandransh 1951 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
1952 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 1953 
 
3064 chandransh 1954 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
1955 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1956 
    args = markOrdersAsManifested_args()
1957 
    args.warehouseId = warehouseId
1408 ankur.sing 1958 
    args.providerId = providerId
3064 chandransh 1959 
    args.cod = cod
1408 ankur.sing 1960 
    args.write(self._oprot)
1961 
    self._oprot.writeMessageEnd()
1962 
    self._oprot.trans.flush()
1963 
 
3064 chandransh 1964 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 1965 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1966 
    if mtype == TMessageType.EXCEPTION:
1967 
      x = TApplicationException()
1968 
      x.read(self._iprot)
1969 
      self._iprot.readMessageEnd()
1970 
      raise x
3064 chandransh 1971 
    result = markOrdersAsManifested_result()
1408 ankur.sing 1972 
    result.read(self._iprot)
1973 
    self._iprot.readMessageEnd()
3431 rajveer 1974 
    if result.success is not None:
1408 ankur.sing 1975 
      return result.success
3431 rajveer 1976 
    if result.ex is not None:
3064 chandransh 1977 
      raise result.ex
1978 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 1979 
 
3064 chandransh 1980 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 1981 
    """
3064 chandransh 1982 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
1983 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
1984 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1985 
 
94 ashish 1986 
    Parameters:
3064 chandransh 1987 
     - providerId
1988 
     - pickupDetails
304 ashish 1989 
    """
3064 chandransh 1990 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
1991 
    return self.recv_markOrdersAsPickedUp()
94 ashish 1992 
 
3064 chandransh 1993 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
1994 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
1995 
    args = markOrdersAsPickedUp_args()
1996 
    args.providerId = providerId
1997 
    args.pickupDetails = pickupDetails
304 ashish 1998 
    args.write(self._oprot)
1999 
    self._oprot.writeMessageEnd()
2000 
    self._oprot.trans.flush()
2001 
 
3064 chandransh 2002 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2004 
    if mtype == TMessageType.EXCEPTION:
2005 
      x = TApplicationException()
2006 
      x.read(self._iprot)
2007 
      self._iprot.readMessageEnd()
2008 
      raise x
3064 chandransh 2009 
    result = markOrdersAsPickedUp_result()
304 ashish 2010 
    result.read(self._iprot)
2011 
    self._iprot.readMessageEnd()
3431 rajveer 2012 
    if result.success is not None:
304 ashish 2013 
      return result.success
3431 rajveer 2014 
    if result.ex is not None:
3064 chandransh 2015 
      raise result.ex
2016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2017 
 
3064 chandransh 2018 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2019 
    """
3064 chandransh 2020 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2021 
    the name of the receiver.
2022 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2023 
 
304 ashish 2024 
    Parameters:
3064 chandransh 2025 
     - providerId
2026 
     - deliveredOrders
304 ashish 2027 
    """
3064 chandransh 2028 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2029 
    self.recv_markOrdersAsDelivered()
304 ashish 2030 
 
3064 chandransh 2031 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2032 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2033 
    args = markOrdersAsDelivered_args()
2034 
    args.providerId = providerId
2035 
    args.deliveredOrders = deliveredOrders
304 ashish 2036 
    args.write(self._oprot)
2037 
    self._oprot.writeMessageEnd()
2038 
    self._oprot.trans.flush()
2039 
 
3064 chandransh 2040 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2042 
    if mtype == TMessageType.EXCEPTION:
2043 
      x = TApplicationException()
2044 
      x.read(self._iprot)
2045 
      self._iprot.readMessageEnd()
2046 
      raise x
3064 chandransh 2047 
    result = markOrdersAsDelivered_result()
304 ashish 2048 
    result.read(self._iprot)
2049 
    self._iprot.readMessageEnd()
3431 rajveer 2050 
    if result.ex is not None:
3064 chandransh 2051 
      raise result.ex
304 ashish 2052 
    return
2053 
 
3064 chandransh 2054 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2055 
    """
3064 chandransh 2056 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2057 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2058 
 
3064 chandransh 2059 
    Parameters:
2060 
     - providerId
2061 
     - returnedOrders
1596 ankur.sing 2062 
    """
3064 chandransh 2063 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2064 
    self.recv_markOrdersAsFailed()
304 ashish 2065 
 
3064 chandransh 2066 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2067 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2068 
    args = markOrdersAsFailed_args()
2069 
    args.providerId = providerId
2070 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2071 
    args.write(self._oprot)
2072 
    self._oprot.writeMessageEnd()
2073 
    self._oprot.trans.flush()
2074 
 
3064 chandransh 2075 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2077 
    if mtype == TMessageType.EXCEPTION:
2078 
      x = TApplicationException()
2079 
      x.read(self._iprot)
2080 
      self._iprot.readMessageEnd()
2081 
      raise x
3064 chandransh 2082 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2083 
    result.read(self._iprot)
2084 
    self._iprot.readMessageEnd()
3431 rajveer 2085 
    if result.ex is not None:
3064 chandransh 2086 
      raise result.ex
2087 
    return
1596 ankur.sing 2088 
 
3064 chandransh 2089 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2090 
    """
3064 chandransh 2091 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2092 
 
3064 chandransh 2093 
    Parameters:
2094 
     - providerId
2095 
     - undeliveredOrders
1627 ankur.sing 2096 
    """
3064 chandransh 2097 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2098 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2099 
 
3064 chandransh 2100 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2101 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2102 
    args = updateNonDeliveryReason_args()
2103 
    args.providerId = providerId
2104 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2105 
    args.write(self._oprot)
2106 
    self._oprot.writeMessageEnd()
2107 
    self._oprot.trans.flush()
2108 
 
3064 chandransh 2109 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2111 
    if mtype == TMessageType.EXCEPTION:
2112 
      x = TApplicationException()
2113 
      x.read(self._iprot)
2114 
      self._iprot.readMessageEnd()
2115 
      raise x
3064 chandransh 2116 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2117 
    result.read(self._iprot)
2118 
    self._iprot.readMessageEnd()
3431 rajveer 2119 
    if result.ex is not None:
3064 chandransh 2120 
      raise result.ex
2121 
    return
1627 ankur.sing 2122 
 
3064 chandransh 2123 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2124 
    """
3064 chandransh 2125 
    Returns the list of orders whose delivery time has passed but have not been
2126 
    delivered yet for the given provider and warehouse. To get a complete list of
2127 
    undelivered orders, pass them as -1.
2128 
    Returns an empty list if no such orders exist.
3431 rajveer 2129 
 
1886 ankur.sing 2130 
    Parameters:
3064 chandransh 2131 
     - providerId
2132 
     - warehouseId
1886 ankur.sing 2133 
    """
3064 chandransh 2134 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2135 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2136 
 
3064 chandransh 2137 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2138 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2139 
    args = getUndeliveredOrders_args()
2140 
    args.providerId = providerId
2141 
    args.warehouseId = warehouseId
1886 ankur.sing 2142 
    args.write(self._oprot)
2143 
    self._oprot.writeMessageEnd()
2144 
    self._oprot.trans.flush()
2145 
 
3064 chandransh 2146 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2147 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2148 
    if mtype == TMessageType.EXCEPTION:
2149 
      x = TApplicationException()
2150 
      x.read(self._iprot)
2151 
      self._iprot.readMessageEnd()
2152 
      raise x
3064 chandransh 2153 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2154 
    result.read(self._iprot)
2155 
    self._iprot.readMessageEnd()
3431 rajveer 2156 
    if result.success is not None:
1886 ankur.sing 2157 
      return result.success
3064 chandransh 2158 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2159 
 
2536 chandransh 2160 
  def toggleDOAFlag(self, orderId):
2161 
    """
2162 
    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.
2163 
    Returns the final flag status.
2164 
    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 2165 
 
2536 chandransh 2166 
    Parameters:
2167 
     - orderId
2168 
    """
2169 
    self.send_toggleDOAFlag(orderId)
2170 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2171 
 
2536 chandransh 2172 
  def send_toggleDOAFlag(self, orderId):
2173 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2174 
    args = toggleDOAFlag_args()
2175 
    args.orderId = orderId
2176 
    args.write(self._oprot)
2177 
    self._oprot.writeMessageEnd()
2178 
    self._oprot.trans.flush()
2179 
 
2180 
  def recv_toggleDOAFlag(self, ):
2181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2182 
    if mtype == TMessageType.EXCEPTION:
2183 
      x = TApplicationException()
2184 
      x.read(self._iprot)
2185 
      self._iprot.readMessageEnd()
2186 
      raise x
2187 
    result = toggleDOAFlag_result()
2188 
    result.read(self._iprot)
2189 
    self._iprot.readMessageEnd()
3431 rajveer 2190 
    if result.success is not None:
2536 chandransh 2191 
      return result.success
3431 rajveer 2192 
    if result.ex is not None:
2536 chandransh 2193 
      raise result.ex
2194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2195 
 
2196 
  def requestPickupNumber(self, orderId):
2197 
    """
2198 
    Sends out an email to the account manager of the original courier provider used to ship the order.
2199 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
2200 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
2201 
    For any other status, it returns false.
2202 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2203 
 
2536 chandransh 2204 
    Parameters:
2205 
     - orderId
2206 
    """
2207 
    self.send_requestPickupNumber(orderId)
2208 
    return self.recv_requestPickupNumber()
2209 
 
2210 
  def send_requestPickupNumber(self, orderId):
2211 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2212 
    args = requestPickupNumber_args()
2213 
    args.orderId = orderId
2214 
    args.write(self._oprot)
2215 
    self._oprot.writeMessageEnd()
2216 
    self._oprot.trans.flush()
2217 
 
2218 
  def recv_requestPickupNumber(self, ):
2219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2220 
    if mtype == TMessageType.EXCEPTION:
2221 
      x = TApplicationException()
2222 
      x.read(self._iprot)
2223 
      self._iprot.readMessageEnd()
2224 
      raise x
2225 
    result = requestPickupNumber_result()
2226 
    result.read(self._iprot)
2227 
    self._iprot.readMessageEnd()
3431 rajveer 2228 
    if result.success is not None:
2536 chandransh 2229 
      return result.success
3431 rajveer 2230 
    if result.ex is not None:
2536 chandransh 2231 
      raise result.ex
2232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2233 
 
2234 
  def authorizePickup(self, orderId, pickupNumber):
2235 
    """
2236 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
2237 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2238 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2239 
    	3. Returns true
2591 chandransh 2240 
    If the order is in any other status, it returns false.
2536 chandransh 2241 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2242 
 
2536 chandransh 2243 
    Parameters:
2244 
     - orderId
2245 
     - pickupNumber
2246 
    """
2247 
    self.send_authorizePickup(orderId, pickupNumber)
2248 
    return self.recv_authorizePickup()
2249 
 
2250 
  def send_authorizePickup(self, orderId, pickupNumber):
2251 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2252 
    args = authorizePickup_args()
2253 
    args.orderId = orderId
2254 
    args.pickupNumber = pickupNumber
2255 
    args.write(self._oprot)
2256 
    self._oprot.writeMessageEnd()
2257 
    self._oprot.trans.flush()
2258 
 
2259 
  def recv_authorizePickup(self, ):
2260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2261 
    if mtype == TMessageType.EXCEPTION:
2262 
      x = TApplicationException()
2263 
      x.read(self._iprot)
2264 
      self._iprot.readMessageEnd()
2265 
      raise x
2266 
    result = authorizePickup_result()
2267 
    result.read(self._iprot)
2268 
    self._iprot.readMessageEnd()
3431 rajveer 2269 
    if result.success is not None:
2536 chandransh 2270 
      return result.success
3431 rajveer 2271 
    if result.ex is not None:
2536 chandransh 2272 
      raise result.ex
2273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2274 
 
2764 chandransh 2275 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2276 
    """
2277 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2278 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2279 
 
2764 chandransh 2280 
    Parameters:
2281 
     - providerId
2282 
     - pickupDetails
2283 
    """
2284 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2285 
    return self.recv_markDoasAsPickedUp()
2286 
 
2287 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2288 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2289 
    args = markDoasAsPickedUp_args()
2290 
    args.providerId = providerId
2291 
    args.pickupDetails = pickupDetails
2292 
    args.write(self._oprot)
2293 
    self._oprot.writeMessageEnd()
2294 
    self._oprot.trans.flush()
2295 
 
2296 
  def recv_markDoasAsPickedUp(self, ):
2297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2298 
    if mtype == TMessageType.EXCEPTION:
2299 
      x = TApplicationException()
2300 
      x.read(self._iprot)
2301 
      self._iprot.readMessageEnd()
2302 
      raise x
2303 
    result = markDoasAsPickedUp_result()
2304 
    result.read(self._iprot)
2305 
    self._iprot.readMessageEnd()
3431 rajveer 2306 
    if result.success is not None:
2764 chandransh 2307 
      return result.success
2308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2309 
 
2616 chandransh 2310 
  def receiveReturn(self, orderId):
2591 chandransh 2311 
    """
2599 chandransh 2312 
    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 2313 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 2314 
    If the order is in any other state, it returns false.
2315 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2316 
 
2591 chandransh 2317 
    Parameters:
2318 
     - orderId
2319 
    """
2616 chandransh 2320 
    self.send_receiveReturn(orderId)
2321 
    return self.recv_receiveReturn()
2536 chandransh 2322 
 
2616 chandransh 2323 
  def send_receiveReturn(self, orderId):
2324 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2325 
    args = receiveReturn_args()
2591 chandransh 2326 
    args.orderId = orderId
2327 
    args.write(self._oprot)
2328 
    self._oprot.writeMessageEnd()
2329 
    self._oprot.trans.flush()
2330 
 
2616 chandransh 2331 
  def recv_receiveReturn(self, ):
2591 chandransh 2332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2333 
    if mtype == TMessageType.EXCEPTION:
2334 
      x = TApplicationException()
2335 
      x.read(self._iprot)
2336 
      self._iprot.readMessageEnd()
2337 
      raise x
2616 chandransh 2338 
    result = receiveReturn_result()
2591 chandransh 2339 
    result.read(self._iprot)
2340 
    self._iprot.readMessageEnd()
3431 rajveer 2341 
    if result.success is not None:
2591 chandransh 2342 
      return result.success
3431 rajveer 2343 
    if result.ex is not None:
2591 chandransh 2344 
      raise result.ex
2616 chandransh 2345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2346 
 
2347 
  def validateDoa(self, orderId, isValid):
2348 
    """
2599 chandransh 2349 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 2350 
    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 2351 
    If the order is in any other state, it returns false.
2352 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2353 
 
2591 chandransh 2354 
    Parameters:
2355 
     - orderId
2356 
     - isValid
2357 
    """
2358 
    self.send_validateDoa(orderId, isValid)
2359 
    return self.recv_validateDoa()
2360 
 
2361 
  def send_validateDoa(self, orderId, isValid):
2362 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2363 
    args = validateDoa_args()
2364 
    args.orderId = orderId
2365 
    args.isValid = isValid
2366 
    args.write(self._oprot)
2367 
    self._oprot.writeMessageEnd()
2368 
    self._oprot.trans.flush()
2369 
 
2370 
  def recv_validateDoa(self, ):
2371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2372 
    if mtype == TMessageType.EXCEPTION:
2373 
      x = TApplicationException()
2374 
      x.read(self._iprot)
2375 
      self._iprot.readMessageEnd()
2376 
      raise x
2377 
    result = validateDoa_result()
2378 
    result.read(self._iprot)
2379 
    self._iprot.readMessageEnd()
3431 rajveer 2380 
    if result.success is not None:
2591 chandransh 2381 
      return result.success
3431 rajveer 2382 
    if result.ex is not None:
2591 chandransh 2383 
      raise result.ex
2384 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2385 
 
2616 chandransh 2386 
  def reshipOrder(self, orderId):
2387 
    """
2388 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2389 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2390 
    	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.
2391 
 
2392 
    If the order is in DOA_CERT_VALID state, it does the following:
2393 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2394 
    	2. Creates a return order for the warehouse executive to return the DOA material.
2395 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 2396 
 
2616 chandransh 2397 
    Returns the id of the newly created order.
3431 rajveer 2398 
 
2616 chandransh 2399 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2400 
 
2616 chandransh 2401 
    Parameters:
2402 
     - orderId
2403 
    """
2404 
    self.send_reshipOrder(orderId)
2405 
    return self.recv_reshipOrder()
2591 chandransh 2406 
 
2616 chandransh 2407 
  def send_reshipOrder(self, orderId):
2408 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2409 
    args = reshipOrder_args()
2410 
    args.orderId = orderId
2411 
    args.write(self._oprot)
2412 
    self._oprot.writeMessageEnd()
2413 
    self._oprot.trans.flush()
2414 
 
2415 
  def recv_reshipOrder(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 = reshipOrder_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, "reshipOrder failed: unknown result");
2430 
 
3226 chandransh 2431 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2432 
    """
2433 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2434 
    	1. Creates a refund request for batch processing.
2435 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2436 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2437 
 
2616 chandransh 2438 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2439 
    	1. Creates a refund request for batch processing.
3226 chandransh 2440 
    	2. Cancels the reservation of the item in the warehouse.
2441 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2442 
 
3226 chandransh 2443 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2444 
    	1. Cancels the reservation of the item in the warehouse.
2445 
    	2. Marks the current order as CANCELED.
2446 
 
2447 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2448 
 
2616 chandransh 2449 
    Returns True if it is successful, False otherwise.
3431 rajveer 2450 
 
2616 chandransh 2451 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2452 
 
2616 chandransh 2453 
    Parameters:
2454 
     - orderId
3226 chandransh 2455 
     - refundedBy
2456 
     - reason
2616 chandransh 2457 
    """
3226 chandransh 2458 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2459 
    return self.recv_refundOrder()
2460 
 
3226 chandransh 2461 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2462 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2463 
    args = refundOrder_args()
2464 
    args.orderId = orderId
3226 chandransh 2465 
    args.refundedBy = refundedBy
2466 
    args.reason = reason
2616 chandransh 2467 
    args.write(self._oprot)
2468 
    self._oprot.writeMessageEnd()
2469 
    self._oprot.trans.flush()
2470 
 
2471 
  def recv_refundOrder(self, ):
2472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2473 
    if mtype == TMessageType.EXCEPTION:
2474 
      x = TApplicationException()
2475 
      x.read(self._iprot)
2476 
      self._iprot.readMessageEnd()
2477 
      raise x
2478 
    result = refundOrder_result()
2479 
    result.read(self._iprot)
2480 
    self._iprot.readMessageEnd()
3431 rajveer 2481 
    if result.success is not None:
2616 chandransh 2482 
      return result.success
3431 rajveer 2483 
    if result.ex is not None:
2616 chandransh 2484 
      raise result.ex
2485 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2486 
 
2690 chandransh 2487 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2488 
    """
2489 
    Get all return orders created between the from and to dates for the given warehouse.
2490 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2491 
 
2690 chandransh 2492 
    Parameters:
2493 
     - warehouseId
2494 
     - fromDate
2495 
     - toDate
2496 
    """
2497 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2498 
    return self.recv_getReturnOrders()
2616 chandransh 2499 
 
2690 chandransh 2500 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2501 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2502 
    args = getReturnOrders_args()
2503 
    args.warehouseId = warehouseId
2504 
    args.fromDate = fromDate
2505 
    args.toDate = toDate
2506 
    args.write(self._oprot)
2507 
    self._oprot.writeMessageEnd()
2508 
    self._oprot.trans.flush()
2509 
 
2510 
  def recv_getReturnOrders(self, ):
2511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2512 
    if mtype == TMessageType.EXCEPTION:
2513 
      x = TApplicationException()
2514 
      x.read(self._iprot)
2515 
      self._iprot.readMessageEnd()
2516 
      raise x
2517 
    result = getReturnOrders_result()
2518 
    result.read(self._iprot)
2519 
    self._iprot.readMessageEnd()
3431 rajveer 2520 
    if result.success is not None:
2690 chandransh 2521 
      return result.success
2522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2523 
 
2700 chandransh 2524 
  def getReturnOrder(self, id):
2525 
    """
2526 
    Returns the ReturnOrder corresponding to the given id.
2527 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2528 
 
2700 chandransh 2529 
    Parameters:
2530 
     - id
2531 
    """
2532 
    self.send_getReturnOrder(id)
2533 
    return self.recv_getReturnOrder()
2534 
 
2535 
  def send_getReturnOrder(self, id):
2536 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2537 
    args = getReturnOrder_args()
2538 
    args.id = id
2539 
    args.write(self._oprot)
2540 
    self._oprot.writeMessageEnd()
2541 
    self._oprot.trans.flush()
2542 
 
2543 
  def recv_getReturnOrder(self, ):
2544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2545 
    if mtype == TMessageType.EXCEPTION:
2546 
      x = TApplicationException()
2547 
      x.read(self._iprot)
2548 
      self._iprot.readMessageEnd()
2549 
      raise x
2550 
    result = getReturnOrder_result()
2551 
    result.read(self._iprot)
2552 
    self._iprot.readMessageEnd()
3431 rajveer 2553 
    if result.success is not None:
2700 chandransh 2554 
      return result.success
3431 rajveer 2555 
    if result.ex is not None:
2700 chandransh 2556 
      raise result.ex
2557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2558 
 
2690 chandransh 2559 
  def processReturn(self, returnOrderId):
2560 
    """
2561 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2562 
 
2690 chandransh 2563 
    Parameters:
2564 
     - returnOrderId
2565 
    """
2566 
    self.send_processReturn(returnOrderId)
2567 
    self.recv_processReturn()
2568 
 
2569 
  def send_processReturn(self, returnOrderId):
2570 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2571 
    args = processReturn_args()
2572 
    args.returnOrderId = returnOrderId
2573 
    args.write(self._oprot)
2574 
    self._oprot.writeMessageEnd()
2575 
    self._oprot.trans.flush()
2576 
 
2577 
  def recv_processReturn(self, ):
2578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2579 
    if mtype == TMessageType.EXCEPTION:
2580 
      x = TApplicationException()
2581 
      x.read(self._iprot)
2582 
      self._iprot.readMessageEnd()
2583 
      raise x
2584 
    result = processReturn_result()
2585 
    result.read(self._iprot)
2586 
    self._iprot.readMessageEnd()
3431 rajveer 2587 
    if result.ex is not None:
2690 chandransh 2588 
      raise result.ex
2589 
    return
2590 
 
2819 chandransh 2591 
  def createPurchaseOrder(self, warehouseId):
2592 
    """
2593 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2594 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2595 
 
2819 chandransh 2596 
    Parameters:
2597 
     - warehouseId
2598 
    """
2599 
    self.send_createPurchaseOrder(warehouseId)
2600 
    return self.recv_createPurchaseOrder()
2690 chandransh 2601 
 
2819 chandransh 2602 
  def send_createPurchaseOrder(self, warehouseId):
2603 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2604 
    args = createPurchaseOrder_args()
2605 
    args.warehouseId = warehouseId
2606 
    args.write(self._oprot)
2607 
    self._oprot.writeMessageEnd()
2608 
    self._oprot.trans.flush()
2609 
 
2610 
  def recv_createPurchaseOrder(self, ):
2611 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2612 
    if mtype == TMessageType.EXCEPTION:
2613 
      x = TApplicationException()
2614 
      x.read(self._iprot)
2615 
      self._iprot.readMessageEnd()
2616 
      raise x
2617 
    result = createPurchaseOrder_result()
2618 
    result.read(self._iprot)
2619 
    self._iprot.readMessageEnd()
3431 rajveer 2620 
    if result.success is not None:
2819 chandransh 2621 
      return result.success
3431 rajveer 2622 
    if result.ex is not None:
2819 chandransh 2623 
      raise result.ex
2624 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2625 
 
3451 chandransh 2626 
  def updateWeight(self, orderId, weight):
2627 
    """
2628 
    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 2629 
 
3451 chandransh 2630 
    Parameters:
2631 
     - orderId
2632 
     - weight
2633 
    """
2634 
    self.send_updateWeight(orderId, weight)
2635 
    return self.recv_updateWeight()
2636 
 
2637 
  def send_updateWeight(self, orderId, weight):
2638 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2639 
    args = updateWeight_args()
2640 
    args.orderId = orderId
2641 
    args.weight = weight
2642 
    args.write(self._oprot)
2643 
    self._oprot.writeMessageEnd()
2644 
    self._oprot.trans.flush()
2645 
 
2646 
  def recv_updateWeight(self, ):
2647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2648 
    if mtype == TMessageType.EXCEPTION:
2649 
      x = TApplicationException()
2650 
      x.read(self._iprot)
2651 
      self._iprot.readMessageEnd()
2652 
      raise x
2653 
    result = updateWeight_result()
2654 
    result.read(self._iprot)
2655 
    self._iprot.readMessageEnd()
2656 
    if result.success is not None:
2657 
      return result.success
2658 
    if result.ex is not None:
2659 
      raise result.ex
2660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2661 
 
3469 chandransh 2662 
  def changeItem(self, orderId, itemId):
2663 
    """
2664 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2665 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2666 
 
3469 chandransh 2667 
    Parameters:
2668 
     - orderId
2669 
     - itemId
2670 
    """
2671 
    self.send_changeItem(orderId, itemId)
2672 
    return self.recv_changeItem()
2673 
 
2674 
  def send_changeItem(self, orderId, itemId):
2675 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2676 
    args = changeItem_args()
2677 
    args.orderId = orderId
2678 
    args.itemId = itemId
2679 
    args.write(self._oprot)
2680 
    self._oprot.writeMessageEnd()
2681 
    self._oprot.trans.flush()
2682 
 
2683 
  def recv_changeItem(self, ):
2684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2685 
    if mtype == TMessageType.EXCEPTION:
2686 
      x = TApplicationException()
2687 
      x.read(self._iprot)
2688 
      self._iprot.readMessageEnd()
2689 
      raise x
2690 
    result = changeItem_result()
2691 
    result.read(self._iprot)
2692 
    self._iprot.readMessageEnd()
2693 
    if result.success is not None:
2694 
      return result.success
2695 
    if result.ex is not None:
2696 
      raise result.ex
2697 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2698 
 
2699 
  def shiftToWarehouse(self, orderId, warehouseId):
2700 
    """
2701 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2702 
 
2703 
    Parameters:
2704 
     - orderId
2705 
     - warehouseId
2706 
    """
2707 
    self.send_shiftToWarehouse(orderId, warehouseId)
2708 
    return self.recv_shiftToWarehouse()
2709 
 
2710 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2711 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2712 
    args = shiftToWarehouse_args()
2713 
    args.orderId = orderId
2714 
    args.warehouseId = warehouseId
2715 
    args.write(self._oprot)
2716 
    self._oprot.writeMessageEnd()
2717 
    self._oprot.trans.flush()
2718 
 
2719 
  def recv_shiftToWarehouse(self, ):
2720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2721 
    if mtype == TMessageType.EXCEPTION:
2722 
      x = TApplicationException()
2723 
      x.read(self._iprot)
2724 
      self._iprot.readMessageEnd()
2725 
      raise x
2726 
    result = shiftToWarehouse_result()
2727 
    result.read(self._iprot)
2728 
    self._iprot.readMessageEnd()
2729 
    if result.success is not None:
2730 
      return result.success
2731 
    if result.ex is not None:
2732 
      raise result.ex
2733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
2734 
 
3986 chandransh 2735 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2736 
    """
2737 
    Adds the given delay reason to the given order.
3986 chandransh 2738 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 2739 
    Raises an exception if no order with the given id can be found.
3469 chandransh 2740 
 
3553 chandransh 2741 
    Parameters:
2742 
     - orderId
2743 
     - delayReason
3986 chandransh 2744 
     - furtherDelay
3553 chandransh 2745 
    """
3986 chandransh 2746 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 2747 
    return self.recv_addDelayReason()
2748 
 
3986 chandransh 2749 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2750 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
2751 
    args = addDelayReason_args()
2752 
    args.orderId = orderId
2753 
    args.delayReason = delayReason
3986 chandransh 2754 
    args.furtherDelay = furtherDelay
3553 chandransh 2755 
    args.write(self._oprot)
2756 
    self._oprot.writeMessageEnd()
2757 
    self._oprot.trans.flush()
2758 
 
2759 
  def recv_addDelayReason(self, ):
2760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2761 
    if mtype == TMessageType.EXCEPTION:
2762 
      x = TApplicationException()
2763 
      x.read(self._iprot)
2764 
      self._iprot.readMessageEnd()
2765 
      raise x
2766 
    result = addDelayReason_result()
2767 
    result.read(self._iprot)
2768 
    self._iprot.readMessageEnd()
2769 
    if result.success is not None:
2770 
      return result.success
2771 
    if result.ex is not None:
2772 
      raise result.ex
2773 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
2774 
 
3956 chandransh 2775 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2776 
    """
2777 
    Marks the COD orders with given AWB nos. as having been processed.
2778 
    Updates the captured amount for the corresponding payment.
3553 chandransh 2779 
 
3956 chandransh 2780 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
2781 
    1. There is no order corresponding to an AWB number.
2782 
    2. The captured amount for a payment exceeds the total payment.
2783 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
2784 
 
2785 
    Parameters:
2786 
     - collectedAmountMap
2787 
     - xferBy
2788 
     - xferTxnId
2789 
     - xferDate
2790 
    """
2791 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
2792 
    return self.recv_reconcileCodCollection()
2793 
 
2794 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2795 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
2796 
    args = reconcileCodCollection_args()
2797 
    args.collectedAmountMap = collectedAmountMap
2798 
    args.xferBy = xferBy
2799 
    args.xferTxnId = xferTxnId
2800 
    args.xferDate = xferDate
2801 
    args.write(self._oprot)
2802 
    self._oprot.writeMessageEnd()
2803 
    self._oprot.trans.flush()
2804 
 
2805 
  def recv_reconcileCodCollection(self, ):
2806 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2807 
    if mtype == TMessageType.EXCEPTION:
2808 
      x = TApplicationException()
2809 
      x.read(self._iprot)
2810 
      self._iprot.readMessageEnd()
2811 
      raise x
2812 
    result = reconcileCodCollection_result()
2813 
    result.read(self._iprot)
2814 
    self._iprot.readMessageEnd()
2815 
    if result.success is not None:
2816 
      return result.success
2817 
    if result.ex is not None:
2818 
      raise result.ex
2819 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
2820 
 
4008 mandeep.dh 2821 
  def getTransactionsRequiringExtraProcessing(self, category):
2822 
    """
4065 mandeep.dh 2823 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 2824 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 2825 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 2826 
 
4008 mandeep.dh 2827 
    Parameters:
2828 
     - category
2829 
    """
2830 
    self.send_getTransactionsRequiringExtraProcessing(category)
2831 
    return self.recv_getTransactionsRequiringExtraProcessing()
2832 
 
2833 
  def send_getTransactionsRequiringExtraProcessing(self, category):
2834 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
2835 
    args = getTransactionsRequiringExtraProcessing_args()
2836 
    args.category = category
2837 
    args.write(self._oprot)
2838 
    self._oprot.writeMessageEnd()
2839 
    self._oprot.trans.flush()
2840 
 
2841 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
2842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2843 
    if mtype == TMessageType.EXCEPTION:
2844 
      x = TApplicationException()
2845 
      x.read(self._iprot)
2846 
      self._iprot.readMessageEnd()
2847 
      raise x
2848 
    result = getTransactionsRequiringExtraProcessing_result()
2849 
    result.read(self._iprot)
2850 
    self._iprot.readMessageEnd()
2851 
    if result.success is not None:
2852 
      return result.success
2853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
2854 
 
2855 
  def markTransactionAsProcessed(self, transactionId, category):
2856 
    """
2857 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 2858 
    It essentially deletes the transaction id record for a particular
2859 
    processing type category (if present) from DB.
2860 
    This is currently used by CRM application.
4008 mandeep.dh 2861 
 
2862 
    Parameters:
2863 
     - transactionId
2864 
     - category
2865 
    """
2866 
    self.send_markTransactionAsProcessed(transactionId, category)
2867 
    self.recv_markTransactionAsProcessed()
2868 
 
2869 
  def send_markTransactionAsProcessed(self, transactionId, category):
2870 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
2871 
    args = markTransactionAsProcessed_args()
2872 
    args.transactionId = transactionId
2873 
    args.category = category
2874 
    args.write(self._oprot)
2875 
    self._oprot.writeMessageEnd()
2876 
    self._oprot.trans.flush()
2877 
 
2878 
  def recv_markTransactionAsProcessed(self, ):
2879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2880 
    if mtype == TMessageType.EXCEPTION:
2881 
      x = TApplicationException()
2882 
      x.read(self._iprot)
2883 
      self._iprot.readMessageEnd()
2884 
      raise x
2885 
    result = markTransactionAsProcessed_result()
2886 
    result.read(self._iprot)
2887 
    self._iprot.readMessageEnd()
2888 
    return
2889 
 
4018 chandransh 2890 
  def getItemWiseRiskyOrdersCount(self, ):
2891 
    """
2892 
    Returns a map containing the number of risky orders keyed by item id. A risky order
2893 
    is defined as one whose shipping date is about to expire.
2894 
    """
2895 
    self.send_getItemWiseRiskyOrdersCount()
2896 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 2897 
 
4018 chandransh 2898 
  def send_getItemWiseRiskyOrdersCount(self, ):
2899 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
2900 
    args = getItemWiseRiskyOrdersCount_args()
2901 
    args.write(self._oprot)
2902 
    self._oprot.writeMessageEnd()
2903 
    self._oprot.trans.flush()
2904 
 
2905 
  def recv_getItemWiseRiskyOrdersCount(self, ):
2906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2907 
    if mtype == TMessageType.EXCEPTION:
2908 
      x = TApplicationException()
2909 
      x.read(self._iprot)
2910 
      self._iprot.readMessageEnd()
2911 
      raise x
2912 
    result = getItemWiseRiskyOrdersCount_result()
2913 
    result.read(self._iprot)
2914 
    self._iprot.readMessageEnd()
2915 
    if result.success is not None:
2916 
      return result.success
2917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
2918 
 
4247 rajveer 2919 
  def markOrderCancellationRequestReceived(self, orderId):
2920 
    """
2921 
    Mark order as cancellation request received. If customer sends request of cancellation of
2922 
    a particular order, this method will be called. It will just change status of the order
2923 
    depending on its current status. It also records the previous status, so that we can move
2924 
    back to that status if cancellation request is denied.
4018 chandransh 2925 
 
4247 rajveer 2926 
    Parameters:
2927 
     - orderId
2928 
    """
2929 
    self.send_markOrderCancellationRequestReceived(orderId)
2930 
    self.recv_markOrderCancellationRequestReceived()
2931 
 
2932 
  def send_markOrderCancellationRequestReceived(self, orderId):
2933 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
2934 
    args = markOrderCancellationRequestReceived_args()
2935 
    args.orderId = orderId
2936 
    args.write(self._oprot)
2937 
    self._oprot.writeMessageEnd()
2938 
    self._oprot.trans.flush()
2939 
 
2940 
  def recv_markOrderCancellationRequestReceived(self, ):
2941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2942 
    if mtype == TMessageType.EXCEPTION:
2943 
      x = TApplicationException()
2944 
      x.read(self._iprot)
2945 
      self._iprot.readMessageEnd()
2946 
      raise x
2947 
    result = markOrderCancellationRequestReceived_result()
2948 
    result.read(self._iprot)
2949 
    self._iprot.readMessageEnd()
2950 
    if result.ex is not None:
2951 
      raise result.ex
2952 
    return
2953 
 
2954 
  def markOrderCancellationRequestConfirmed(self, orderId):
2955 
    """
2956 
    If we decide to to cancel order, CRM will call this method to move the status of order to
2957 
    cancellation request confirmed. After this OM will be able to cancel the order.
2958 
 
2959 
    Parameters:
2960 
     - orderId
2961 
    """
2962 
    self.send_markOrderCancellationRequestConfirmed(orderId)
2963 
    self.recv_markOrderCancellationRequestConfirmed()
2964 
 
2965 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
2966 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
2967 
    args = markOrderCancellationRequestConfirmed_args()
2968 
    args.orderId = orderId
2969 
    args.write(self._oprot)
2970 
    self._oprot.writeMessageEnd()
2971 
    self._oprot.trans.flush()
2972 
 
2973 
  def recv_markOrderCancellationRequestConfirmed(self, ):
2974 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2975 
    if mtype == TMessageType.EXCEPTION:
2976 
      x = TApplicationException()
2977 
      x.read(self._iprot)
2978 
      self._iprot.readMessageEnd()
2979 
      raise x
2980 
    result = markOrderCancellationRequestConfirmed_result()
2981 
    result.read(self._iprot)
2982 
    self._iprot.readMessageEnd()
2983 
    if result.ex is not None:
2984 
      raise result.ex
2985 
    return
2986 
 
2987 
  def markOrderCancellationRequestDenied(self, orderId):
2988 
    """
2989 
    If we decide to not to cancel order, we will move the order ro previous status.
2990 
 
2991 
    Parameters:
2992 
     - orderId
2993 
    """
2994 
    self.send_markOrderCancellationRequestDenied(orderId)
2995 
    self.recv_markOrderCancellationRequestDenied()
2996 
 
2997 
  def send_markOrderCancellationRequestDenied(self, orderId):
2998 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
2999 
    args = markOrderCancellationRequestDenied_args()
3000 
    args.orderId = orderId
3001 
    args.write(self._oprot)
3002 
    self._oprot.writeMessageEnd()
3003 
    self._oprot.trans.flush()
3004 
 
3005 
  def recv_markOrderCancellationRequestDenied(self, ):
3006 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3007 
    if mtype == TMessageType.EXCEPTION:
3008 
      x = TApplicationException()
3009 
      x.read(self._iprot)
3010 
      self._iprot.readMessageEnd()
3011 
      raise x
3012 
    result = markOrderCancellationRequestDenied_result()
3013 
    result.read(self._iprot)
3014 
    self._iprot.readMessageEnd()
3015 
    if result.ex is not None:
3016 
      raise result.ex
3017 
    return
3018 
 
4258 rajveer 3019 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3020 
    """
4258 rajveer 3021 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3022 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3023 
 
3024 
    Parameters:
4258 rajveer 3025 
     - transactionId
4247 rajveer 3026 
    """
4258 rajveer 3027 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3028 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3029 
 
4258 rajveer 3030 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3031 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3032 
    args = markTransactionAsPaymentFlagRemoved_args()
3033 
    args.transactionId = transactionId
4247 rajveer 3034 
    args.write(self._oprot)
3035 
    self._oprot.writeMessageEnd()
3036 
    self._oprot.trans.flush()
3037 
 
4258 rajveer 3038 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3040 
    if mtype == TMessageType.EXCEPTION:
3041 
      x = TApplicationException()
3042 
      x.read(self._iprot)
3043 
      self._iprot.readMessageEnd()
3044 
      raise x
4258 rajveer 3045 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3046 
    result.read(self._iprot)
3047 
    self._iprot.readMessageEnd()
3048 
    if result.ex is not None:
3049 
      raise result.ex
3050 
    return
3051 
 
4259 anupam.sin 3052 
  def refundTransaction(self, transactionId, refundedBy, reason):
3053 
    """
3054 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3055 
    need to be cancelled
4247 rajveer 3056 
 
4259 anupam.sin 3057 
    Parameters:
3058 
     - transactionId
3059 
     - refundedBy
3060 
     - reason
3061 
    """
3062 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3063 
    self.recv_refundTransaction()
3064 
 
3065 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3066 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3067 
    args = refundTransaction_args()
3068 
    args.transactionId = transactionId
3069 
    args.refundedBy = refundedBy
3070 
    args.reason = reason
3071 
    args.write(self._oprot)
3072 
    self._oprot.writeMessageEnd()
3073 
    self._oprot.trans.flush()
3074 
 
3075 
  def recv_refundTransaction(self, ):
3076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3077 
    if mtype == TMessageType.EXCEPTION:
3078 
      x = TApplicationException()
3079 
      x.read(self._iprot)
3080 
      self._iprot.readMessageEnd()
3081 
      raise x
3082 
    result = refundTransaction_result()
3083 
    result.read(self._iprot)
3084 
    self._iprot.readMessageEnd()
3085 
    if result.ex is not None:
3086 
      raise result.ex
3087 
    return
3088 
 
3089 
 
3376 rajveer 3090 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3091 
  def __init__(self, handler):
3376 rajveer 3092 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3093 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3094 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3095 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3096 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3097 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3098 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3099 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3100 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3101 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3102 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3103 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3104 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3105 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3106 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3107 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3108 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3109 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3110 
    self._processMap["createOrder"] = Processor.process_createOrder
3111 
    self._processMap["getOrder"] = Processor.process_getOrder
3112 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3113 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3114 
    self._processMap["getAlerts"] = Processor.process_getAlerts
3115 
    self._processMap["setAlert"] = Processor.process_setAlert
3116 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3117 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3118 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3119 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3120 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3121 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3122 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3123 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3124 
    self._processMap["billOrder"] = Processor.process_billOrder
3125 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
3126 
    self._processMap["addJacketNumber"] = Processor.process_addJacketNumber
759 chandransh 3127 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 3128 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3129 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3130 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3131 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3132 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3133 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
3134 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3135 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3136 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3137 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3138 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 3139 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3140 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3141 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3142 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3143 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3144 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3145 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3146 
    self._processMap["changeItem"] = Processor.process_changeItem
3147 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3148 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3149 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3150 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3151 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3152 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4247 rajveer 3153 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3154 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3155 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3156 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3157 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
94 ashish 3158 
 
3159 
  def process(self, iprot, oprot):
3160 
    (name, type, seqid) = iprot.readMessageBegin()
3161 
    if name not in self._processMap:
3162 
      iprot.skip(TType.STRUCT)
3163 
      iprot.readMessageEnd()
3164 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3165 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3166 
      x.write(oprot)
3167 
      oprot.writeMessageEnd()
3168 
      oprot.trans.flush()
3169 
      return
3170 
    else:
3171 
      self._processMap[name](self, seqid, iprot, oprot)
3172 
    return True
3173 
 
3174 
  def process_createTransaction(self, seqid, iprot, oprot):
3175 
    args = createTransaction_args()
3176 
    args.read(iprot)
3177 
    iprot.readMessageEnd()
3178 
    result = createTransaction_result()
3179 
    try:
132 ashish 3180 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3181 
    except TransactionServiceException, ex:
3182 
      result.ex = ex
3183 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3184 
    result.write(oprot)
3185 
    oprot.writeMessageEnd()
3186 
    oprot.trans.flush()
3187 
 
3188 
  def process_getTransaction(self, seqid, iprot, oprot):
3189 
    args = getTransaction_args()
3190 
    args.read(iprot)
3191 
    iprot.readMessageEnd()
3192 
    result = getTransaction_result()
3193 
    try:
3194 
      result.success = self._handler.getTransaction(args.id)
3195 
    except TransactionServiceException, ex:
3196 
      result.ex = ex
3197 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3198 
    result.write(oprot)
3199 
    oprot.writeMessageEnd()
3200 
    oprot.trans.flush()
3201 
 
3202 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3203 
    args = getTransactionsForCustomer_args()
3204 
    args.read(iprot)
3205 
    iprot.readMessageEnd()
3206 
    result = getTransactionsForCustomer_result()
3207 
    try:
3208 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3209 
    except TransactionServiceException, ex:
3210 
      result.ex = ex
3211 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3212 
    result.write(oprot)
3213 
    oprot.writeMessageEnd()
3214 
    oprot.trans.flush()
3215 
 
132 ashish 3216 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3217 
    args = getTransactionsForShoppingCartId_args()
3218 
    args.read(iprot)
3219 
    iprot.readMessageEnd()
3220 
    result = getTransactionsForShoppingCartId_result()
3221 
    try:
3222 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3223 
    except TransactionServiceException, ex:
3224 
      result.ex = ex
3225 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3226 
    result.write(oprot)
3227 
    oprot.writeMessageEnd()
3228 
    oprot.trans.flush()
3229 
 
94 ashish 3230 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3231 
    args = getTransactionStatus_args()
3232 
    args.read(iprot)
3233 
    iprot.readMessageEnd()
3234 
    result = getTransactionStatus_result()
3235 
    try:
3236 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3237 
    except TransactionServiceException, ex:
3238 
      result.ex = ex
3239 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3240 
    result.write(oprot)
3241 
    oprot.writeMessageEnd()
3242 
    oprot.trans.flush()
3243 
 
3244 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3245 
    args = changeTransactionStatus_args()
3246 
    args.read(iprot)
3247 
    iprot.readMessageEnd()
3248 
    result = changeTransactionStatus_result()
3249 
    try:
3250 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3251 
    except TransactionServiceException, ex:
3252 
      result.ex = ex
3253 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3254 
    result.write(oprot)
3255 
    oprot.writeMessageEnd()
3256 
    oprot.trans.flush()
3257 
 
1398 varun.gupt 3258 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3259 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3260 
    args.read(iprot)
3261 
    iprot.readMessageEnd()
1398 varun.gupt 3262 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3263 
    try:
1398 varun.gupt 3264 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3265 
    except TransactionServiceException, ex:
3266 
      result.ex = ex
1398 varun.gupt 3267 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3268 
    result.write(oprot)
3269 
    oprot.writeMessageEnd()
3270 
    oprot.trans.flush()
3271 
 
483 rajveer 3272 
  def process_getAllOrders(self, seqid, iprot, oprot):
3273 
    args = getAllOrders_args()
94 ashish 3274 
    args.read(iprot)
3275 
    iprot.readMessageEnd()
483 rajveer 3276 
    result = getAllOrders_result()
94 ashish 3277 
    try:
483 rajveer 3278 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3279 
    except TransactionServiceException, ex:
3280 
      result.ex = ex
483 rajveer 3281 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3282 
    result.write(oprot)
3283 
    oprot.writeMessageEnd()
3284 
    oprot.trans.flush()
3285 
 
4133 chandransh 3286 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3287 
    args = getOrdersInBatch_args()
3288 
    args.read(iprot)
3289 
    iprot.readMessageEnd()
3290 
    result = getOrdersInBatch_result()
3291 
    try:
3292 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3293 
    except TransactionServiceException, ex:
3294 
      result.ex = ex
3295 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3296 
    result.write(oprot)
3297 
    oprot.writeMessageEnd()
3298 
    oprot.trans.flush()
3299 
 
3300 
  def process_getOrderCount(self, seqid, iprot, oprot):
3301 
    args = getOrderCount_args()
3302 
    args.read(iprot)
3303 
    iprot.readMessageEnd()
3304 
    result = getOrderCount_result()
3305 
    try:
3306 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3307 
    except TransactionServiceException, ex:
3308 
      result.ex = ex
3309 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3310 
    result.write(oprot)
3311 
    oprot.writeMessageEnd()
3312 
    oprot.trans.flush()
3313 
 
999 varun.gupt 3314 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3315 
    args = getOrdersByBillingDate_args()
3316 
    args.read(iprot)
3317 
    iprot.readMessageEnd()
3318 
    result = getOrdersByBillingDate_result()
3319 
    try:
3320 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3321 
    except TransactionServiceException, ex:
3322 
      result.ex = ex
3323 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3324 
    result.write(oprot)
3325 
    oprot.writeMessageEnd()
3326 
    oprot.trans.flush()
3327 
 
3427 chandransh 3328 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3329 
    args = getOrdersByShippingDate_args()
3330 
    args.read(iprot)
3331 
    iprot.readMessageEnd()
3332 
    result = getOrdersByShippingDate_result()
3333 
    try:
3451 chandransh 3334 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3335 
    except TransactionServiceException, ex:
3336 
      result.ex = ex
3337 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3338 
    result.write(oprot)
3339 
    oprot.writeMessageEnd()
3340 
    oprot.trans.flush()
3341 
 
1382 varun.gupt 3342 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3343 
    args = getReturnableOrdersForCustomer_args()
3344 
    args.read(iprot)
3345 
    iprot.readMessageEnd()
3346 
    result = getReturnableOrdersForCustomer_result()
3347 
    try:
3348 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3349 
    except TransactionServiceException, ex:
3350 
      result.ex = ex
3351 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3352 
    result.write(oprot)
3353 
    oprot.writeMessageEnd()
3354 
    oprot.trans.flush()
3355 
 
3356 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3357 
    args = getCancellableOrdersForCustomer_args()
3358 
    args.read(iprot)
3359 
    iprot.readMessageEnd()
3360 
    result = getCancellableOrdersForCustomer_result()
3361 
    try:
3362 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3363 
    except TransactionServiceException, ex:
3364 
      result.ex = ex
3365 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3366 
    result.write(oprot)
3367 
    oprot.writeMessageEnd()
3368 
    oprot.trans.flush()
3369 
 
483 rajveer 3370 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3371 
    args = changeOrderStatus_args()
94 ashish 3372 
    args.read(iprot)
3373 
    iprot.readMessageEnd()
483 rajveer 3374 
    result = changeOrderStatus_result()
94 ashish 3375 
    try:
483 rajveer 3376 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3377 
    except TransactionServiceException, ex:
3378 
      result.ex = ex
483 rajveer 3379 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3380 
    result.write(oprot)
3381 
    oprot.writeMessageEnd()
3382 
    oprot.trans.flush()
3383 
 
483 rajveer 3384 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3385 
    args = getOrdersForTransaction_args()
94 ashish 3386 
    args.read(iprot)
3387 
    iprot.readMessageEnd()
483 rajveer 3388 
    result = getOrdersForTransaction_result()
94 ashish 3389 
    try:
1528 ankur.sing 3390 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 3391 
    except TransactionServiceException, ex:
3392 
      result.ex = ex
483 rajveer 3393 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 3394 
    result.write(oprot)
3395 
    oprot.writeMessageEnd()
3396 
    oprot.trans.flush()
3397 
 
483 rajveer 3398 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
3399 
    args = getOrdersForCustomer_args()
94 ashish 3400 
    args.read(iprot)
3401 
    iprot.readMessageEnd()
483 rajveer 3402 
    result = getOrdersForCustomer_result()
94 ashish 3403 
    try:
3014 chandransh 3404 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 3405 
    except TransactionServiceException, ex:
3406 
      result.ex = ex
483 rajveer 3407 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 3408 
    result.write(oprot)
3409 
    oprot.writeMessageEnd()
3410 
    oprot.trans.flush()
3411 
 
483 rajveer 3412 
  def process_createOrder(self, seqid, iprot, oprot):
3413 
    args = createOrder_args()
94 ashish 3414 
    args.read(iprot)
3415 
    iprot.readMessageEnd()
483 rajveer 3416 
    result = createOrder_result()
94 ashish 3417 
    try:
483 rajveer 3418 
      result.success = self._handler.createOrder(args.order)
94 ashish 3419 
    except TransactionServiceException, ex:
3420 
      result.ex = ex
483 rajveer 3421 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 3422 
    result.write(oprot)
3423 
    oprot.writeMessageEnd()
3424 
    oprot.trans.flush()
3425 
 
483 rajveer 3426 
  def process_getOrder(self, seqid, iprot, oprot):
3427 
    args = getOrder_args()
94 ashish 3428 
    args.read(iprot)
3429 
    iprot.readMessageEnd()
483 rajveer 3430 
    result = getOrder_result()
94 ashish 3431 
    try:
483 rajveer 3432 
      result.success = self._handler.getOrder(args.id)
94 ashish 3433 
    except TransactionServiceException, ex:
3434 
      result.ex = ex
483 rajveer 3435 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 3436 
    result.write(oprot)
3437 
    oprot.writeMessageEnd()
3438 
    oprot.trans.flush()
3439 
 
483 rajveer 3440 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
3441 
    args = getLineItemsForOrder_args()
94 ashish 3442 
    args.read(iprot)
3443 
    iprot.readMessageEnd()
483 rajveer 3444 
    result = getLineItemsForOrder_result()
94 ashish 3445 
    try:
483 rajveer 3446 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 3447 
    except TransactionServiceException, ex:
3448 
      result.ex = ex
483 rajveer 3449 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 3450 
    result.write(oprot)
3451 
    oprot.writeMessageEnd()
3452 
    oprot.trans.flush()
3453 
 
1528 ankur.sing 3454 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
3455 
    args = getOrderForCustomer_args()
3456 
    args.read(iprot)
3457 
    iprot.readMessageEnd()
3458 
    result = getOrderForCustomer_result()
3459 
    try:
3460 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
3461 
    except TransactionServiceException, ex:
3462 
      result.ex = ex
3463 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
3464 
    result.write(oprot)
3465 
    oprot.writeMessageEnd()
3466 
    oprot.trans.flush()
3467 
 
3064 chandransh 3468 
  def process_getAlerts(self, seqid, iprot, oprot):
3469 
    args = getAlerts_args()
3470 
    args.read(iprot)
3471 
    iprot.readMessageEnd()
3472 
    result = getAlerts_result()
3473 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
3474 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
3475 
    result.write(oprot)
3476 
    oprot.writeMessageEnd()
3477 
    oprot.trans.flush()
3478 
 
3479 
  def process_setAlert(self, seqid, iprot, oprot):
3480 
    args = setAlert_args()
3481 
    args.read(iprot)
3482 
    iprot.readMessageEnd()
3483 
    result = setAlert_result()
3484 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
3485 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
3486 
    result.write(oprot)
3487 
    oprot.writeMessageEnd()
3488 
    oprot.trans.flush()
3489 
 
3490 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
3491 
    args = getValidOrderCount_args()
3492 
    args.read(iprot)
3493 
    iprot.readMessageEnd()
3494 
    result = getValidOrderCount_result()
3495 
    result.success = self._handler.getValidOrderCount()
3496 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
3497 
    result.write(oprot)
3498 
    oprot.writeMessageEnd()
3499 
    oprot.trans.flush()
3500 
 
3501 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
3502 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
3503 
    args.read(iprot)
3504 
    iprot.readMessageEnd()
3505 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
3506 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
3507 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
3508 
    result.write(oprot)
3509 
    oprot.writeMessageEnd()
3510 
    oprot.trans.flush()
3511 
 
3512 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
3513 
    args = getValidOrdersAmountRange_args()
3514 
    args.read(iprot)
3515 
    iprot.readMessageEnd()
3516 
    result = getValidOrdersAmountRange_result()
3517 
    result.success = self._handler.getValidOrdersAmountRange()
3518 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
3519 
    result.write(oprot)
3520 
    oprot.writeMessageEnd()
3521 
    oprot.trans.flush()
3522 
 
3523 
  def process_getValidOrders(self, seqid, iprot, oprot):
3524 
    args = getValidOrders_args()
3525 
    args.read(iprot)
3526 
    iprot.readMessageEnd()
3527 
    result = getValidOrders_result()
3528 
    result.success = self._handler.getValidOrders(args.limit)
3529 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
3530 
    result.write(oprot)
3531 
    oprot.writeMessageEnd()
3532 
    oprot.trans.flush()
3533 
 
1220 chandransh 3534 
  def process_batchOrders(self, seqid, iprot, oprot):
3535 
    args = batchOrders_args()
3536 
    args.read(iprot)
3537 
    iprot.readMessageEnd()
3538 
    result = batchOrders_result()
3539 
    try:
3540 
      result.success = self._handler.batchOrders(args.warehouseId)
3541 
    except TransactionServiceException, ex:
3542 
      result.ex = ex
3543 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
3544 
    result.write(oprot)
3545 
    oprot.writeMessageEnd()
3546 
    oprot.trans.flush()
3547 
 
1208 chandransh 3548 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
3549 
    args = markOrderAsOutOfStock_args()
3550 
    args.read(iprot)
3551 
    iprot.readMessageEnd()
3552 
    result = markOrderAsOutOfStock_result()
3553 
    try:
3554 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
3555 
    except TransactionServiceException, ex:
3556 
      result.ex = ex
3557 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
3558 
    result.write(oprot)
3559 
    oprot.writeMessageEnd()
3560 
    oprot.trans.flush()
3561 
 
3064 chandransh 3562 
  def process_verifyOrder(self, seqid, iprot, oprot):
3563 
    args = verifyOrder_args()
759 chandransh 3564 
    args.read(iprot)
3565 
    iprot.readMessageEnd()
3064 chandransh 3566 
    result = verifyOrder_result()
759 chandransh 3567 
    try:
3064 chandransh 3568 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 3569 
    except TransactionServiceException, ex:
3570 
      result.ex = ex
3064 chandransh 3571 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 3572 
    result.write(oprot)
3573 
    oprot.writeMessageEnd()
3574 
    oprot.trans.flush()
3575 
 
3064 chandransh 3576 
  def process_acceptOrder(self, seqid, iprot, oprot):
3577 
    args = acceptOrder_args()
1113 chandransh 3578 
    args.read(iprot)
3579 
    iprot.readMessageEnd()
3064 chandransh 3580 
    result = acceptOrder_result()
1113 chandransh 3581 
    try:
3064 chandransh 3582 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 3583 
    except TransactionServiceException, ex:
3584 
      result.ex = ex
3064 chandransh 3585 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 3586 
    result.write(oprot)
3587 
    oprot.writeMessageEnd()
3588 
    oprot.trans.flush()
3589 
 
3064 chandransh 3590 
  def process_billOrder(self, seqid, iprot, oprot):
3591 
    args = billOrder_args()
1132 chandransh 3592 
    args.read(iprot)
3593 
    iprot.readMessageEnd()
3064 chandransh 3594 
    result = billOrder_result()
1132 chandransh 3595 
    try:
3064 chandransh 3596 
      result.success = self._handler.billOrder(args.orderId)
1132 chandransh 3597 
    except TransactionServiceException, ex:
3598 
      result.ex = ex
3064 chandransh 3599 
    oprot.writeMessageBegin("billOrder", TMessageType.REPLY, seqid)
1132 chandransh 3600 
    result.write(oprot)
3601 
    oprot.writeMessageEnd()
3602 
    oprot.trans.flush()
3603 
 
3064 chandransh 3604 
  def process_addBillingDetails(self, seqid, iprot, oprot):
3605 
    args = addBillingDetails_args()
1135 chandransh 3606 
    args.read(iprot)
3607 
    iprot.readMessageEnd()
3064 chandransh 3608 
    result = addBillingDetails_result()
1135 chandransh 3609 
    try:
4264 rajveer 3610 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.billed_by, args.jacketNumber)
1135 chandransh 3611 
    except TransactionServiceException, ex:
3612 
      result.ex = ex
3064 chandransh 3613 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 3614 
    result.write(oprot)
3615 
    oprot.writeMessageEnd()
3616 
    oprot.trans.flush()
3617 
 
3064 chandransh 3618 
  def process_addJacketNumber(self, seqid, iprot, oprot):
3619 
    args = addJacketNumber_args()
1246 chandransh 3620 
    args.read(iprot)
3621 
    iprot.readMessageEnd()
3064 chandransh 3622 
    result = addJacketNumber_result()
1246 chandransh 3623 
    try:
3064 chandransh 3624 
      result.success = self._handler.addJacketNumber(args.orderId, args.jacketNumber, args.imeiNumber, args.itemNumber, args.billedBy, args.billingType)
1246 chandransh 3625 
    except TransactionServiceException, ex:
3626 
      result.ex = ex
3064 chandransh 3627 
    oprot.writeMessageBegin("addJacketNumber", TMessageType.REPLY, seqid)
1246 chandransh 3628 
    result.write(oprot)
3629 
    oprot.writeMessageEnd()
3630 
    oprot.trans.flush()
3631 
 
3064 chandransh 3632 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
3633 
    args = markOrdersAsManifested_args()
1408 ankur.sing 3634 
    args.read(iprot)
3635 
    iprot.readMessageEnd()
3064 chandransh 3636 
    result = markOrdersAsManifested_result()
3637 
    try:
3638 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
3639 
    except TransactionServiceException, ex:
3640 
      result.ex = ex
3641 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 3642 
    result.write(oprot)
3643 
    oprot.writeMessageEnd()
3644 
    oprot.trans.flush()
3645 
 
3064 chandransh 3646 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
3647 
    args = markOrdersAsPickedUp_args()
304 ashish 3648 
    args.read(iprot)
3649 
    iprot.readMessageEnd()
3064 chandransh 3650 
    result = markOrdersAsPickedUp_result()
3651 
    try:
3652 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3653 
    except TransactionServiceException, ex:
3654 
      result.ex = ex
3655 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 3656 
    result.write(oprot)
3657 
    oprot.writeMessageEnd()
3658 
    oprot.trans.flush()
94 ashish 3659 
 
3064 chandransh 3660 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
3661 
    args = markOrdersAsDelivered_args()
304 ashish 3662 
    args.read(iprot)
3663 
    iprot.readMessageEnd()
3064 chandransh 3664 
    result = markOrdersAsDelivered_result()
3665 
    try:
3666 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
3667 
    except TransactionServiceException, ex:
3668 
      result.ex = ex
3669 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 3670 
    result.write(oprot)
3671 
    oprot.writeMessageEnd()
3672 
    oprot.trans.flush()
3673 
 
3064 chandransh 3674 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
3675 
    args = markOrdersAsFailed_args()
1596 ankur.sing 3676 
    args.read(iprot)
3677 
    iprot.readMessageEnd()
3064 chandransh 3678 
    result = markOrdersAsFailed_result()
3679 
    try:
3680 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
3681 
    except TransactionServiceException, ex:
3682 
      result.ex = ex
3683 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 3684 
    result.write(oprot)
3685 
    oprot.writeMessageEnd()
3686 
    oprot.trans.flush()
304 ashish 3687 
 
3064 chandransh 3688 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
3689 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 3690 
    args.read(iprot)
3691 
    iprot.readMessageEnd()
3064 chandransh 3692 
    result = updateNonDeliveryReason_result()
3693 
    try:
3694 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3695 
    except TransactionServiceException, ex:
3696 
      result.ex = ex
3697 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 3698 
    result.write(oprot)
3699 
    oprot.writeMessageEnd()
3700 
    oprot.trans.flush()
1596 ankur.sing 3701 
 
3064 chandransh 3702 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
3703 
    args = getUndeliveredOrders_args()
1627 ankur.sing 3704 
    args.read(iprot)
3705 
    iprot.readMessageEnd()
3064 chandransh 3706 
    result = getUndeliveredOrders_result()
3707 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
3708 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 3709 
    result.write(oprot)
3710 
    oprot.writeMessageEnd()
3711 
    oprot.trans.flush()
3712 
 
2536 chandransh 3713 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
3714 
    args = toggleDOAFlag_args()
3715 
    args.read(iprot)
3716 
    iprot.readMessageEnd()
3717 
    result = toggleDOAFlag_result()
3718 
    try:
3719 
      result.success = self._handler.toggleDOAFlag(args.orderId)
3720 
    except TransactionServiceException, ex:
3721 
      result.ex = ex
3722 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
3723 
    result.write(oprot)
3724 
    oprot.writeMessageEnd()
3725 
    oprot.trans.flush()
1886 ankur.sing 3726 
 
2536 chandransh 3727 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
3728 
    args = requestPickupNumber_args()
3729 
    args.read(iprot)
3730 
    iprot.readMessageEnd()
3731 
    result = requestPickupNumber_result()
3732 
    try:
3733 
      result.success = self._handler.requestPickupNumber(args.orderId)
3734 
    except TransactionServiceException, ex:
3735 
      result.ex = ex
3736 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
3737 
    result.write(oprot)
3738 
    oprot.writeMessageEnd()
3739 
    oprot.trans.flush()
3740 
 
3741 
  def process_authorizePickup(self, seqid, iprot, oprot):
3742 
    args = authorizePickup_args()
3743 
    args.read(iprot)
3744 
    iprot.readMessageEnd()
3745 
    result = authorizePickup_result()
3746 
    try:
3747 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
3748 
    except TransactionServiceException, ex:
3749 
      result.ex = ex
3750 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
3751 
    result.write(oprot)
3752 
    oprot.writeMessageEnd()
3753 
    oprot.trans.flush()
3754 
 
2764 chandransh 3755 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
3756 
    args = markDoasAsPickedUp_args()
3757 
    args.read(iprot)
3758 
    iprot.readMessageEnd()
3759 
    result = markDoasAsPickedUp_result()
3760 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
3761 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
3762 
    result.write(oprot)
3763 
    oprot.writeMessageEnd()
3764 
    oprot.trans.flush()
3765 
 
2616 chandransh 3766 
  def process_receiveReturn(self, seqid, iprot, oprot):
3767 
    args = receiveReturn_args()
2591 chandransh 3768 
    args.read(iprot)
3769 
    iprot.readMessageEnd()
2616 chandransh 3770 
    result = receiveReturn_result()
2591 chandransh 3771 
    try:
2616 chandransh 3772 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 3773 
    except TransactionServiceException, ex:
3774 
      result.ex = ex
2616 chandransh 3775 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 3776 
    result.write(oprot)
3777 
    oprot.writeMessageEnd()
3778 
    oprot.trans.flush()
2536 chandransh 3779 
 
2591 chandransh 3780 
  def process_validateDoa(self, seqid, iprot, oprot):
3781 
    args = validateDoa_args()
3782 
    args.read(iprot)
3783 
    iprot.readMessageEnd()
3784 
    result = validateDoa_result()
3785 
    try:
3786 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
3787 
    except TransactionServiceException, ex:
3788 
      result.ex = ex
3789 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
3790 
    result.write(oprot)
3791 
    oprot.writeMessageEnd()
3792 
    oprot.trans.flush()
3793 
 
2616 chandransh 3794 
  def process_reshipOrder(self, seqid, iprot, oprot):
3795 
    args = reshipOrder_args()
3796 
    args.read(iprot)
3797 
    iprot.readMessageEnd()
3798 
    result = reshipOrder_result()
3799 
    try:
3800 
      result.success = self._handler.reshipOrder(args.orderId)
3801 
    except TransactionServiceException, ex:
3802 
      result.ex = ex
3803 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
3804 
    result.write(oprot)
3805 
    oprot.writeMessageEnd()
3806 
    oprot.trans.flush()
2591 chandransh 3807 
 
2616 chandransh 3808 
  def process_refundOrder(self, seqid, iprot, oprot):
3809 
    args = refundOrder_args()
3810 
    args.read(iprot)
3811 
    iprot.readMessageEnd()
3812 
    result = refundOrder_result()
3813 
    try:
3226 chandransh 3814 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 3815 
    except TransactionServiceException, ex:
3816 
      result.ex = ex
3817 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
3818 
    result.write(oprot)
3819 
    oprot.writeMessageEnd()
3820 
    oprot.trans.flush()
3821 
 
2690 chandransh 3822 
  def process_getReturnOrders(self, seqid, iprot, oprot):
3823 
    args = getReturnOrders_args()
3824 
    args.read(iprot)
3825 
    iprot.readMessageEnd()
3826 
    result = getReturnOrders_result()
3827 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
3828 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
3829 
    result.write(oprot)
3830 
    oprot.writeMessageEnd()
3831 
    oprot.trans.flush()
2616 chandransh 3832 
 
2700 chandransh 3833 
  def process_getReturnOrder(self, seqid, iprot, oprot):
3834 
    args = getReturnOrder_args()
3835 
    args.read(iprot)
3836 
    iprot.readMessageEnd()
3837 
    result = getReturnOrder_result()
3838 
    try:
3839 
      result.success = self._handler.getReturnOrder(args.id)
3840 
    except TransactionServiceException, ex:
3841 
      result.ex = ex
3842 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
3843 
    result.write(oprot)
3844 
    oprot.writeMessageEnd()
3845 
    oprot.trans.flush()
3846 
 
2690 chandransh 3847 
  def process_processReturn(self, seqid, iprot, oprot):
3848 
    args = processReturn_args()
3849 
    args.read(iprot)
3850 
    iprot.readMessageEnd()
3851 
    result = processReturn_result()
3852 
    try:
3853 
      self._handler.processReturn(args.returnOrderId)
3854 
    except TransactionServiceException, ex:
3855 
      result.ex = ex
3856 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
3857 
    result.write(oprot)
3858 
    oprot.writeMessageEnd()
3859 
    oprot.trans.flush()
3860 
 
2819 chandransh 3861 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
3862 
    args = createPurchaseOrder_args()
3863 
    args.read(iprot)
3864 
    iprot.readMessageEnd()
3865 
    result = createPurchaseOrder_result()
3866 
    try:
3867 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
3868 
    except TransactionServiceException, ex:
3869 
      result.ex = ex
3870 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
3871 
    result.write(oprot)
3872 
    oprot.writeMessageEnd()
3873 
    oprot.trans.flush()
2690 chandransh 3874 
 
3451 chandransh 3875 
  def process_updateWeight(self, seqid, iprot, oprot):
3876 
    args = updateWeight_args()
3877 
    args.read(iprot)
3878 
    iprot.readMessageEnd()
3879 
    result = updateWeight_result()
3880 
    try:
3881 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
3882 
    except TransactionServiceException, ex:
3883 
      result.ex = ex
3884 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
3885 
    result.write(oprot)
3886 
    oprot.writeMessageEnd()
3887 
    oprot.trans.flush()
2819 chandransh 3888 
 
3469 chandransh 3889 
  def process_changeItem(self, seqid, iprot, oprot):
3890 
    args = changeItem_args()
3891 
    args.read(iprot)
3892 
    iprot.readMessageEnd()
3893 
    result = changeItem_result()
3894 
    try:
3895 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
3896 
    except TransactionServiceException, ex:
3897 
      result.ex = ex
3898 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
3899 
    result.write(oprot)
3900 
    oprot.writeMessageEnd()
3901 
    oprot.trans.flush()
3451 chandransh 3902 
 
3469 chandransh 3903 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
3904 
    args = shiftToWarehouse_args()
3905 
    args.read(iprot)
3906 
    iprot.readMessageEnd()
3907 
    result = shiftToWarehouse_result()
3908 
    try:
3909 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
3910 
    except TransactionServiceException, ex:
3911 
      result.ex = ex
3912 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
3913 
    result.write(oprot)
3914 
    oprot.writeMessageEnd()
3915 
    oprot.trans.flush()
3916 
 
3553 chandransh 3917 
  def process_addDelayReason(self, seqid, iprot, oprot):
3918 
    args = addDelayReason_args()
3919 
    args.read(iprot)
3920 
    iprot.readMessageEnd()
3921 
    result = addDelayReason_result()
3922 
    try:
3986 chandransh 3923 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 3924 
    except TransactionServiceException, ex:
3925 
      result.ex = ex
3926 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
3927 
    result.write(oprot)
3928 
    oprot.writeMessageEnd()
3929 
    oprot.trans.flush()
3469 chandransh 3930 
 
3956 chandransh 3931 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
3932 
    args = reconcileCodCollection_args()
3933 
    args.read(iprot)
3934 
    iprot.readMessageEnd()
3935 
    result = reconcileCodCollection_result()
3936 
    try:
3937 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
3938 
    except TransactionServiceException, ex:
3939 
      result.ex = ex
3940 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
3941 
    result.write(oprot)
3942 
    oprot.writeMessageEnd()
3943 
    oprot.trans.flush()
3553 chandransh 3944 
 
4008 mandeep.dh 3945 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
3946 
    args = getTransactionsRequiringExtraProcessing_args()
3947 
    args.read(iprot)
3948 
    iprot.readMessageEnd()
3949 
    result = getTransactionsRequiringExtraProcessing_result()
3950 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
3951 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
3952 
    result.write(oprot)
3953 
    oprot.writeMessageEnd()
3954 
    oprot.trans.flush()
3956 chandransh 3955 
 
4008 mandeep.dh 3956 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
3957 
    args = markTransactionAsProcessed_args()
3958 
    args.read(iprot)
3959 
    iprot.readMessageEnd()
3960 
    result = markTransactionAsProcessed_result()
3961 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
3962 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
3963 
    result.write(oprot)
3964 
    oprot.writeMessageEnd()
3965 
    oprot.trans.flush()
3966 
 
4018 chandransh 3967 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
3968 
    args = getItemWiseRiskyOrdersCount_args()
3969 
    args.read(iprot)
3970 
    iprot.readMessageEnd()
3971 
    result = getItemWiseRiskyOrdersCount_result()
3972 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
3973 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
3974 
    result.write(oprot)
3975 
    oprot.writeMessageEnd()
3976 
    oprot.trans.flush()
4008 mandeep.dh 3977 
 
4247 rajveer 3978 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
3979 
    args = markOrderCancellationRequestReceived_args()
3980 
    args.read(iprot)
3981 
    iprot.readMessageEnd()
3982 
    result = markOrderCancellationRequestReceived_result()
3983 
    try:
3984 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
3985 
    except TransactionServiceException, ex:
3986 
      result.ex = ex
3987 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
3988 
    result.write(oprot)
3989 
    oprot.writeMessageEnd()
3990 
    oprot.trans.flush()
4018 chandransh 3991 
 
4247 rajveer 3992 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
3993 
    args = markOrderCancellationRequestConfirmed_args()
3994 
    args.read(iprot)
3995 
    iprot.readMessageEnd()
3996 
    result = markOrderCancellationRequestConfirmed_result()
3997 
    try:
3998 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
3999 
    except TransactionServiceException, ex:
4000 
      result.ex = ex
4001 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
4002 
    result.write(oprot)
4003 
    oprot.writeMessageEnd()
4004 
    oprot.trans.flush()
4005 
 
4006 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4007 
    args = markOrderCancellationRequestDenied_args()
4008 
    args.read(iprot)
4009 
    iprot.readMessageEnd()
4010 
    result = markOrderCancellationRequestDenied_result()
4011 
    try:
4012 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4013 
    except TransactionServiceException, ex:
4014 
      result.ex = ex
4015 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4016 
    result.write(oprot)
4017 
    oprot.writeMessageEnd()
4018 
    oprot.trans.flush()
4019 
 
4258 rajveer 4020 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4021 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4022 
    args.read(iprot)
4023 
    iprot.readMessageEnd()
4258 rajveer 4024 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4025 
    try:
4258 rajveer 4026 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4027 
    except TransactionServiceException, ex:
4028 
      result.ex = ex
4258 rajveer 4029 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4030 
    result.write(oprot)
4031 
    oprot.writeMessageEnd()
4032 
    oprot.trans.flush()
4033 
 
4259 anupam.sin 4034 
  def process_refundTransaction(self, seqid, iprot, oprot):
4035 
    args = refundTransaction_args()
4036 
    args.read(iprot)
4037 
    iprot.readMessageEnd()
4038 
    result = refundTransaction_result()
4039 
    try:
4040 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4041 
    except TransactionServiceException, ex:
4042 
      result.ex = ex
4043 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4044 
    result.write(oprot)
4045 
    oprot.writeMessageEnd()
4046 
    oprot.trans.flush()
4247 rajveer 4047 
 
4259 anupam.sin 4048 
 
94 ashish 4049 
# HELPER FUNCTIONS AND STRUCTURES
4050 
 
4051 
class createTransaction_args:
4052 
  """
4053 
  Attributes:
4054 
   - transaction
4055 
  """
4056 
 
4057 
  thrift_spec = (
4058 
    None, # 0
4059 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4060 
  )
4061 
 
4062 
  def __init__(self, transaction=None,):
4063 
    self.transaction = transaction
4064 
 
4065 
  def read(self, iprot):
4066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4068 
      return
4069 
    iprot.readStructBegin()
4070 
    while True:
4071 
      (fname, ftype, fid) = iprot.readFieldBegin()
4072 
      if ftype == TType.STOP:
4073 
        break
4074 
      if fid == 1:
4075 
        if ftype == TType.STRUCT:
4076 
          self.transaction = Transaction()
4077 
          self.transaction.read(iprot)
4078 
        else:
4079 
          iprot.skip(ftype)
4080 
      else:
4081 
        iprot.skip(ftype)
4082 
      iprot.readFieldEnd()
4083 
    iprot.readStructEnd()
4084 
 
4085 
  def write(self, oprot):
4086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4088 
      return
4089 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4090 
    if self.transaction is not None:
94 ashish 4091 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4092 
      self.transaction.write(oprot)
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 createTransaction_result:
4113 
  """
4114 
  Attributes:
132 ashish 4115 
   - success
94 ashish 4116 
   - ex
4117 
  """
4118 
 
4119 
  thrift_spec = (
132 ashish 4120 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4121 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4122 
  )
4123 
 
132 ashish 4124 
  def __init__(self, success=None, ex=None,):
4125 
    self.success = success
94 ashish 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
132 ashish 4137 
      if fid == 0:
4138 
        if ftype == TType.I64:
4139 
          self.success = iprot.readI64();
4140 
        else:
4141 
          iprot.skip(ftype)
4142 
      elif fid == 1:
94 ashish 4143 
        if ftype == TType.STRUCT:
4144 
          self.ex = TransactionServiceException()
4145 
          self.ex.read(iprot)
4146 
        else:
4147 
          iprot.skip(ftype)
4148 
      else:
4149 
        iprot.skip(ftype)
4150 
      iprot.readFieldEnd()
4151 
    iprot.readStructEnd()
4152 
 
4153 
  def write(self, oprot):
4154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4156 
      return
4157 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4158 
    if self.success is not None:
132 ashish 4159 
      oprot.writeFieldBegin('success', TType.I64, 0)
4160 
      oprot.writeI64(self.success)
4161 
      oprot.writeFieldEnd()
3431 rajveer 4162 
    if self.ex is not None:
94 ashish 4163 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4164 
      self.ex.write(oprot)
4165 
      oprot.writeFieldEnd()
4166 
    oprot.writeFieldStop()
4167 
    oprot.writeStructEnd()
4168 
 
3431 rajveer 4169 
  def validate(self):
4170 
    return
4171 
 
4172 
 
94 ashish 4173 
  def __repr__(self):
4174 
    L = ['%s=%r' % (key, value)
4175 
      for key, value in self.__dict__.iteritems()]
4176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4177 
 
4178 
  def __eq__(self, other):
4179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4180 
 
4181 
  def __ne__(self, other):
4182 
    return not (self == other)
4183 
 
4184 
class getTransaction_args:
4185 
  """
4186 
  Attributes:
4187 
   - id
4188 
  """
4189 
 
4190 
  thrift_spec = (
4191 
    None, # 0
4192 
    (1, TType.I64, 'id', None, None, ), # 1
4193 
  )
4194 
 
4195 
  def __init__(self, id=None,):
4196 
    self.id = id
4197 
 
4198 
  def read(self, iprot):
4199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4201 
      return
4202 
    iprot.readStructBegin()
4203 
    while True:
4204 
      (fname, ftype, fid) = iprot.readFieldBegin()
4205 
      if ftype == TType.STOP:
4206 
        break
4207 
      if fid == 1:
4208 
        if ftype == TType.I64:
4209 
          self.id = iprot.readI64();
4210 
        else:
4211 
          iprot.skip(ftype)
4212 
      else:
4213 
        iprot.skip(ftype)
4214 
      iprot.readFieldEnd()
4215 
    iprot.readStructEnd()
4216 
 
4217 
  def write(self, oprot):
4218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4220 
      return
4221 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 4222 
    if self.id is not None:
94 ashish 4223 
      oprot.writeFieldBegin('id', TType.I64, 1)
4224 
      oprot.writeI64(self.id)
4225 
      oprot.writeFieldEnd()
4226 
    oprot.writeFieldStop()
4227 
    oprot.writeStructEnd()
4228 
 
3431 rajveer 4229 
  def validate(self):
4230 
    return
4231 
 
4232 
 
94 ashish 4233 
  def __repr__(self):
4234 
    L = ['%s=%r' % (key, value)
4235 
      for key, value in self.__dict__.iteritems()]
4236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4237 
 
4238 
  def __eq__(self, other):
4239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4240 
 
4241 
  def __ne__(self, other):
4242 
    return not (self == other)
4243 
 
4244 
class getTransaction_result:
4245 
  """
4246 
  Attributes:
4247 
   - success
4248 
   - ex
4249 
  """
4250 
 
4251 
  thrift_spec = (
4252 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
4253 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4254 
  )
4255 
 
4256 
  def __init__(self, success=None, ex=None,):
4257 
    self.success = success
4258 
    self.ex = ex
4259 
 
4260 
  def read(self, iprot):
4261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4263 
      return
4264 
    iprot.readStructBegin()
4265 
    while True:
4266 
      (fname, ftype, fid) = iprot.readFieldBegin()
4267 
      if ftype == TType.STOP:
4268 
        break
4269 
      if fid == 0:
4270 
        if ftype == TType.STRUCT:
4271 
          self.success = Transaction()
4272 
          self.success.read(iprot)
4273 
        else:
4274 
          iprot.skip(ftype)
4275 
      elif fid == 1:
4276 
        if ftype == TType.STRUCT:
4277 
          self.ex = TransactionServiceException()
4278 
          self.ex.read(iprot)
4279 
        else:
4280 
          iprot.skip(ftype)
4281 
      else:
4282 
        iprot.skip(ftype)
4283 
      iprot.readFieldEnd()
4284 
    iprot.readStructEnd()
4285 
 
4286 
  def write(self, oprot):
4287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4289 
      return
4290 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 4291 
    if self.success is not None:
94 ashish 4292 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4293 
      self.success.write(oprot)
4294 
      oprot.writeFieldEnd()
3431 rajveer 4295 
    if self.ex is not None:
94 ashish 4296 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4297 
      self.ex.write(oprot)
4298 
      oprot.writeFieldEnd()
4299 
    oprot.writeFieldStop()
4300 
    oprot.writeStructEnd()
4301 
 
3431 rajveer 4302 
  def validate(self):
4303 
    return
4304 
 
4305 
 
94 ashish 4306 
  def __repr__(self):
4307 
    L = ['%s=%r' % (key, value)
4308 
      for key, value in self.__dict__.iteritems()]
4309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4310 
 
4311 
  def __eq__(self, other):
4312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4313 
 
4314 
  def __ne__(self, other):
4315 
    return not (self == other)
4316 
 
4317 
class getTransactionsForCustomer_args:
4318 
  """
4319 
  Attributes:
4320 
   - customerId
4321 
   - from_date
4322 
   - to_date
4323 
   - status
4324 
  """
4325 
 
4326 
  thrift_spec = (
4327 
    None, # 0
4328 
    (1, TType.I64, 'customerId', None, None, ), # 1
4329 
    (2, TType.I64, 'from_date', None, None, ), # 2
4330 
    (3, TType.I64, 'to_date', None, None, ), # 3
4331 
    (4, TType.I32, 'status', None, None, ), # 4
4332 
  )
4333 
 
4334 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
4335 
    self.customerId = customerId
4336 
    self.from_date = from_date
4337 
    self.to_date = to_date
4338 
    self.status = status
4339 
 
4340 
  def read(self, iprot):
4341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4343 
      return
4344 
    iprot.readStructBegin()
4345 
    while True:
4346 
      (fname, ftype, fid) = iprot.readFieldBegin()
4347 
      if ftype == TType.STOP:
4348 
        break
4349 
      if fid == 1:
4350 
        if ftype == TType.I64:
4351 
          self.customerId = iprot.readI64();
4352 
        else:
4353 
          iprot.skip(ftype)
4354 
      elif fid == 2:
4355 
        if ftype == TType.I64:
4356 
          self.from_date = iprot.readI64();
4357 
        else:
4358 
          iprot.skip(ftype)
4359 
      elif fid == 3:
4360 
        if ftype == TType.I64:
4361 
          self.to_date = iprot.readI64();
4362 
        else:
4363 
          iprot.skip(ftype)
4364 
      elif fid == 4:
4365 
        if ftype == TType.I32:
4366 
          self.status = iprot.readI32();
4367 
        else:
4368 
          iprot.skip(ftype)
4369 
      else:
4370 
        iprot.skip(ftype)
4371 
      iprot.readFieldEnd()
4372 
    iprot.readStructEnd()
4373 
 
4374 
  def write(self, oprot):
4375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4377 
      return
4378 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 4379 
    if self.customerId is not None:
94 ashish 4380 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
4381 
      oprot.writeI64(self.customerId)
4382 
      oprot.writeFieldEnd()
3431 rajveer 4383 
    if self.from_date is not None:
94 ashish 4384 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4385 
      oprot.writeI64(self.from_date)
4386 
      oprot.writeFieldEnd()
3431 rajveer 4387 
    if self.to_date is not None:
94 ashish 4388 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4389 
      oprot.writeI64(self.to_date)
4390 
      oprot.writeFieldEnd()
3431 rajveer 4391 
    if self.status is not None:
94 ashish 4392 
      oprot.writeFieldBegin('status', TType.I32, 4)
4393 
      oprot.writeI32(self.status)
4394 
      oprot.writeFieldEnd()
4395 
    oprot.writeFieldStop()
4396 
    oprot.writeStructEnd()
4397 
 
3431 rajveer 4398 
  def validate(self):
4399 
    return
4400 
 
4401 
 
94 ashish 4402 
  def __repr__(self):
4403 
    L = ['%s=%r' % (key, value)
4404 
      for key, value in self.__dict__.iteritems()]
4405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4406 
 
4407 
  def __eq__(self, other):
4408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4409 
 
4410 
  def __ne__(self, other):
4411 
    return not (self == other)
4412 
 
4413 
class getTransactionsForCustomer_result:
4414 
  """
4415 
  Attributes:
4416 
   - success
4417 
   - ex
4418 
  """
4419 
 
4420 
  thrift_spec = (
4421 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4422 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4423 
  )
4424 
 
4425 
  def __init__(self, success=None, ex=None,):
4426 
    self.success = success
4427 
    self.ex = ex
4428 
 
4429 
  def read(self, iprot):
4430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4432 
      return
4433 
    iprot.readStructBegin()
4434 
    while True:
4435 
      (fname, ftype, fid) = iprot.readFieldBegin()
4436 
      if ftype == TType.STOP:
4437 
        break
4438 
      if fid == 0:
4439 
        if ftype == TType.LIST:
4440 
          self.success = []
685 chandransh 4441 
          (_etype17, _size14) = iprot.readListBegin()
4442 
          for _i18 in xrange(_size14):
4443 
            _elem19 = Transaction()
4444 
            _elem19.read(iprot)
4445 
            self.success.append(_elem19)
94 ashish 4446 
          iprot.readListEnd()
4447 
        else:
4448 
          iprot.skip(ftype)
4449 
      elif fid == 1:
4450 
        if ftype == TType.STRUCT:
4451 
          self.ex = TransactionServiceException()
4452 
          self.ex.read(iprot)
4453 
        else:
4454 
          iprot.skip(ftype)
4455 
      else:
4456 
        iprot.skip(ftype)
4457 
      iprot.readFieldEnd()
4458 
    iprot.readStructEnd()
4459 
 
4460 
  def write(self, oprot):
4461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4463 
      return
4464 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 4465 
    if self.success is not None:
94 ashish 4466 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4467 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4468 
      for iter20 in self.success:
4469 
        iter20.write(oprot)
94 ashish 4470 
      oprot.writeListEnd()
4471 
      oprot.writeFieldEnd()
3431 rajveer 4472 
    if self.ex is not None:
94 ashish 4473 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4474 
      self.ex.write(oprot)
4475 
      oprot.writeFieldEnd()
4476 
    oprot.writeFieldStop()
4477 
    oprot.writeStructEnd()
4478 
 
3431 rajveer 4479 
  def validate(self):
4480 
    return
4481 
 
4482 
 
94 ashish 4483 
  def __repr__(self):
4484 
    L = ['%s=%r' % (key, value)
4485 
      for key, value in self.__dict__.iteritems()]
4486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4487 
 
4488 
  def __eq__(self, other):
4489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4490 
 
4491 
  def __ne__(self, other):
4492 
    return not (self == other)
4493 
 
132 ashish 4494 
class getTransactionsForShoppingCartId_args:
4495 
  """
4496 
  Attributes:
4497 
   - shoppingCartId
4498 
  """
4499 
 
4500 
  thrift_spec = (
4501 
    None, # 0
4502 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
4503 
  )
4504 
 
4505 
  def __init__(self, shoppingCartId=None,):
4506 
    self.shoppingCartId = shoppingCartId
4507 
 
4508 
  def read(self, iprot):
4509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4511 
      return
4512 
    iprot.readStructBegin()
4513 
    while True:
4514 
      (fname, ftype, fid) = iprot.readFieldBegin()
4515 
      if ftype == TType.STOP:
4516 
        break
4517 
      if fid == 1:
4518 
        if ftype == TType.I64:
4519 
          self.shoppingCartId = iprot.readI64();
4520 
        else:
4521 
          iprot.skip(ftype)
4522 
      else:
4523 
        iprot.skip(ftype)
4524 
      iprot.readFieldEnd()
4525 
    iprot.readStructEnd()
4526 
 
4527 
  def write(self, oprot):
4528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4530 
      return
4531 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 4532 
    if self.shoppingCartId is not None:
132 ashish 4533 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
4534 
      oprot.writeI64(self.shoppingCartId)
4535 
      oprot.writeFieldEnd()
4536 
    oprot.writeFieldStop()
4537 
    oprot.writeStructEnd()
4538 
 
3431 rajveer 4539 
  def validate(self):
4540 
    return
4541 
 
4542 
 
132 ashish 4543 
  def __repr__(self):
4544 
    L = ['%s=%r' % (key, value)
4545 
      for key, value in self.__dict__.iteritems()]
4546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4547 
 
4548 
  def __eq__(self, other):
4549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4550 
 
4551 
  def __ne__(self, other):
4552 
    return not (self == other)
4553 
 
4554 
class getTransactionsForShoppingCartId_result:
4555 
  """
4556 
  Attributes:
4557 
   - success
4558 
   - ex
4559 
  """
4560 
 
4561 
  thrift_spec = (
4562 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4563 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4564 
  )
4565 
 
4566 
  def __init__(self, success=None, ex=None,):
4567 
    self.success = success
4568 
    self.ex = ex
4569 
 
4570 
  def read(self, iprot):
4571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4573 
      return
4574 
    iprot.readStructBegin()
4575 
    while True:
4576 
      (fname, ftype, fid) = iprot.readFieldBegin()
4577 
      if ftype == TType.STOP:
4578 
        break
4579 
      if fid == 0:
4580 
        if ftype == TType.LIST:
4581 
          self.success = []
685 chandransh 4582 
          (_etype24, _size21) = iprot.readListBegin()
4583 
          for _i25 in xrange(_size21):
4584 
            _elem26 = Transaction()
4585 
            _elem26.read(iprot)
4586 
            self.success.append(_elem26)
132 ashish 4587 
          iprot.readListEnd()
4588 
        else:
4589 
          iprot.skip(ftype)
4590 
      elif fid == 1:
4591 
        if ftype == TType.STRUCT:
4592 
          self.ex = TransactionServiceException()
4593 
          self.ex.read(iprot)
4594 
        else:
4595 
          iprot.skip(ftype)
4596 
      else:
4597 
        iprot.skip(ftype)
4598 
      iprot.readFieldEnd()
4599 
    iprot.readStructEnd()
4600 
 
4601 
  def write(self, oprot):
4602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4604 
      return
4605 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 4606 
    if self.success is not None:
132 ashish 4607 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4608 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4609 
      for iter27 in self.success:
4610 
        iter27.write(oprot)
132 ashish 4611 
      oprot.writeListEnd()
4612 
      oprot.writeFieldEnd()
3431 rajveer 4613 
    if self.ex is not None:
132 ashish 4614 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4615 
      self.ex.write(oprot)
4616 
      oprot.writeFieldEnd()
4617 
    oprot.writeFieldStop()
4618 
    oprot.writeStructEnd()
4619 
 
3431 rajveer 4620 
  def validate(self):
4621 
    return
4622 
 
4623 
 
132 ashish 4624 
  def __repr__(self):
4625 
    L = ['%s=%r' % (key, value)
4626 
      for key, value in self.__dict__.iteritems()]
4627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4628 
 
4629 
  def __eq__(self, other):
4630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4631 
 
4632 
  def __ne__(self, other):
4633 
    return not (self == other)
4634 
 
94 ashish 4635 
class getTransactionStatus_args:
4636 
  """
4637 
  Attributes:
4638 
   - transactionId
4639 
  """
4640 
 
4641 
  thrift_spec = (
4642 
    None, # 0
4643 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4644 
  )
4645 
 
4646 
  def __init__(self, transactionId=None,):
4647 
    self.transactionId = transactionId
4648 
 
4649 
  def read(self, iprot):
4650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4652 
      return
4653 
    iprot.readStructBegin()
4654 
    while True:
4655 
      (fname, ftype, fid) = iprot.readFieldBegin()
4656 
      if ftype == TType.STOP:
4657 
        break
4658 
      if fid == 1:
4659 
        if ftype == TType.I64:
4660 
          self.transactionId = iprot.readI64();
4661 
        else:
4662 
          iprot.skip(ftype)
4663 
      else:
4664 
        iprot.skip(ftype)
4665 
      iprot.readFieldEnd()
4666 
    iprot.readStructEnd()
4667 
 
4668 
  def write(self, oprot):
4669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4671 
      return
4672 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 4673 
    if self.transactionId is not None:
94 ashish 4674 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4675 
      oprot.writeI64(self.transactionId)
4676 
      oprot.writeFieldEnd()
4677 
    oprot.writeFieldStop()
4678 
    oprot.writeStructEnd()
4679 
 
3431 rajveer 4680 
  def validate(self):
4681 
    return
4682 
 
4683 
 
94 ashish 4684 
  def __repr__(self):
4685 
    L = ['%s=%r' % (key, value)
4686 
      for key, value in self.__dict__.iteritems()]
4687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4688 
 
4689 
  def __eq__(self, other):
4690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4691 
 
4692 
  def __ne__(self, other):
4693 
    return not (self == other)
4694 
 
4695 
class getTransactionStatus_result:
4696 
  """
4697 
  Attributes:
4698 
   - success
4699 
   - ex
4700 
  """
4701 
 
4702 
  thrift_spec = (
4703 
    (0, TType.I32, 'success', None, None, ), # 0
4704 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4705 
  )
4706 
 
4707 
  def __init__(self, success=None, ex=None,):
4708 
    self.success = success
4709 
    self.ex = ex
4710 
 
4711 
  def read(self, iprot):
4712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4714 
      return
4715 
    iprot.readStructBegin()
4716 
    while True:
4717 
      (fname, ftype, fid) = iprot.readFieldBegin()
4718 
      if ftype == TType.STOP:
4719 
        break
4720 
      if fid == 0:
4721 
        if ftype == TType.I32:
4722 
          self.success = iprot.readI32();
4723 
        else:
4724 
          iprot.skip(ftype)
4725 
      elif fid == 1:
4726 
        if ftype == TType.STRUCT:
4727 
          self.ex = TransactionServiceException()
4728 
          self.ex.read(iprot)
4729 
        else:
4730 
          iprot.skip(ftype)
4731 
      else:
4732 
        iprot.skip(ftype)
4733 
      iprot.readFieldEnd()
4734 
    iprot.readStructEnd()
4735 
 
4736 
  def write(self, oprot):
4737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4739 
      return
4740 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 4741 
    if self.success is not None:
94 ashish 4742 
      oprot.writeFieldBegin('success', TType.I32, 0)
4743 
      oprot.writeI32(self.success)
4744 
      oprot.writeFieldEnd()
3431 rajveer 4745 
    if self.ex is not None:
94 ashish 4746 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4747 
      self.ex.write(oprot)
4748 
      oprot.writeFieldEnd()
4749 
    oprot.writeFieldStop()
4750 
    oprot.writeStructEnd()
4751 
 
3431 rajveer 4752 
  def validate(self):
4753 
    return
4754 
 
4755 
 
94 ashish 4756 
  def __repr__(self):
4757 
    L = ['%s=%r' % (key, value)
4758 
      for key, value in self.__dict__.iteritems()]
4759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4760 
 
4761 
  def __eq__(self, other):
4762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4763 
 
4764 
  def __ne__(self, other):
4765 
    return not (self == other)
4766 
 
4767 
class changeTransactionStatus_args:
4768 
  """
4769 
  Attributes:
4770 
   - transactionId
4771 
   - status
4772 
   - description
4773 
  """
4774 
 
4775 
  thrift_spec = (
4776 
    None, # 0
4777 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4778 
    (2, TType.I32, 'status', None, None, ), # 2
4779 
    (3, TType.STRING, 'description', None, None, ), # 3
4780 
  )
4781 
 
4782 
  def __init__(self, transactionId=None, status=None, description=None,):
4783 
    self.transactionId = transactionId
4784 
    self.status = status
4785 
    self.description = description
4786 
 
4787 
  def read(self, iprot):
4788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4790 
      return
4791 
    iprot.readStructBegin()
4792 
    while True:
4793 
      (fname, ftype, fid) = iprot.readFieldBegin()
4794 
      if ftype == TType.STOP:
4795 
        break
4796 
      if fid == 1:
4797 
        if ftype == TType.I64:
4798 
          self.transactionId = iprot.readI64();
4799 
        else:
4800 
          iprot.skip(ftype)
4801 
      elif fid == 2:
4802 
        if ftype == TType.I32:
4803 
          self.status = iprot.readI32();
4804 
        else:
4805 
          iprot.skip(ftype)
4806 
      elif fid == 3:
4807 
        if ftype == TType.STRING:
4808 
          self.description = iprot.readString();
4809 
        else:
4810 
          iprot.skip(ftype)
4811 
      else:
4812 
        iprot.skip(ftype)
4813 
      iprot.readFieldEnd()
4814 
    iprot.readStructEnd()
4815 
 
4816 
  def write(self, oprot):
4817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4819 
      return
4820 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 4821 
    if self.transactionId is not None:
94 ashish 4822 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4823 
      oprot.writeI64(self.transactionId)
4824 
      oprot.writeFieldEnd()
3431 rajveer 4825 
    if self.status is not None:
94 ashish 4826 
      oprot.writeFieldBegin('status', TType.I32, 2)
4827 
      oprot.writeI32(self.status)
4828 
      oprot.writeFieldEnd()
3431 rajveer 4829 
    if self.description is not None:
94 ashish 4830 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4831 
      oprot.writeString(self.description)
4832 
      oprot.writeFieldEnd()
4833 
    oprot.writeFieldStop()
4834 
    oprot.writeStructEnd()
4835 
 
3431 rajveer 4836 
  def validate(self):
4837 
    return
4838 
 
4839 
 
94 ashish 4840 
  def __repr__(self):
4841 
    L = ['%s=%r' % (key, value)
4842 
      for key, value in self.__dict__.iteritems()]
4843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4844 
 
4845 
  def __eq__(self, other):
4846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4847 
 
4848 
  def __ne__(self, other):
4849 
    return not (self == other)
4850 
 
4851 
class changeTransactionStatus_result:
4852 
  """
4853 
  Attributes:
4854 
   - success
4855 
   - ex
4856 
  """
4857 
 
4858 
  thrift_spec = (
4859 
    (0, TType.BOOL, 'success', None, None, ), # 0
4860 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4861 
  )
4862 
 
4863 
  def __init__(self, success=None, ex=None,):
4864 
    self.success = success
4865 
    self.ex = ex
4866 
 
4867 
  def read(self, iprot):
4868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4870 
      return
4871 
    iprot.readStructBegin()
4872 
    while True:
4873 
      (fname, ftype, fid) = iprot.readFieldBegin()
4874 
      if ftype == TType.STOP:
4875 
        break
4876 
      if fid == 0:
4877 
        if ftype == TType.BOOL:
4878 
          self.success = iprot.readBool();
4879 
        else:
4880 
          iprot.skip(ftype)
4881 
      elif fid == 1:
4882 
        if ftype == TType.STRUCT:
4883 
          self.ex = TransactionServiceException()
4884 
          self.ex.read(iprot)
4885 
        else:
4886 
          iprot.skip(ftype)
4887 
      else:
4888 
        iprot.skip(ftype)
4889 
      iprot.readFieldEnd()
4890 
    iprot.readStructEnd()
4891 
 
4892 
  def write(self, oprot):
4893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4895 
      return
4896 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 4897 
    if self.success is not None:
94 ashish 4898 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4899 
      oprot.writeBool(self.success)
4900 
      oprot.writeFieldEnd()
3431 rajveer 4901 
    if self.ex is not None:
94 ashish 4902 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4903 
      self.ex.write(oprot)
4904 
      oprot.writeFieldEnd()
4905 
    oprot.writeFieldStop()
4906 
    oprot.writeStructEnd()
4907 
 
3431 rajveer 4908 
  def validate(self):
4909 
    return
4910 
 
4911 
 
94 ashish 4912 
  def __repr__(self):
4913 
    L = ['%s=%r' % (key, value)
4914 
      for key, value in self.__dict__.iteritems()]
4915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4916 
 
4917 
  def __eq__(self, other):
4918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4919 
 
4920 
  def __ne__(self, other):
4921 
    return not (self == other)
4922 
 
1398 varun.gupt 4923 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 4924 
  """
4925 
  Attributes:
4926 
   - transactionId
4927 
  """
4928 
 
4929 
  thrift_spec = (
4930 
    None, # 0
4931 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4932 
  )
4933 
 
4934 
  def __init__(self, transactionId=None,):
4935 
    self.transactionId = transactionId
4936 
 
4937 
  def read(self, iprot):
4938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4940 
      return
4941 
    iprot.readStructBegin()
4942 
    while True:
4943 
      (fname, ftype, fid) = iprot.readFieldBegin()
4944 
      if ftype == TType.STOP:
4945 
        break
4946 
      if fid == 1:
4947 
        if ftype == TType.I64:
4948 
          self.transactionId = iprot.readI64();
4949 
        else:
4950 
          iprot.skip(ftype)
4951 
      else:
4952 
        iprot.skip(ftype)
4953 
      iprot.readFieldEnd()
4954 
    iprot.readStructEnd()
4955 
 
4956 
  def write(self, oprot):
4957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4959 
      return
1398 varun.gupt 4960 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 4961 
    if self.transactionId is not None:
1382 varun.gupt 4962 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4963 
      oprot.writeI64(self.transactionId)
4964 
      oprot.writeFieldEnd()
4965 
    oprot.writeFieldStop()
4966 
    oprot.writeStructEnd()
4967 
 
3431 rajveer 4968 
  def validate(self):
4969 
    return
4970 
 
4971 
 
1382 varun.gupt 4972 
  def __repr__(self):
4973 
    L = ['%s=%r' % (key, value)
4974 
      for key, value in self.__dict__.iteritems()]
4975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4976 
 
4977 
  def __eq__(self, other):
4978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4979 
 
4980 
  def __ne__(self, other):
4981 
    return not (self == other)
4982 
 
1398 varun.gupt 4983 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 4984 
  """
4985 
  Attributes:
4986 
   - success
4987 
   - ex
4988 
  """
4989 
 
4990 
  thrift_spec = (
4991 
    (0, TType.BOOL, 'success', None, None, ), # 0
4992 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4993 
  )
4994 
 
4995 
  def __init__(self, success=None, ex=None,):
4996 
    self.success = success
4997 
    self.ex = ex
4998 
 
4999 
  def read(self, iprot):
5000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5002 
      return
5003 
    iprot.readStructBegin()
5004 
    while True:
5005 
      (fname, ftype, fid) = iprot.readFieldBegin()
5006 
      if ftype == TType.STOP:
5007 
        break
5008 
      if fid == 0:
5009 
        if ftype == TType.BOOL:
5010 
          self.success = iprot.readBool();
5011 
        else:
5012 
          iprot.skip(ftype)
5013 
      elif fid == 1:
5014 
        if ftype == TType.STRUCT:
5015 
          self.ex = TransactionServiceException()
5016 
          self.ex.read(iprot)
5017 
        else:
5018 
          iprot.skip(ftype)
5019 
      else:
5020 
        iprot.skip(ftype)
5021 
      iprot.readFieldEnd()
5022 
    iprot.readStructEnd()
5023 
 
5024 
  def write(self, oprot):
5025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5027 
      return
1398 varun.gupt 5028 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5029 
    if self.success is not None:
1382 varun.gupt 5030 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5031 
      oprot.writeBool(self.success)
5032 
      oprot.writeFieldEnd()
3431 rajveer 5033 
    if self.ex is not None:
1382 varun.gupt 5034 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5035 
      self.ex.write(oprot)
5036 
      oprot.writeFieldEnd()
5037 
    oprot.writeFieldStop()
5038 
    oprot.writeStructEnd()
5039 
 
3431 rajveer 5040 
  def validate(self):
5041 
    return
5042 
 
5043 
 
1382 varun.gupt 5044 
  def __repr__(self):
5045 
    L = ['%s=%r' % (key, value)
5046 
      for key, value in self.__dict__.iteritems()]
5047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5048 
 
5049 
  def __eq__(self, other):
5050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5051 
 
5052 
  def __ne__(self, other):
5053 
    return not (self == other)
5054 
 
483 rajveer 5055 
class getAllOrders_args:
94 ashish 5056 
  """
5057 
  Attributes:
483 rajveer 5058 
   - status
5059 
   - from_date
5060 
   - to_date
5061 
   - warehouse_id
94 ashish 5062 
  """
5063 
 
5064 
  thrift_spec = (
5065 
    None, # 0
483 rajveer 5066 
    (1, TType.I32, 'status', None, None, ), # 1
5067 
    (2, TType.I64, 'from_date', None, None, ), # 2
5068 
    (3, TType.I64, 'to_date', None, None, ), # 3
5069 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5070 
  )
5071 
 
483 rajveer 5072 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5073 
    self.status = status
5074 
    self.from_date = from_date
5075 
    self.to_date = to_date
5076 
    self.warehouse_id = warehouse_id
94 ashish 5077 
 
5078 
  def read(self, iprot):
5079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5081 
      return
5082 
    iprot.readStructBegin()
5083 
    while True:
5084 
      (fname, ftype, fid) = iprot.readFieldBegin()
5085 
      if ftype == TType.STOP:
5086 
        break
5087 
      if fid == 1:
483 rajveer 5088 
        if ftype == TType.I32:
5089 
          self.status = iprot.readI32();
94 ashish 5090 
        else:
5091 
          iprot.skip(ftype)
483 rajveer 5092 
      elif fid == 2:
5093 
        if ftype == TType.I64:
5094 
          self.from_date = iprot.readI64();
94 ashish 5095 
        else:
5096 
          iprot.skip(ftype)
483 rajveer 5097 
      elif fid == 3:
5098 
        if ftype == TType.I64:
5099 
          self.to_date = iprot.readI64();
94 ashish 5100 
        else:
5101 
          iprot.skip(ftype)
483 rajveer 5102 
      elif fid == 4:
94 ashish 5103 
        if ftype == TType.I64:
483 rajveer 5104 
          self.warehouse_id = iprot.readI64();
94 ashish 5105 
        else:
5106 
          iprot.skip(ftype)
5107 
      else:
5108 
        iprot.skip(ftype)
5109 
      iprot.readFieldEnd()
5110 
    iprot.readStructEnd()
5111 
 
5112 
  def write(self, oprot):
5113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5115 
      return
483 rajveer 5116 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5117 
    if self.status is not None:
483 rajveer 5118 
      oprot.writeFieldBegin('status', TType.I32, 1)
5119 
      oprot.writeI32(self.status)
94 ashish 5120 
      oprot.writeFieldEnd()
3431 rajveer 5121 
    if self.from_date is not None:
483 rajveer 5122 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5123 
      oprot.writeI64(self.from_date)
94 ashish 5124 
      oprot.writeFieldEnd()
3431 rajveer 5125 
    if self.to_date is not None:
483 rajveer 5126 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5127 
      oprot.writeI64(self.to_date)
94 ashish 5128 
      oprot.writeFieldEnd()
3431 rajveer 5129 
    if self.warehouse_id is not None:
483 rajveer 5130 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5131 
      oprot.writeI64(self.warehouse_id)
94 ashish 5132 
      oprot.writeFieldEnd()
5133 
    oprot.writeFieldStop()
5134 
    oprot.writeStructEnd()
5135 
 
3431 rajveer 5136 
  def validate(self):
5137 
    return
5138 
 
5139 
 
94 ashish 5140 
  def __repr__(self):
5141 
    L = ['%s=%r' % (key, value)
5142 
      for key, value in self.__dict__.iteritems()]
5143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5144 
 
5145 
  def __eq__(self, other):
5146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5147 
 
5148 
  def __ne__(self, other):
5149 
    return not (self == other)
5150 
 
483 rajveer 5151 
class getAllOrders_result:
94 ashish 5152 
  """
5153 
  Attributes:
5154 
   - success
5155 
   - ex
5156 
  """
5157 
 
5158 
  thrift_spec = (
483 rajveer 5159 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5160 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5161 
  )
5162 
 
5163 
  def __init__(self, success=None, ex=None,):
5164 
    self.success = success
5165 
    self.ex = ex
5166 
 
5167 
  def read(self, iprot):
5168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5170 
      return
5171 
    iprot.readStructBegin()
5172 
    while True:
5173 
      (fname, ftype, fid) = iprot.readFieldBegin()
5174 
      if ftype == TType.STOP:
5175 
        break
5176 
      if fid == 0:
483 rajveer 5177 
        if ftype == TType.LIST:
5178 
          self.success = []
685 chandransh 5179 
          (_etype31, _size28) = iprot.readListBegin()
5180 
          for _i32 in xrange(_size28):
5181 
            _elem33 = Order()
5182 
            _elem33.read(iprot)
5183 
            self.success.append(_elem33)
483 rajveer 5184 
          iprot.readListEnd()
94 ashish 5185 
        else:
5186 
          iprot.skip(ftype)
5187 
      elif fid == 1:
5188 
        if ftype == TType.STRUCT:
5189 
          self.ex = TransactionServiceException()
5190 
          self.ex.read(iprot)
5191 
        else:
5192 
          iprot.skip(ftype)
5193 
      else:
5194 
        iprot.skip(ftype)
5195 
      iprot.readFieldEnd()
5196 
    iprot.readStructEnd()
5197 
 
5198 
  def write(self, oprot):
5199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5201 
      return
483 rajveer 5202 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5203 
    if self.success is not None:
483 rajveer 5204 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5205 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5206 
      for iter34 in self.success:
5207 
        iter34.write(oprot)
483 rajveer 5208 
      oprot.writeListEnd()
94 ashish 5209 
      oprot.writeFieldEnd()
3431 rajveer 5210 
    if self.ex is not None:
94 ashish 5211 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5212 
      self.ex.write(oprot)
5213 
      oprot.writeFieldEnd()
5214 
    oprot.writeFieldStop()
5215 
    oprot.writeStructEnd()
5216 
 
3431 rajveer 5217 
  def validate(self):
5218 
    return
5219 
 
5220 
 
94 ashish 5221 
  def __repr__(self):
5222 
    L = ['%s=%r' % (key, value)
5223 
      for key, value in self.__dict__.iteritems()]
5224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5225 
 
5226 
  def __eq__(self, other):
5227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5228 
 
5229 
  def __ne__(self, other):
5230 
    return not (self == other)
5231 
 
4133 chandransh 5232 
class getOrdersInBatch_args:
5233 
  """
5234 
  Attributes:
5235 
   - statuses
5236 
   - offset
5237 
   - limit
5238 
   - warehouse_id
5239 
  """
5240 
 
5241 
  thrift_spec = (
5242 
    None, # 0
5243 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5244 
    (2, TType.I64, 'offset', None, None, ), # 2
5245 
    (3, TType.I64, 'limit', None, None, ), # 3
5246 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5247 
  )
5248 
 
5249 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
5250 
    self.statuses = statuses
5251 
    self.offset = offset
5252 
    self.limit = limit
5253 
    self.warehouse_id = warehouse_id
5254 
 
5255 
  def read(self, iprot):
5256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5258 
      return
5259 
    iprot.readStructBegin()
5260 
    while True:
5261 
      (fname, ftype, fid) = iprot.readFieldBegin()
5262 
      if ftype == TType.STOP:
5263 
        break
5264 
      if fid == 1:
5265 
        if ftype == TType.LIST:
5266 
          self.statuses = []
5267 
          (_etype38, _size35) = iprot.readListBegin()
5268 
          for _i39 in xrange(_size35):
5269 
            _elem40 = iprot.readI32();
5270 
            self.statuses.append(_elem40)
5271 
          iprot.readListEnd()
5272 
        else:
5273 
          iprot.skip(ftype)
5274 
      elif fid == 2:
5275 
        if ftype == TType.I64:
5276 
          self.offset = iprot.readI64();
5277 
        else:
5278 
          iprot.skip(ftype)
5279 
      elif fid == 3:
5280 
        if ftype == TType.I64:
5281 
          self.limit = iprot.readI64();
5282 
        else:
5283 
          iprot.skip(ftype)
5284 
      elif fid == 4:
5285 
        if ftype == TType.I64:
5286 
          self.warehouse_id = iprot.readI64();
5287 
        else:
5288 
          iprot.skip(ftype)
5289 
      else:
5290 
        iprot.skip(ftype)
5291 
      iprot.readFieldEnd()
5292 
    iprot.readStructEnd()
5293 
 
5294 
  def write(self, oprot):
5295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5297 
      return
5298 
    oprot.writeStructBegin('getOrdersInBatch_args')
5299 
    if self.statuses is not None:
5300 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5301 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5302 
      for iter41 in self.statuses:
5303 
        oprot.writeI32(iter41)
5304 
      oprot.writeListEnd()
5305 
      oprot.writeFieldEnd()
5306 
    if self.offset is not None:
5307 
      oprot.writeFieldBegin('offset', TType.I64, 2)
5308 
      oprot.writeI64(self.offset)
5309 
      oprot.writeFieldEnd()
5310 
    if self.limit is not None:
5311 
      oprot.writeFieldBegin('limit', TType.I64, 3)
5312 
      oprot.writeI64(self.limit)
5313 
      oprot.writeFieldEnd()
5314 
    if self.warehouse_id is not None:
5315 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5316 
      oprot.writeI64(self.warehouse_id)
5317 
      oprot.writeFieldEnd()
5318 
    oprot.writeFieldStop()
5319 
    oprot.writeStructEnd()
5320 
 
5321 
  def validate(self):
5322 
    return
5323 
 
5324 
 
5325 
  def __repr__(self):
5326 
    L = ['%s=%r' % (key, value)
5327 
      for key, value in self.__dict__.iteritems()]
5328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5329 
 
5330 
  def __eq__(self, other):
5331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5332 
 
5333 
  def __ne__(self, other):
5334 
    return not (self == other)
5335 
 
5336 
class getOrdersInBatch_result:
5337 
  """
5338 
  Attributes:
5339 
   - success
5340 
   - ex
5341 
  """
5342 
 
5343 
  thrift_spec = (
5344 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5345 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5346 
  )
5347 
 
5348 
  def __init__(self, success=None, ex=None,):
5349 
    self.success = success
5350 
    self.ex = ex
5351 
 
5352 
  def read(self, iprot):
5353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5355 
      return
5356 
    iprot.readStructBegin()
5357 
    while True:
5358 
      (fname, ftype, fid) = iprot.readFieldBegin()
5359 
      if ftype == TType.STOP:
5360 
        break
5361 
      if fid == 0:
5362 
        if ftype == TType.LIST:
5363 
          self.success = []
5364 
          (_etype45, _size42) = iprot.readListBegin()
5365 
          for _i46 in xrange(_size42):
5366 
            _elem47 = Order()
5367 
            _elem47.read(iprot)
5368 
            self.success.append(_elem47)
5369 
          iprot.readListEnd()
5370 
        else:
5371 
          iprot.skip(ftype)
5372 
      elif fid == 1:
5373 
        if ftype == TType.STRUCT:
5374 
          self.ex = TransactionServiceException()
5375 
          self.ex.read(iprot)
5376 
        else:
5377 
          iprot.skip(ftype)
5378 
      else:
5379 
        iprot.skip(ftype)
5380 
      iprot.readFieldEnd()
5381 
    iprot.readStructEnd()
5382 
 
5383 
  def write(self, oprot):
5384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5386 
      return
5387 
    oprot.writeStructBegin('getOrdersInBatch_result')
5388 
    if self.success is not None:
5389 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5390 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5391 
      for iter48 in self.success:
5392 
        iter48.write(oprot)
5393 
      oprot.writeListEnd()
5394 
      oprot.writeFieldEnd()
5395 
    if self.ex is not None:
5396 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5397 
      self.ex.write(oprot)
5398 
      oprot.writeFieldEnd()
5399 
    oprot.writeFieldStop()
5400 
    oprot.writeStructEnd()
5401 
 
5402 
  def validate(self):
5403 
    return
5404 
 
5405 
 
5406 
  def __repr__(self):
5407 
    L = ['%s=%r' % (key, value)
5408 
      for key, value in self.__dict__.iteritems()]
5409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5410 
 
5411 
  def __eq__(self, other):
5412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5413 
 
5414 
  def __ne__(self, other):
5415 
    return not (self == other)
5416 
 
5417 
class getOrderCount_args:
5418 
  """
5419 
  Attributes:
5420 
   - statuses
5421 
   - warehouseId
5422 
  """
5423 
 
5424 
  thrift_spec = (
5425 
    None, # 0
5426 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5427 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5428 
  )
5429 
 
5430 
  def __init__(self, statuses=None, warehouseId=None,):
5431 
    self.statuses = statuses
5432 
    self.warehouseId = warehouseId
5433 
 
5434 
  def read(self, iprot):
5435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5437 
      return
5438 
    iprot.readStructBegin()
5439 
    while True:
5440 
      (fname, ftype, fid) = iprot.readFieldBegin()
5441 
      if ftype == TType.STOP:
5442 
        break
5443 
      if fid == 1:
5444 
        if ftype == TType.LIST:
5445 
          self.statuses = []
5446 
          (_etype52, _size49) = iprot.readListBegin()
5447 
          for _i53 in xrange(_size49):
5448 
            _elem54 = iprot.readI32();
5449 
            self.statuses.append(_elem54)
5450 
          iprot.readListEnd()
5451 
        else:
5452 
          iprot.skip(ftype)
5453 
      elif fid == 2:
5454 
        if ftype == TType.I64:
5455 
          self.warehouseId = iprot.readI64();
5456 
        else:
5457 
          iprot.skip(ftype)
5458 
      else:
5459 
        iprot.skip(ftype)
5460 
      iprot.readFieldEnd()
5461 
    iprot.readStructEnd()
5462 
 
5463 
  def write(self, oprot):
5464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5466 
      return
5467 
    oprot.writeStructBegin('getOrderCount_args')
5468 
    if self.statuses is not None:
5469 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5470 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5471 
      for iter55 in self.statuses:
5472 
        oprot.writeI32(iter55)
5473 
      oprot.writeListEnd()
5474 
      oprot.writeFieldEnd()
5475 
    if self.warehouseId is not None:
5476 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5477 
      oprot.writeI64(self.warehouseId)
5478 
      oprot.writeFieldEnd()
5479 
    oprot.writeFieldStop()
5480 
    oprot.writeStructEnd()
5481 
 
5482 
  def validate(self):
5483 
    return
5484 
 
5485 
 
5486 
  def __repr__(self):
5487 
    L = ['%s=%r' % (key, value)
5488 
      for key, value in self.__dict__.iteritems()]
5489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5490 
 
5491 
  def __eq__(self, other):
5492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5493 
 
5494 
  def __ne__(self, other):
5495 
    return not (self == other)
5496 
 
5497 
class getOrderCount_result:
5498 
  """
5499 
  Attributes:
5500 
   - success
5501 
   - ex
5502 
  """
5503 
 
5504 
  thrift_spec = (
5505 
    (0, TType.I32, 'success', None, None, ), # 0
5506 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5507 
  )
5508 
 
5509 
  def __init__(self, success=None, ex=None,):
5510 
    self.success = success
5511 
    self.ex = ex
5512 
 
5513 
  def read(self, iprot):
5514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5516 
      return
5517 
    iprot.readStructBegin()
5518 
    while True:
5519 
      (fname, ftype, fid) = iprot.readFieldBegin()
5520 
      if ftype == TType.STOP:
5521 
        break
5522 
      if fid == 0:
5523 
        if ftype == TType.I32:
5524 
          self.success = iprot.readI32();
5525 
        else:
5526 
          iprot.skip(ftype)
5527 
      elif fid == 1:
5528 
        if ftype == TType.STRUCT:
5529 
          self.ex = TransactionServiceException()
5530 
          self.ex.read(iprot)
5531 
        else:
5532 
          iprot.skip(ftype)
5533 
      else:
5534 
        iprot.skip(ftype)
5535 
      iprot.readFieldEnd()
5536 
    iprot.readStructEnd()
5537 
 
5538 
  def write(self, oprot):
5539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5541 
      return
5542 
    oprot.writeStructBegin('getOrderCount_result')
5543 
    if self.success is not None:
5544 
      oprot.writeFieldBegin('success', TType.I32, 0)
5545 
      oprot.writeI32(self.success)
5546 
      oprot.writeFieldEnd()
5547 
    if self.ex is not None:
5548 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5549 
      self.ex.write(oprot)
5550 
      oprot.writeFieldEnd()
5551 
    oprot.writeFieldStop()
5552 
    oprot.writeStructEnd()
5553 
 
5554 
  def validate(self):
5555 
    return
5556 
 
5557 
 
5558 
  def __repr__(self):
5559 
    L = ['%s=%r' % (key, value)
5560 
      for key, value in self.__dict__.iteritems()]
5561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5562 
 
5563 
  def __eq__(self, other):
5564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5565 
 
5566 
  def __ne__(self, other):
5567 
    return not (self == other)
5568 
 
999 varun.gupt 5569 
class getOrdersByBillingDate_args:
5570 
  """
5571 
  Attributes:
5572 
   - status
5573 
   - start_billing_date
5574 
   - end_billing_date
5575 
   - warehouse_id
5576 
  """
5577 
 
5578 
  thrift_spec = (
5579 
    None, # 0
5580 
    (1, TType.I32, 'status', None, None, ), # 1
5581 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
5582 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
5583 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5584 
  )
5585 
 
5586 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
5587 
    self.status = status
5588 
    self.start_billing_date = start_billing_date
5589 
    self.end_billing_date = end_billing_date
5590 
    self.warehouse_id = warehouse_id
5591 
 
5592 
  def read(self, iprot):
5593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5595 
      return
5596 
    iprot.readStructBegin()
5597 
    while True:
5598 
      (fname, ftype, fid) = iprot.readFieldBegin()
5599 
      if ftype == TType.STOP:
5600 
        break
5601 
      if fid == 1:
5602 
        if ftype == TType.I32:
5603 
          self.status = iprot.readI32();
5604 
        else:
5605 
          iprot.skip(ftype)
5606 
      elif fid == 2:
5607 
        if ftype == TType.I64:
5608 
          self.start_billing_date = iprot.readI64();
5609 
        else:
5610 
          iprot.skip(ftype)
5611 
      elif fid == 3:
5612 
        if ftype == TType.I64:
5613 
          self.end_billing_date = iprot.readI64();
5614 
        else:
5615 
          iprot.skip(ftype)
5616 
      elif fid == 4:
5617 
        if ftype == TType.I64:
5618 
          self.warehouse_id = iprot.readI64();
5619 
        else:
5620 
          iprot.skip(ftype)
5621 
      else:
5622 
        iprot.skip(ftype)
5623 
      iprot.readFieldEnd()
5624 
    iprot.readStructEnd()
5625 
 
5626 
  def write(self, oprot):
5627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5629 
      return
5630 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 5631 
    if self.status is not None:
999 varun.gupt 5632 
      oprot.writeFieldBegin('status', TType.I32, 1)
5633 
      oprot.writeI32(self.status)
5634 
      oprot.writeFieldEnd()
3431 rajveer 5635 
    if self.start_billing_date is not None:
999 varun.gupt 5636 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
5637 
      oprot.writeI64(self.start_billing_date)
5638 
      oprot.writeFieldEnd()
3431 rajveer 5639 
    if self.end_billing_date is not None:
999 varun.gupt 5640 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
5641 
      oprot.writeI64(self.end_billing_date)
5642 
      oprot.writeFieldEnd()
3431 rajveer 5643 
    if self.warehouse_id is not None:
999 varun.gupt 5644 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5645 
      oprot.writeI64(self.warehouse_id)
5646 
      oprot.writeFieldEnd()
5647 
    oprot.writeFieldStop()
5648 
    oprot.writeStructEnd()
5649 
 
3431 rajveer 5650 
  def validate(self):
5651 
    return
5652 
 
5653 
 
999 varun.gupt 5654 
  def __repr__(self):
5655 
    L = ['%s=%r' % (key, value)
5656 
      for key, value in self.__dict__.iteritems()]
5657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5658 
 
5659 
  def __eq__(self, other):
5660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5661 
 
5662 
  def __ne__(self, other):
5663 
    return not (self == other)
5664 
 
5665 
class getOrdersByBillingDate_result:
5666 
  """
5667 
  Attributes:
5668 
   - success
5669 
   - ex
5670 
  """
5671 
 
5672 
  thrift_spec = (
5673 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5674 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5675 
  )
5676 
 
5677 
  def __init__(self, success=None, ex=None,):
5678 
    self.success = success
5679 
    self.ex = ex
5680 
 
5681 
  def read(self, iprot):
5682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5684 
      return
5685 
    iprot.readStructBegin()
5686 
    while True:
5687 
      (fname, ftype, fid) = iprot.readFieldBegin()
5688 
      if ftype == TType.STOP:
5689 
        break
5690 
      if fid == 0:
5691 
        if ftype == TType.LIST:
5692 
          self.success = []
4133 chandransh 5693 
          (_etype59, _size56) = iprot.readListBegin()
5694 
          for _i60 in xrange(_size56):
5695 
            _elem61 = Order()
5696 
            _elem61.read(iprot)
5697 
            self.success.append(_elem61)
999 varun.gupt 5698 
          iprot.readListEnd()
5699 
        else:
5700 
          iprot.skip(ftype)
5701 
      elif fid == 1:
5702 
        if ftype == TType.STRUCT:
5703 
          self.ex = TransactionServiceException()
5704 
          self.ex.read(iprot)
5705 
        else:
5706 
          iprot.skip(ftype)
5707 
      else:
5708 
        iprot.skip(ftype)
5709 
      iprot.readFieldEnd()
5710 
    iprot.readStructEnd()
5711 
 
5712 
  def write(self, oprot):
5713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5715 
      return
5716 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 5717 
    if self.success is not None:
999 varun.gupt 5718 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5719 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 5720 
      for iter62 in self.success:
5721 
        iter62.write(oprot)
999 varun.gupt 5722 
      oprot.writeListEnd()
5723 
      oprot.writeFieldEnd()
3431 rajveer 5724 
    if self.ex is not None:
999 varun.gupt 5725 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5726 
      self.ex.write(oprot)
5727 
      oprot.writeFieldEnd()
5728 
    oprot.writeFieldStop()
5729 
    oprot.writeStructEnd()
5730 
 
3431 rajveer 5731 
  def validate(self):
5732 
    return
5733 
 
5734 
 
999 varun.gupt 5735 
  def __repr__(self):
5736 
    L = ['%s=%r' % (key, value)
5737 
      for key, value in self.__dict__.iteritems()]
5738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5739 
 
5740 
  def __eq__(self, other):
5741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5742 
 
5743 
  def __ne__(self, other):
5744 
    return not (self == other)
5745 
 
3427 chandransh 5746 
class getOrdersByShippingDate_args:
5747 
  """
5748 
  Attributes:
5749 
   - fromShippingDate
5750 
   - toShippingDate
5751 
   - providerId
5752 
   - warehouseId
3451 chandransh 5753 
   - cod
3427 chandransh 5754 
  """
5755 
 
5756 
  thrift_spec = (
5757 
    None, # 0
5758 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
5759 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
5760 
    (3, TType.I64, 'providerId', None, None, ), # 3
5761 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 5762 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 5763 
  )
5764 
 
3451 chandransh 5765 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 5766 
    self.fromShippingDate = fromShippingDate
5767 
    self.toShippingDate = toShippingDate
5768 
    self.providerId = providerId
5769 
    self.warehouseId = warehouseId
3451 chandransh 5770 
    self.cod = cod
3427 chandransh 5771 
 
5772 
  def read(self, iprot):
5773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5775 
      return
5776 
    iprot.readStructBegin()
5777 
    while True:
5778 
      (fname, ftype, fid) = iprot.readFieldBegin()
5779 
      if ftype == TType.STOP:
5780 
        break
5781 
      if fid == 1:
5782 
        if ftype == TType.I64:
5783 
          self.fromShippingDate = iprot.readI64();
5784 
        else:
5785 
          iprot.skip(ftype)
5786 
      elif fid == 2:
5787 
        if ftype == TType.I64:
5788 
          self.toShippingDate = iprot.readI64();
5789 
        else:
5790 
          iprot.skip(ftype)
5791 
      elif fid == 3:
5792 
        if ftype == TType.I64:
5793 
          self.providerId = iprot.readI64();
5794 
        else:
5795 
          iprot.skip(ftype)
5796 
      elif fid == 4:
5797 
        if ftype == TType.I64:
5798 
          self.warehouseId = iprot.readI64();
5799 
        else:
5800 
          iprot.skip(ftype)
3451 chandransh 5801 
      elif fid == 5:
5802 
        if ftype == TType.BOOL:
5803 
          self.cod = iprot.readBool();
5804 
        else:
5805 
          iprot.skip(ftype)
3427 chandransh 5806 
      else:
5807 
        iprot.skip(ftype)
5808 
      iprot.readFieldEnd()
5809 
    iprot.readStructEnd()
5810 
 
5811 
  def write(self, oprot):
5812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5814 
      return
5815 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 5816 
    if self.fromShippingDate is not None:
3427 chandransh 5817 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
5818 
      oprot.writeI64(self.fromShippingDate)
5819 
      oprot.writeFieldEnd()
3431 rajveer 5820 
    if self.toShippingDate is not None:
3427 chandransh 5821 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
5822 
      oprot.writeI64(self.toShippingDate)
5823 
      oprot.writeFieldEnd()
3431 rajveer 5824 
    if self.providerId is not None:
3427 chandransh 5825 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
5826 
      oprot.writeI64(self.providerId)
5827 
      oprot.writeFieldEnd()
3431 rajveer 5828 
    if self.warehouseId is not None:
3427 chandransh 5829 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
5830 
      oprot.writeI64(self.warehouseId)
5831 
      oprot.writeFieldEnd()
3451 chandransh 5832 
    if self.cod is not None:
5833 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
5834 
      oprot.writeBool(self.cod)
5835 
      oprot.writeFieldEnd()
3427 chandransh 5836 
    oprot.writeFieldStop()
5837 
    oprot.writeStructEnd()
5838 
 
3431 rajveer 5839 
  def validate(self):
5840 
    return
5841 
 
5842 
 
3427 chandransh 5843 
  def __repr__(self):
5844 
    L = ['%s=%r' % (key, value)
5845 
      for key, value in self.__dict__.iteritems()]
5846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5847 
 
5848 
  def __eq__(self, other):
5849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5850 
 
5851 
  def __ne__(self, other):
5852 
    return not (self == other)
5853 
 
5854 
class getOrdersByShippingDate_result:
5855 
  """
5856 
  Attributes:
5857 
   - success
5858 
   - ex
5859 
  """
5860 
 
5861 
  thrift_spec = (
5862 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5863 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5864 
  )
5865 
 
5866 
  def __init__(self, success=None, ex=None,):
5867 
    self.success = success
5868 
    self.ex = ex
5869 
 
5870 
  def read(self, iprot):
5871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5873 
      return
5874 
    iprot.readStructBegin()
5875 
    while True:
5876 
      (fname, ftype, fid) = iprot.readFieldBegin()
5877 
      if ftype == TType.STOP:
5878 
        break
5879 
      if fid == 0:
5880 
        if ftype == TType.LIST:
5881 
          self.success = []
4133 chandransh 5882 
          (_etype66, _size63) = iprot.readListBegin()
5883 
          for _i67 in xrange(_size63):
5884 
            _elem68 = Order()
5885 
            _elem68.read(iprot)
5886 
            self.success.append(_elem68)
3427 chandransh 5887 
          iprot.readListEnd()
5888 
        else:
5889 
          iprot.skip(ftype)
5890 
      elif fid == 1:
5891 
        if ftype == TType.STRUCT:
5892 
          self.ex = TransactionServiceException()
5893 
          self.ex.read(iprot)
5894 
        else:
5895 
          iprot.skip(ftype)
5896 
      else:
5897 
        iprot.skip(ftype)
5898 
      iprot.readFieldEnd()
5899 
    iprot.readStructEnd()
5900 
 
5901 
  def write(self, oprot):
5902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5904 
      return
5905 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 5906 
    if self.success is not None:
3427 chandransh 5907 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5908 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 5909 
      for iter69 in self.success:
5910 
        iter69.write(oprot)
3427 chandransh 5911 
      oprot.writeListEnd()
5912 
      oprot.writeFieldEnd()
3431 rajveer 5913 
    if self.ex is not None:
3427 chandransh 5914 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5915 
      self.ex.write(oprot)
5916 
      oprot.writeFieldEnd()
5917 
    oprot.writeFieldStop()
5918 
    oprot.writeStructEnd()
5919 
 
3431 rajveer 5920 
  def validate(self):
5921 
    return
5922 
 
5923 
 
3427 chandransh 5924 
  def __repr__(self):
5925 
    L = ['%s=%r' % (key, value)
5926 
      for key, value in self.__dict__.iteritems()]
5927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5928 
 
5929 
  def __eq__(self, other):
5930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5931 
 
5932 
  def __ne__(self, other):
5933 
    return not (self == other)
5934 
 
1382 varun.gupt 5935 
class getReturnableOrdersForCustomer_args:
5936 
  """
5937 
  Attributes:
5938 
   - customer_id
5939 
   - limit
5940 
  """
5941 
 
5942 
  thrift_spec = (
5943 
    None, # 0
5944 
    (1, TType.I64, 'customer_id', None, None, ), # 1
5945 
    (2, TType.I64, 'limit', None, None, ), # 2
5946 
  )
5947 
 
5948 
  def __init__(self, customer_id=None, limit=None,):
5949 
    self.customer_id = customer_id
5950 
    self.limit = limit
5951 
 
5952 
  def read(self, iprot):
5953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5955 
      return
5956 
    iprot.readStructBegin()
5957 
    while True:
5958 
      (fname, ftype, fid) = iprot.readFieldBegin()
5959 
      if ftype == TType.STOP:
5960 
        break
5961 
      if fid == 1:
5962 
        if ftype == TType.I64:
5963 
          self.customer_id = iprot.readI64();
5964 
        else:
5965 
          iprot.skip(ftype)
5966 
      elif fid == 2:
5967 
        if ftype == TType.I64:
5968 
          self.limit = iprot.readI64();
5969 
        else:
5970 
          iprot.skip(ftype)
5971 
      else:
5972 
        iprot.skip(ftype)
5973 
      iprot.readFieldEnd()
5974 
    iprot.readStructEnd()
5975 
 
5976 
  def write(self, oprot):
5977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5979 
      return
5980 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 5981 
    if self.customer_id is not None:
1382 varun.gupt 5982 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
5983 
      oprot.writeI64(self.customer_id)
5984 
      oprot.writeFieldEnd()
3431 rajveer 5985 
    if self.limit is not None:
1382 varun.gupt 5986 
      oprot.writeFieldBegin('limit', TType.I64, 2)
5987 
      oprot.writeI64(self.limit)
5988 
      oprot.writeFieldEnd()
5989 
    oprot.writeFieldStop()
5990 
    oprot.writeStructEnd()
5991 
 
3431 rajveer 5992 
  def validate(self):
5993 
    return
5994 
 
5995 
 
1382 varun.gupt 5996 
  def __repr__(self):
5997 
    L = ['%s=%r' % (key, value)
5998 
      for key, value in self.__dict__.iteritems()]
5999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6000 
 
6001 
  def __eq__(self, other):
6002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6003 
 
6004 
  def __ne__(self, other):
6005 
    return not (self == other)
6006 
 
6007 
class getReturnableOrdersForCustomer_result:
6008 
  """
6009 
  Attributes:
6010 
   - success
6011 
   - ex
6012 
  """
6013 
 
6014 
  thrift_spec = (
6015 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6016 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6017 
  )
6018 
 
6019 
  def __init__(self, success=None, ex=None,):
6020 
    self.success = success
6021 
    self.ex = ex
6022 
 
6023 
  def read(self, iprot):
6024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6026 
      return
6027 
    iprot.readStructBegin()
6028 
    while True:
6029 
      (fname, ftype, fid) = iprot.readFieldBegin()
6030 
      if ftype == TType.STOP:
6031 
        break
6032 
      if fid == 0:
6033 
        if ftype == TType.LIST:
6034 
          self.success = []
4133 chandransh 6035 
          (_etype73, _size70) = iprot.readListBegin()
6036 
          for _i74 in xrange(_size70):
6037 
            _elem75 = iprot.readI64();
6038 
            self.success.append(_elem75)
1382 varun.gupt 6039 
          iprot.readListEnd()
6040 
        else:
6041 
          iprot.skip(ftype)
6042 
      elif fid == 1:
6043 
        if ftype == TType.STRUCT:
6044 
          self.ex = TransactionServiceException()
6045 
          self.ex.read(iprot)
6046 
        else:
6047 
          iprot.skip(ftype)
6048 
      else:
6049 
        iprot.skip(ftype)
6050 
      iprot.readFieldEnd()
6051 
    iprot.readStructEnd()
6052 
 
6053 
  def write(self, oprot):
6054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6056 
      return
6057 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6058 
    if self.success is not None:
1382 varun.gupt 6059 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6060 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6061 
      for iter76 in self.success:
6062 
        oprot.writeI64(iter76)
1382 varun.gupt 6063 
      oprot.writeListEnd()
6064 
      oprot.writeFieldEnd()
3431 rajveer 6065 
    if self.ex is not None:
1382 varun.gupt 6066 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6067 
      self.ex.write(oprot)
6068 
      oprot.writeFieldEnd()
6069 
    oprot.writeFieldStop()
6070 
    oprot.writeStructEnd()
6071 
 
3431 rajveer 6072 
  def validate(self):
6073 
    return
6074 
 
6075 
 
1382 varun.gupt 6076 
  def __repr__(self):
6077 
    L = ['%s=%r' % (key, value)
6078 
      for key, value in self.__dict__.iteritems()]
6079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6080 
 
6081 
  def __eq__(self, other):
6082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6083 
 
6084 
  def __ne__(self, other):
6085 
    return not (self == other)
6086 
 
6087 
class getCancellableOrdersForCustomer_args:
6088 
  """
6089 
  Attributes:
6090 
   - customer_id
6091 
   - limit
6092 
  """
6093 
 
6094 
  thrift_spec = (
6095 
    None, # 0
6096 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6097 
    (2, TType.I64, 'limit', None, None, ), # 2
6098 
  )
6099 
 
6100 
  def __init__(self, customer_id=None, limit=None,):
6101 
    self.customer_id = customer_id
6102 
    self.limit = limit
6103 
 
6104 
  def read(self, iprot):
6105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6107 
      return
6108 
    iprot.readStructBegin()
6109 
    while True:
6110 
      (fname, ftype, fid) = iprot.readFieldBegin()
6111 
      if ftype == TType.STOP:
6112 
        break
6113 
      if fid == 1:
6114 
        if ftype == TType.I64:
6115 
          self.customer_id = iprot.readI64();
6116 
        else:
6117 
          iprot.skip(ftype)
6118 
      elif fid == 2:
6119 
        if ftype == TType.I64:
6120 
          self.limit = iprot.readI64();
6121 
        else:
6122 
          iprot.skip(ftype)
6123 
      else:
6124 
        iprot.skip(ftype)
6125 
      iprot.readFieldEnd()
6126 
    iprot.readStructEnd()
6127 
 
6128 
  def write(self, oprot):
6129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6131 
      return
6132 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6133 
    if self.customer_id is not None:
1382 varun.gupt 6134 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6135 
      oprot.writeI64(self.customer_id)
6136 
      oprot.writeFieldEnd()
3431 rajveer 6137 
    if self.limit is not None:
1382 varun.gupt 6138 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6139 
      oprot.writeI64(self.limit)
6140 
      oprot.writeFieldEnd()
6141 
    oprot.writeFieldStop()
6142 
    oprot.writeStructEnd()
6143 
 
3431 rajveer 6144 
  def validate(self):
6145 
    return
6146 
 
6147 
 
1382 varun.gupt 6148 
  def __repr__(self):
6149 
    L = ['%s=%r' % (key, value)
6150 
      for key, value in self.__dict__.iteritems()]
6151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6152 
 
6153 
  def __eq__(self, other):
6154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6155 
 
6156 
  def __ne__(self, other):
6157 
    return not (self == other)
6158 
 
6159 
class getCancellableOrdersForCustomer_result:
6160 
  """
6161 
  Attributes:
6162 
   - success
6163 
   - ex
6164 
  """
6165 
 
6166 
  thrift_spec = (
6167 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6168 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6169 
  )
6170 
 
6171 
  def __init__(self, success=None, ex=None,):
6172 
    self.success = success
6173 
    self.ex = ex
6174 
 
6175 
  def read(self, iprot):
6176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6178 
      return
6179 
    iprot.readStructBegin()
6180 
    while True:
6181 
      (fname, ftype, fid) = iprot.readFieldBegin()
6182 
      if ftype == TType.STOP:
6183 
        break
6184 
      if fid == 0:
6185 
        if ftype == TType.LIST:
6186 
          self.success = []
4133 chandransh 6187 
          (_etype80, _size77) = iprot.readListBegin()
6188 
          for _i81 in xrange(_size77):
6189 
            _elem82 = iprot.readI64();
6190 
            self.success.append(_elem82)
1382 varun.gupt 6191 
          iprot.readListEnd()
6192 
        else:
6193 
          iprot.skip(ftype)
6194 
      elif fid == 1:
6195 
        if ftype == TType.STRUCT:
6196 
          self.ex = TransactionServiceException()
6197 
          self.ex.read(iprot)
6198 
        else:
6199 
          iprot.skip(ftype)
6200 
      else:
6201 
        iprot.skip(ftype)
6202 
      iprot.readFieldEnd()
6203 
    iprot.readStructEnd()
6204 
 
6205 
  def write(self, oprot):
6206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6208 
      return
6209 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6210 
    if self.success is not None:
1382 varun.gupt 6211 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6212 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6213 
      for iter83 in self.success:
6214 
        oprot.writeI64(iter83)
1382 varun.gupt 6215 
      oprot.writeListEnd()
6216 
      oprot.writeFieldEnd()
3431 rajveer 6217 
    if self.ex is not None:
1382 varun.gupt 6218 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6219 
      self.ex.write(oprot)
6220 
      oprot.writeFieldEnd()
6221 
    oprot.writeFieldStop()
6222 
    oprot.writeStructEnd()
6223 
 
3431 rajveer 6224 
  def validate(self):
6225 
    return
6226 
 
6227 
 
1382 varun.gupt 6228 
  def __repr__(self):
6229 
    L = ['%s=%r' % (key, value)
6230 
      for key, value in self.__dict__.iteritems()]
6231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6232 
 
6233 
  def __eq__(self, other):
6234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6235 
 
6236 
  def __ne__(self, other):
6237 
    return not (self == other)
6238 
 
483 rajveer 6239 
class changeOrderStatus_args:
94 ashish 6240 
  """
6241 
  Attributes:
483 rajveer 6242 
   - orderId
6243 
   - status
6244 
   - description
94 ashish 6245 
  """
6246 
 
6247 
  thrift_spec = (
6248 
    None, # 0
483 rajveer 6249 
    (1, TType.I64, 'orderId', None, None, ), # 1
6250 
    (2, TType.I32, 'status', None, None, ), # 2
6251 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 6252 
  )
6253 
 
483 rajveer 6254 
  def __init__(self, orderId=None, status=None, description=None,):
6255 
    self.orderId = orderId
6256 
    self.status = status
6257 
    self.description = description
94 ashish 6258 
 
6259 
  def read(self, iprot):
6260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6262 
      return
6263 
    iprot.readStructBegin()
6264 
    while True:
6265 
      (fname, ftype, fid) = iprot.readFieldBegin()
6266 
      if ftype == TType.STOP:
6267 
        break
6268 
      if fid == 1:
6269 
        if ftype == TType.I64:
483 rajveer 6270 
          self.orderId = iprot.readI64();
94 ashish 6271 
        else:
6272 
          iprot.skip(ftype)
6273 
      elif fid == 2:
483 rajveer 6274 
        if ftype == TType.I32:
6275 
          self.status = iprot.readI32();
94 ashish 6276 
        else:
6277 
          iprot.skip(ftype)
483 rajveer 6278 
      elif fid == 3:
6279 
        if ftype == TType.STRING:
6280 
          self.description = iprot.readString();
6281 
        else:
6282 
          iprot.skip(ftype)
94 ashish 6283 
      else:
6284 
        iprot.skip(ftype)
6285 
      iprot.readFieldEnd()
6286 
    iprot.readStructEnd()
6287 
 
6288 
  def write(self, oprot):
6289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6291 
      return
483 rajveer 6292 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 6293 
    if self.orderId is not None:
483 rajveer 6294 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6295 
      oprot.writeI64(self.orderId)
94 ashish 6296 
      oprot.writeFieldEnd()
3431 rajveer 6297 
    if self.status is not None:
483 rajveer 6298 
      oprot.writeFieldBegin('status', TType.I32, 2)
6299 
      oprot.writeI32(self.status)
94 ashish 6300 
      oprot.writeFieldEnd()
3431 rajveer 6301 
    if self.description is not None:
483 rajveer 6302 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6303 
      oprot.writeString(self.description)
6304 
      oprot.writeFieldEnd()
94 ashish 6305 
    oprot.writeFieldStop()
6306 
    oprot.writeStructEnd()
6307 
 
3431 rajveer 6308 
  def validate(self):
6309 
    return
6310 
 
6311 
 
94 ashish 6312 
  def __repr__(self):
6313 
    L = ['%s=%r' % (key, value)
6314 
      for key, value in self.__dict__.iteritems()]
6315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6316 
 
6317 
  def __eq__(self, other):
6318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6319 
 
6320 
  def __ne__(self, other):
6321 
    return not (self == other)
6322 
 
483 rajveer 6323 
class changeOrderStatus_result:
94 ashish 6324 
  """
6325 
  Attributes:
6326 
   - success
6327 
   - ex
6328 
  """
6329 
 
6330 
  thrift_spec = (
6331 
    (0, TType.BOOL, 'success', None, None, ), # 0
6332 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6333 
  )
6334 
 
6335 
  def __init__(self, success=None, ex=None,):
6336 
    self.success = success
6337 
    self.ex = ex
6338 
 
6339 
  def read(self, iprot):
6340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6342 
      return
6343 
    iprot.readStructBegin()
6344 
    while True:
6345 
      (fname, ftype, fid) = iprot.readFieldBegin()
6346 
      if ftype == TType.STOP:
6347 
        break
6348 
      if fid == 0:
6349 
        if ftype == TType.BOOL:
6350 
          self.success = iprot.readBool();
6351 
        else:
6352 
          iprot.skip(ftype)
6353 
      elif fid == 1:
6354 
        if ftype == TType.STRUCT:
6355 
          self.ex = TransactionServiceException()
6356 
          self.ex.read(iprot)
6357 
        else:
6358 
          iprot.skip(ftype)
6359 
      else:
6360 
        iprot.skip(ftype)
6361 
      iprot.readFieldEnd()
6362 
    iprot.readStructEnd()
6363 
 
6364 
  def write(self, oprot):
6365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6367 
      return
483 rajveer 6368 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 6369 
    if self.success is not None:
94 ashish 6370 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6371 
      oprot.writeBool(self.success)
6372 
      oprot.writeFieldEnd()
3431 rajveer 6373 
    if self.ex is not None:
94 ashish 6374 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6375 
      self.ex.write(oprot)
6376 
      oprot.writeFieldEnd()
6377 
    oprot.writeFieldStop()
6378 
    oprot.writeStructEnd()
6379 
 
3431 rajveer 6380 
  def validate(self):
6381 
    return
6382 
 
6383 
 
94 ashish 6384 
  def __repr__(self):
6385 
    L = ['%s=%r' % (key, value)
6386 
      for key, value in self.__dict__.iteritems()]
6387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6388 
 
6389 
  def __eq__(self, other):
6390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6391 
 
6392 
  def __ne__(self, other):
6393 
    return not (self == other)
6394 
 
3064 chandransh 6395 
class getOrdersForTransaction_args:
494 rajveer 6396 
  """
6397 
  Attributes:
3064 chandransh 6398 
   - transactionId
6399 
   - customerId
494 rajveer 6400 
  """
6401 
 
6402 
  thrift_spec = (
6403 
    None, # 0
3064 chandransh 6404 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6405 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 6406 
  )
6407 
 
3064 chandransh 6408 
  def __init__(self, transactionId=None, customerId=None,):
6409 
    self.transactionId = transactionId
6410 
    self.customerId = customerId
494 rajveer 6411 
 
6412 
  def read(self, iprot):
6413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6415 
      return
6416 
    iprot.readStructBegin()
6417 
    while True:
6418 
      (fname, ftype, fid) = iprot.readFieldBegin()
6419 
      if ftype == TType.STOP:
6420 
        break
6421 
      if fid == 1:
6422 
        if ftype == TType.I64:
3064 chandransh 6423 
          self.transactionId = iprot.readI64();
494 rajveer 6424 
        else:
6425 
          iprot.skip(ftype)
6426 
      elif fid == 2:
3064 chandransh 6427 
        if ftype == TType.I64:
6428 
          self.customerId = iprot.readI64();
494 rajveer 6429 
        else:
6430 
          iprot.skip(ftype)
6431 
      else:
6432 
        iprot.skip(ftype)
6433 
      iprot.readFieldEnd()
6434 
    iprot.readStructEnd()
6435 
 
6436 
  def write(self, oprot):
6437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6439 
      return
3064 chandransh 6440 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 6441 
    if self.transactionId is not None:
3064 chandransh 6442 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6443 
      oprot.writeI64(self.transactionId)
494 rajveer 6444 
      oprot.writeFieldEnd()
3431 rajveer 6445 
    if self.customerId is not None:
3064 chandransh 6446 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
6447 
      oprot.writeI64(self.customerId)
494 rajveer 6448 
      oprot.writeFieldEnd()
6449 
    oprot.writeFieldStop()
6450 
    oprot.writeStructEnd()
6451 
 
3431 rajveer 6452 
  def validate(self):
6453 
    return
6454 
 
6455 
 
494 rajveer 6456 
  def __repr__(self):
6457 
    L = ['%s=%r' % (key, value)
6458 
      for key, value in self.__dict__.iteritems()]
6459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6460 
 
6461 
  def __eq__(self, other):
6462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6463 
 
6464 
  def __ne__(self, other):
6465 
    return not (self == other)
6466 
 
3064 chandransh 6467 
class getOrdersForTransaction_result:
494 rajveer 6468 
  """
6469 
  Attributes:
6470 
   - success
6471 
   - ex
6472 
  """
6473 
 
6474 
  thrift_spec = (
3064 chandransh 6475 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 6476 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6477 
  )
6478 
 
6479 
  def __init__(self, success=None, ex=None,):
6480 
    self.success = success
6481 
    self.ex = ex
6482 
 
6483 
  def read(self, iprot):
6484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6486 
      return
6487 
    iprot.readStructBegin()
6488 
    while True:
6489 
      (fname, ftype, fid) = iprot.readFieldBegin()
6490 
      if ftype == TType.STOP:
6491 
        break
6492 
      if fid == 0:
3064 chandransh 6493 
        if ftype == TType.LIST:
6494 
          self.success = []
4133 chandransh 6495 
          (_etype87, _size84) = iprot.readListBegin()
6496 
          for _i88 in xrange(_size84):
6497 
            _elem89 = Order()
6498 
            _elem89.read(iprot)
6499 
            self.success.append(_elem89)
3064 chandransh 6500 
          iprot.readListEnd()
494 rajveer 6501 
        else:
6502 
          iprot.skip(ftype)
6503 
      elif fid == 1:
6504 
        if ftype == TType.STRUCT:
6505 
          self.ex = TransactionServiceException()
6506 
          self.ex.read(iprot)
6507 
        else:
6508 
          iprot.skip(ftype)
6509 
      else:
6510 
        iprot.skip(ftype)
6511 
      iprot.readFieldEnd()
6512 
    iprot.readStructEnd()
6513 
 
6514 
  def write(self, oprot):
6515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6517 
      return
3064 chandransh 6518 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 6519 
    if self.success is not None:
3064 chandransh 6520 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6521 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6522 
      for iter90 in self.success:
6523 
        iter90.write(oprot)
3064 chandransh 6524 
      oprot.writeListEnd()
494 rajveer 6525 
      oprot.writeFieldEnd()
3431 rajveer 6526 
    if self.ex is not None:
494 rajveer 6527 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6528 
      self.ex.write(oprot)
6529 
      oprot.writeFieldEnd()
6530 
    oprot.writeFieldStop()
6531 
    oprot.writeStructEnd()
6532 
 
3431 rajveer 6533 
  def validate(self):
6534 
    return
6535 
 
6536 
 
494 rajveer 6537 
  def __repr__(self):
6538 
    L = ['%s=%r' % (key, value)
6539 
      for key, value in self.__dict__.iteritems()]
6540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6541 
 
6542 
  def __eq__(self, other):
6543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6544 
 
6545 
  def __ne__(self, other):
6546 
    return not (self == other)
6547 
 
3064 chandransh 6548 
class getOrdersForCustomer_args:
1149 chandransh 6549 
  """
6550 
  Attributes:
3064 chandransh 6551 
   - customerId
6552 
   - from_date
6553 
   - to_date
6554 
   - statuses
1149 chandransh 6555 
  """
6556 
 
6557 
  thrift_spec = (
6558 
    None, # 0
3064 chandransh 6559 
    (1, TType.I64, 'customerId', None, None, ), # 1
6560 
    (2, TType.I64, 'from_date', None, None, ), # 2
6561 
    (3, TType.I64, 'to_date', None, None, ), # 3
6562 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 6563 
  )
6564 
 
3064 chandransh 6565 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
6566 
    self.customerId = customerId
6567 
    self.from_date = from_date
6568 
    self.to_date = to_date
6569 
    self.statuses = statuses
1149 chandransh 6570 
 
6571 
  def read(self, iprot):
6572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6574 
      return
6575 
    iprot.readStructBegin()
6576 
    while True:
6577 
      (fname, ftype, fid) = iprot.readFieldBegin()
6578 
      if ftype == TType.STOP:
6579 
        break
6580 
      if fid == 1:
6581 
        if ftype == TType.I64:
3064 chandransh 6582 
          self.customerId = iprot.readI64();
1149 chandransh 6583 
        else:
6584 
          iprot.skip(ftype)
6585 
      elif fid == 2:
6586 
        if ftype == TType.I64:
3064 chandransh 6587 
          self.from_date = iprot.readI64();
1149 chandransh 6588 
        else:
6589 
          iprot.skip(ftype)
2783 chandransh 6590 
      elif fid == 3:
6591 
        if ftype == TType.I64:
3064 chandransh 6592 
          self.to_date = iprot.readI64();
2783 chandransh 6593 
        else:
6594 
          iprot.skip(ftype)
6595 
      elif fid == 4:
3064 chandransh 6596 
        if ftype == TType.LIST:
6597 
          self.statuses = []
4133 chandransh 6598 
          (_etype94, _size91) = iprot.readListBegin()
6599 
          for _i95 in xrange(_size91):
6600 
            _elem96 = iprot.readI32();
6601 
            self.statuses.append(_elem96)
3064 chandransh 6602 
          iprot.readListEnd()
2783 chandransh 6603 
        else:
6604 
          iprot.skip(ftype)
1149 chandransh 6605 
      else:
6606 
        iprot.skip(ftype)
6607 
      iprot.readFieldEnd()
6608 
    iprot.readStructEnd()
6609 
 
6610 
  def write(self, oprot):
6611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6613 
      return
3064 chandransh 6614 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 6615 
    if self.customerId is not None:
3064 chandransh 6616 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6617 
      oprot.writeI64(self.customerId)
1149 chandransh 6618 
      oprot.writeFieldEnd()
3431 rajveer 6619 
    if self.from_date is not None:
3064 chandransh 6620 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6621 
      oprot.writeI64(self.from_date)
1149 chandransh 6622 
      oprot.writeFieldEnd()
3431 rajveer 6623 
    if self.to_date is not None:
3064 chandransh 6624 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6625 
      oprot.writeI64(self.to_date)
2783 chandransh 6626 
      oprot.writeFieldEnd()
3431 rajveer 6627 
    if self.statuses is not None:
3064 chandransh 6628 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
6629 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 6630 
      for iter97 in self.statuses:
6631 
        oprot.writeI32(iter97)
3064 chandransh 6632 
      oprot.writeListEnd()
2783 chandransh 6633 
      oprot.writeFieldEnd()
1149 chandransh 6634 
    oprot.writeFieldStop()
6635 
    oprot.writeStructEnd()
6636 
 
3431 rajveer 6637 
  def validate(self):
6638 
    return
6639 
 
6640 
 
1149 chandransh 6641 
  def __repr__(self):
6642 
    L = ['%s=%r' % (key, value)
6643 
      for key, value in self.__dict__.iteritems()]
6644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6645 
 
6646 
  def __eq__(self, other):
6647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6648 
 
6649 
  def __ne__(self, other):
6650 
    return not (self == other)
6651 
 
3064 chandransh 6652 
class getOrdersForCustomer_result:
1149 chandransh 6653 
  """
6654 
  Attributes:
6655 
   - success
6656 
   - ex
6657 
  """
6658 
 
6659 
  thrift_spec = (
3064 chandransh 6660 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 6661 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6662 
  )
6663 
 
6664 
  def __init__(self, success=None, ex=None,):
6665 
    self.success = success
6666 
    self.ex = ex
6667 
 
6668 
  def read(self, iprot):
6669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6671 
      return
6672 
    iprot.readStructBegin()
6673 
    while True:
6674 
      (fname, ftype, fid) = iprot.readFieldBegin()
6675 
      if ftype == TType.STOP:
6676 
        break
6677 
      if fid == 0:
3064 chandransh 6678 
        if ftype == TType.LIST:
6679 
          self.success = []
4133 chandransh 6680 
          (_etype101, _size98) = iprot.readListBegin()
6681 
          for _i102 in xrange(_size98):
6682 
            _elem103 = Order()
6683 
            _elem103.read(iprot)
6684 
            self.success.append(_elem103)
3064 chandransh 6685 
          iprot.readListEnd()
1149 chandransh 6686 
        else:
6687 
          iprot.skip(ftype)
6688 
      elif fid == 1:
6689 
        if ftype == TType.STRUCT:
6690 
          self.ex = TransactionServiceException()
6691 
          self.ex.read(iprot)
6692 
        else:
6693 
          iprot.skip(ftype)
6694 
      else:
6695 
        iprot.skip(ftype)
6696 
      iprot.readFieldEnd()
6697 
    iprot.readStructEnd()
6698 
 
6699 
  def write(self, oprot):
6700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6702 
      return
3064 chandransh 6703 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 6704 
    if self.success is not None:
3064 chandransh 6705 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6706 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6707 
      for iter104 in self.success:
6708 
        iter104.write(oprot)
3064 chandransh 6709 
      oprot.writeListEnd()
1149 chandransh 6710 
      oprot.writeFieldEnd()
3431 rajveer 6711 
    if self.ex is not None:
1149 chandransh 6712 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6713 
      self.ex.write(oprot)
6714 
      oprot.writeFieldEnd()
6715 
    oprot.writeFieldStop()
6716 
    oprot.writeStructEnd()
6717 
 
3431 rajveer 6718 
  def validate(self):
6719 
    return
6720 
 
6721 
 
1149 chandransh 6722 
  def __repr__(self):
6723 
    L = ['%s=%r' % (key, value)
6724 
      for key, value in self.__dict__.iteritems()]
6725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6726 
 
6727 
  def __eq__(self, other):
6728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6729 
 
6730 
  def __ne__(self, other):
6731 
    return not (self == other)
6732 
 
3064 chandransh 6733 
class createOrder_args:
921 rajveer 6734 
  """
6735 
  Attributes:
3064 chandransh 6736 
   - order
921 rajveer 6737 
  """
6738 
 
6739 
  thrift_spec = (
6740 
    None, # 0
3064 chandransh 6741 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 6742 
  )
6743 
 
3064 chandransh 6744 
  def __init__(self, order=None,):
6745 
    self.order = order
921 rajveer 6746 
 
6747 
  def read(self, iprot):
6748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6750 
      return
6751 
    iprot.readStructBegin()
6752 
    while True:
6753 
      (fname, ftype, fid) = iprot.readFieldBegin()
6754 
      if ftype == TType.STOP:
6755 
        break
6756 
      if fid == 1:
3064 chandransh 6757 
        if ftype == TType.STRUCT:
6758 
          self.order = Order()
6759 
          self.order.read(iprot)
921 rajveer 6760 
        else:
6761 
          iprot.skip(ftype)
6762 
      else:
6763 
        iprot.skip(ftype)
6764 
      iprot.readFieldEnd()
6765 
    iprot.readStructEnd()
6766 
 
6767 
  def write(self, oprot):
6768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6770 
      return
3064 chandransh 6771 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 6772 
    if self.order is not None:
3064 chandransh 6773 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
6774 
      self.order.write(oprot)
921 rajveer 6775 
      oprot.writeFieldEnd()
6776 
    oprot.writeFieldStop()
6777 
    oprot.writeStructEnd()
6778 
 
3431 rajveer 6779 
  def validate(self):
6780 
    return
6781 
 
6782 
 
921 rajveer 6783 
  def __repr__(self):
6784 
    L = ['%s=%r' % (key, value)
6785 
      for key, value in self.__dict__.iteritems()]
6786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6787 
 
6788 
  def __eq__(self, other):
6789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6790 
 
6791 
  def __ne__(self, other):
6792 
    return not (self == other)
6793 
 
3064 chandransh 6794 
class createOrder_result:
921 rajveer 6795 
  """
6796 
  Attributes:
6797 
   - success
6798 
   - ex
6799 
  """
6800 
 
6801 
  thrift_spec = (
3064 chandransh 6802 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 6803 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6804 
  )
6805 
 
6806 
  def __init__(self, success=None, ex=None,):
6807 
    self.success = success
6808 
    self.ex = ex
6809 
 
6810 
  def read(self, iprot):
6811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6813 
      return
6814 
    iprot.readStructBegin()
6815 
    while True:
6816 
      (fname, ftype, fid) = iprot.readFieldBegin()
6817 
      if ftype == TType.STOP:
6818 
        break
6819 
      if fid == 0:
3064 chandransh 6820 
        if ftype == TType.I64:
6821 
          self.success = iprot.readI64();
921 rajveer 6822 
        else:
6823 
          iprot.skip(ftype)
6824 
      elif fid == 1:
6825 
        if ftype == TType.STRUCT:
6826 
          self.ex = TransactionServiceException()
6827 
          self.ex.read(iprot)
6828 
        else:
6829 
          iprot.skip(ftype)
6830 
      else:
6831 
        iprot.skip(ftype)
6832 
      iprot.readFieldEnd()
6833 
    iprot.readStructEnd()
6834 
 
6835 
  def write(self, oprot):
6836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6838 
      return
3064 chandransh 6839 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 6840 
    if self.success is not None:
3064 chandransh 6841 
      oprot.writeFieldBegin('success', TType.I64, 0)
6842 
      oprot.writeI64(self.success)
921 rajveer 6843 
      oprot.writeFieldEnd()
3431 rajveer 6844 
    if self.ex is not None:
921 rajveer 6845 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6846 
      self.ex.write(oprot)
6847 
      oprot.writeFieldEnd()
6848 
    oprot.writeFieldStop()
6849 
    oprot.writeStructEnd()
6850 
 
3431 rajveer 6851 
  def validate(self):
6852 
    return
6853 
 
6854 
 
921 rajveer 6855 
  def __repr__(self):
6856 
    L = ['%s=%r' % (key, value)
6857 
      for key, value in self.__dict__.iteritems()]
6858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6859 
 
6860 
  def __eq__(self, other):
6861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6862 
 
6863 
  def __ne__(self, other):
6864 
    return not (self == other)
6865 
 
3064 chandransh 6866 
class getOrder_args:
921 rajveer 6867 
  """
6868 
  Attributes:
3064 chandransh 6869 
   - id
921 rajveer 6870 
  """
6871 
 
6872 
  thrift_spec = (
6873 
    None, # 0
3064 chandransh 6874 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 6875 
  )
6876 
 
3064 chandransh 6877 
  def __init__(self, id=None,):
6878 
    self.id = id
921 rajveer 6879 
 
6880 
  def read(self, iprot):
6881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6883 
      return
6884 
    iprot.readStructBegin()
6885 
    while True:
6886 
      (fname, ftype, fid) = iprot.readFieldBegin()
6887 
      if ftype == TType.STOP:
6888 
        break
6889 
      if fid == 1:
6890 
        if ftype == TType.I64:
3064 chandransh 6891 
          self.id = iprot.readI64();
921 rajveer 6892 
        else:
6893 
          iprot.skip(ftype)
6894 
      else:
6895 
        iprot.skip(ftype)
6896 
      iprot.readFieldEnd()
6897 
    iprot.readStructEnd()
6898 
 
6899 
  def write(self, oprot):
6900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6902 
      return
3064 chandransh 6903 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 6904 
    if self.id is not None:
3064 chandransh 6905 
      oprot.writeFieldBegin('id', TType.I64, 1)
6906 
      oprot.writeI64(self.id)
921 rajveer 6907 
      oprot.writeFieldEnd()
6908 
    oprot.writeFieldStop()
6909 
    oprot.writeStructEnd()
6910 
 
3431 rajveer 6911 
  def validate(self):
6912 
    return
6913 
 
6914 
 
921 rajveer 6915 
  def __repr__(self):
6916 
    L = ['%s=%r' % (key, value)
6917 
      for key, value in self.__dict__.iteritems()]
6918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6919 
 
6920 
  def __eq__(self, other):
6921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6922 
 
6923 
  def __ne__(self, other):
6924 
    return not (self == other)
6925 
 
3064 chandransh 6926 
class getOrder_result:
921 rajveer 6927 
  """
6928 
  Attributes:
6929 
   - success
6930 
   - ex
6931 
  """
6932 
 
6933 
  thrift_spec = (
3064 chandransh 6934 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 6935 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6936 
  )
6937 
 
6938 
  def __init__(self, success=None, ex=None,):
6939 
    self.success = success
6940 
    self.ex = ex
6941 
 
6942 
  def read(self, iprot):
6943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6945 
      return
6946 
    iprot.readStructBegin()
6947 
    while True:
6948 
      (fname, ftype, fid) = iprot.readFieldBegin()
6949 
      if ftype == TType.STOP:
6950 
        break
6951 
      if fid == 0:
3064 chandransh 6952 
        if ftype == TType.STRUCT:
6953 
          self.success = Order()
6954 
          self.success.read(iprot)
921 rajveer 6955 
        else:
6956 
          iprot.skip(ftype)
6957 
      elif fid == 1:
6958 
        if ftype == TType.STRUCT:
6959 
          self.ex = TransactionServiceException()
6960 
          self.ex.read(iprot)
6961 
        else:
6962 
          iprot.skip(ftype)
6963 
      else:
6964 
        iprot.skip(ftype)
6965 
      iprot.readFieldEnd()
6966 
    iprot.readStructEnd()
6967 
 
6968 
  def write(self, oprot):
6969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6971 
      return
3064 chandransh 6972 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 6973 
    if self.success is not None:
3064 chandransh 6974 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6975 
      self.success.write(oprot)
921 rajveer 6976 
      oprot.writeFieldEnd()
3431 rajveer 6977 
    if self.ex is not None:
921 rajveer 6978 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6979 
      self.ex.write(oprot)
6980 
      oprot.writeFieldEnd()
6981 
    oprot.writeFieldStop()
6982 
    oprot.writeStructEnd()
6983 
 
3431 rajveer 6984 
  def validate(self):
6985 
    return
6986 
 
6987 
 
921 rajveer 6988 
  def __repr__(self):
6989 
    L = ['%s=%r' % (key, value)
6990 
      for key, value in self.__dict__.iteritems()]
6991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6992 
 
6993 
  def __eq__(self, other):
6994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6995 
 
6996 
  def __ne__(self, other):
6997 
    return not (self == other)
6998 
 
3064 chandransh 6999 
class getLineItemsForOrder_args:
94 ashish 7000 
  """
7001 
  Attributes:
3064 chandransh 7002 
   - orderId
94 ashish 7003 
  """
7004 
 
7005 
  thrift_spec = (
7006 
    None, # 0
3064 chandransh 7007 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7008 
  )
7009 
 
3064 chandransh 7010 
  def __init__(self, orderId=None,):
7011 
    self.orderId = orderId
94 ashish 7012 
 
7013 
  def read(self, iprot):
7014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7016 
      return
7017 
    iprot.readStructBegin()
7018 
    while True:
7019 
      (fname, ftype, fid) = iprot.readFieldBegin()
7020 
      if ftype == TType.STOP:
7021 
        break
7022 
      if fid == 1:
7023 
        if ftype == TType.I64:
3064 chandransh 7024 
          self.orderId = iprot.readI64();
94 ashish 7025 
        else:
7026 
          iprot.skip(ftype)
7027 
      else:
7028 
        iprot.skip(ftype)
7029 
      iprot.readFieldEnd()
7030 
    iprot.readStructEnd()
7031 
 
7032 
  def write(self, oprot):
7033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7035 
      return
3064 chandransh 7036 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7037 
    if self.orderId is not None:
3064 chandransh 7038 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7039 
      oprot.writeI64(self.orderId)
94 ashish 7040 
      oprot.writeFieldEnd()
7041 
    oprot.writeFieldStop()
7042 
    oprot.writeStructEnd()
7043 
 
3431 rajveer 7044 
  def validate(self):
7045 
    return
7046 
 
7047 
 
94 ashish 7048 
  def __repr__(self):
7049 
    L = ['%s=%r' % (key, value)
7050 
      for key, value in self.__dict__.iteritems()]
7051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7052 
 
7053 
  def __eq__(self, other):
7054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7055 
 
7056 
  def __ne__(self, other):
7057 
    return not (self == other)
7058 
 
3064 chandransh 7059 
class getLineItemsForOrder_result:
94 ashish 7060 
  """
7061 
  Attributes:
7062 
   - success
7063 
   - ex
7064 
  """
7065 
 
7066 
  thrift_spec = (
3064 chandransh 7067 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7068 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7069 
  )
7070 
 
7071 
  def __init__(self, success=None, ex=None,):
7072 
    self.success = success
7073 
    self.ex = ex
7074 
 
7075 
  def read(self, iprot):
7076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7078 
      return
7079 
    iprot.readStructBegin()
7080 
    while True:
7081 
      (fname, ftype, fid) = iprot.readFieldBegin()
7082 
      if ftype == TType.STOP:
7083 
        break
7084 
      if fid == 0:
483 rajveer 7085 
        if ftype == TType.LIST:
7086 
          self.success = []
4133 chandransh 7087 
          (_etype108, _size105) = iprot.readListBegin()
7088 
          for _i109 in xrange(_size105):
7089 
            _elem110 = LineItem()
7090 
            _elem110.read(iprot)
7091 
            self.success.append(_elem110)
483 rajveer 7092 
          iprot.readListEnd()
94 ashish 7093 
        else:
7094 
          iprot.skip(ftype)
7095 
      elif fid == 1:
7096 
        if ftype == TType.STRUCT:
7097 
          self.ex = TransactionServiceException()
7098 
          self.ex.read(iprot)
7099 
        else:
7100 
          iprot.skip(ftype)
7101 
      else:
7102 
        iprot.skip(ftype)
7103 
      iprot.readFieldEnd()
7104 
    iprot.readStructEnd()
7105 
 
7106 
  def write(self, oprot):
7107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7109 
      return
3064 chandransh 7110 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7111 
    if self.success is not None:
483 rajveer 7112 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7113 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7114 
      for iter111 in self.success:
7115 
        iter111.write(oprot)
483 rajveer 7116 
      oprot.writeListEnd()
94 ashish 7117 
      oprot.writeFieldEnd()
3431 rajveer 7118 
    if self.ex is not None:
94 ashish 7119 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7120 
      self.ex.write(oprot)
7121 
      oprot.writeFieldEnd()
7122 
    oprot.writeFieldStop()
7123 
    oprot.writeStructEnd()
7124 
 
3431 rajveer 7125 
  def validate(self):
7126 
    return
7127 
 
7128 
 
94 ashish 7129 
  def __repr__(self):
7130 
    L = ['%s=%r' % (key, value)
7131 
      for key, value in self.__dict__.iteritems()]
7132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7133 
 
7134 
  def __eq__(self, other):
7135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7136 
 
7137 
  def __ne__(self, other):
7138 
    return not (self == other)
7139 
 
3064 chandransh 7140 
class getOrderForCustomer_args:
94 ashish 7141 
  """
7142 
  Attributes:
3064 chandransh 7143 
   - orderId
483 rajveer 7144 
   - customerId
94 ashish 7145 
  """
7146 
 
7147 
  thrift_spec = (
7148 
    None, # 0
3064 chandransh 7149 
    (1, TType.I64, 'orderId', None, None, ), # 1
7150 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7151 
  )
7152 
 
3064 chandransh 7153 
  def __init__(self, orderId=None, customerId=None,):
7154 
    self.orderId = orderId
483 rajveer 7155 
    self.customerId = customerId
94 ashish 7156 
 
7157 
  def read(self, iprot):
7158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7160 
      return
7161 
    iprot.readStructBegin()
7162 
    while True:
7163 
      (fname, ftype, fid) = iprot.readFieldBegin()
7164 
      if ftype == TType.STOP:
7165 
        break
7166 
      if fid == 1:
7167 
        if ftype == TType.I64:
3064 chandransh 7168 
          self.orderId = iprot.readI64();
94 ashish 7169 
        else:
7170 
          iprot.skip(ftype)
7171 
      elif fid == 2:
7172 
        if ftype == TType.I64:
3064 chandransh 7173 
          self.customerId = iprot.readI64();
94 ashish 7174 
        else:
7175 
          iprot.skip(ftype)
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('getOrderForCustomer_args')
3431 rajveer 7186 
    if self.orderId is not None:
3064 chandransh 7187 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7188 
      oprot.writeI64(self.orderId)
7189 
      oprot.writeFieldEnd()
3431 rajveer 7190 
    if self.customerId is not None:
3064 chandransh 7191 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7192 
      oprot.writeI64(self.customerId)
94 ashish 7193 
      oprot.writeFieldEnd()
7194 
    oprot.writeFieldStop()
7195 
    oprot.writeStructEnd()
7196 
 
3431 rajveer 7197 
  def validate(self):
7198 
    return
7199 
 
7200 
 
94 ashish 7201 
  def __repr__(self):
7202 
    L = ['%s=%r' % (key, value)
7203 
      for key, value in self.__dict__.iteritems()]
7204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7205 
 
7206 
  def __eq__(self, other):
7207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7208 
 
7209 
  def __ne__(self, other):
7210 
    return not (self == other)
7211 
 
3064 chandransh 7212 
class getOrderForCustomer_result:
94 ashish 7213 
  """
7214 
  Attributes:
7215 
   - success
7216 
   - ex
7217 
  """
7218 
 
7219 
  thrift_spec = (
3064 chandransh 7220 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 7221 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7222 
  )
7223 
 
7224 
  def __init__(self, success=None, ex=None,):
7225 
    self.success = success
7226 
    self.ex = ex
7227 
 
7228 
  def read(self, iprot):
7229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7231 
      return
7232 
    iprot.readStructBegin()
7233 
    while True:
7234 
      (fname, ftype, fid) = iprot.readFieldBegin()
7235 
      if ftype == TType.STOP:
7236 
        break
7237 
      if fid == 0:
3064 chandransh 7238 
        if ftype == TType.STRUCT:
7239 
          self.success = Order()
7240 
          self.success.read(iprot)
94 ashish 7241 
        else:
7242 
          iprot.skip(ftype)
7243 
      elif fid == 1:
7244 
        if ftype == TType.STRUCT:
7245 
          self.ex = TransactionServiceException()
7246 
          self.ex.read(iprot)
7247 
        else:
7248 
          iprot.skip(ftype)
7249 
      else:
7250 
        iprot.skip(ftype)
7251 
      iprot.readFieldEnd()
7252 
    iprot.readStructEnd()
7253 
 
7254 
  def write(self, oprot):
7255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7257 
      return
3064 chandransh 7258 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 7259 
    if self.success is not None:
3064 chandransh 7260 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7261 
      self.success.write(oprot)
94 ashish 7262 
      oprot.writeFieldEnd()
3431 rajveer 7263 
    if self.ex is not None:
94 ashish 7264 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7265 
      self.ex.write(oprot)
7266 
      oprot.writeFieldEnd()
7267 
    oprot.writeFieldStop()
7268 
    oprot.writeStructEnd()
7269 
 
3431 rajveer 7270 
  def validate(self):
7271 
    return
7272 
 
7273 
 
94 ashish 7274 
  def __repr__(self):
7275 
    L = ['%s=%r' % (key, value)
7276 
      for key, value in self.__dict__.iteritems()]
7277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7278 
 
7279 
  def __eq__(self, other):
7280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7281 
 
7282 
  def __ne__(self, other):
7283 
    return not (self == other)
7284 
 
3064 chandransh 7285 
class getAlerts_args:
94 ashish 7286 
  """
7287 
  Attributes:
3064 chandransh 7288 
   - orderId
7289 
   - valid
94 ashish 7290 
  """
7291 
 
7292 
  thrift_spec = (
7293 
    None, # 0
3064 chandransh 7294 
    (1, TType.I64, 'orderId', None, None, ), # 1
7295 
    (2, TType.BOOL, 'valid', None, None, ), # 2
94 ashish 7296 
  )
7297 
 
3064 chandransh 7298 
  def __init__(self, orderId=None, valid=None,):
7299 
    self.orderId = orderId
7300 
    self.valid = valid
94 ashish 7301 
 
7302 
  def read(self, iprot):
7303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7305 
      return
7306 
    iprot.readStructBegin()
7307 
    while True:
7308 
      (fname, ftype, fid) = iprot.readFieldBegin()
7309 
      if ftype == TType.STOP:
7310 
        break
7311 
      if fid == 1:
3064 chandransh 7312 
        if ftype == TType.I64:
7313 
          self.orderId = iprot.readI64();
94 ashish 7314 
        else:
7315 
          iprot.skip(ftype)
3064 chandransh 7316 
      elif fid == 2:
7317 
        if ftype == TType.BOOL:
7318 
          self.valid = iprot.readBool();
7319 
        else:
7320 
          iprot.skip(ftype)
94 ashish 7321 
      else:
7322 
        iprot.skip(ftype)
7323 
      iprot.readFieldEnd()
7324 
    iprot.readStructEnd()
7325 
 
7326 
  def write(self, oprot):
7327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7329 
      return
3064 chandransh 7330 
    oprot.writeStructBegin('getAlerts_args')
3431 rajveer 7331 
    if self.orderId is not None:
3064 chandransh 7332 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7333 
      oprot.writeI64(self.orderId)
94 ashish 7334 
      oprot.writeFieldEnd()
3431 rajveer 7335 
    if self.valid is not None:
3064 chandransh 7336 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
7337 
      oprot.writeBool(self.valid)
7338 
      oprot.writeFieldEnd()
94 ashish 7339 
    oprot.writeFieldStop()
7340 
    oprot.writeStructEnd()
7341 
 
3431 rajveer 7342 
  def validate(self):
7343 
    return
7344 
 
7345 
 
94 ashish 7346 
  def __repr__(self):
7347 
    L = ['%s=%r' % (key, value)
7348 
      for key, value in self.__dict__.iteritems()]
7349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7350 
 
7351 
  def __eq__(self, other):
7352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7353 
 
7354 
  def __ne__(self, other):
7355 
    return not (self == other)
7356 
 
3064 chandransh 7357 
class getAlerts_result:
94 ashish 7358 
  """
7359 
  Attributes:
7360 
   - success
7361 
  """
7362 
 
7363 
  thrift_spec = (
3064 chandransh 7364 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 7365 
  )
7366 
 
3064 chandransh 7367 
  def __init__(self, success=None,):
94 ashish 7368 
    self.success = success
7369 
 
7370 
  def read(self, iprot):
7371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7373 
      return
7374 
    iprot.readStructBegin()
7375 
    while True:
7376 
      (fname, ftype, fid) = iprot.readFieldBegin()
7377 
      if ftype == TType.STOP:
7378 
        break
7379 
      if fid == 0:
3064 chandransh 7380 
        if ftype == TType.LIST:
7381 
          self.success = []
4133 chandransh 7382 
          (_etype115, _size112) = iprot.readListBegin()
7383 
          for _i116 in xrange(_size112):
7384 
            _elem117 = Alert()
7385 
            _elem117.read(iprot)
7386 
            self.success.append(_elem117)
3064 chandransh 7387 
          iprot.readListEnd()
94 ashish 7388 
        else:
7389 
          iprot.skip(ftype)
7390 
      else:
7391 
        iprot.skip(ftype)
7392 
      iprot.readFieldEnd()
7393 
    iprot.readStructEnd()
7394 
 
7395 
  def write(self, oprot):
7396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7398 
      return
3064 chandransh 7399 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 7400 
    if self.success is not None:
3064 chandransh 7401 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7402 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7403 
      for iter118 in self.success:
7404 
        iter118.write(oprot)
3064 chandransh 7405 
      oprot.writeListEnd()
94 ashish 7406 
      oprot.writeFieldEnd()
7407 
    oprot.writeFieldStop()
7408 
    oprot.writeStructEnd()
7409 
 
3431 rajveer 7410 
  def validate(self):
7411 
    return
7412 
 
7413 
 
94 ashish 7414 
  def __repr__(self):
7415 
    L = ['%s=%r' % (key, value)
7416 
      for key, value in self.__dict__.iteritems()]
7417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7418 
 
7419 
  def __eq__(self, other):
7420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7421 
 
7422 
  def __ne__(self, other):
7423 
    return not (self == other)
7424 
 
3064 chandransh 7425 
class setAlert_args:
94 ashish 7426 
  """
7427 
  Attributes:
3064 chandransh 7428 
   - orderId
7429 
   - unset
7430 
   - type
7431 
   - comment
94 ashish 7432 
  """
7433 
 
7434 
  thrift_spec = (
7435 
    None, # 0
3064 chandransh 7436 
    (1, TType.I64, 'orderId', None, None, ), # 1
7437 
    (2, TType.BOOL, 'unset', None, None, ), # 2
7438 
    (3, TType.I64, 'type', None, None, ), # 3
7439 
    (4, TType.STRING, 'comment', None, None, ), # 4
94 ashish 7440 
  )
7441 
 
3064 chandransh 7442 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
7443 
    self.orderId = orderId
7444 
    self.unset = unset
7445 
    self.type = type
7446 
    self.comment = comment
94 ashish 7447 
 
7448 
  def read(self, iprot):
7449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7451 
      return
7452 
    iprot.readStructBegin()
7453 
    while True:
7454 
      (fname, ftype, fid) = iprot.readFieldBegin()
7455 
      if ftype == TType.STOP:
7456 
        break
7457 
      if fid == 1:
7458 
        if ftype == TType.I64:
3064 chandransh 7459 
          self.orderId = iprot.readI64();
94 ashish 7460 
        else:
7461 
          iprot.skip(ftype)
3064 chandransh 7462 
      elif fid == 2:
7463 
        if ftype == TType.BOOL:
7464 
          self.unset = iprot.readBool();
7465 
        else:
7466 
          iprot.skip(ftype)
7467 
      elif fid == 3:
7468 
        if ftype == TType.I64:
7469 
          self.type = iprot.readI64();
7470 
        else:
7471 
          iprot.skip(ftype)
7472 
      elif fid == 4:
7473 
        if ftype == TType.STRING:
7474 
          self.comment = iprot.readString();
7475 
        else:
7476 
          iprot.skip(ftype)
94 ashish 7477 
      else:
7478 
        iprot.skip(ftype)
7479 
      iprot.readFieldEnd()
7480 
    iprot.readStructEnd()
7481 
 
7482 
  def write(self, oprot):
7483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7485 
      return
3064 chandransh 7486 
    oprot.writeStructBegin('setAlert_args')
3431 rajveer 7487 
    if self.orderId is not None:
3064 chandransh 7488 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7489 
      oprot.writeI64(self.orderId)
94 ashish 7490 
      oprot.writeFieldEnd()
3431 rajveer 7491 
    if self.unset is not None:
3064 chandransh 7492 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
7493 
      oprot.writeBool(self.unset)
7494 
      oprot.writeFieldEnd()
3431 rajveer 7495 
    if self.type is not None:
3064 chandransh 7496 
      oprot.writeFieldBegin('type', TType.I64, 3)
7497 
      oprot.writeI64(self.type)
7498 
      oprot.writeFieldEnd()
3431 rajveer 7499 
    if self.comment is not None:
3064 chandransh 7500 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
7501 
      oprot.writeString(self.comment)
7502 
      oprot.writeFieldEnd()
94 ashish 7503 
    oprot.writeFieldStop()
7504 
    oprot.writeStructEnd()
7505 
 
3431 rajveer 7506 
  def validate(self):
7507 
    return
7508 
 
7509 
 
94 ashish 7510 
  def __repr__(self):
7511 
    L = ['%s=%r' % (key, value)
7512 
      for key, value in self.__dict__.iteritems()]
7513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7514 
 
7515 
  def __eq__(self, other):
7516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7517 
 
7518 
  def __ne__(self, other):
7519 
    return not (self == other)
7520 
 
3064 chandransh 7521 
class setAlert_result:
7522 
 
7523 
  thrift_spec = (
7524 
  )
7525 
 
7526 
  def read(self, iprot):
7527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7529 
      return
7530 
    iprot.readStructBegin()
7531 
    while True:
7532 
      (fname, ftype, fid) = iprot.readFieldBegin()
7533 
      if ftype == TType.STOP:
7534 
        break
7535 
      else:
7536 
        iprot.skip(ftype)
7537 
      iprot.readFieldEnd()
7538 
    iprot.readStructEnd()
7539 
 
7540 
  def write(self, oprot):
7541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7543 
      return
7544 
    oprot.writeStructBegin('setAlert_result')
7545 
    oprot.writeFieldStop()
7546 
    oprot.writeStructEnd()
7547 
 
3431 rajveer 7548 
  def validate(self):
7549 
    return
7550 
 
7551 
 
3064 chandransh 7552 
  def __repr__(self):
7553 
    L = ['%s=%r' % (key, value)
7554 
      for key, value in self.__dict__.iteritems()]
7555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7556 
 
7557 
  def __eq__(self, other):
7558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7559 
 
7560 
  def __ne__(self, other):
7561 
    return not (self == other)
7562 
 
7563 
class getValidOrderCount_args:
7564 
 
7565 
  thrift_spec = (
7566 
  )
7567 
 
7568 
  def read(self, iprot):
7569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7571 
      return
7572 
    iprot.readStructBegin()
7573 
    while True:
7574 
      (fname, ftype, fid) = iprot.readFieldBegin()
7575 
      if ftype == TType.STOP:
7576 
        break
7577 
      else:
7578 
        iprot.skip(ftype)
7579 
      iprot.readFieldEnd()
7580 
    iprot.readStructEnd()
7581 
 
7582 
  def write(self, oprot):
7583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7585 
      return
7586 
    oprot.writeStructBegin('getValidOrderCount_args')
7587 
    oprot.writeFieldStop()
7588 
    oprot.writeStructEnd()
7589 
 
3431 rajveer 7590 
  def validate(self):
7591 
    return
7592 
 
7593 
 
3064 chandransh 7594 
  def __repr__(self):
7595 
    L = ['%s=%r' % (key, value)
7596 
      for key, value in self.__dict__.iteritems()]
7597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7598 
 
7599 
  def __eq__(self, other):
7600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7601 
 
7602 
  def __ne__(self, other):
7603 
    return not (self == other)
7604 
 
7605 
class getValidOrderCount_result:
94 ashish 7606 
  """
7607 
  Attributes:
7608 
   - success
7609 
  """
7610 
 
7611 
  thrift_spec = (
3064 chandransh 7612 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7613 
  )
7614 
 
3064 chandransh 7615 
  def __init__(self, success=None,):
94 ashish 7616 
    self.success = success
7617 
 
7618 
  def read(self, iprot):
7619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7621 
      return
7622 
    iprot.readStructBegin()
7623 
    while True:
7624 
      (fname, ftype, fid) = iprot.readFieldBegin()
7625 
      if ftype == TType.STOP:
7626 
        break
7627 
      if fid == 0:
3064 chandransh 7628 
        if ftype == TType.I64:
7629 
          self.success = iprot.readI64();
94 ashish 7630 
        else:
7631 
          iprot.skip(ftype)
7632 
      else:
7633 
        iprot.skip(ftype)
7634 
      iprot.readFieldEnd()
7635 
    iprot.readStructEnd()
7636 
 
7637 
  def write(self, oprot):
7638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7640 
      return
3064 chandransh 7641 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 7642 
    if self.success is not None:
3064 chandransh 7643 
      oprot.writeFieldBegin('success', TType.I64, 0)
7644 
      oprot.writeI64(self.success)
94 ashish 7645 
      oprot.writeFieldEnd()
7646 
    oprot.writeFieldStop()
7647 
    oprot.writeStructEnd()
7648 
 
3431 rajveer 7649 
  def validate(self):
7650 
    return
7651 
 
7652 
 
94 ashish 7653 
  def __repr__(self):
7654 
    L = ['%s=%r' % (key, value)
7655 
      for key, value in self.__dict__.iteritems()]
7656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7657 
 
7658 
  def __eq__(self, other):
7659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7660 
 
7661 
  def __ne__(self, other):
7662 
    return not (self == other)
7663 
 
3064 chandransh 7664 
class getNoOfCustomersWithSuccessfulTransaction_args:
7665 
 
7666 
  thrift_spec = (
7667 
  )
7668 
 
7669 
  def read(self, iprot):
7670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7672 
      return
7673 
    iprot.readStructBegin()
7674 
    while True:
7675 
      (fname, ftype, fid) = iprot.readFieldBegin()
7676 
      if ftype == TType.STOP:
7677 
        break
7678 
      else:
7679 
        iprot.skip(ftype)
7680 
      iprot.readFieldEnd()
7681 
    iprot.readStructEnd()
7682 
 
7683 
  def write(self, oprot):
7684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7686 
      return
7687 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
7688 
    oprot.writeFieldStop()
7689 
    oprot.writeStructEnd()
7690 
 
3431 rajveer 7691 
  def validate(self):
7692 
    return
7693 
 
7694 
 
3064 chandransh 7695 
  def __repr__(self):
7696 
    L = ['%s=%r' % (key, value)
7697 
      for key, value in self.__dict__.iteritems()]
7698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7699 
 
7700 
  def __eq__(self, other):
7701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7702 
 
7703 
  def __ne__(self, other):
7704 
    return not (self == other)
7705 
 
7706 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 7707 
  """
7708 
  Attributes:
3064 chandransh 7709 
   - success
94 ashish 7710 
  """
7711 
 
7712 
  thrift_spec = (
3064 chandransh 7713 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7714 
  )
7715 
 
3064 chandransh 7716 
  def __init__(self, success=None,):
7717 
    self.success = success
94 ashish 7718 
 
7719 
  def read(self, iprot):
7720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7722 
      return
7723 
    iprot.readStructBegin()
7724 
    while True:
7725 
      (fname, ftype, fid) = iprot.readFieldBegin()
7726 
      if ftype == TType.STOP:
7727 
        break
3064 chandransh 7728 
      if fid == 0:
94 ashish 7729 
        if ftype == TType.I64:
3064 chandransh 7730 
          self.success = iprot.readI64();
94 ashish 7731 
        else:
7732 
          iprot.skip(ftype)
7733 
      else:
7734 
        iprot.skip(ftype)
7735 
      iprot.readFieldEnd()
7736 
    iprot.readStructEnd()
7737 
 
7738 
  def write(self, oprot):
7739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7741 
      return
3064 chandransh 7742 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 7743 
    if self.success is not None:
3064 chandransh 7744 
      oprot.writeFieldBegin('success', TType.I64, 0)
7745 
      oprot.writeI64(self.success)
94 ashish 7746 
      oprot.writeFieldEnd()
7747 
    oprot.writeFieldStop()
7748 
    oprot.writeStructEnd()
7749 
 
3431 rajveer 7750 
  def validate(self):
7751 
    return
7752 
 
7753 
 
94 ashish 7754 
  def __repr__(self):
7755 
    L = ['%s=%r' % (key, value)
7756 
      for key, value in self.__dict__.iteritems()]
7757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7758 
 
7759 
  def __eq__(self, other):
7760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7761 
 
7762 
  def __ne__(self, other):
7763 
    return not (self == other)
7764 
 
3064 chandransh 7765 
class getValidOrdersAmountRange_args:
7766 
 
7767 
  thrift_spec = (
7768 
  )
7769 
 
7770 
  def read(self, iprot):
7771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7773 
      return
7774 
    iprot.readStructBegin()
7775 
    while True:
7776 
      (fname, ftype, fid) = iprot.readFieldBegin()
7777 
      if ftype == TType.STOP:
7778 
        break
7779 
      else:
7780 
        iprot.skip(ftype)
7781 
      iprot.readFieldEnd()
7782 
    iprot.readStructEnd()
7783 
 
7784 
  def write(self, oprot):
7785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7787 
      return
7788 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
7789 
    oprot.writeFieldStop()
7790 
    oprot.writeStructEnd()
7791 
 
3431 rajveer 7792 
  def validate(self):
7793 
    return
7794 
 
7795 
 
3064 chandransh 7796 
  def __repr__(self):
7797 
    L = ['%s=%r' % (key, value)
7798 
      for key, value in self.__dict__.iteritems()]
7799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7800 
 
7801 
  def __eq__(self, other):
7802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7803 
 
7804 
  def __ne__(self, other):
7805 
    return not (self == other)
7806 
 
7807 
class getValidOrdersAmountRange_result:
94 ashish 7808 
  """
7809 
  Attributes:
7810 
   - success
7811 
  """
7812 
 
7813 
  thrift_spec = (
3064 chandransh 7814 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 7815 
  )
7816 
 
3064 chandransh 7817 
  def __init__(self, success=None,):
94 ashish 7818 
    self.success = success
7819 
 
7820 
  def read(self, iprot):
7821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7823 
      return
7824 
    iprot.readStructBegin()
7825 
    while True:
7826 
      (fname, ftype, fid) = iprot.readFieldBegin()
7827 
      if ftype == TType.STOP:
7828 
        break
7829 
      if fid == 0:
483 rajveer 7830 
        if ftype == TType.LIST:
7831 
          self.success = []
4133 chandransh 7832 
          (_etype122, _size119) = iprot.readListBegin()
7833 
          for _i123 in xrange(_size119):
7834 
            _elem124 = iprot.readDouble();
7835 
            self.success.append(_elem124)
483 rajveer 7836 
          iprot.readListEnd()
94 ashish 7837 
        else:
7838 
          iprot.skip(ftype)
7839 
      else:
7840 
        iprot.skip(ftype)
7841 
      iprot.readFieldEnd()
7842 
    iprot.readStructEnd()
7843 
 
7844 
  def write(self, oprot):
7845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7847 
      return
3064 chandransh 7848 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 7849 
    if self.success is not None:
483 rajveer 7850 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 7851 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 7852 
      for iter125 in self.success:
7853 
        oprot.writeDouble(iter125)
483 rajveer 7854 
      oprot.writeListEnd()
94 ashish 7855 
      oprot.writeFieldEnd()
7856 
    oprot.writeFieldStop()
7857 
    oprot.writeStructEnd()
7858 
 
3431 rajveer 7859 
  def validate(self):
7860 
    return
7861 
 
7862 
 
94 ashish 7863 
  def __repr__(self):
7864 
    L = ['%s=%r' % (key, value)
7865 
      for key, value in self.__dict__.iteritems()]
7866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7867 
 
7868 
  def __eq__(self, other):
7869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7870 
 
7871 
  def __ne__(self, other):
7872 
    return not (self == other)
7873 
 
3064 chandransh 7874 
class getValidOrders_args:
1528 ankur.sing 7875 
  """
7876 
  Attributes:
3064 chandransh 7877 
   - limit
1528 ankur.sing 7878 
  """
7879 
 
7880 
  thrift_spec = (
7881 
    None, # 0
3064 chandransh 7882 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 7883 
  )
7884 
 
3064 chandransh 7885 
  def __init__(self, limit=None,):
7886 
    self.limit = limit
1528 ankur.sing 7887 
 
7888 
  def read(self, iprot):
7889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7891 
      return
7892 
    iprot.readStructBegin()
7893 
    while True:
7894 
      (fname, ftype, fid) = iprot.readFieldBegin()
7895 
      if ftype == TType.STOP:
7896 
        break
7897 
      if fid == 1:
7898 
        if ftype == TType.I64:
3064 chandransh 7899 
          self.limit = iprot.readI64();
1528 ankur.sing 7900 
        else:
7901 
          iprot.skip(ftype)
7902 
      else:
7903 
        iprot.skip(ftype)
7904 
      iprot.readFieldEnd()
7905 
    iprot.readStructEnd()
7906 
 
7907 
  def write(self, oprot):
7908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7910 
      return
3064 chandransh 7911 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 7912 
    if self.limit is not None:
3064 chandransh 7913 
      oprot.writeFieldBegin('limit', TType.I64, 1)
7914 
      oprot.writeI64(self.limit)
1528 ankur.sing 7915 
      oprot.writeFieldEnd()
7916 
    oprot.writeFieldStop()
7917 
    oprot.writeStructEnd()
7918 
 
3431 rajveer 7919 
  def validate(self):
7920 
    return
7921 
 
7922 
 
1528 ankur.sing 7923 
  def __repr__(self):
7924 
    L = ['%s=%r' % (key, value)
7925 
      for key, value in self.__dict__.iteritems()]
7926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7927 
 
7928 
  def __eq__(self, other):
7929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7930 
 
7931 
  def __ne__(self, other):
7932 
    return not (self == other)
7933 
 
3064 chandransh 7934 
class getValidOrders_result:
1528 ankur.sing 7935 
  """
7936 
  Attributes:
7937 
   - success
7938 
  """
7939 
 
7940 
  thrift_spec = (
3064 chandransh 7941 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 7942 
  )
7943 
 
3064 chandransh 7944 
  def __init__(self, success=None,):
1528 ankur.sing 7945 
    self.success = success
7946 
 
7947 
  def read(self, iprot):
7948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7950 
      return
7951 
    iprot.readStructBegin()
7952 
    while True:
7953 
      (fname, ftype, fid) = iprot.readFieldBegin()
7954 
      if ftype == TType.STOP:
7955 
        break
7956 
      if fid == 0:
3064 chandransh 7957 
        if ftype == TType.LIST:
7958 
          self.success = []
4133 chandransh 7959 
          (_etype129, _size126) = iprot.readListBegin()
7960 
          for _i130 in xrange(_size126):
7961 
            _elem131 = Order()
7962 
            _elem131.read(iprot)
7963 
            self.success.append(_elem131)
3064 chandransh 7964 
          iprot.readListEnd()
1528 ankur.sing 7965 
        else:
7966 
          iprot.skip(ftype)
7967 
      else:
7968 
        iprot.skip(ftype)
7969 
      iprot.readFieldEnd()
7970 
    iprot.readStructEnd()
7971 
 
7972 
  def write(self, oprot):
7973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7975 
      return
3064 chandransh 7976 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 7977 
    if self.success is not None:
3064 chandransh 7978 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7979 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7980 
      for iter132 in self.success:
7981 
        iter132.write(oprot)
3064 chandransh 7982 
      oprot.writeListEnd()
1528 ankur.sing 7983 
      oprot.writeFieldEnd()
7984 
    oprot.writeFieldStop()
7985 
    oprot.writeStructEnd()
7986 
 
3431 rajveer 7987 
  def validate(self):
7988 
    return
7989 
 
7990 
 
1528 ankur.sing 7991 
  def __repr__(self):
7992 
    L = ['%s=%r' % (key, value)
7993 
      for key, value in self.__dict__.iteritems()]
7994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7995 
 
7996 
  def __eq__(self, other):
7997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7998 
 
7999 
  def __ne__(self, other):
8000 
    return not (self == other)
8001 
 
1220 chandransh 8002 
class batchOrders_args:
8003 
  """
8004 
  Attributes:
8005 
   - warehouseId
8006 
  """
8007 
 
8008 
  thrift_spec = (
8009 
    None, # 0
8010 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8011 
  )
8012 
 
8013 
  def __init__(self, warehouseId=None,):
8014 
    self.warehouseId = warehouseId
8015 
 
8016 
  def read(self, iprot):
8017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8019 
      return
8020 
    iprot.readStructBegin()
8021 
    while True:
8022 
      (fname, ftype, fid) = iprot.readFieldBegin()
8023 
      if ftype == TType.STOP:
8024 
        break
8025 
      if fid == 1:
8026 
        if ftype == TType.I64:
8027 
          self.warehouseId = iprot.readI64();
8028 
        else:
8029 
          iprot.skip(ftype)
8030 
      else:
8031 
        iprot.skip(ftype)
8032 
      iprot.readFieldEnd()
8033 
    iprot.readStructEnd()
8034 
 
8035 
  def write(self, oprot):
8036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8038 
      return
8039 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 8040 
    if self.warehouseId is not None:
1220 chandransh 8041 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8042 
      oprot.writeI64(self.warehouseId)
8043 
      oprot.writeFieldEnd()
8044 
    oprot.writeFieldStop()
8045 
    oprot.writeStructEnd()
8046 
 
3431 rajveer 8047 
  def validate(self):
8048 
    return
8049 
 
8050 
 
1220 chandransh 8051 
  def __repr__(self):
8052 
    L = ['%s=%r' % (key, value)
8053 
      for key, value in self.__dict__.iteritems()]
8054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8055 
 
8056 
  def __eq__(self, other):
8057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8058 
 
8059 
  def __ne__(self, other):
8060 
    return not (self == other)
8061 
 
8062 
class batchOrders_result:
8063 
  """
8064 
  Attributes:
8065 
   - success
8066 
   - ex
8067 
  """
8068 
 
8069 
  thrift_spec = (
8070 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8071 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8072 
  )
8073 
 
8074 
  def __init__(self, success=None, ex=None,):
8075 
    self.success = success
8076 
    self.ex = ex
8077 
 
8078 
  def read(self, iprot):
8079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8081 
      return
8082 
    iprot.readStructBegin()
8083 
    while True:
8084 
      (fname, ftype, fid) = iprot.readFieldBegin()
8085 
      if ftype == TType.STOP:
8086 
        break
8087 
      if fid == 0:
8088 
        if ftype == TType.LIST:
8089 
          self.success = []
4133 chandransh 8090 
          (_etype136, _size133) = iprot.readListBegin()
8091 
          for _i137 in xrange(_size133):
8092 
            _elem138 = Order()
8093 
            _elem138.read(iprot)
8094 
            self.success.append(_elem138)
1220 chandransh 8095 
          iprot.readListEnd()
8096 
        else:
8097 
          iprot.skip(ftype)
8098 
      elif fid == 1:
8099 
        if ftype == TType.STRUCT:
8100 
          self.ex = TransactionServiceException()
8101 
          self.ex.read(iprot)
8102 
        else:
8103 
          iprot.skip(ftype)
8104 
      else:
8105 
        iprot.skip(ftype)
8106 
      iprot.readFieldEnd()
8107 
    iprot.readStructEnd()
8108 
 
8109 
  def write(self, oprot):
8110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8112 
      return
8113 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 8114 
    if self.success is not None:
1220 chandransh 8115 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8116 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8117 
      for iter139 in self.success:
8118 
        iter139.write(oprot)
1220 chandransh 8119 
      oprot.writeListEnd()
8120 
      oprot.writeFieldEnd()
3431 rajveer 8121 
    if self.ex is not None:
1220 chandransh 8122 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8123 
      self.ex.write(oprot)
8124 
      oprot.writeFieldEnd()
8125 
    oprot.writeFieldStop()
8126 
    oprot.writeStructEnd()
8127 
 
3431 rajveer 8128 
  def validate(self):
8129 
    return
8130 
 
8131 
 
1220 chandransh 8132 
  def __repr__(self):
8133 
    L = ['%s=%r' % (key, value)
8134 
      for key, value in self.__dict__.iteritems()]
8135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8136 
 
8137 
  def __eq__(self, other):
8138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8139 
 
8140 
  def __ne__(self, other):
8141 
    return not (self == other)
8142 
 
1208 chandransh 8143 
class markOrderAsOutOfStock_args:
8144 
  """
8145 
  Attributes:
8146 
   - orderId
8147 
  """
8148 
 
8149 
  thrift_spec = (
8150 
    None, # 0
8151 
    (1, TType.I64, 'orderId', None, None, ), # 1
8152 
  )
8153 
 
8154 
  def __init__(self, orderId=None,):
8155 
    self.orderId = orderId
8156 
 
8157 
  def read(self, iprot):
8158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8160 
      return
8161 
    iprot.readStructBegin()
8162 
    while True:
8163 
      (fname, ftype, fid) = iprot.readFieldBegin()
8164 
      if ftype == TType.STOP:
8165 
        break
8166 
      if fid == 1:
8167 
        if ftype == TType.I64:
8168 
          self.orderId = iprot.readI64();
8169 
        else:
8170 
          iprot.skip(ftype)
8171 
      else:
8172 
        iprot.skip(ftype)
8173 
      iprot.readFieldEnd()
8174 
    iprot.readStructEnd()
8175 
 
8176 
  def write(self, oprot):
8177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8179 
      return
8180 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 8181 
    if self.orderId is not None:
1208 chandransh 8182 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8183 
      oprot.writeI64(self.orderId)
8184 
      oprot.writeFieldEnd()
8185 
    oprot.writeFieldStop()
8186 
    oprot.writeStructEnd()
8187 
 
3431 rajveer 8188 
  def validate(self):
8189 
    return
8190 
 
8191 
 
1208 chandransh 8192 
  def __repr__(self):
8193 
    L = ['%s=%r' % (key, value)
8194 
      for key, value in self.__dict__.iteritems()]
8195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8196 
 
8197 
  def __eq__(self, other):
8198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8199 
 
8200 
  def __ne__(self, other):
8201 
    return not (self == other)
8202 
 
8203 
class markOrderAsOutOfStock_result:
8204 
  """
8205 
  Attributes:
8206 
   - success
8207 
   - ex
8208 
  """
8209 
 
8210 
  thrift_spec = (
8211 
    (0, TType.BOOL, 'success', None, None, ), # 0
8212 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8213 
  )
8214 
 
8215 
  def __init__(self, success=None, ex=None,):
8216 
    self.success = success
8217 
    self.ex = ex
8218 
 
8219 
  def read(self, iprot):
8220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8222 
      return
8223 
    iprot.readStructBegin()
8224 
    while True:
8225 
      (fname, ftype, fid) = iprot.readFieldBegin()
8226 
      if ftype == TType.STOP:
8227 
        break
8228 
      if fid == 0:
8229 
        if ftype == TType.BOOL:
8230 
          self.success = iprot.readBool();
8231 
        else:
8232 
          iprot.skip(ftype)
8233 
      elif fid == 1:
8234 
        if ftype == TType.STRUCT:
8235 
          self.ex = TransactionServiceException()
8236 
          self.ex.read(iprot)
8237 
        else:
8238 
          iprot.skip(ftype)
8239 
      else:
8240 
        iprot.skip(ftype)
8241 
      iprot.readFieldEnd()
8242 
    iprot.readStructEnd()
8243 
 
8244 
  def write(self, oprot):
8245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8247 
      return
8248 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 8249 
    if self.success is not None:
1208 chandransh 8250 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8251 
      oprot.writeBool(self.success)
8252 
      oprot.writeFieldEnd()
3431 rajveer 8253 
    if self.ex is not None:
1208 chandransh 8254 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8255 
      self.ex.write(oprot)
8256 
      oprot.writeFieldEnd()
8257 
    oprot.writeFieldStop()
8258 
    oprot.writeStructEnd()
8259 
 
3431 rajveer 8260 
  def validate(self):
8261 
    return
8262 
 
8263 
 
1208 chandransh 8264 
  def __repr__(self):
8265 
    L = ['%s=%r' % (key, value)
8266 
      for key, value in self.__dict__.iteritems()]
8267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8268 
 
8269 
  def __eq__(self, other):
8270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8271 
 
8272 
  def __ne__(self, other):
8273 
    return not (self == other)
8274 
 
3064 chandransh 8275 
class verifyOrder_args:
759 chandransh 8276 
  """
8277 
  Attributes:
3064 chandransh 8278 
   - orderId
759 chandransh 8279 
  """
8280 
 
8281 
  thrift_spec = (
8282 
    None, # 0
3064 chandransh 8283 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 8284 
  )
8285 
 
3064 chandransh 8286 
  def __init__(self, orderId=None,):
8287 
    self.orderId = orderId
759 chandransh 8288 
 
8289 
  def read(self, iprot):
8290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8292 
      return
8293 
    iprot.readStructBegin()
8294 
    while True:
8295 
      (fname, ftype, fid) = iprot.readFieldBegin()
8296 
      if ftype == TType.STOP:
8297 
        break
8298 
      if fid == 1:
8299 
        if ftype == TType.I64:
3064 chandransh 8300 
          self.orderId = iprot.readI64();
759 chandransh 8301 
        else:
8302 
          iprot.skip(ftype)
8303 
      else:
8304 
        iprot.skip(ftype)
8305 
      iprot.readFieldEnd()
8306 
    iprot.readStructEnd()
8307 
 
8308 
  def write(self, oprot):
8309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8311 
      return
3064 chandransh 8312 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 8313 
    if self.orderId is not None:
3064 chandransh 8314 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8315 
      oprot.writeI64(self.orderId)
759 chandransh 8316 
      oprot.writeFieldEnd()
8317 
    oprot.writeFieldStop()
8318 
    oprot.writeStructEnd()
8319 
 
3431 rajveer 8320 
  def validate(self):
8321 
    return
8322 
 
8323 
 
759 chandransh 8324 
  def __repr__(self):
8325 
    L = ['%s=%r' % (key, value)
8326 
      for key, value in self.__dict__.iteritems()]
8327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8328 
 
8329 
  def __eq__(self, other):
8330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8331 
 
8332 
  def __ne__(self, other):
8333 
    return not (self == other)
8334 
 
3064 chandransh 8335 
class verifyOrder_result:
759 chandransh 8336 
  """
8337 
  Attributes:
8338 
   - success
8339 
   - ex
8340 
  """
8341 
 
8342 
  thrift_spec = (
8343 
    (0, TType.BOOL, 'success', None, None, ), # 0
8344 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8345 
  )
8346 
 
8347 
  def __init__(self, success=None, ex=None,):
8348 
    self.success = success
8349 
    self.ex = ex
8350 
 
8351 
  def read(self, iprot):
8352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8354 
      return
8355 
    iprot.readStructBegin()
8356 
    while True:
8357 
      (fname, ftype, fid) = iprot.readFieldBegin()
8358 
      if ftype == TType.STOP:
8359 
        break
8360 
      if fid == 0:
8361 
        if ftype == TType.BOOL:
8362 
          self.success = iprot.readBool();
8363 
        else:
8364 
          iprot.skip(ftype)
8365 
      elif fid == 1:
8366 
        if ftype == TType.STRUCT:
8367 
          self.ex = TransactionServiceException()
8368 
          self.ex.read(iprot)
8369 
        else:
8370 
          iprot.skip(ftype)
8371 
      else:
8372 
        iprot.skip(ftype)
8373 
      iprot.readFieldEnd()
8374 
    iprot.readStructEnd()
8375 
 
8376 
  def write(self, oprot):
8377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8379 
      return
3064 chandransh 8380 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 8381 
    if self.success is not None:
759 chandransh 8382 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8383 
      oprot.writeBool(self.success)
8384 
      oprot.writeFieldEnd()
3431 rajveer 8385 
    if self.ex is not None:
759 chandransh 8386 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8387 
      self.ex.write(oprot)
8388 
      oprot.writeFieldEnd()
8389 
    oprot.writeFieldStop()
8390 
    oprot.writeStructEnd()
8391 
 
3431 rajveer 8392 
  def validate(self):
8393 
    return
8394 
 
8395 
 
759 chandransh 8396 
  def __repr__(self):
8397 
    L = ['%s=%r' % (key, value)
8398 
      for key, value in self.__dict__.iteritems()]
8399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8400 
 
8401 
  def __eq__(self, other):
8402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8403 
 
8404 
  def __ne__(self, other):
8405 
    return not (self == other)
8406 
 
3064 chandransh 8407 
class acceptOrder_args:
1113 chandransh 8408 
  """
8409 
  Attributes:
3064 chandransh 8410 
   - orderId
1113 chandransh 8411 
  """
8412 
 
8413 
  thrift_spec = (
8414 
    None, # 0
3064 chandransh 8415 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 8416 
  )
8417 
 
3064 chandransh 8418 
  def __init__(self, orderId=None,):
8419 
    self.orderId = orderId
1113 chandransh 8420 
 
8421 
  def read(self, iprot):
8422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8424 
      return
8425 
    iprot.readStructBegin()
8426 
    while True:
8427 
      (fname, ftype, fid) = iprot.readFieldBegin()
8428 
      if ftype == TType.STOP:
8429 
        break
8430 
      if fid == 1:
8431 
        if ftype == TType.I64:
3064 chandransh 8432 
          self.orderId = iprot.readI64();
1113 chandransh 8433 
        else:
8434 
          iprot.skip(ftype)
8435 
      else:
8436 
        iprot.skip(ftype)
8437 
      iprot.readFieldEnd()
8438 
    iprot.readStructEnd()
8439 
 
8440 
  def write(self, oprot):
8441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8443 
      return
3064 chandransh 8444 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 8445 
    if self.orderId is not None:
3064 chandransh 8446 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8447 
      oprot.writeI64(self.orderId)
1113 chandransh 8448 
      oprot.writeFieldEnd()
8449 
    oprot.writeFieldStop()
8450 
    oprot.writeStructEnd()
8451 
 
3431 rajveer 8452 
  def validate(self):
8453 
    return
8454 
 
8455 
 
1113 chandransh 8456 
  def __repr__(self):
8457 
    L = ['%s=%r' % (key, value)
8458 
      for key, value in self.__dict__.iteritems()]
8459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8460 
 
8461 
  def __eq__(self, other):
8462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8463 
 
8464 
  def __ne__(self, other):
8465 
    return not (self == other)
8466 
 
3064 chandransh 8467 
class acceptOrder_result:
1113 chandransh 8468 
  """
8469 
  Attributes:
8470 
   - success
8471 
   - ex
8472 
  """
8473 
 
8474 
  thrift_spec = (
3064 chandransh 8475 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 8476 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8477 
  )
8478 
 
8479 
  def __init__(self, success=None, ex=None,):
8480 
    self.success = success
8481 
    self.ex = ex
8482 
 
8483 
  def read(self, iprot):
8484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8486 
      return
8487 
    iprot.readStructBegin()
8488 
    while True:
8489 
      (fname, ftype, fid) = iprot.readFieldBegin()
8490 
      if ftype == TType.STOP:
8491 
        break
8492 
      if fid == 0:
3064 chandransh 8493 
        if ftype == TType.BOOL:
8494 
          self.success = iprot.readBool();
1113 chandransh 8495 
        else:
8496 
          iprot.skip(ftype)
8497 
      elif fid == 1:
8498 
        if ftype == TType.STRUCT:
8499 
          self.ex = TransactionServiceException()
8500 
          self.ex.read(iprot)
8501 
        else:
8502 
          iprot.skip(ftype)
8503 
      else:
8504 
        iprot.skip(ftype)
8505 
      iprot.readFieldEnd()
8506 
    iprot.readStructEnd()
8507 
 
8508 
  def write(self, oprot):
8509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8511 
      return
3064 chandransh 8512 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 8513 
    if self.success is not None:
3064 chandransh 8514 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8515 
      oprot.writeBool(self.success)
1113 chandransh 8516 
      oprot.writeFieldEnd()
3431 rajveer 8517 
    if self.ex is not None:
1113 chandransh 8518 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8519 
      self.ex.write(oprot)
8520 
      oprot.writeFieldEnd()
8521 
    oprot.writeFieldStop()
8522 
    oprot.writeStructEnd()
8523 
 
3431 rajveer 8524 
  def validate(self):
8525 
    return
8526 
 
8527 
 
1113 chandransh 8528 
  def __repr__(self):
8529 
    L = ['%s=%r' % (key, value)
8530 
      for key, value in self.__dict__.iteritems()]
8531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8532 
 
8533 
  def __eq__(self, other):
8534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8535 
 
8536 
  def __ne__(self, other):
8537 
    return not (self == other)
8538 
 
3064 chandransh 8539 
class billOrder_args:
1132 chandransh 8540 
  """
8541 
  Attributes:
3064 chandransh 8542 
   - orderId
1132 chandransh 8543 
  """
8544 
 
8545 
  thrift_spec = (
8546 
    None, # 0
3064 chandransh 8547 
    (1, TType.I64, 'orderId', None, None, ), # 1
1132 chandransh 8548 
  )
8549 
 
3064 chandransh 8550 
  def __init__(self, orderId=None,):
8551 
    self.orderId = orderId
1132 chandransh 8552 
 
8553 
  def read(self, iprot):
8554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8556 
      return
8557 
    iprot.readStructBegin()
8558 
    while True:
8559 
      (fname, ftype, fid) = iprot.readFieldBegin()
8560 
      if ftype == TType.STOP:
8561 
        break
8562 
      if fid == 1:
8563 
        if ftype == TType.I64:
3064 chandransh 8564 
          self.orderId = iprot.readI64();
1132 chandransh 8565 
        else:
8566 
          iprot.skip(ftype)
8567 
      else:
8568 
        iprot.skip(ftype)
8569 
      iprot.readFieldEnd()
8570 
    iprot.readStructEnd()
8571 
 
8572 
  def write(self, oprot):
8573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8575 
      return
3064 chandransh 8576 
    oprot.writeStructBegin('billOrder_args')
3431 rajveer 8577 
    if self.orderId is not None:
3064 chandransh 8578 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8579 
      oprot.writeI64(self.orderId)
1132 chandransh 8580 
      oprot.writeFieldEnd()
8581 
    oprot.writeFieldStop()
8582 
    oprot.writeStructEnd()
8583 
 
3431 rajveer 8584 
  def validate(self):
8585 
    return
8586 
 
8587 
 
1132 chandransh 8588 
  def __repr__(self):
8589 
    L = ['%s=%r' % (key, value)
8590 
      for key, value in self.__dict__.iteritems()]
8591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8592 
 
8593 
  def __eq__(self, other):
8594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8595 
 
8596 
  def __ne__(self, other):
8597 
    return not (self == other)
8598 
 
3064 chandransh 8599 
class billOrder_result:
1132 chandransh 8600 
  """
8601 
  Attributes:
3064 chandransh 8602 
   - success
1132 chandransh 8603 
   - ex
8604 
  """
8605 
 
8606 
  thrift_spec = (
3064 chandransh 8607 
    (0, TType.BOOL, 'success', None, None, ), # 0
1132 chandransh 8608 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8609 
  )
8610 
 
3064 chandransh 8611 
  def __init__(self, success=None, ex=None,):
8612 
    self.success = success
1132 chandransh 8613 
    self.ex = ex
8614 
 
8615 
  def read(self, iprot):
8616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8618 
      return
8619 
    iprot.readStructBegin()
8620 
    while True:
8621 
      (fname, ftype, fid) = iprot.readFieldBegin()
8622 
      if ftype == TType.STOP:
8623 
        break
3064 chandransh 8624 
      if fid == 0:
8625 
        if ftype == TType.BOOL:
8626 
          self.success = iprot.readBool();
8627 
        else:
8628 
          iprot.skip(ftype)
8629 
      elif fid == 1:
1132 chandransh 8630 
        if ftype == TType.STRUCT:
8631 
          self.ex = TransactionServiceException()
8632 
          self.ex.read(iprot)
8633 
        else:
8634 
          iprot.skip(ftype)
8635 
      else:
8636 
        iprot.skip(ftype)
8637 
      iprot.readFieldEnd()
8638 
    iprot.readStructEnd()
8639 
 
8640 
  def write(self, oprot):
8641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8643 
      return
3064 chandransh 8644 
    oprot.writeStructBegin('billOrder_result')
3431 rajveer 8645 
    if self.success is not None:
3064 chandransh 8646 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8647 
      oprot.writeBool(self.success)
8648 
      oprot.writeFieldEnd()
3431 rajveer 8649 
    if self.ex is not None:
1132 chandransh 8650 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8651 
      self.ex.write(oprot)
8652 
      oprot.writeFieldEnd()
8653 
    oprot.writeFieldStop()
8654 
    oprot.writeStructEnd()
8655 
 
3431 rajveer 8656 
  def validate(self):
8657 
    return
8658 
 
8659 
 
1132 chandransh 8660 
  def __repr__(self):
8661 
    L = ['%s=%r' % (key, value)
8662 
      for key, value in self.__dict__.iteritems()]
8663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8664 
 
8665 
  def __eq__(self, other):
8666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8667 
 
8668 
  def __ne__(self, other):
8669 
    return not (self == other)
8670 
 
3064 chandransh 8671 
class addBillingDetails_args:
1135 chandransh 8672 
  """
8673 
  Attributes:
3064 chandransh 8674 
   - orderId
8675 
   - invoice_number
8676 
   - billed_by
4264 rajveer 8677 
   - jacketNumber
1135 chandransh 8678 
  """
8679 
 
8680 
  thrift_spec = (
8681 
    None, # 0
3064 chandransh 8682 
    (1, TType.I64, 'orderId', None, None, ), # 1
8683 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
8684 
    (3, TType.STRING, 'billed_by', None, None, ), # 3
4264 rajveer 8685 
    (4, TType.I64, 'jacketNumber', None, None, ), # 4
1135 chandransh 8686 
  )
8687 
 
4264 rajveer 8688 
  def __init__(self, orderId=None, invoice_number=None, billed_by=None, jacketNumber=None,):
3064 chandransh 8689 
    self.orderId = orderId
8690 
    self.invoice_number = invoice_number
8691 
    self.billed_by = billed_by
4264 rajveer 8692 
    self.jacketNumber = jacketNumber
1135 chandransh 8693 
 
8694 
  def read(self, iprot):
8695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8697 
      return
8698 
    iprot.readStructBegin()
8699 
    while True:
8700 
      (fname, ftype, fid) = iprot.readFieldBegin()
8701 
      if ftype == TType.STOP:
8702 
        break
8703 
      if fid == 1:
8704 
        if ftype == TType.I64:
3064 chandransh 8705 
          self.orderId = iprot.readI64();
1135 chandransh 8706 
        else:
8707 
          iprot.skip(ftype)
8708 
      elif fid == 2:
3064 chandransh 8709 
        if ftype == TType.STRING:
8710 
          self.invoice_number = iprot.readString();
1135 chandransh 8711 
        else:
8712 
          iprot.skip(ftype)
3064 chandransh 8713 
      elif fid == 3:
8714 
        if ftype == TType.STRING:
8715 
          self.billed_by = iprot.readString();
8716 
        else:
8717 
          iprot.skip(ftype)
4264 rajveer 8718 
      elif fid == 4:
8719 
        if ftype == TType.I64:
8720 
          self.jacketNumber = iprot.readI64();
8721 
        else:
8722 
          iprot.skip(ftype)
1135 chandransh 8723 
      else:
8724 
        iprot.skip(ftype)
8725 
      iprot.readFieldEnd()
8726 
    iprot.readStructEnd()
8727 
 
8728 
  def write(self, oprot):
8729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8731 
      return
3064 chandransh 8732 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 8733 
    if self.orderId is not None:
3064 chandransh 8734 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8735 
      oprot.writeI64(self.orderId)
1135 chandransh 8736 
      oprot.writeFieldEnd()
3431 rajveer 8737 
    if self.invoice_number is not None:
3064 chandransh 8738 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
8739 
      oprot.writeString(self.invoice_number)
1135 chandransh 8740 
      oprot.writeFieldEnd()
3431 rajveer 8741 
    if self.billed_by is not None:
3064 chandransh 8742 
      oprot.writeFieldBegin('billed_by', TType.STRING, 3)
8743 
      oprot.writeString(self.billed_by)
8744 
      oprot.writeFieldEnd()
4264 rajveer 8745 
    if self.jacketNumber is not None:
8746 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 4)
8747 
      oprot.writeI64(self.jacketNumber)
8748 
      oprot.writeFieldEnd()
1135 chandransh 8749 
    oprot.writeFieldStop()
8750 
    oprot.writeStructEnd()
8751 
 
3431 rajveer 8752 
  def validate(self):
8753 
    return
8754 
 
8755 
 
1135 chandransh 8756 
  def __repr__(self):
8757 
    L = ['%s=%r' % (key, value)
8758 
      for key, value in self.__dict__.iteritems()]
8759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8760 
 
8761 
  def __eq__(self, other):
8762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8763 
 
8764 
  def __ne__(self, other):
8765 
    return not (self == other)
8766 
 
3064 chandransh 8767 
class addBillingDetails_result:
1135 chandransh 8768 
  """
8769 
  Attributes:
3064 chandransh 8770 
   - success
1135 chandransh 8771 
   - ex
8772 
  """
8773 
 
8774 
  thrift_spec = (
3064 chandransh 8775 
    (0, TType.BOOL, 'success', None, None, ), # 0
1135 chandransh 8776 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8777 
  )
8778 
 
3064 chandransh 8779 
  def __init__(self, success=None, ex=None,):
8780 
    self.success = success
1135 chandransh 8781 
    self.ex = ex
8782 
 
8783 
  def read(self, iprot):
8784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8786 
      return
8787 
    iprot.readStructBegin()
8788 
    while True:
8789 
      (fname, ftype, fid) = iprot.readFieldBegin()
8790 
      if ftype == TType.STOP:
8791 
        break
3064 chandransh 8792 
      if fid == 0:
8793 
        if ftype == TType.BOOL:
8794 
          self.success = iprot.readBool();
8795 
        else:
8796 
          iprot.skip(ftype)
8797 
      elif fid == 1:
1135 chandransh 8798 
        if ftype == TType.STRUCT:
8799 
          self.ex = TransactionServiceException()
8800 
          self.ex.read(iprot)
8801 
        else:
8802 
          iprot.skip(ftype)
8803 
      else:
8804 
        iprot.skip(ftype)
8805 
      iprot.readFieldEnd()
8806 
    iprot.readStructEnd()
8807 
 
8808 
  def write(self, oprot):
8809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8811 
      return
3064 chandransh 8812 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 8813 
    if self.success is not None:
3064 chandransh 8814 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8815 
      oprot.writeBool(self.success)
8816 
      oprot.writeFieldEnd()
3431 rajveer 8817 
    if self.ex is not None:
1135 chandransh 8818 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8819 
      self.ex.write(oprot)
8820 
      oprot.writeFieldEnd()
8821 
    oprot.writeFieldStop()
8822 
    oprot.writeStructEnd()
8823 
 
3431 rajveer 8824 
  def validate(self):
8825 
    return
8826 
 
8827 
 
1135 chandransh 8828 
  def __repr__(self):
8829 
    L = ['%s=%r' % (key, value)
8830 
      for key, value in self.__dict__.iteritems()]
8831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8832 
 
8833 
  def __eq__(self, other):
8834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8835 
 
8836 
  def __ne__(self, other):
8837 
    return not (self == other)
8838 
 
3064 chandransh 8839 
class addJacketNumber_args:
1246 chandransh 8840 
  """
8841 
  Attributes:
3064 chandransh 8842 
   - orderId
8843 
   - jacketNumber
8844 
   - imeiNumber
8845 
   - itemNumber
8846 
   - billedBy
8847 
   - billingType
1246 chandransh 8848 
  """
8849 
 
8850 
  thrift_spec = (
8851 
    None, # 0
3064 chandransh 8852 
    (1, TType.I64, 'orderId', None, None, ), # 1
8853 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
8854 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
8855 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
8856 
    (5, TType.STRING, 'billedBy', None, None, ), # 5
8857 
    (6, TType.I64, 'billingType', None, None, ), # 6
1246 chandransh 8858 
  )
8859 
 
3064 chandransh 8860 
  def __init__(self, orderId=None, jacketNumber=None, imeiNumber=None, itemNumber=None, billedBy=None, billingType=None,):
8861 
    self.orderId = orderId
8862 
    self.jacketNumber = jacketNumber
8863 
    self.imeiNumber = imeiNumber
8864 
    self.itemNumber = itemNumber
8865 
    self.billedBy = billedBy
8866 
    self.billingType = billingType
1246 chandransh 8867 
 
8868 
  def read(self, iprot):
8869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8871 
      return
8872 
    iprot.readStructBegin()
8873 
    while True:
8874 
      (fname, ftype, fid) = iprot.readFieldBegin()
8875 
      if ftype == TType.STOP:
8876 
        break
8877 
      if fid == 1:
8878 
        if ftype == TType.I64:
3064 chandransh 8879 
          self.orderId = iprot.readI64();
1246 chandransh 8880 
        else:
8881 
          iprot.skip(ftype)
8882 
      elif fid == 2:
3064 chandransh 8883 
        if ftype == TType.I64:
8884 
          self.jacketNumber = iprot.readI64();
1246 chandransh 8885 
        else:
8886 
          iprot.skip(ftype)
3064 chandransh 8887 
      elif fid == 3:
8888 
        if ftype == TType.I64:
8889 
          self.imeiNumber = iprot.readI64();
8890 
        else:
8891 
          iprot.skip(ftype)
8892 
      elif fid == 4:
8893 
        if ftype == TType.STRING:
8894 
          self.itemNumber = iprot.readString();
8895 
        else:
8896 
          iprot.skip(ftype)
8897 
      elif fid == 5:
8898 
        if ftype == TType.STRING:
8899 
          self.billedBy = iprot.readString();
8900 
        else:
8901 
          iprot.skip(ftype)
8902 
      elif fid == 6:
8903 
        if ftype == TType.I64:
8904 
          self.billingType = iprot.readI64();
8905 
        else:
8906 
          iprot.skip(ftype)
1246 chandransh 8907 
      else:
8908 
        iprot.skip(ftype)
8909 
      iprot.readFieldEnd()
8910 
    iprot.readStructEnd()
8911 
 
8912 
  def write(self, oprot):
8913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8915 
      return
3064 chandransh 8916 
    oprot.writeStructBegin('addJacketNumber_args')
3431 rajveer 8917 
    if self.orderId is not None:
3064 chandransh 8918 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8919 
      oprot.writeI64(self.orderId)
1246 chandransh 8920 
      oprot.writeFieldEnd()
3431 rajveer 8921 
    if self.jacketNumber is not None:
3064 chandransh 8922 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
8923 
      oprot.writeI64(self.jacketNumber)
1246 chandransh 8924 
      oprot.writeFieldEnd()
3431 rajveer 8925 
    if self.imeiNumber is not None:
3064 chandransh 8926 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
8927 
      oprot.writeI64(self.imeiNumber)
8928 
      oprot.writeFieldEnd()
3431 rajveer 8929 
    if self.itemNumber is not None:
3064 chandransh 8930 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
8931 
      oprot.writeString(self.itemNumber)
8932 
      oprot.writeFieldEnd()
3431 rajveer 8933 
    if self.billedBy is not None:
3064 chandransh 8934 
      oprot.writeFieldBegin('billedBy', TType.STRING, 5)
8935 
      oprot.writeString(self.billedBy)
8936 
      oprot.writeFieldEnd()
3431 rajveer 8937 
    if self.billingType is not None:
3064 chandransh 8938 
      oprot.writeFieldBegin('billingType', TType.I64, 6)
8939 
      oprot.writeI64(self.billingType)
8940 
      oprot.writeFieldEnd()
1246 chandransh 8941 
    oprot.writeFieldStop()
8942 
    oprot.writeStructEnd()
8943 
 
3431 rajveer 8944 
  def validate(self):
8945 
    return
8946 
 
8947 
 
1246 chandransh 8948 
  def __repr__(self):
8949 
    L = ['%s=%r' % (key, value)
8950 
      for key, value in self.__dict__.iteritems()]
8951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8952 
 
8953 
  def __eq__(self, other):
8954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8955 
 
8956 
  def __ne__(self, other):
8957 
    return not (self == other)
8958 
 
3064 chandransh 8959 
class addJacketNumber_result:
1246 chandransh 8960 
  """
8961 
  Attributes:
3064 chandransh 8962 
   - success
1246 chandransh 8963 
   - ex
8964 
  """
8965 
 
8966 
  thrift_spec = (
3064 chandransh 8967 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 8968 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8969 
  )
8970 
 
3064 chandransh 8971 
  def __init__(self, success=None, ex=None,):
8972 
    self.success = success
1246 chandransh 8973 
    self.ex = ex
8974 
 
8975 
  def read(self, iprot):
8976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8978 
      return
8979 
    iprot.readStructBegin()
8980 
    while True:
8981 
      (fname, ftype, fid) = iprot.readFieldBegin()
8982 
      if ftype == TType.STOP:
8983 
        break
3064 chandransh 8984 
      if fid == 0:
8985 
        if ftype == TType.BOOL:
8986 
          self.success = iprot.readBool();
8987 
        else:
8988 
          iprot.skip(ftype)
8989 
      elif fid == 1:
1246 chandransh 8990 
        if ftype == TType.STRUCT:
8991 
          self.ex = TransactionServiceException()
8992 
          self.ex.read(iprot)
8993 
        else:
8994 
          iprot.skip(ftype)
8995 
      else:
8996 
        iprot.skip(ftype)
8997 
      iprot.readFieldEnd()
8998 
    iprot.readStructEnd()
8999 
 
9000 
  def write(self, oprot):
9001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9003 
      return
3064 chandransh 9004 
    oprot.writeStructBegin('addJacketNumber_result')
3431 rajveer 9005 
    if self.success is not None:
3064 chandransh 9006 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9007 
      oprot.writeBool(self.success)
9008 
      oprot.writeFieldEnd()
3431 rajveer 9009 
    if self.ex is not None:
1246 chandransh 9010 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9011 
      self.ex.write(oprot)
9012 
      oprot.writeFieldEnd()
9013 
    oprot.writeFieldStop()
9014 
    oprot.writeStructEnd()
9015 
 
3431 rajveer 9016 
  def validate(self):
9017 
    return
9018 
 
9019 
 
1246 chandransh 9020 
  def __repr__(self):
9021 
    L = ['%s=%r' % (key, value)
9022 
      for key, value in self.__dict__.iteritems()]
9023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9024 
 
9025 
  def __eq__(self, other):
9026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9027 
 
9028 
  def __ne__(self, other):
9029 
    return not (self == other)
9030 
 
3064 chandransh 9031 
class markOrdersAsManifested_args:
1408 ankur.sing 9032 
  """
9033 
  Attributes:
3064 chandransh 9034 
   - warehouseId
1408 ankur.sing 9035 
   - providerId
3064 chandransh 9036 
   - cod
1408 ankur.sing 9037 
  """
9038 
 
9039 
  thrift_spec = (
9040 
    None, # 0
3064 chandransh 9041 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9042 
    (2, TType.I64, 'providerId', None, None, ), # 2
9043 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 9044 
  )
9045 
 
3064 chandransh 9046 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9047 
    self.warehouseId = warehouseId
1408 ankur.sing 9048 
    self.providerId = providerId
3064 chandransh 9049 
    self.cod = cod
1408 ankur.sing 9050 
 
9051 
  def read(self, iprot):
9052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9054 
      return
9055 
    iprot.readStructBegin()
9056 
    while True:
9057 
      (fname, ftype, fid) = iprot.readFieldBegin()
9058 
      if ftype == TType.STOP:
9059 
        break
9060 
      if fid == 1:
9061 
        if ftype == TType.I64:
3064 chandransh 9062 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 9063 
        else:
9064 
          iprot.skip(ftype)
9065 
      elif fid == 2:
9066 
        if ftype == TType.I64:
3064 chandransh 9067 
          self.providerId = iprot.readI64();
1408 ankur.sing 9068 
        else:
9069 
          iprot.skip(ftype)
3064 chandransh 9070 
      elif fid == 3:
9071 
        if ftype == TType.BOOL:
9072 
          self.cod = iprot.readBool();
9073 
        else:
9074 
          iprot.skip(ftype)
1408 ankur.sing 9075 
      else:
9076 
        iprot.skip(ftype)
9077 
      iprot.readFieldEnd()
9078 
    iprot.readStructEnd()
9079 
 
9080 
  def write(self, oprot):
9081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9083 
      return
3064 chandransh 9084 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 9085 
    if self.warehouseId is not None:
3064 chandransh 9086 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9087 
      oprot.writeI64(self.warehouseId)
9088 
      oprot.writeFieldEnd()
3431 rajveer 9089 
    if self.providerId is not None:
3064 chandransh 9090 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9091 
      oprot.writeI64(self.providerId)
9092 
      oprot.writeFieldEnd()
3431 rajveer 9093 
    if self.cod is not None:
3064 chandransh 9094 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9095 
      oprot.writeBool(self.cod)
1408 ankur.sing 9096 
      oprot.writeFieldEnd()
9097 
    oprot.writeFieldStop()
9098 
    oprot.writeStructEnd()
9099 
 
3431 rajveer 9100 
  def validate(self):
9101 
    return
9102 
 
9103 
 
1408 ankur.sing 9104 
  def __repr__(self):
9105 
    L = ['%s=%r' % (key, value)
9106 
      for key, value in self.__dict__.iteritems()]
9107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9108 
 
9109 
  def __eq__(self, other):
9110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9111 
 
9112 
  def __ne__(self, other):
9113 
    return not (self == other)
9114 
 
3064 chandransh 9115 
class markOrdersAsManifested_result:
1408 ankur.sing 9116 
  """
9117 
  Attributes:
9118 
   - success
3064 chandransh 9119 
   - ex
1408 ankur.sing 9120 
  """
9121 
 
9122 
  thrift_spec = (
3064 chandransh 9123 
    (0, TType.BOOL, 'success', None, None, ), # 0
9124 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 9125 
  )
9126 
 
3064 chandransh 9127 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 9128 
    self.success = success
3064 chandransh 9129 
    self.ex = ex
1408 ankur.sing 9130 
 
9131 
  def read(self, iprot):
9132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9134 
      return
9135 
    iprot.readStructBegin()
9136 
    while True:
9137 
      (fname, ftype, fid) = iprot.readFieldBegin()
9138 
      if ftype == TType.STOP:
9139 
        break
9140 
      if fid == 0:
3064 chandransh 9141 
        if ftype == TType.BOOL:
9142 
          self.success = iprot.readBool();
1408 ankur.sing 9143 
        else:
9144 
          iprot.skip(ftype)
3064 chandransh 9145 
      elif fid == 1:
9146 
        if ftype == TType.STRUCT:
9147 
          self.ex = TransactionServiceException()
9148 
          self.ex.read(iprot)
9149 
        else:
9150 
          iprot.skip(ftype)
1408 ankur.sing 9151 
      else:
9152 
        iprot.skip(ftype)
9153 
      iprot.readFieldEnd()
9154 
    iprot.readStructEnd()
9155 
 
9156 
  def write(self, oprot):
9157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9159 
      return
3064 chandransh 9160 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 9161 
    if self.success is not None:
3064 chandransh 9162 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9163 
      oprot.writeBool(self.success)
1408 ankur.sing 9164 
      oprot.writeFieldEnd()
3431 rajveer 9165 
    if self.ex is not None:
3064 chandransh 9166 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9167 
      self.ex.write(oprot)
9168 
      oprot.writeFieldEnd()
1408 ankur.sing 9169 
    oprot.writeFieldStop()
9170 
    oprot.writeStructEnd()
9171 
 
3431 rajveer 9172 
  def validate(self):
9173 
    return
9174 
 
9175 
 
1408 ankur.sing 9176 
  def __repr__(self):
9177 
    L = ['%s=%r' % (key, value)
9178 
      for key, value in self.__dict__.iteritems()]
9179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9180 
 
9181 
  def __eq__(self, other):
9182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9183 
 
9184 
  def __ne__(self, other):
9185 
    return not (self == other)
9186 
 
3064 chandransh 9187 
class markOrdersAsPickedUp_args:
304 ashish 9188 
  """
9189 
  Attributes:
3064 chandransh 9190 
   - providerId
9191 
   - pickupDetails
304 ashish 9192 
  """
94 ashish 9193 
 
304 ashish 9194 
  thrift_spec = (
9195 
    None, # 0
3064 chandransh 9196 
    (1, TType.I64, 'providerId', None, None, ), # 1
9197 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9198 
  )
9199 
 
3064 chandransh 9200 
  def __init__(self, providerId=None, pickupDetails=None,):
9201 
    self.providerId = providerId
9202 
    self.pickupDetails = pickupDetails
304 ashish 9203 
 
9204 
  def read(self, iprot):
9205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9207 
      return
9208 
    iprot.readStructBegin()
9209 
    while True:
9210 
      (fname, ftype, fid) = iprot.readFieldBegin()
9211 
      if ftype == TType.STOP:
9212 
        break
9213 
      if fid == 1:
9214 
        if ftype == TType.I64:
3064 chandransh 9215 
          self.providerId = iprot.readI64();
304 ashish 9216 
        else:
9217 
          iprot.skip(ftype)
9218 
      elif fid == 2:
3064 chandransh 9219 
        if ftype == TType.MAP:
9220 
          self.pickupDetails = {}
4133 chandransh 9221 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
9222 
          for _i144 in xrange(_size140):
9223 
            _key145 = iprot.readString();
9224 
            _val146 = iprot.readString();
9225 
            self.pickupDetails[_key145] = _val146
3064 chandransh 9226 
          iprot.readMapEnd()
304 ashish 9227 
        else:
9228 
          iprot.skip(ftype)
9229 
      else:
9230 
        iprot.skip(ftype)
9231 
      iprot.readFieldEnd()
9232 
    iprot.readStructEnd()
9233 
 
9234 
  def write(self, oprot):
9235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9237 
      return
3064 chandransh 9238 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 9239 
    if self.providerId is not None:
3064 chandransh 9240 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9241 
      oprot.writeI64(self.providerId)
304 ashish 9242 
      oprot.writeFieldEnd()
3431 rajveer 9243 
    if self.pickupDetails is not None:
3064 chandransh 9244 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
9245 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 9246 
      for kiter147,viter148 in self.pickupDetails.items():
9247 
        oprot.writeString(kiter147)
9248 
        oprot.writeString(viter148)
3064 chandransh 9249 
      oprot.writeMapEnd()
304 ashish 9250 
      oprot.writeFieldEnd()
9251 
    oprot.writeFieldStop()
9252 
    oprot.writeStructEnd()
9253 
 
3431 rajveer 9254 
  def validate(self):
9255 
    return
9256 
 
9257 
 
304 ashish 9258 
  def __repr__(self):
9259 
    L = ['%s=%r' % (key, value)
9260 
      for key, value in self.__dict__.iteritems()]
9261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9262 
 
9263 
  def __eq__(self, other):
9264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9265 
 
9266 
  def __ne__(self, other):
9267 
    return not (self == other)
9268 
 
3064 chandransh 9269 
class markOrdersAsPickedUp_result:
304 ashish 9270 
  """
9271 
  Attributes:
9272 
   - success
3064 chandransh 9273 
   - ex
304 ashish 9274 
  """
9275 
 
9276 
  thrift_spec = (
3064 chandransh 9277 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9278 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9279 
  )
9280 
 
3064 chandransh 9281 
  def __init__(self, success=None, ex=None,):
304 ashish 9282 
    self.success = success
3064 chandransh 9283 
    self.ex = ex
304 ashish 9284 
 
9285 
  def read(self, iprot):
9286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9288 
      return
9289 
    iprot.readStructBegin()
9290 
    while True:
9291 
      (fname, ftype, fid) = iprot.readFieldBegin()
9292 
      if ftype == TType.STOP:
9293 
        break
9294 
      if fid == 0:
9295 
        if ftype == TType.LIST:
9296 
          self.success = []
4133 chandransh 9297 
          (_etype152, _size149) = iprot.readListBegin()
9298 
          for _i153 in xrange(_size149):
9299 
            _elem154 = Order()
9300 
            _elem154.read(iprot)
9301 
            self.success.append(_elem154)
304 ashish 9302 
          iprot.readListEnd()
9303 
        else:
9304 
          iprot.skip(ftype)
3064 chandransh 9305 
      elif fid == 1:
9306 
        if ftype == TType.STRUCT:
9307 
          self.ex = TransactionServiceException()
9308 
          self.ex.read(iprot)
9309 
        else:
9310 
          iprot.skip(ftype)
304 ashish 9311 
      else:
9312 
        iprot.skip(ftype)
9313 
      iprot.readFieldEnd()
9314 
    iprot.readStructEnd()
9315 
 
9316 
  def write(self, oprot):
9317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9319 
      return
3064 chandransh 9320 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 9321 
    if self.success is not None:
304 ashish 9322 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9323 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9324 
      for iter155 in self.success:
9325 
        iter155.write(oprot)
304 ashish 9326 
      oprot.writeListEnd()
9327 
      oprot.writeFieldEnd()
3431 rajveer 9328 
    if self.ex is not None:
3064 chandransh 9329 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9330 
      self.ex.write(oprot)
9331 
      oprot.writeFieldEnd()
304 ashish 9332 
    oprot.writeFieldStop()
9333 
    oprot.writeStructEnd()
9334 
 
3431 rajveer 9335 
  def validate(self):
9336 
    return
9337 
 
9338 
 
304 ashish 9339 
  def __repr__(self):
9340 
    L = ['%s=%r' % (key, value)
9341 
      for key, value in self.__dict__.iteritems()]
9342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9343 
 
9344 
  def __eq__(self, other):
9345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9346 
 
9347 
  def __ne__(self, other):
9348 
    return not (self == other)
9349 
 
3064 chandransh 9350 
class markOrdersAsDelivered_args:
304 ashish 9351 
  """
9352 
  Attributes:
3064 chandransh 9353 
   - providerId
9354 
   - deliveredOrders
304 ashish 9355 
  """
9356 
 
9357 
  thrift_spec = (
9358 
    None, # 0
3064 chandransh 9359 
    (1, TType.I64, 'providerId', None, None, ), # 1
9360 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9361 
  )
9362 
 
3064 chandransh 9363 
  def __init__(self, providerId=None, deliveredOrders=None,):
9364 
    self.providerId = providerId
9365 
    self.deliveredOrders = deliveredOrders
304 ashish 9366 
 
9367 
  def read(self, iprot):
9368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9370 
      return
9371 
    iprot.readStructBegin()
9372 
    while True:
9373 
      (fname, ftype, fid) = iprot.readFieldBegin()
9374 
      if ftype == TType.STOP:
9375 
        break
9376 
      if fid == 1:
9377 
        if ftype == TType.I64:
3064 chandransh 9378 
          self.providerId = iprot.readI64();
304 ashish 9379 
        else:
9380 
          iprot.skip(ftype)
9381 
      elif fid == 2:
3064 chandransh 9382 
        if ftype == TType.MAP:
9383 
          self.deliveredOrders = {}
4133 chandransh 9384 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9385 
          for _i160 in xrange(_size156):
9386 
            _key161 = iprot.readString();
9387 
            _val162 = iprot.readString();
9388 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 9389 
          iprot.readMapEnd()
304 ashish 9390 
        else:
9391 
          iprot.skip(ftype)
9392 
      else:
9393 
        iprot.skip(ftype)
9394 
      iprot.readFieldEnd()
9395 
    iprot.readStructEnd()
9396 
 
9397 
  def write(self, oprot):
9398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9400 
      return
3064 chandransh 9401 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 9402 
    if self.providerId is not None:
3064 chandransh 9403 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9404 
      oprot.writeI64(self.providerId)
304 ashish 9405 
      oprot.writeFieldEnd()
3431 rajveer 9406 
    if self.deliveredOrders is not None:
3064 chandransh 9407 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
9408 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 9409 
      for kiter163,viter164 in self.deliveredOrders.items():
9410 
        oprot.writeString(kiter163)
9411 
        oprot.writeString(viter164)
3064 chandransh 9412 
      oprot.writeMapEnd()
304 ashish 9413 
      oprot.writeFieldEnd()
9414 
    oprot.writeFieldStop()
9415 
    oprot.writeStructEnd()
9416 
 
3431 rajveer 9417 
  def validate(self):
9418 
    return
9419 
 
9420 
 
304 ashish 9421 
  def __repr__(self):
9422 
    L = ['%s=%r' % (key, value)
9423 
      for key, value in self.__dict__.iteritems()]
9424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9425 
 
9426 
  def __eq__(self, other):
9427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9428 
 
9429 
  def __ne__(self, other):
9430 
    return not (self == other)
9431 
 
3064 chandransh 9432 
class markOrdersAsDelivered_result:
9433 
  """
9434 
  Attributes:
9435 
   - ex
9436 
  """
304 ashish 9437 
 
9438 
  thrift_spec = (
3064 chandransh 9439 
    None, # 0
9440 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9441 
  )
9442 
 
3064 chandransh 9443 
  def __init__(self, ex=None,):
9444 
    self.ex = ex
304 ashish 9445 
 
1596 ankur.sing 9446 
  def read(self, iprot):
9447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9449 
      return
9450 
    iprot.readStructBegin()
9451 
    while True:
9452 
      (fname, ftype, fid) = iprot.readFieldBegin()
9453 
      if ftype == TType.STOP:
9454 
        break
3064 chandransh 9455 
      if fid == 1:
9456 
        if ftype == TType.STRUCT:
9457 
          self.ex = TransactionServiceException()
9458 
          self.ex.read(iprot)
9459 
        else:
9460 
          iprot.skip(ftype)
1596 ankur.sing 9461 
      else:
9462 
        iprot.skip(ftype)
9463 
      iprot.readFieldEnd()
9464 
    iprot.readStructEnd()
9465 
 
9466 
  def write(self, oprot):
9467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9469 
      return
3064 chandransh 9470 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 9471 
    if self.ex is not None:
3064 chandransh 9472 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9473 
      self.ex.write(oprot)
9474 
      oprot.writeFieldEnd()
1596 ankur.sing 9475 
    oprot.writeFieldStop()
9476 
    oprot.writeStructEnd()
9477 
 
3431 rajveer 9478 
  def validate(self):
9479 
    return
9480 
 
9481 
 
1596 ankur.sing 9482 
  def __repr__(self):
9483 
    L = ['%s=%r' % (key, value)
9484 
      for key, value in self.__dict__.iteritems()]
9485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9486 
 
9487 
  def __eq__(self, other):
9488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9489 
 
9490 
  def __ne__(self, other):
9491 
    return not (self == other)
9492 
 
3064 chandransh 9493 
class markOrdersAsFailed_args:
1596 ankur.sing 9494 
  """
9495 
  Attributes:
3064 chandransh 9496 
   - providerId
9497 
   - returnedOrders
1596 ankur.sing 9498 
  """
9499 
 
9500 
  thrift_spec = (
3064 chandransh 9501 
    None, # 0
9502 
    (1, TType.I64, 'providerId', None, None, ), # 1
9503 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 9504 
  )
9505 
 
3064 chandransh 9506 
  def __init__(self, providerId=None, returnedOrders=None,):
9507 
    self.providerId = providerId
9508 
    self.returnedOrders = returnedOrders
1596 ankur.sing 9509 
 
9510 
  def read(self, iprot):
9511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9513 
      return
9514 
    iprot.readStructBegin()
9515 
    while True:
9516 
      (fname, ftype, fid) = iprot.readFieldBegin()
9517 
      if ftype == TType.STOP:
9518 
        break
3064 chandransh 9519 
      if fid == 1:
1596 ankur.sing 9520 
        if ftype == TType.I64:
3064 chandransh 9521 
          self.providerId = iprot.readI64();
1596 ankur.sing 9522 
        else:
9523 
          iprot.skip(ftype)
3064 chandransh 9524 
      elif fid == 2:
9525 
        if ftype == TType.MAP:
9526 
          self.returnedOrders = {}
4133 chandransh 9527 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
9528 
          for _i169 in xrange(_size165):
9529 
            _key170 = iprot.readString();
9530 
            _val171 = iprot.readString();
9531 
            self.returnedOrders[_key170] = _val171
3064 chandransh 9532 
          iprot.readMapEnd()
9533 
        else:
9534 
          iprot.skip(ftype)
1596 ankur.sing 9535 
      else:
9536 
        iprot.skip(ftype)
9537 
      iprot.readFieldEnd()
9538 
    iprot.readStructEnd()
9539 
 
9540 
  def write(self, oprot):
9541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9543 
      return
3064 chandransh 9544 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 9545 
    if self.providerId is not None:
3064 chandransh 9546 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9547 
      oprot.writeI64(self.providerId)
1596 ankur.sing 9548 
      oprot.writeFieldEnd()
3431 rajveer 9549 
    if self.returnedOrders is not None:
3064 chandransh 9550 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
9551 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 9552 
      for kiter172,viter173 in self.returnedOrders.items():
9553 
        oprot.writeString(kiter172)
9554 
        oprot.writeString(viter173)
3064 chandransh 9555 
      oprot.writeMapEnd()
9556 
      oprot.writeFieldEnd()
1596 ankur.sing 9557 
    oprot.writeFieldStop()
9558 
    oprot.writeStructEnd()
9559 
 
3431 rajveer 9560 
  def validate(self):
9561 
    return
9562 
 
9563 
 
1596 ankur.sing 9564 
  def __repr__(self):
9565 
    L = ['%s=%r' % (key, value)
9566 
      for key, value in self.__dict__.iteritems()]
9567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9568 
 
9569 
  def __eq__(self, other):
9570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9571 
 
9572 
  def __ne__(self, other):
9573 
    return not (self == other)
9574 
 
3064 chandransh 9575 
class markOrdersAsFailed_result:
9576 
  """
9577 
  Attributes:
9578 
   - ex
9579 
  """
1596 ankur.sing 9580 
 
1627 ankur.sing 9581 
  thrift_spec = (
3064 chandransh 9582 
    None, # 0
9583 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9584 
  )
9585 
 
3064 chandransh 9586 
  def __init__(self, ex=None,):
9587 
    self.ex = ex
9588 
 
1627 ankur.sing 9589 
  def read(self, iprot):
9590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9592 
      return
9593 
    iprot.readStructBegin()
9594 
    while True:
9595 
      (fname, ftype, fid) = iprot.readFieldBegin()
9596 
      if ftype == TType.STOP:
9597 
        break
3064 chandransh 9598 
      if fid == 1:
9599 
        if ftype == TType.STRUCT:
9600 
          self.ex = TransactionServiceException()
9601 
          self.ex.read(iprot)
9602 
        else:
9603 
          iprot.skip(ftype)
1627 ankur.sing 9604 
      else:
9605 
        iprot.skip(ftype)
9606 
      iprot.readFieldEnd()
9607 
    iprot.readStructEnd()
9608 
 
9609 
  def write(self, oprot):
9610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9612 
      return
3064 chandransh 9613 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 9614 
    if self.ex is not None:
3064 chandransh 9615 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9616 
      self.ex.write(oprot)
9617 
      oprot.writeFieldEnd()
1627 ankur.sing 9618 
    oprot.writeFieldStop()
9619 
    oprot.writeStructEnd()
9620 
 
3431 rajveer 9621 
  def validate(self):
9622 
    return
9623 
 
9624 
 
1627 ankur.sing 9625 
  def __repr__(self):
9626 
    L = ['%s=%r' % (key, value)
9627 
      for key, value in self.__dict__.iteritems()]
9628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9629 
 
9630 
  def __eq__(self, other):
9631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9632 
 
9633 
  def __ne__(self, other):
9634 
    return not (self == other)
9635 
 
3064 chandransh 9636 
class updateNonDeliveryReason_args:
1627 ankur.sing 9637 
  """
9638 
  Attributes:
3064 chandransh 9639 
   - providerId
9640 
   - undeliveredOrders
1627 ankur.sing 9641 
  """
9642 
 
9643 
  thrift_spec = (
3064 chandransh 9644 
    None, # 0
9645 
    (1, TType.I64, 'providerId', None, None, ), # 1
9646 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 9647 
  )
9648 
 
3064 chandransh 9649 
  def __init__(self, providerId=None, undeliveredOrders=None,):
9650 
    self.providerId = providerId
9651 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 9652 
 
9653 
  def read(self, iprot):
9654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9656 
      return
9657 
    iprot.readStructBegin()
9658 
    while True:
9659 
      (fname, ftype, fid) = iprot.readFieldBegin()
9660 
      if ftype == TType.STOP:
9661 
        break
3064 chandransh 9662 
      if fid == 1:
1627 ankur.sing 9663 
        if ftype == TType.I64:
3064 chandransh 9664 
          self.providerId = iprot.readI64();
1627 ankur.sing 9665 
        else:
9666 
          iprot.skip(ftype)
3064 chandransh 9667 
      elif fid == 2:
9668 
        if ftype == TType.MAP:
9669 
          self.undeliveredOrders = {}
4133 chandransh 9670 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
9671 
          for _i178 in xrange(_size174):
9672 
            _key179 = iprot.readString();
9673 
            _val180 = iprot.readString();
9674 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 9675 
          iprot.readMapEnd()
9676 
        else:
9677 
          iprot.skip(ftype)
1627 ankur.sing 9678 
      else:
9679 
        iprot.skip(ftype)
9680 
      iprot.readFieldEnd()
9681 
    iprot.readStructEnd()
9682 
 
9683 
  def write(self, oprot):
9684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9686 
      return
3064 chandransh 9687 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 9688 
    if self.providerId is not None:
3064 chandransh 9689 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9690 
      oprot.writeI64(self.providerId)
1627 ankur.sing 9691 
      oprot.writeFieldEnd()
3431 rajveer 9692 
    if self.undeliveredOrders is not None:
3064 chandransh 9693 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
9694 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 9695 
      for kiter181,viter182 in self.undeliveredOrders.items():
9696 
        oprot.writeString(kiter181)
9697 
        oprot.writeString(viter182)
3064 chandransh 9698 
      oprot.writeMapEnd()
9699 
      oprot.writeFieldEnd()
1627 ankur.sing 9700 
    oprot.writeFieldStop()
9701 
    oprot.writeStructEnd()
9702 
 
3431 rajveer 9703 
  def validate(self):
9704 
    return
9705 
 
9706 
 
1627 ankur.sing 9707 
  def __repr__(self):
9708 
    L = ['%s=%r' % (key, value)
9709 
      for key, value in self.__dict__.iteritems()]
9710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9711 
 
9712 
  def __eq__(self, other):
9713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9714 
 
9715 
  def __ne__(self, other):
9716 
    return not (self == other)
9717 
 
3064 chandransh 9718 
class updateNonDeliveryReason_result:
1627 ankur.sing 9719 
  """
9720 
  Attributes:
3064 chandransh 9721 
   - ex
1627 ankur.sing 9722 
  """
9723 
 
9724 
  thrift_spec = (
3064 chandransh 9725 
    None, # 0
9726 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9727 
  )
9728 
 
3064 chandransh 9729 
  def __init__(self, ex=None,):
9730 
    self.ex = ex
1627 ankur.sing 9731 
 
9732 
  def read(self, iprot):
9733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9735 
      return
9736 
    iprot.readStructBegin()
9737 
    while True:
9738 
      (fname, ftype, fid) = iprot.readFieldBegin()
9739 
      if ftype == TType.STOP:
9740 
        break
3064 chandransh 9741 
      if fid == 1:
9742 
        if ftype == TType.STRUCT:
9743 
          self.ex = TransactionServiceException()
9744 
          self.ex.read(iprot)
1627 ankur.sing 9745 
        else:
9746 
          iprot.skip(ftype)
9747 
      else:
9748 
        iprot.skip(ftype)
9749 
      iprot.readFieldEnd()
9750 
    iprot.readStructEnd()
9751 
 
9752 
  def write(self, oprot):
9753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9755 
      return
3064 chandransh 9756 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 9757 
    if self.ex is not None:
3064 chandransh 9758 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9759 
      self.ex.write(oprot)
1627 ankur.sing 9760 
      oprot.writeFieldEnd()
9761 
    oprot.writeFieldStop()
9762 
    oprot.writeStructEnd()
9763 
 
3431 rajveer 9764 
  def validate(self):
9765 
    return
9766 
 
9767 
 
1627 ankur.sing 9768 
  def __repr__(self):
9769 
    L = ['%s=%r' % (key, value)
9770 
      for key, value in self.__dict__.iteritems()]
9771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9772 
 
9773 
  def __eq__(self, other):
9774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9775 
 
9776 
  def __ne__(self, other):
9777 
    return not (self == other)
9778 
 
3064 chandransh 9779 
class getUndeliveredOrders_args:
1886 ankur.sing 9780 
  """
9781 
  Attributes:
3064 chandransh 9782 
   - providerId
9783 
   - warehouseId
1886 ankur.sing 9784 
  """
1627 ankur.sing 9785 
 
1886 ankur.sing 9786 
  thrift_spec = (
9787 
    None, # 0
3064 chandransh 9788 
    (1, TType.I64, 'providerId', None, None, ), # 1
9789 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 9790 
  )
9791 
 
3064 chandransh 9792 
  def __init__(self, providerId=None, warehouseId=None,):
9793 
    self.providerId = providerId
9794 
    self.warehouseId = warehouseId
1886 ankur.sing 9795 
 
9796 
  def read(self, iprot):
9797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9799 
      return
9800 
    iprot.readStructBegin()
9801 
    while True:
9802 
      (fname, ftype, fid) = iprot.readFieldBegin()
9803 
      if ftype == TType.STOP:
9804 
        break
9805 
      if fid == 1:
9806 
        if ftype == TType.I64:
3064 chandransh 9807 
          self.providerId = iprot.readI64();
1886 ankur.sing 9808 
        else:
9809 
          iprot.skip(ftype)
3064 chandransh 9810 
      elif fid == 2:
9811 
        if ftype == TType.I64:
9812 
          self.warehouseId = iprot.readI64();
9813 
        else:
9814 
          iprot.skip(ftype)
1886 ankur.sing 9815 
      else:
9816 
        iprot.skip(ftype)
9817 
      iprot.readFieldEnd()
9818 
    iprot.readStructEnd()
9819 
 
9820 
  def write(self, oprot):
9821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9823 
      return
3064 chandransh 9824 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 9825 
    if self.providerId is not None:
3064 chandransh 9826 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9827 
      oprot.writeI64(self.providerId)
1886 ankur.sing 9828 
      oprot.writeFieldEnd()
3431 rajveer 9829 
    if self.warehouseId is not None:
3064 chandransh 9830 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9831 
      oprot.writeI64(self.warehouseId)
9832 
      oprot.writeFieldEnd()
1886 ankur.sing 9833 
    oprot.writeFieldStop()
9834 
    oprot.writeStructEnd()
9835 
 
3431 rajveer 9836 
  def validate(self):
9837 
    return
9838 
 
9839 
 
1886 ankur.sing 9840 
  def __repr__(self):
9841 
    L = ['%s=%r' % (key, value)
9842 
      for key, value in self.__dict__.iteritems()]
9843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9844 
 
9845 
  def __eq__(self, other):
9846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9847 
 
9848 
  def __ne__(self, other):
9849 
    return not (self == other)
9850 
 
3064 chandransh 9851 
class getUndeliveredOrders_result:
1886 ankur.sing 9852 
  """
9853 
  Attributes:
9854 
   - success
9855 
  """
9856 
 
9857 
  thrift_spec = (
9858 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9859 
  )
9860 
 
9861 
  def __init__(self, success=None,):
9862 
    self.success = success
9863 
 
9864 
  def read(self, iprot):
9865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9867 
      return
9868 
    iprot.readStructBegin()
9869 
    while True:
9870 
      (fname, ftype, fid) = iprot.readFieldBegin()
9871 
      if ftype == TType.STOP:
9872 
        break
9873 
      if fid == 0:
9874 
        if ftype == TType.LIST:
9875 
          self.success = []
4133 chandransh 9876 
          (_etype186, _size183) = iprot.readListBegin()
9877 
          for _i187 in xrange(_size183):
9878 
            _elem188 = Order()
9879 
            _elem188.read(iprot)
9880 
            self.success.append(_elem188)
1886 ankur.sing 9881 
          iprot.readListEnd()
9882 
        else:
9883 
          iprot.skip(ftype)
9884 
      else:
9885 
        iprot.skip(ftype)
9886 
      iprot.readFieldEnd()
9887 
    iprot.readStructEnd()
9888 
 
9889 
  def write(self, oprot):
9890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9892 
      return
3064 chandransh 9893 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 9894 
    if self.success is not None:
1886 ankur.sing 9895 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9896 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9897 
      for iter189 in self.success:
9898 
        iter189.write(oprot)
1886 ankur.sing 9899 
      oprot.writeListEnd()
9900 
      oprot.writeFieldEnd()
9901 
    oprot.writeFieldStop()
9902 
    oprot.writeStructEnd()
9903 
 
3431 rajveer 9904 
  def validate(self):
9905 
    return
9906 
 
9907 
 
1886 ankur.sing 9908 
  def __repr__(self):
9909 
    L = ['%s=%r' % (key, value)
9910 
      for key, value in self.__dict__.iteritems()]
9911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9912 
 
9913 
  def __eq__(self, other):
9914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9915 
 
9916 
  def __ne__(self, other):
9917 
    return not (self == other)
9918 
 
2536 chandransh 9919 
class toggleDOAFlag_args:
9920 
  """
9921 
  Attributes:
9922 
   - orderId
9923 
  """
1886 ankur.sing 9924 
 
2536 chandransh 9925 
  thrift_spec = (
9926 
    None, # 0
9927 
    (1, TType.I64, 'orderId', None, None, ), # 1
9928 
  )
9929 
 
9930 
  def __init__(self, orderId=None,):
9931 
    self.orderId = orderId
9932 
 
9933 
  def read(self, iprot):
9934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9936 
      return
9937 
    iprot.readStructBegin()
9938 
    while True:
9939 
      (fname, ftype, fid) = iprot.readFieldBegin()
9940 
      if ftype == TType.STOP:
9941 
        break
9942 
      if fid == 1:
9943 
        if ftype == TType.I64:
9944 
          self.orderId = iprot.readI64();
9945 
        else:
9946 
          iprot.skip(ftype)
9947 
      else:
9948 
        iprot.skip(ftype)
9949 
      iprot.readFieldEnd()
9950 
    iprot.readStructEnd()
9951 
 
9952 
  def write(self, oprot):
9953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9955 
      return
9956 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 9957 
    if self.orderId is not None:
2536 chandransh 9958 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9959 
      oprot.writeI64(self.orderId)
9960 
      oprot.writeFieldEnd()
9961 
    oprot.writeFieldStop()
9962 
    oprot.writeStructEnd()
9963 
 
3431 rajveer 9964 
  def validate(self):
9965 
    return
9966 
 
9967 
 
2536 chandransh 9968 
  def __repr__(self):
9969 
    L = ['%s=%r' % (key, value)
9970 
      for key, value in self.__dict__.iteritems()]
9971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9972 
 
9973 
  def __eq__(self, other):
9974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9975 
 
9976 
  def __ne__(self, other):
9977 
    return not (self == other)
9978 
 
9979 
class toggleDOAFlag_result:
9980 
  """
9981 
  Attributes:
9982 
   - success
9983 
   - ex
9984 
  """
9985 
 
9986 
  thrift_spec = (
9987 
    (0, TType.BOOL, 'success', None, None, ), # 0
9988 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9989 
  )
9990 
 
9991 
  def __init__(self, success=None, ex=None,):
9992 
    self.success = success
9993 
    self.ex = ex
9994 
 
9995 
  def read(self, iprot):
9996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9998 
      return
9999 
    iprot.readStructBegin()
10000 
    while True:
10001 
      (fname, ftype, fid) = iprot.readFieldBegin()
10002 
      if ftype == TType.STOP:
10003 
        break
10004 
      if fid == 0:
10005 
        if ftype == TType.BOOL:
10006 
          self.success = iprot.readBool();
10007 
        else:
10008 
          iprot.skip(ftype)
10009 
      elif fid == 1:
10010 
        if ftype == TType.STRUCT:
10011 
          self.ex = TransactionServiceException()
10012 
          self.ex.read(iprot)
10013 
        else:
10014 
          iprot.skip(ftype)
10015 
      else:
10016 
        iprot.skip(ftype)
10017 
      iprot.readFieldEnd()
10018 
    iprot.readStructEnd()
10019 
 
10020 
  def write(self, oprot):
10021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10023 
      return
10024 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 10025 
    if self.success is not None:
2536 chandransh 10026 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10027 
      oprot.writeBool(self.success)
10028 
      oprot.writeFieldEnd()
3431 rajveer 10029 
    if self.ex is not None:
2536 chandransh 10030 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10031 
      self.ex.write(oprot)
10032 
      oprot.writeFieldEnd()
10033 
    oprot.writeFieldStop()
10034 
    oprot.writeStructEnd()
10035 
 
3431 rajveer 10036 
  def validate(self):
10037 
    return
10038 
 
10039 
 
2536 chandransh 10040 
  def __repr__(self):
10041 
    L = ['%s=%r' % (key, value)
10042 
      for key, value in self.__dict__.iteritems()]
10043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10044 
 
10045 
  def __eq__(self, other):
10046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10047 
 
10048 
  def __ne__(self, other):
10049 
    return not (self == other)
10050 
 
10051 
class requestPickupNumber_args:
10052 
  """
10053 
  Attributes:
10054 
   - orderId
10055 
  """
10056 
 
10057 
  thrift_spec = (
10058 
    None, # 0
10059 
    (1, TType.I64, 'orderId', None, None, ), # 1
10060 
  )
10061 
 
10062 
  def __init__(self, orderId=None,):
10063 
    self.orderId = orderId
10064 
 
10065 
  def read(self, iprot):
10066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10068 
      return
10069 
    iprot.readStructBegin()
10070 
    while True:
10071 
      (fname, ftype, fid) = iprot.readFieldBegin()
10072 
      if ftype == TType.STOP:
10073 
        break
10074 
      if fid == 1:
10075 
        if ftype == TType.I64:
10076 
          self.orderId = iprot.readI64();
10077 
        else:
10078 
          iprot.skip(ftype)
10079 
      else:
10080 
        iprot.skip(ftype)
10081 
      iprot.readFieldEnd()
10082 
    iprot.readStructEnd()
10083 
 
10084 
  def write(self, oprot):
10085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10087 
      return
10088 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 10089 
    if self.orderId is not None:
2536 chandransh 10090 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10091 
      oprot.writeI64(self.orderId)
10092 
      oprot.writeFieldEnd()
10093 
    oprot.writeFieldStop()
10094 
    oprot.writeStructEnd()
10095 
 
3431 rajveer 10096 
  def validate(self):
10097 
    return
10098 
 
10099 
 
2536 chandransh 10100 
  def __repr__(self):
10101 
    L = ['%s=%r' % (key, value)
10102 
      for key, value in self.__dict__.iteritems()]
10103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10104 
 
10105 
  def __eq__(self, other):
10106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10107 
 
10108 
  def __ne__(self, other):
10109 
    return not (self == other)
10110 
 
10111 
class requestPickupNumber_result:
10112 
  """
10113 
  Attributes:
10114 
   - success
10115 
   - ex
10116 
  """
10117 
 
10118 
  thrift_spec = (
10119 
    (0, TType.BOOL, 'success', None, None, ), # 0
10120 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10121 
  )
10122 
 
10123 
  def __init__(self, success=None, ex=None,):
10124 
    self.success = success
10125 
    self.ex = ex
10126 
 
10127 
  def read(self, iprot):
10128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10130 
      return
10131 
    iprot.readStructBegin()
10132 
    while True:
10133 
      (fname, ftype, fid) = iprot.readFieldBegin()
10134 
      if ftype == TType.STOP:
10135 
        break
10136 
      if fid == 0:
10137 
        if ftype == TType.BOOL:
10138 
          self.success = iprot.readBool();
10139 
        else:
10140 
          iprot.skip(ftype)
10141 
      elif fid == 1:
10142 
        if ftype == TType.STRUCT:
10143 
          self.ex = TransactionServiceException()
10144 
          self.ex.read(iprot)
10145 
        else:
10146 
          iprot.skip(ftype)
10147 
      else:
10148 
        iprot.skip(ftype)
10149 
      iprot.readFieldEnd()
10150 
    iprot.readStructEnd()
10151 
 
10152 
  def write(self, oprot):
10153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10155 
      return
10156 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 10157 
    if self.success is not None:
2536 chandransh 10158 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10159 
      oprot.writeBool(self.success)
10160 
      oprot.writeFieldEnd()
3431 rajveer 10161 
    if self.ex is not None:
2536 chandransh 10162 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10163 
      self.ex.write(oprot)
10164 
      oprot.writeFieldEnd()
10165 
    oprot.writeFieldStop()
10166 
    oprot.writeStructEnd()
10167 
 
3431 rajveer 10168 
  def validate(self):
10169 
    return
10170 
 
10171 
 
2536 chandransh 10172 
  def __repr__(self):
10173 
    L = ['%s=%r' % (key, value)
10174 
      for key, value in self.__dict__.iteritems()]
10175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10176 
 
10177 
  def __eq__(self, other):
10178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10179 
 
10180 
  def __ne__(self, other):
10181 
    return not (self == other)
10182 
 
10183 
class authorizePickup_args:
10184 
  """
10185 
  Attributes:
10186 
   - orderId
10187 
   - pickupNumber
10188 
  """
10189 
 
10190 
  thrift_spec = (
10191 
    None, # 0
10192 
    (1, TType.I64, 'orderId', None, None, ), # 1
10193 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
10194 
  )
10195 
 
10196 
  def __init__(self, orderId=None, pickupNumber=None,):
10197 
    self.orderId = orderId
10198 
    self.pickupNumber = pickupNumber
10199 
 
10200 
  def read(self, iprot):
10201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10203 
      return
10204 
    iprot.readStructBegin()
10205 
    while True:
10206 
      (fname, ftype, fid) = iprot.readFieldBegin()
10207 
      if ftype == TType.STOP:
10208 
        break
10209 
      if fid == 1:
10210 
        if ftype == TType.I64:
10211 
          self.orderId = iprot.readI64();
10212 
        else:
10213 
          iprot.skip(ftype)
10214 
      elif fid == 2:
10215 
        if ftype == TType.STRING:
10216 
          self.pickupNumber = iprot.readString();
10217 
        else:
10218 
          iprot.skip(ftype)
10219 
      else:
10220 
        iprot.skip(ftype)
10221 
      iprot.readFieldEnd()
10222 
    iprot.readStructEnd()
10223 
 
10224 
  def write(self, oprot):
10225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10227 
      return
10228 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 10229 
    if self.orderId is not None:
2536 chandransh 10230 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10231 
      oprot.writeI64(self.orderId)
10232 
      oprot.writeFieldEnd()
3431 rajveer 10233 
    if self.pickupNumber is not None:
2536 chandransh 10234 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
10235 
      oprot.writeString(self.pickupNumber)
10236 
      oprot.writeFieldEnd()
10237 
    oprot.writeFieldStop()
10238 
    oprot.writeStructEnd()
10239 
 
3431 rajveer 10240 
  def validate(self):
10241 
    return
10242 
 
10243 
 
2536 chandransh 10244 
  def __repr__(self):
10245 
    L = ['%s=%r' % (key, value)
10246 
      for key, value in self.__dict__.iteritems()]
10247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10248 
 
10249 
  def __eq__(self, other):
10250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10251 
 
10252 
  def __ne__(self, other):
10253 
    return not (self == other)
10254 
 
10255 
class authorizePickup_result:
10256 
  """
10257 
  Attributes:
10258 
   - success
10259 
   - ex
10260 
  """
10261 
 
10262 
  thrift_spec = (
10263 
    (0, TType.BOOL, 'success', None, None, ), # 0
10264 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10265 
  )
10266 
 
10267 
  def __init__(self, success=None, ex=None,):
10268 
    self.success = success
10269 
    self.ex = ex
10270 
 
10271 
  def read(self, iprot):
10272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10274 
      return
10275 
    iprot.readStructBegin()
10276 
    while True:
10277 
      (fname, ftype, fid) = iprot.readFieldBegin()
10278 
      if ftype == TType.STOP:
10279 
        break
10280 
      if fid == 0:
10281 
        if ftype == TType.BOOL:
10282 
          self.success = iprot.readBool();
10283 
        else:
10284 
          iprot.skip(ftype)
10285 
      elif fid == 1:
10286 
        if ftype == TType.STRUCT:
10287 
          self.ex = TransactionServiceException()
10288 
          self.ex.read(iprot)
10289 
        else:
10290 
          iprot.skip(ftype)
10291 
      else:
10292 
        iprot.skip(ftype)
10293 
      iprot.readFieldEnd()
10294 
    iprot.readStructEnd()
10295 
 
10296 
  def write(self, oprot):
10297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10299 
      return
10300 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 10301 
    if self.success is not None:
2536 chandransh 10302 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10303 
      oprot.writeBool(self.success)
10304 
      oprot.writeFieldEnd()
3431 rajveer 10305 
    if self.ex is not None:
2536 chandransh 10306 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10307 
      self.ex.write(oprot)
10308 
      oprot.writeFieldEnd()
10309 
    oprot.writeFieldStop()
10310 
    oprot.writeStructEnd()
10311 
 
3431 rajveer 10312 
  def validate(self):
10313 
    return
10314 
 
10315 
 
2536 chandransh 10316 
  def __repr__(self):
10317 
    L = ['%s=%r' % (key, value)
10318 
      for key, value in self.__dict__.iteritems()]
10319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10320 
 
10321 
  def __eq__(self, other):
10322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10323 
 
10324 
  def __ne__(self, other):
10325 
    return not (self == other)
10326 
 
2764 chandransh 10327 
class markDoasAsPickedUp_args:
10328 
  """
10329 
  Attributes:
10330 
   - providerId
10331 
   - pickupDetails
10332 
  """
10333 
 
10334 
  thrift_spec = (
10335 
    None, # 0
10336 
    (1, TType.I64, 'providerId', None, None, ), # 1
10337 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
10338 
  )
10339 
 
10340 
  def __init__(self, providerId=None, pickupDetails=None,):
10341 
    self.providerId = providerId
10342 
    self.pickupDetails = pickupDetails
10343 
 
10344 
  def read(self, iprot):
10345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10347 
      return
10348 
    iprot.readStructBegin()
10349 
    while True:
10350 
      (fname, ftype, fid) = iprot.readFieldBegin()
10351 
      if ftype == TType.STOP:
10352 
        break
10353 
      if fid == 1:
10354 
        if ftype == TType.I64:
10355 
          self.providerId = iprot.readI64();
10356 
        else:
10357 
          iprot.skip(ftype)
10358 
      elif fid == 2:
10359 
        if ftype == TType.MAP:
10360 
          self.pickupDetails = {}
4133 chandransh 10361 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
10362 
          for _i194 in xrange(_size190):
10363 
            _key195 = iprot.readString();
10364 
            _val196 = iprot.readString();
10365 
            self.pickupDetails[_key195] = _val196
2764 chandransh 10366 
          iprot.readMapEnd()
10367 
        else:
10368 
          iprot.skip(ftype)
10369 
      else:
10370 
        iprot.skip(ftype)
10371 
      iprot.readFieldEnd()
10372 
    iprot.readStructEnd()
10373 
 
10374 
  def write(self, oprot):
10375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10377 
      return
10378 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 10379 
    if self.providerId is not None:
2764 chandransh 10380 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10381 
      oprot.writeI64(self.providerId)
10382 
      oprot.writeFieldEnd()
3431 rajveer 10383 
    if self.pickupDetails is not None:
2764 chandransh 10384 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10385 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10386 
      for kiter197,viter198 in self.pickupDetails.items():
10387 
        oprot.writeString(kiter197)
10388 
        oprot.writeString(viter198)
2764 chandransh 10389 
      oprot.writeMapEnd()
10390 
      oprot.writeFieldEnd()
10391 
    oprot.writeFieldStop()
10392 
    oprot.writeStructEnd()
10393 
 
3431 rajveer 10394 
  def validate(self):
10395 
    return
10396 
 
10397 
 
2764 chandransh 10398 
  def __repr__(self):
10399 
    L = ['%s=%r' % (key, value)
10400 
      for key, value in self.__dict__.iteritems()]
10401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10402 
 
10403 
  def __eq__(self, other):
10404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10405 
 
10406 
  def __ne__(self, other):
10407 
    return not (self == other)
10408 
 
10409 
class markDoasAsPickedUp_result:
10410 
  """
10411 
  Attributes:
10412 
   - success
10413 
  """
10414 
 
10415 
  thrift_spec = (
10416 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10417 
  )
10418 
 
10419 
  def __init__(self, success=None,):
10420 
    self.success = success
10421 
 
10422 
  def read(self, iprot):
10423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10425 
      return
10426 
    iprot.readStructBegin()
10427 
    while True:
10428 
      (fname, ftype, fid) = iprot.readFieldBegin()
10429 
      if ftype == TType.STOP:
10430 
        break
10431 
      if fid == 0:
10432 
        if ftype == TType.LIST:
10433 
          self.success = []
4133 chandransh 10434 
          (_etype202, _size199) = iprot.readListBegin()
10435 
          for _i203 in xrange(_size199):
10436 
            _elem204 = Order()
10437 
            _elem204.read(iprot)
10438 
            self.success.append(_elem204)
2764 chandransh 10439 
          iprot.readListEnd()
10440 
        else:
10441 
          iprot.skip(ftype)
10442 
      else:
10443 
        iprot.skip(ftype)
10444 
      iprot.readFieldEnd()
10445 
    iprot.readStructEnd()
10446 
 
10447 
  def write(self, oprot):
10448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10450 
      return
10451 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 10452 
    if self.success is not None:
2764 chandransh 10453 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10454 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10455 
      for iter205 in self.success:
10456 
        iter205.write(oprot)
2764 chandransh 10457 
      oprot.writeListEnd()
10458 
      oprot.writeFieldEnd()
10459 
    oprot.writeFieldStop()
10460 
    oprot.writeStructEnd()
10461 
 
3431 rajveer 10462 
  def validate(self):
10463 
    return
10464 
 
10465 
 
2764 chandransh 10466 
  def __repr__(self):
10467 
    L = ['%s=%r' % (key, value)
10468 
      for key, value in self.__dict__.iteritems()]
10469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10470 
 
10471 
  def __eq__(self, other):
10472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10473 
 
10474 
  def __ne__(self, other):
10475 
    return not (self == other)
10476 
 
2616 chandransh 10477 
class receiveReturn_args:
2591 chandransh 10478 
  """
10479 
  Attributes:
10480 
   - orderId
10481 
  """
2536 chandransh 10482 
 
2591 chandransh 10483 
  thrift_spec = (
10484 
    None, # 0
10485 
    (1, TType.I64, 'orderId', None, None, ), # 1
10486 
  )
10487 
 
10488 
  def __init__(self, orderId=None,):
10489 
    self.orderId = orderId
10490 
 
10491 
  def read(self, iprot):
10492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10494 
      return
10495 
    iprot.readStructBegin()
10496 
    while True:
10497 
      (fname, ftype, fid) = iprot.readFieldBegin()
10498 
      if ftype == TType.STOP:
10499 
        break
10500 
      if fid == 1:
10501 
        if ftype == TType.I64:
10502 
          self.orderId = iprot.readI64();
10503 
        else:
10504 
          iprot.skip(ftype)
10505 
      else:
10506 
        iprot.skip(ftype)
10507 
      iprot.readFieldEnd()
10508 
    iprot.readStructEnd()
10509 
 
10510 
  def write(self, oprot):
10511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10513 
      return
2616 chandransh 10514 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 10515 
    if self.orderId is not None:
2591 chandransh 10516 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10517 
      oprot.writeI64(self.orderId)
10518 
      oprot.writeFieldEnd()
10519 
    oprot.writeFieldStop()
10520 
    oprot.writeStructEnd()
10521 
 
3431 rajveer 10522 
  def validate(self):
10523 
    return
10524 
 
10525 
 
2591 chandransh 10526 
  def __repr__(self):
10527 
    L = ['%s=%r' % (key, value)
10528 
      for key, value in self.__dict__.iteritems()]
10529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10530 
 
10531 
  def __eq__(self, other):
10532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10533 
 
10534 
  def __ne__(self, other):
10535 
    return not (self == other)
10536 
 
2616 chandransh 10537 
class receiveReturn_result:
2591 chandransh 10538 
  """
10539 
  Attributes:
10540 
   - success
10541 
   - ex
10542 
  """
10543 
 
10544 
  thrift_spec = (
10545 
    (0, TType.BOOL, 'success', None, None, ), # 0
10546 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10547 
  )
10548 
 
10549 
  def __init__(self, success=None, ex=None,):
10550 
    self.success = success
10551 
    self.ex = ex
10552 
 
10553 
  def read(self, iprot):
10554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10556 
      return
10557 
    iprot.readStructBegin()
10558 
    while True:
10559 
      (fname, ftype, fid) = iprot.readFieldBegin()
10560 
      if ftype == TType.STOP:
10561 
        break
10562 
      if fid == 0:
10563 
        if ftype == TType.BOOL:
10564 
          self.success = iprot.readBool();
10565 
        else:
10566 
          iprot.skip(ftype)
10567 
      elif fid == 1:
10568 
        if ftype == TType.STRUCT:
10569 
          self.ex = TransactionServiceException()
10570 
          self.ex.read(iprot)
10571 
        else:
10572 
          iprot.skip(ftype)
10573 
      else:
10574 
        iprot.skip(ftype)
10575 
      iprot.readFieldEnd()
10576 
    iprot.readStructEnd()
10577 
 
10578 
  def write(self, oprot):
10579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10581 
      return
2616 chandransh 10582 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 10583 
    if self.success is not None:
2591 chandransh 10584 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10585 
      oprot.writeBool(self.success)
10586 
      oprot.writeFieldEnd()
3431 rajveer 10587 
    if self.ex is not None:
2591 chandransh 10588 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10589 
      self.ex.write(oprot)
10590 
      oprot.writeFieldEnd()
10591 
    oprot.writeFieldStop()
10592 
    oprot.writeStructEnd()
10593 
 
3431 rajveer 10594 
  def validate(self):
10595 
    return
10596 
 
10597 
 
2591 chandransh 10598 
  def __repr__(self):
10599 
    L = ['%s=%r' % (key, value)
10600 
      for key, value in self.__dict__.iteritems()]
10601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10602 
 
10603 
  def __eq__(self, other):
10604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10605 
 
10606 
  def __ne__(self, other):
10607 
    return not (self == other)
10608 
 
10609 
class validateDoa_args:
10610 
  """
10611 
  Attributes:
10612 
   - orderId
10613 
   - isValid
10614 
  """
10615 
 
10616 
  thrift_spec = (
10617 
    None, # 0
10618 
    (1, TType.I64, 'orderId', None, None, ), # 1
10619 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
10620 
  )
10621 
 
10622 
  def __init__(self, orderId=None, isValid=None,):
10623 
    self.orderId = orderId
10624 
    self.isValid = isValid
10625 
 
10626 
  def read(self, iprot):
10627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10629 
      return
10630 
    iprot.readStructBegin()
10631 
    while True:
10632 
      (fname, ftype, fid) = iprot.readFieldBegin()
10633 
      if ftype == TType.STOP:
10634 
        break
10635 
      if fid == 1:
10636 
        if ftype == TType.I64:
10637 
          self.orderId = iprot.readI64();
10638 
        else:
10639 
          iprot.skip(ftype)
10640 
      elif fid == 2:
10641 
        if ftype == TType.BOOL:
10642 
          self.isValid = iprot.readBool();
10643 
        else:
10644 
          iprot.skip(ftype)
10645 
      else:
10646 
        iprot.skip(ftype)
10647 
      iprot.readFieldEnd()
10648 
    iprot.readStructEnd()
10649 
 
10650 
  def write(self, oprot):
10651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10653 
      return
10654 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 10655 
    if self.orderId is not None:
2591 chandransh 10656 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10657 
      oprot.writeI64(self.orderId)
10658 
      oprot.writeFieldEnd()
3431 rajveer 10659 
    if self.isValid is not None:
2591 chandransh 10660 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
10661 
      oprot.writeBool(self.isValid)
10662 
      oprot.writeFieldEnd()
10663 
    oprot.writeFieldStop()
10664 
    oprot.writeStructEnd()
10665 
 
3431 rajveer 10666 
  def validate(self):
10667 
    return
10668 
 
10669 
 
2591 chandransh 10670 
  def __repr__(self):
10671 
    L = ['%s=%r' % (key, value)
10672 
      for key, value in self.__dict__.iteritems()]
10673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10674 
 
10675 
  def __eq__(self, other):
10676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10677 
 
10678 
  def __ne__(self, other):
10679 
    return not (self == other)
10680 
 
10681 
class validateDoa_result:
10682 
  """
10683 
  Attributes:
10684 
   - success
10685 
   - ex
10686 
  """
10687 
 
10688 
  thrift_spec = (
10689 
    (0, TType.BOOL, 'success', None, None, ), # 0
10690 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10691 
  )
10692 
 
10693 
  def __init__(self, success=None, ex=None,):
10694 
    self.success = success
10695 
    self.ex = ex
10696 
 
10697 
  def read(self, iprot):
10698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10700 
      return
10701 
    iprot.readStructBegin()
10702 
    while True:
10703 
      (fname, ftype, fid) = iprot.readFieldBegin()
10704 
      if ftype == TType.STOP:
10705 
        break
10706 
      if fid == 0:
10707 
        if ftype == TType.BOOL:
10708 
          self.success = iprot.readBool();
10709 
        else:
10710 
          iprot.skip(ftype)
10711 
      elif fid == 1:
10712 
        if ftype == TType.STRUCT:
10713 
          self.ex = TransactionServiceException()
10714 
          self.ex.read(iprot)
10715 
        else:
10716 
          iprot.skip(ftype)
10717 
      else:
10718 
        iprot.skip(ftype)
10719 
      iprot.readFieldEnd()
10720 
    iprot.readStructEnd()
10721 
 
10722 
  def write(self, oprot):
10723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10725 
      return
10726 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 10727 
    if self.success is not None:
2591 chandransh 10728 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10729 
      oprot.writeBool(self.success)
10730 
      oprot.writeFieldEnd()
3431 rajveer 10731 
    if self.ex is not None:
2591 chandransh 10732 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10733 
      self.ex.write(oprot)
10734 
      oprot.writeFieldEnd()
10735 
    oprot.writeFieldStop()
10736 
    oprot.writeStructEnd()
10737 
 
3431 rajveer 10738 
  def validate(self):
10739 
    return
10740 
 
10741 
 
2591 chandransh 10742 
  def __repr__(self):
10743 
    L = ['%s=%r' % (key, value)
10744 
      for key, value in self.__dict__.iteritems()]
10745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10746 
 
10747 
  def __eq__(self, other):
10748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10749 
 
10750 
  def __ne__(self, other):
10751 
    return not (self == other)
10752 
 
2616 chandransh 10753 
class reshipOrder_args:
10754 
  """
10755 
  Attributes:
10756 
   - orderId
10757 
  """
2591 chandransh 10758 
 
2616 chandransh 10759 
  thrift_spec = (
10760 
    None, # 0
10761 
    (1, TType.I64, 'orderId', None, None, ), # 1
10762 
  )
10763 
 
10764 
  def __init__(self, orderId=None,):
10765 
    self.orderId = orderId
10766 
 
10767 
  def read(self, iprot):
10768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10770 
      return
10771 
    iprot.readStructBegin()
10772 
    while True:
10773 
      (fname, ftype, fid) = iprot.readFieldBegin()
10774 
      if ftype == TType.STOP:
10775 
        break
10776 
      if fid == 1:
10777 
        if ftype == TType.I64:
10778 
          self.orderId = iprot.readI64();
10779 
        else:
10780 
          iprot.skip(ftype)
10781 
      else:
10782 
        iprot.skip(ftype)
10783 
      iprot.readFieldEnd()
10784 
    iprot.readStructEnd()
10785 
 
10786 
  def write(self, oprot):
10787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10789 
      return
10790 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 10791 
    if self.orderId is not None:
2616 chandransh 10792 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10793 
      oprot.writeI64(self.orderId)
10794 
      oprot.writeFieldEnd()
10795 
    oprot.writeFieldStop()
10796 
    oprot.writeStructEnd()
10797 
 
3431 rajveer 10798 
  def validate(self):
10799 
    return
10800 
 
10801 
 
2616 chandransh 10802 
  def __repr__(self):
10803 
    L = ['%s=%r' % (key, value)
10804 
      for key, value in self.__dict__.iteritems()]
10805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10806 
 
10807 
  def __eq__(self, other):
10808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10809 
 
10810 
  def __ne__(self, other):
10811 
    return not (self == other)
10812 
 
10813 
class reshipOrder_result:
10814 
  """
10815 
  Attributes:
10816 
   - success
10817 
   - ex
10818 
  """
10819 
 
10820 
  thrift_spec = (
10821 
    (0, TType.I64, 'success', None, None, ), # 0
10822 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10823 
  )
10824 
 
10825 
  def __init__(self, success=None, ex=None,):
10826 
    self.success = success
10827 
    self.ex = ex
10828 
 
10829 
  def read(self, iprot):
10830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10832 
      return
10833 
    iprot.readStructBegin()
10834 
    while True:
10835 
      (fname, ftype, fid) = iprot.readFieldBegin()
10836 
      if ftype == TType.STOP:
10837 
        break
10838 
      if fid == 0:
10839 
        if ftype == TType.I64:
10840 
          self.success = iprot.readI64();
10841 
        else:
10842 
          iprot.skip(ftype)
10843 
      elif fid == 1:
10844 
        if ftype == TType.STRUCT:
10845 
          self.ex = TransactionServiceException()
10846 
          self.ex.read(iprot)
10847 
        else:
10848 
          iprot.skip(ftype)
10849 
      else:
10850 
        iprot.skip(ftype)
10851 
      iprot.readFieldEnd()
10852 
    iprot.readStructEnd()
10853 
 
10854 
  def write(self, oprot):
10855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10857 
      return
10858 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 10859 
    if self.success is not None:
2616 chandransh 10860 
      oprot.writeFieldBegin('success', TType.I64, 0)
10861 
      oprot.writeI64(self.success)
10862 
      oprot.writeFieldEnd()
3431 rajveer 10863 
    if self.ex is not None:
2616 chandransh 10864 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10865 
      self.ex.write(oprot)
10866 
      oprot.writeFieldEnd()
10867 
    oprot.writeFieldStop()
10868 
    oprot.writeStructEnd()
10869 
 
3431 rajveer 10870 
  def validate(self):
10871 
    return
10872 
 
10873 
 
2616 chandransh 10874 
  def __repr__(self):
10875 
    L = ['%s=%r' % (key, value)
10876 
      for key, value in self.__dict__.iteritems()]
10877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10878 
 
10879 
  def __eq__(self, other):
10880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10881 
 
10882 
  def __ne__(self, other):
10883 
    return not (self == other)
10884 
 
10885 
class refundOrder_args:
10886 
  """
10887 
  Attributes:
10888 
   - orderId
3226 chandransh 10889 
   - refundedBy
10890 
   - reason
2616 chandransh 10891 
  """
10892 
 
10893 
  thrift_spec = (
10894 
    None, # 0
10895 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 10896 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
10897 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 10898 
  )
10899 
 
3226 chandransh 10900 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 10901 
    self.orderId = orderId
3226 chandransh 10902 
    self.refundedBy = refundedBy
10903 
    self.reason = reason
2616 chandransh 10904 
 
10905 
  def read(self, iprot):
10906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10908 
      return
10909 
    iprot.readStructBegin()
10910 
    while True:
10911 
      (fname, ftype, fid) = iprot.readFieldBegin()
10912 
      if ftype == TType.STOP:
10913 
        break
10914 
      if fid == 1:
10915 
        if ftype == TType.I64:
10916 
          self.orderId = iprot.readI64();
10917 
        else:
10918 
          iprot.skip(ftype)
3226 chandransh 10919 
      elif fid == 2:
10920 
        if ftype == TType.STRING:
10921 
          self.refundedBy = iprot.readString();
10922 
        else:
10923 
          iprot.skip(ftype)
10924 
      elif fid == 3:
10925 
        if ftype == TType.STRING:
10926 
          self.reason = iprot.readString();
10927 
        else:
10928 
          iprot.skip(ftype)
2616 chandransh 10929 
      else:
10930 
        iprot.skip(ftype)
10931 
      iprot.readFieldEnd()
10932 
    iprot.readStructEnd()
10933 
 
10934 
  def write(self, oprot):
10935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10937 
      return
10938 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 10939 
    if self.orderId is not None:
2616 chandransh 10940 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10941 
      oprot.writeI64(self.orderId)
10942 
      oprot.writeFieldEnd()
3431 rajveer 10943 
    if self.refundedBy is not None:
3226 chandransh 10944 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
10945 
      oprot.writeString(self.refundedBy)
10946 
      oprot.writeFieldEnd()
3431 rajveer 10947 
    if self.reason is not None:
3226 chandransh 10948 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
10949 
      oprot.writeString(self.reason)
10950 
      oprot.writeFieldEnd()
2616 chandransh 10951 
    oprot.writeFieldStop()
10952 
    oprot.writeStructEnd()
10953 
 
3431 rajveer 10954 
  def validate(self):
10955 
    return
10956 
 
10957 
 
2616 chandransh 10958 
  def __repr__(self):
10959 
    L = ['%s=%r' % (key, value)
10960 
      for key, value in self.__dict__.iteritems()]
10961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10962 
 
10963 
  def __eq__(self, other):
10964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10965 
 
10966 
  def __ne__(self, other):
10967 
    return not (self == other)
10968 
 
10969 
class refundOrder_result:
10970 
  """
10971 
  Attributes:
10972 
   - success
10973 
   - ex
10974 
  """
10975 
 
10976 
  thrift_spec = (
10977 
    (0, TType.BOOL, 'success', None, None, ), # 0
10978 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10979 
  )
10980 
 
10981 
  def __init__(self, success=None, ex=None,):
10982 
    self.success = success
10983 
    self.ex = ex
10984 
 
10985 
  def read(self, iprot):
10986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10988 
      return
10989 
    iprot.readStructBegin()
10990 
    while True:
10991 
      (fname, ftype, fid) = iprot.readFieldBegin()
10992 
      if ftype == TType.STOP:
10993 
        break
10994 
      if fid == 0:
10995 
        if ftype == TType.BOOL:
10996 
          self.success = iprot.readBool();
10997 
        else:
10998 
          iprot.skip(ftype)
10999 
      elif fid == 1:
11000 
        if ftype == TType.STRUCT:
11001 
          self.ex = TransactionServiceException()
11002 
          self.ex.read(iprot)
11003 
        else:
11004 
          iprot.skip(ftype)
11005 
      else:
11006 
        iprot.skip(ftype)
11007 
      iprot.readFieldEnd()
11008 
    iprot.readStructEnd()
11009 
 
11010 
  def write(self, oprot):
11011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11013 
      return
11014 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 11015 
    if self.success is not None:
2616 chandransh 11016 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11017 
      oprot.writeBool(self.success)
11018 
      oprot.writeFieldEnd()
3431 rajveer 11019 
    if self.ex is not None:
2616 chandransh 11020 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11021 
      self.ex.write(oprot)
11022 
      oprot.writeFieldEnd()
11023 
    oprot.writeFieldStop()
11024 
    oprot.writeStructEnd()
11025 
 
3431 rajveer 11026 
  def validate(self):
11027 
    return
11028 
 
11029 
 
2616 chandransh 11030 
  def __repr__(self):
11031 
    L = ['%s=%r' % (key, value)
11032 
      for key, value in self.__dict__.iteritems()]
11033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11034 
 
11035 
  def __eq__(self, other):
11036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11037 
 
11038 
  def __ne__(self, other):
11039 
    return not (self == other)
11040 
 
2690 chandransh 11041 
class getReturnOrders_args:
11042 
  """
11043 
  Attributes:
11044 
   - warehouseId
11045 
   - fromDate
11046 
   - toDate
11047 
  """
2616 chandransh 11048 
 
2690 chandransh 11049 
  thrift_spec = (
11050 
    None, # 0
11051 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11052 
    (2, TType.I64, 'fromDate', None, None, ), # 2
11053 
    (3, TType.I64, 'toDate', None, None, ), # 3
11054 
  )
11055 
 
11056 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
11057 
    self.warehouseId = warehouseId
11058 
    self.fromDate = fromDate
11059 
    self.toDate = toDate
11060 
 
11061 
  def read(self, iprot):
11062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11064 
      return
11065 
    iprot.readStructBegin()
11066 
    while True:
11067 
      (fname, ftype, fid) = iprot.readFieldBegin()
11068 
      if ftype == TType.STOP:
11069 
        break
11070 
      if fid == 1:
11071 
        if ftype == TType.I64:
11072 
          self.warehouseId = iprot.readI64();
11073 
        else:
11074 
          iprot.skip(ftype)
11075 
      elif fid == 2:
11076 
        if ftype == TType.I64:
11077 
          self.fromDate = iprot.readI64();
11078 
        else:
11079 
          iprot.skip(ftype)
11080 
      elif fid == 3:
11081 
        if ftype == TType.I64:
11082 
          self.toDate = iprot.readI64();
11083 
        else:
11084 
          iprot.skip(ftype)
11085 
      else:
11086 
        iprot.skip(ftype)
11087 
      iprot.readFieldEnd()
11088 
    iprot.readStructEnd()
11089 
 
11090 
  def write(self, oprot):
11091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11093 
      return
11094 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 11095 
    if self.warehouseId is not None:
2690 chandransh 11096 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11097 
      oprot.writeI64(self.warehouseId)
11098 
      oprot.writeFieldEnd()
3431 rajveer 11099 
    if self.fromDate is not None:
2690 chandransh 11100 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
11101 
      oprot.writeI64(self.fromDate)
11102 
      oprot.writeFieldEnd()
3431 rajveer 11103 
    if self.toDate is not None:
2690 chandransh 11104 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
11105 
      oprot.writeI64(self.toDate)
11106 
      oprot.writeFieldEnd()
11107 
    oprot.writeFieldStop()
11108 
    oprot.writeStructEnd()
11109 
 
3431 rajveer 11110 
  def validate(self):
11111 
    return
11112 
 
11113 
 
2690 chandransh 11114 
  def __repr__(self):
11115 
    L = ['%s=%r' % (key, value)
11116 
      for key, value in self.__dict__.iteritems()]
11117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11118 
 
11119 
  def __eq__(self, other):
11120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11121 
 
11122 
  def __ne__(self, other):
11123 
    return not (self == other)
11124 
 
11125 
class getReturnOrders_result:
11126 
  """
11127 
  Attributes:
11128 
   - success
11129 
  """
11130 
 
11131 
  thrift_spec = (
11132 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
11133 
  )
11134 
 
11135 
  def __init__(self, success=None,):
11136 
    self.success = success
11137 
 
11138 
  def read(self, iprot):
11139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11141 
      return
11142 
    iprot.readStructBegin()
11143 
    while True:
11144 
      (fname, ftype, fid) = iprot.readFieldBegin()
11145 
      if ftype == TType.STOP:
11146 
        break
11147 
      if fid == 0:
11148 
        if ftype == TType.LIST:
11149 
          self.success = []
4133 chandransh 11150 
          (_etype209, _size206) = iprot.readListBegin()
11151 
          for _i210 in xrange(_size206):
11152 
            _elem211 = ReturnOrder()
11153 
            _elem211.read(iprot)
11154 
            self.success.append(_elem211)
2690 chandransh 11155 
          iprot.readListEnd()
11156 
        else:
11157 
          iprot.skip(ftype)
11158 
      else:
11159 
        iprot.skip(ftype)
11160 
      iprot.readFieldEnd()
11161 
    iprot.readStructEnd()
11162 
 
11163 
  def write(self, oprot):
11164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11166 
      return
11167 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 11168 
    if self.success is not None:
2690 chandransh 11169 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11170 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11171 
      for iter212 in self.success:
11172 
        iter212.write(oprot)
2690 chandransh 11173 
      oprot.writeListEnd()
11174 
      oprot.writeFieldEnd()
11175 
    oprot.writeFieldStop()
11176 
    oprot.writeStructEnd()
11177 
 
3431 rajveer 11178 
  def validate(self):
11179 
    return
11180 
 
11181 
 
2690 chandransh 11182 
  def __repr__(self):
11183 
    L = ['%s=%r' % (key, value)
11184 
      for key, value in self.__dict__.iteritems()]
11185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11186 
 
11187 
  def __eq__(self, other):
11188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11189 
 
11190 
  def __ne__(self, other):
11191 
    return not (self == other)
11192 
 
2700 chandransh 11193 
class getReturnOrder_args:
11194 
  """
11195 
  Attributes:
11196 
   - id
11197 
  """
11198 
 
11199 
  thrift_spec = (
11200 
    None, # 0
11201 
    (1, TType.I64, 'id', None, None, ), # 1
11202 
  )
11203 
 
11204 
  def __init__(self, id=None,):
11205 
    self.id = id
11206 
 
11207 
  def read(self, iprot):
11208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11210 
      return
11211 
    iprot.readStructBegin()
11212 
    while True:
11213 
      (fname, ftype, fid) = iprot.readFieldBegin()
11214 
      if ftype == TType.STOP:
11215 
        break
11216 
      if fid == 1:
11217 
        if ftype == TType.I64:
11218 
          self.id = iprot.readI64();
11219 
        else:
11220 
          iprot.skip(ftype)
11221 
      else:
11222 
        iprot.skip(ftype)
11223 
      iprot.readFieldEnd()
11224 
    iprot.readStructEnd()
11225 
 
11226 
  def write(self, oprot):
11227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11229 
      return
11230 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 11231 
    if self.id is not None:
2700 chandransh 11232 
      oprot.writeFieldBegin('id', TType.I64, 1)
11233 
      oprot.writeI64(self.id)
11234 
      oprot.writeFieldEnd()
11235 
    oprot.writeFieldStop()
11236 
    oprot.writeStructEnd()
11237 
 
3431 rajveer 11238 
  def validate(self):
11239 
    return
11240 
 
11241 
 
2700 chandransh 11242 
  def __repr__(self):
11243 
    L = ['%s=%r' % (key, value)
11244 
      for key, value in self.__dict__.iteritems()]
11245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11246 
 
11247 
  def __eq__(self, other):
11248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11249 
 
11250 
  def __ne__(self, other):
11251 
    return not (self == other)
11252 
 
11253 
class getReturnOrder_result:
11254 
  """
11255 
  Attributes:
11256 
   - success
11257 
   - ex
11258 
  """
11259 
 
11260 
  thrift_spec = (
11261 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
11262 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11263 
  )
11264 
 
11265 
  def __init__(self, success=None, ex=None,):
11266 
    self.success = success
11267 
    self.ex = ex
11268 
 
11269 
  def read(self, iprot):
11270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11272 
      return
11273 
    iprot.readStructBegin()
11274 
    while True:
11275 
      (fname, ftype, fid) = iprot.readFieldBegin()
11276 
      if ftype == TType.STOP:
11277 
        break
11278 
      if fid == 0:
11279 
        if ftype == TType.STRUCT:
11280 
          self.success = ReturnOrder()
11281 
          self.success.read(iprot)
11282 
        else:
11283 
          iprot.skip(ftype)
11284 
      elif fid == 1:
11285 
        if ftype == TType.STRUCT:
11286 
          self.ex = TransactionServiceException()
11287 
          self.ex.read(iprot)
11288 
        else:
11289 
          iprot.skip(ftype)
11290 
      else:
11291 
        iprot.skip(ftype)
11292 
      iprot.readFieldEnd()
11293 
    iprot.readStructEnd()
11294 
 
11295 
  def write(self, oprot):
11296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11298 
      return
11299 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 11300 
    if self.success is not None:
2700 chandransh 11301 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11302 
      self.success.write(oprot)
11303 
      oprot.writeFieldEnd()
3431 rajveer 11304 
    if self.ex is not None:
2700 chandransh 11305 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11306 
      self.ex.write(oprot)
11307 
      oprot.writeFieldEnd()
11308 
    oprot.writeFieldStop()
11309 
    oprot.writeStructEnd()
11310 
 
3431 rajveer 11311 
  def validate(self):
11312 
    return
11313 
 
11314 
 
2700 chandransh 11315 
  def __repr__(self):
11316 
    L = ['%s=%r' % (key, value)
11317 
      for key, value in self.__dict__.iteritems()]
11318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11319 
 
11320 
  def __eq__(self, other):
11321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11322 
 
11323 
  def __ne__(self, other):
11324 
    return not (self == other)
11325 
 
2690 chandransh 11326 
class processReturn_args:
11327 
  """
11328 
  Attributes:
11329 
   - returnOrderId
11330 
  """
11331 
 
11332 
  thrift_spec = (
11333 
    None, # 0
11334 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
11335 
  )
11336 
 
11337 
  def __init__(self, returnOrderId=None,):
11338 
    self.returnOrderId = returnOrderId
11339 
 
11340 
  def read(self, iprot):
11341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11343 
      return
11344 
    iprot.readStructBegin()
11345 
    while True:
11346 
      (fname, ftype, fid) = iprot.readFieldBegin()
11347 
      if ftype == TType.STOP:
11348 
        break
11349 
      if fid == 1:
11350 
        if ftype == TType.I64:
11351 
          self.returnOrderId = iprot.readI64();
11352 
        else:
11353 
          iprot.skip(ftype)
11354 
      else:
11355 
        iprot.skip(ftype)
11356 
      iprot.readFieldEnd()
11357 
    iprot.readStructEnd()
11358 
 
11359 
  def write(self, oprot):
11360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11362 
      return
11363 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 11364 
    if self.returnOrderId is not None:
2690 chandransh 11365 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
11366 
      oprot.writeI64(self.returnOrderId)
11367 
      oprot.writeFieldEnd()
11368 
    oprot.writeFieldStop()
11369 
    oprot.writeStructEnd()
11370 
 
3431 rajveer 11371 
  def validate(self):
11372 
    return
11373 
 
11374 
 
2690 chandransh 11375 
  def __repr__(self):
11376 
    L = ['%s=%r' % (key, value)
11377 
      for key, value in self.__dict__.iteritems()]
11378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11379 
 
11380 
  def __eq__(self, other):
11381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11382 
 
11383 
  def __ne__(self, other):
11384 
    return not (self == other)
11385 
 
11386 
class processReturn_result:
11387 
  """
11388 
  Attributes:
11389 
   - ex
11390 
  """
11391 
 
11392 
  thrift_spec = (
11393 
    None, # 0
11394 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11395 
  )
11396 
 
11397 
  def __init__(self, ex=None,):
11398 
    self.ex = ex
11399 
 
11400 
  def read(self, iprot):
11401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11403 
      return
11404 
    iprot.readStructBegin()
11405 
    while True:
11406 
      (fname, ftype, fid) = iprot.readFieldBegin()
11407 
      if ftype == TType.STOP:
11408 
        break
11409 
      if fid == 1:
11410 
        if ftype == TType.STRUCT:
11411 
          self.ex = TransactionServiceException()
11412 
          self.ex.read(iprot)
11413 
        else:
11414 
          iprot.skip(ftype)
11415 
      else:
11416 
        iprot.skip(ftype)
11417 
      iprot.readFieldEnd()
11418 
    iprot.readStructEnd()
11419 
 
11420 
  def write(self, oprot):
11421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11423 
      return
11424 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 11425 
    if self.ex is not None:
2690 chandransh 11426 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11427 
      self.ex.write(oprot)
11428 
      oprot.writeFieldEnd()
11429 
    oprot.writeFieldStop()
11430 
    oprot.writeStructEnd()
11431 
 
3431 rajveer 11432 
  def validate(self):
11433 
    return
11434 
 
11435 
 
2690 chandransh 11436 
  def __repr__(self):
11437 
    L = ['%s=%r' % (key, value)
11438 
      for key, value in self.__dict__.iteritems()]
11439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11440 
 
11441 
  def __eq__(self, other):
11442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11443 
 
11444 
  def __ne__(self, other):
11445 
    return not (self == other)
11446 
 
2819 chandransh 11447 
class createPurchaseOrder_args:
11448 
  """
11449 
  Attributes:
11450 
   - warehouseId
11451 
  """
2690 chandransh 11452 
 
2819 chandransh 11453 
  thrift_spec = (
11454 
    None, # 0
11455 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11456 
  )
11457 
 
11458 
  def __init__(self, warehouseId=None,):
11459 
    self.warehouseId = warehouseId
11460 
 
11461 
  def read(self, iprot):
11462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11464 
      return
11465 
    iprot.readStructBegin()
11466 
    while True:
11467 
      (fname, ftype, fid) = iprot.readFieldBegin()
11468 
      if ftype == TType.STOP:
11469 
        break
11470 
      if fid == 1:
11471 
        if ftype == TType.I64:
11472 
          self.warehouseId = iprot.readI64();
11473 
        else:
11474 
          iprot.skip(ftype)
11475 
      else:
11476 
        iprot.skip(ftype)
11477 
      iprot.readFieldEnd()
11478 
    iprot.readStructEnd()
11479 
 
11480 
  def write(self, oprot):
11481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11483 
      return
11484 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 11485 
    if self.warehouseId is not None:
2819 chandransh 11486 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11487 
      oprot.writeI64(self.warehouseId)
11488 
      oprot.writeFieldEnd()
11489 
    oprot.writeFieldStop()
11490 
    oprot.writeStructEnd()
11491 
 
3431 rajveer 11492 
  def validate(self):
11493 
    return
11494 
 
11495 
 
2819 chandransh 11496 
  def __repr__(self):
11497 
    L = ['%s=%r' % (key, value)
11498 
      for key, value in self.__dict__.iteritems()]
11499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11500 
 
11501 
  def __eq__(self, other):
11502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11503 
 
11504 
  def __ne__(self, other):
11505 
    return not (self == other)
11506 
 
11507 
class createPurchaseOrder_result:
11508 
  """
11509 
  Attributes:
11510 
   - success
11511 
   - ex
11512 
  """
11513 
 
11514 
  thrift_spec = (
11515 
    (0, TType.I64, 'success', None, None, ), # 0
11516 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11517 
  )
11518 
 
11519 
  def __init__(self, success=None, ex=None,):
11520 
    self.success = success
11521 
    self.ex = ex
11522 
 
11523 
  def read(self, iprot):
11524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11526 
      return
11527 
    iprot.readStructBegin()
11528 
    while True:
11529 
      (fname, ftype, fid) = iprot.readFieldBegin()
11530 
      if ftype == TType.STOP:
11531 
        break
11532 
      if fid == 0:
11533 
        if ftype == TType.I64:
11534 
          self.success = iprot.readI64();
11535 
        else:
11536 
          iprot.skip(ftype)
11537 
      elif fid == 1:
11538 
        if ftype == TType.STRUCT:
11539 
          self.ex = TransactionServiceException()
11540 
          self.ex.read(iprot)
11541 
        else:
11542 
          iprot.skip(ftype)
11543 
      else:
11544 
        iprot.skip(ftype)
11545 
      iprot.readFieldEnd()
11546 
    iprot.readStructEnd()
11547 
 
11548 
  def write(self, oprot):
11549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11551 
      return
11552 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 11553 
    if self.success is not None:
2819 chandransh 11554 
      oprot.writeFieldBegin('success', TType.I64, 0)
11555 
      oprot.writeI64(self.success)
11556 
      oprot.writeFieldEnd()
3431 rajveer 11557 
    if self.ex is not None:
2819 chandransh 11558 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11559 
      self.ex.write(oprot)
11560 
      oprot.writeFieldEnd()
11561 
    oprot.writeFieldStop()
11562 
    oprot.writeStructEnd()
11563 
 
3431 rajveer 11564 
  def validate(self):
11565 
    return
11566 
 
11567 
 
2819 chandransh 11568 
  def __repr__(self):
11569 
    L = ['%s=%r' % (key, value)
11570 
      for key, value in self.__dict__.iteritems()]
11571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11572 
 
11573 
  def __eq__(self, other):
11574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11575 
 
11576 
  def __ne__(self, other):
11577 
    return not (self == other)
3451 chandransh 11578 
 
11579 
class updateWeight_args:
11580 
  """
11581 
  Attributes:
11582 
   - orderId
11583 
   - weight
11584 
  """
11585 
 
11586 
  thrift_spec = (
11587 
    None, # 0
11588 
    (1, TType.I64, 'orderId', None, None, ), # 1
11589 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
11590 
  )
11591 
 
11592 
  def __init__(self, orderId=None, weight=None,):
11593 
    self.orderId = orderId
11594 
    self.weight = weight
11595 
 
11596 
  def read(self, iprot):
11597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11599 
      return
11600 
    iprot.readStructBegin()
11601 
    while True:
11602 
      (fname, ftype, fid) = iprot.readFieldBegin()
11603 
      if ftype == TType.STOP:
11604 
        break
11605 
      if fid == 1:
11606 
        if ftype == TType.I64:
11607 
          self.orderId = iprot.readI64();
11608 
        else:
11609 
          iprot.skip(ftype)
11610 
      elif fid == 2:
11611 
        if ftype == TType.DOUBLE:
11612 
          self.weight = iprot.readDouble();
11613 
        else:
11614 
          iprot.skip(ftype)
11615 
      else:
11616 
        iprot.skip(ftype)
11617 
      iprot.readFieldEnd()
11618 
    iprot.readStructEnd()
11619 
 
11620 
  def write(self, oprot):
11621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11623 
      return
11624 
    oprot.writeStructBegin('updateWeight_args')
11625 
    if self.orderId is not None:
11626 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11627 
      oprot.writeI64(self.orderId)
11628 
      oprot.writeFieldEnd()
11629 
    if self.weight is not None:
11630 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
11631 
      oprot.writeDouble(self.weight)
11632 
      oprot.writeFieldEnd()
11633 
    oprot.writeFieldStop()
11634 
    oprot.writeStructEnd()
11635 
 
11636 
  def validate(self):
11637 
    return
11638 
 
11639 
 
11640 
  def __repr__(self):
11641 
    L = ['%s=%r' % (key, value)
11642 
      for key, value in self.__dict__.iteritems()]
11643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11644 
 
11645 
  def __eq__(self, other):
11646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11647 
 
11648 
  def __ne__(self, other):
11649 
    return not (self == other)
11650 
 
11651 
class updateWeight_result:
11652 
  """
11653 
  Attributes:
11654 
   - success
11655 
   - ex
11656 
  """
11657 
 
11658 
  thrift_spec = (
11659 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11660 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11661 
  )
11662 
 
11663 
  def __init__(self, success=None, ex=None,):
11664 
    self.success = success
11665 
    self.ex = ex
11666 
 
11667 
  def read(self, iprot):
11668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11670 
      return
11671 
    iprot.readStructBegin()
11672 
    while True:
11673 
      (fname, ftype, fid) = iprot.readFieldBegin()
11674 
      if ftype == TType.STOP:
11675 
        break
11676 
      if fid == 0:
11677 
        if ftype == TType.STRUCT:
11678 
          self.success = Order()
11679 
          self.success.read(iprot)
11680 
        else:
11681 
          iprot.skip(ftype)
11682 
      elif fid == 1:
11683 
        if ftype == TType.STRUCT:
11684 
          self.ex = TransactionServiceException()
11685 
          self.ex.read(iprot)
11686 
        else:
11687 
          iprot.skip(ftype)
11688 
      else:
11689 
        iprot.skip(ftype)
11690 
      iprot.readFieldEnd()
11691 
    iprot.readStructEnd()
11692 
 
11693 
  def write(self, oprot):
11694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11696 
      return
11697 
    oprot.writeStructBegin('updateWeight_result')
11698 
    if self.success is not None:
11699 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11700 
      self.success.write(oprot)
11701 
      oprot.writeFieldEnd()
11702 
    if self.ex is not None:
11703 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11704 
      self.ex.write(oprot)
11705 
      oprot.writeFieldEnd()
11706 
    oprot.writeFieldStop()
11707 
    oprot.writeStructEnd()
11708 
 
11709 
  def validate(self):
11710 
    return
11711 
 
11712 
 
11713 
  def __repr__(self):
11714 
    L = ['%s=%r' % (key, value)
11715 
      for key, value in self.__dict__.iteritems()]
11716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11717 
 
11718 
  def __eq__(self, other):
11719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11720 
 
11721 
  def __ne__(self, other):
11722 
    return not (self == other)
3469 chandransh 11723 
 
11724 
class changeItem_args:
11725 
  """
11726 
  Attributes:
11727 
   - orderId
11728 
   - itemId
11729 
  """
11730 
 
11731 
  thrift_spec = (
11732 
    None, # 0
11733 
    (1, TType.I64, 'orderId', None, None, ), # 1
11734 
    (2, TType.I64, 'itemId', None, None, ), # 2
11735 
  )
11736 
 
11737 
  def __init__(self, orderId=None, itemId=None,):
11738 
    self.orderId = orderId
11739 
    self.itemId = itemId
11740 
 
11741 
  def read(self, iprot):
11742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11744 
      return
11745 
    iprot.readStructBegin()
11746 
    while True:
11747 
      (fname, ftype, fid) = iprot.readFieldBegin()
11748 
      if ftype == TType.STOP:
11749 
        break
11750 
      if fid == 1:
11751 
        if ftype == TType.I64:
11752 
          self.orderId = iprot.readI64();
11753 
        else:
11754 
          iprot.skip(ftype)
11755 
      elif fid == 2:
11756 
        if ftype == TType.I64:
11757 
          self.itemId = iprot.readI64();
11758 
        else:
11759 
          iprot.skip(ftype)
11760 
      else:
11761 
        iprot.skip(ftype)
11762 
      iprot.readFieldEnd()
11763 
    iprot.readStructEnd()
11764 
 
11765 
  def write(self, oprot):
11766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11768 
      return
11769 
    oprot.writeStructBegin('changeItem_args')
11770 
    if self.orderId is not None:
11771 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11772 
      oprot.writeI64(self.orderId)
11773 
      oprot.writeFieldEnd()
11774 
    if self.itemId is not None:
11775 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11776 
      oprot.writeI64(self.itemId)
11777 
      oprot.writeFieldEnd()
11778 
    oprot.writeFieldStop()
11779 
    oprot.writeStructEnd()
11780 
 
11781 
  def validate(self):
11782 
    return
11783 
 
11784 
 
11785 
  def __repr__(self):
11786 
    L = ['%s=%r' % (key, value)
11787 
      for key, value in self.__dict__.iteritems()]
11788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11789 
 
11790 
  def __eq__(self, other):
11791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11792 
 
11793 
  def __ne__(self, other):
11794 
    return not (self == other)
11795 
 
11796 
class changeItem_result:
11797 
  """
11798 
  Attributes:
11799 
   - success
11800 
   - ex
11801 
  """
11802 
 
11803 
  thrift_spec = (
11804 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11805 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11806 
  )
11807 
 
11808 
  def __init__(self, success=None, ex=None,):
11809 
    self.success = success
11810 
    self.ex = ex
11811 
 
11812 
  def read(self, iprot):
11813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11815 
      return
11816 
    iprot.readStructBegin()
11817 
    while True:
11818 
      (fname, ftype, fid) = iprot.readFieldBegin()
11819 
      if ftype == TType.STOP:
11820 
        break
11821 
      if fid == 0:
11822 
        if ftype == TType.STRUCT:
11823 
          self.success = Order()
11824 
          self.success.read(iprot)
11825 
        else:
11826 
          iprot.skip(ftype)
11827 
      elif fid == 1:
11828 
        if ftype == TType.STRUCT:
11829 
          self.ex = TransactionServiceException()
11830 
          self.ex.read(iprot)
11831 
        else:
11832 
          iprot.skip(ftype)
11833 
      else:
11834 
        iprot.skip(ftype)
11835 
      iprot.readFieldEnd()
11836 
    iprot.readStructEnd()
11837 
 
11838 
  def write(self, oprot):
11839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11841 
      return
11842 
    oprot.writeStructBegin('changeItem_result')
11843 
    if self.success is not None:
11844 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11845 
      self.success.write(oprot)
11846 
      oprot.writeFieldEnd()
11847 
    if self.ex is not None:
11848 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11849 
      self.ex.write(oprot)
11850 
      oprot.writeFieldEnd()
11851 
    oprot.writeFieldStop()
11852 
    oprot.writeStructEnd()
11853 
 
11854 
  def validate(self):
11855 
    return
11856 
 
11857 
 
11858 
  def __repr__(self):
11859 
    L = ['%s=%r' % (key, value)
11860 
      for key, value in self.__dict__.iteritems()]
11861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11862 
 
11863 
  def __eq__(self, other):
11864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11865 
 
11866 
  def __ne__(self, other):
11867 
    return not (self == other)
11868 
 
11869 
class shiftToWarehouse_args:
11870 
  """
11871 
  Attributes:
11872 
   - orderId
11873 
   - warehouseId
11874 
  """
11875 
 
11876 
  thrift_spec = (
11877 
    None, # 0
11878 
    (1, TType.I64, 'orderId', None, None, ), # 1
11879 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11880 
  )
11881 
 
11882 
  def __init__(self, orderId=None, warehouseId=None,):
11883 
    self.orderId = orderId
11884 
    self.warehouseId = warehouseId
11885 
 
11886 
  def read(self, iprot):
11887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11889 
      return
11890 
    iprot.readStructBegin()
11891 
    while True:
11892 
      (fname, ftype, fid) = iprot.readFieldBegin()
11893 
      if ftype == TType.STOP:
11894 
        break
11895 
      if fid == 1:
11896 
        if ftype == TType.I64:
11897 
          self.orderId = iprot.readI64();
11898 
        else:
11899 
          iprot.skip(ftype)
11900 
      elif fid == 2:
11901 
        if ftype == TType.I64:
11902 
          self.warehouseId = iprot.readI64();
11903 
        else:
11904 
          iprot.skip(ftype)
11905 
      else:
11906 
        iprot.skip(ftype)
11907 
      iprot.readFieldEnd()
11908 
    iprot.readStructEnd()
11909 
 
11910 
  def write(self, oprot):
11911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11913 
      return
11914 
    oprot.writeStructBegin('shiftToWarehouse_args')
11915 
    if self.orderId is not None:
11916 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11917 
      oprot.writeI64(self.orderId)
11918 
      oprot.writeFieldEnd()
11919 
    if self.warehouseId is not None:
11920 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11921 
      oprot.writeI64(self.warehouseId)
11922 
      oprot.writeFieldEnd()
11923 
    oprot.writeFieldStop()
11924 
    oprot.writeStructEnd()
11925 
 
11926 
  def validate(self):
11927 
    return
11928 
 
11929 
 
11930 
  def __repr__(self):
11931 
    L = ['%s=%r' % (key, value)
11932 
      for key, value in self.__dict__.iteritems()]
11933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11934 
 
11935 
  def __eq__(self, other):
11936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11937 
 
11938 
  def __ne__(self, other):
11939 
    return not (self == other)
11940 
 
11941 
class shiftToWarehouse_result:
11942 
  """
11943 
  Attributes:
11944 
   - success
11945 
   - ex
11946 
  """
11947 
 
11948 
  thrift_spec = (
11949 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11950 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11951 
  )
11952 
 
11953 
  def __init__(self, success=None, ex=None,):
11954 
    self.success = success
11955 
    self.ex = ex
11956 
 
11957 
  def read(self, iprot):
11958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11960 
      return
11961 
    iprot.readStructBegin()
11962 
    while True:
11963 
      (fname, ftype, fid) = iprot.readFieldBegin()
11964 
      if ftype == TType.STOP:
11965 
        break
11966 
      if fid == 0:
11967 
        if ftype == TType.STRUCT:
11968 
          self.success = Order()
11969 
          self.success.read(iprot)
11970 
        else:
11971 
          iprot.skip(ftype)
11972 
      elif fid == 1:
11973 
        if ftype == TType.STRUCT:
11974 
          self.ex = TransactionServiceException()
11975 
          self.ex.read(iprot)
11976 
        else:
11977 
          iprot.skip(ftype)
11978 
      else:
11979 
        iprot.skip(ftype)
11980 
      iprot.readFieldEnd()
11981 
    iprot.readStructEnd()
11982 
 
11983 
  def write(self, oprot):
11984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11986 
      return
11987 
    oprot.writeStructBegin('shiftToWarehouse_result')
11988 
    if self.success is not None:
11989 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11990 
      self.success.write(oprot)
11991 
      oprot.writeFieldEnd()
11992 
    if self.ex is not None:
11993 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11994 
      self.ex.write(oprot)
11995 
      oprot.writeFieldEnd()
11996 
    oprot.writeFieldStop()
11997 
    oprot.writeStructEnd()
11998 
 
11999 
  def validate(self):
12000 
    return
12001 
 
12002 
 
12003 
  def __repr__(self):
12004 
    L = ['%s=%r' % (key, value)
12005 
      for key, value in self.__dict__.iteritems()]
12006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12007 
 
12008 
  def __eq__(self, other):
12009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12010 
 
12011 
  def __ne__(self, other):
12012 
    return not (self == other)
3553 chandransh 12013 
 
12014 
class addDelayReason_args:
12015 
  """
12016 
  Attributes:
12017 
   - orderId
12018 
   - delayReason
3986 chandransh 12019 
   - furtherDelay
3553 chandransh 12020 
  """
12021 
 
12022 
  thrift_spec = (
12023 
    None, # 0
12024 
    (1, TType.I64, 'orderId', None, None, ), # 1
12025 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 12026 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 12027 
  )
12028 
 
3986 chandransh 12029 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 12030 
    self.orderId = orderId
12031 
    self.delayReason = delayReason
3986 chandransh 12032 
    self.furtherDelay = furtherDelay
3553 chandransh 12033 
 
12034 
  def read(self, iprot):
12035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12037 
      return
12038 
    iprot.readStructBegin()
12039 
    while True:
12040 
      (fname, ftype, fid) = iprot.readFieldBegin()
12041 
      if ftype == TType.STOP:
12042 
        break
12043 
      if fid == 1:
12044 
        if ftype == TType.I64:
12045 
          self.orderId = iprot.readI64();
12046 
        else:
12047 
          iprot.skip(ftype)
12048 
      elif fid == 2:
12049 
        if ftype == TType.I32:
12050 
          self.delayReason = iprot.readI32();
12051 
        else:
12052 
          iprot.skip(ftype)
3986 chandransh 12053 
      elif fid == 3:
12054 
        if ftype == TType.I64:
12055 
          self.furtherDelay = iprot.readI64();
12056 
        else:
12057 
          iprot.skip(ftype)
3553 chandransh 12058 
      else:
12059 
        iprot.skip(ftype)
12060 
      iprot.readFieldEnd()
12061 
    iprot.readStructEnd()
12062 
 
12063 
  def write(self, oprot):
12064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12066 
      return
12067 
    oprot.writeStructBegin('addDelayReason_args')
12068 
    if self.orderId is not None:
12069 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12070 
      oprot.writeI64(self.orderId)
12071 
      oprot.writeFieldEnd()
12072 
    if self.delayReason is not None:
12073 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
12074 
      oprot.writeI32(self.delayReason)
12075 
      oprot.writeFieldEnd()
3986 chandransh 12076 
    if self.furtherDelay is not None:
12077 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
12078 
      oprot.writeI64(self.furtherDelay)
12079 
      oprot.writeFieldEnd()
3553 chandransh 12080 
    oprot.writeFieldStop()
12081 
    oprot.writeStructEnd()
12082 
 
12083 
  def validate(self):
12084 
    return
12085 
 
12086 
 
12087 
  def __repr__(self):
12088 
    L = ['%s=%r' % (key, value)
12089 
      for key, value in self.__dict__.iteritems()]
12090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12091 
 
12092 
  def __eq__(self, other):
12093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12094 
 
12095 
  def __ne__(self, other):
12096 
    return not (self == other)
12097 
 
12098 
class addDelayReason_result:
12099 
  """
12100 
  Attributes:
12101 
   - success
12102 
   - ex
12103 
  """
12104 
 
12105 
  thrift_spec = (
12106 
    (0, TType.BOOL, 'success', None, None, ), # 0
12107 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12108 
  )
12109 
 
12110 
  def __init__(self, success=None, ex=None,):
12111 
    self.success = success
12112 
    self.ex = ex
12113 
 
12114 
  def read(self, iprot):
12115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12117 
      return
12118 
    iprot.readStructBegin()
12119 
    while True:
12120 
      (fname, ftype, fid) = iprot.readFieldBegin()
12121 
      if ftype == TType.STOP:
12122 
        break
12123 
      if fid == 0:
12124 
        if ftype == TType.BOOL:
12125 
          self.success = iprot.readBool();
12126 
        else:
12127 
          iprot.skip(ftype)
12128 
      elif fid == 1:
12129 
        if ftype == TType.STRUCT:
12130 
          self.ex = TransactionServiceException()
12131 
          self.ex.read(iprot)
12132 
        else:
12133 
          iprot.skip(ftype)
12134 
      else:
12135 
        iprot.skip(ftype)
12136 
      iprot.readFieldEnd()
12137 
    iprot.readStructEnd()
12138 
 
12139 
  def write(self, oprot):
12140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12142 
      return
12143 
    oprot.writeStructBegin('addDelayReason_result')
12144 
    if self.success is not None:
12145 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12146 
      oprot.writeBool(self.success)
12147 
      oprot.writeFieldEnd()
12148 
    if self.ex is not None:
12149 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12150 
      self.ex.write(oprot)
12151 
      oprot.writeFieldEnd()
12152 
    oprot.writeFieldStop()
12153 
    oprot.writeStructEnd()
12154 
 
12155 
  def validate(self):
12156 
    return
12157 
 
12158 
 
12159 
  def __repr__(self):
12160 
    L = ['%s=%r' % (key, value)
12161 
      for key, value in self.__dict__.iteritems()]
12162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12163 
 
12164 
  def __eq__(self, other):
12165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12166 
 
12167 
  def __ne__(self, other):
12168 
    return not (self == other)
3956 chandransh 12169 
 
12170 
class reconcileCodCollection_args:
12171 
  """
12172 
  Attributes:
12173 
   - collectedAmountMap
12174 
   - xferBy
12175 
   - xferTxnId
12176 
   - xferDate
12177 
  """
12178 
 
12179 
  thrift_spec = (
12180 
    None, # 0
12181 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
12182 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
12183 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
12184 
    (4, TType.I64, 'xferDate', None, None, ), # 4
12185 
  )
12186 
 
12187 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
12188 
    self.collectedAmountMap = collectedAmountMap
12189 
    self.xferBy = xferBy
12190 
    self.xferTxnId = xferTxnId
12191 
    self.xferDate = xferDate
12192 
 
12193 
  def read(self, iprot):
12194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12196 
      return
12197 
    iprot.readStructBegin()
12198 
    while True:
12199 
      (fname, ftype, fid) = iprot.readFieldBegin()
12200 
      if ftype == TType.STOP:
12201 
        break
12202 
      if fid == 1:
12203 
        if ftype == TType.MAP:
12204 
          self.collectedAmountMap = {}
4133 chandransh 12205 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
12206 
          for _i217 in xrange(_size213):
12207 
            _key218 = iprot.readString();
12208 
            _val219 = iprot.readDouble();
12209 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 12210 
          iprot.readMapEnd()
12211 
        else:
12212 
          iprot.skip(ftype)
12213 
      elif fid == 2:
12214 
        if ftype == TType.STRING:
12215 
          self.xferBy = iprot.readString();
12216 
        else:
12217 
          iprot.skip(ftype)
12218 
      elif fid == 3:
12219 
        if ftype == TType.STRING:
12220 
          self.xferTxnId = iprot.readString();
12221 
        else:
12222 
          iprot.skip(ftype)
12223 
      elif fid == 4:
12224 
        if ftype == TType.I64:
12225 
          self.xferDate = iprot.readI64();
12226 
        else:
12227 
          iprot.skip(ftype)
12228 
      else:
12229 
        iprot.skip(ftype)
12230 
      iprot.readFieldEnd()
12231 
    iprot.readStructEnd()
12232 
 
12233 
  def write(self, oprot):
12234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12236 
      return
12237 
    oprot.writeStructBegin('reconcileCodCollection_args')
12238 
    if self.collectedAmountMap is not None:
12239 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
12240 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 12241 
      for kiter220,viter221 in self.collectedAmountMap.items():
12242 
        oprot.writeString(kiter220)
12243 
        oprot.writeDouble(viter221)
3956 chandransh 12244 
      oprot.writeMapEnd()
12245 
      oprot.writeFieldEnd()
12246 
    if self.xferBy is not None:
12247 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
12248 
      oprot.writeString(self.xferBy)
12249 
      oprot.writeFieldEnd()
12250 
    if self.xferTxnId is not None:
12251 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
12252 
      oprot.writeString(self.xferTxnId)
12253 
      oprot.writeFieldEnd()
12254 
    if self.xferDate is not None:
12255 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
12256 
      oprot.writeI64(self.xferDate)
12257 
      oprot.writeFieldEnd()
12258 
    oprot.writeFieldStop()
12259 
    oprot.writeStructEnd()
12260 
 
12261 
  def validate(self):
12262 
    return
12263 
 
12264 
 
12265 
  def __repr__(self):
12266 
    L = ['%s=%r' % (key, value)
12267 
      for key, value in self.__dict__.iteritems()]
12268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12269 
 
12270 
  def __eq__(self, other):
12271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12272 
 
12273 
  def __ne__(self, other):
12274 
    return not (self == other)
12275 
 
12276 
class reconcileCodCollection_result:
12277 
  """
12278 
  Attributes:
12279 
   - success
12280 
   - ex
12281 
  """
12282 
 
12283 
  thrift_spec = (
12284 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
12285 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12286 
  )
12287 
 
12288 
  def __init__(self, success=None, ex=None,):
12289 
    self.success = success
12290 
    self.ex = ex
12291 
 
12292 
  def read(self, iprot):
12293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12295 
      return
12296 
    iprot.readStructBegin()
12297 
    while True:
12298 
      (fname, ftype, fid) = iprot.readFieldBegin()
12299 
      if ftype == TType.STOP:
12300 
        break
12301 
      if fid == 0:
12302 
        if ftype == TType.MAP:
12303 
          self.success = {}
4133 chandransh 12304 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
12305 
          for _i226 in xrange(_size222):
12306 
            _key227 = iprot.readString();
12307 
            _val228 = iprot.readString();
12308 
            self.success[_key227] = _val228
3956 chandransh 12309 
          iprot.readMapEnd()
12310 
        else:
12311 
          iprot.skip(ftype)
12312 
      elif fid == 1:
12313 
        if ftype == TType.STRUCT:
12314 
          self.ex = TransactionServiceException()
12315 
          self.ex.read(iprot)
12316 
        else:
12317 
          iprot.skip(ftype)
12318 
      else:
12319 
        iprot.skip(ftype)
12320 
      iprot.readFieldEnd()
12321 
    iprot.readStructEnd()
12322 
 
12323 
  def write(self, oprot):
12324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12326 
      return
12327 
    oprot.writeStructBegin('reconcileCodCollection_result')
12328 
    if self.success is not None:
12329 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12330 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 12331 
      for kiter229,viter230 in self.success.items():
12332 
        oprot.writeString(kiter229)
12333 
        oprot.writeString(viter230)
3956 chandransh 12334 
      oprot.writeMapEnd()
12335 
      oprot.writeFieldEnd()
12336 
    if self.ex is not None:
12337 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12338 
      self.ex.write(oprot)
12339 
      oprot.writeFieldEnd()
12340 
    oprot.writeFieldStop()
12341 
    oprot.writeStructEnd()
12342 
 
12343 
  def validate(self):
12344 
    return
12345 
 
12346 
 
12347 
  def __repr__(self):
12348 
    L = ['%s=%r' % (key, value)
12349 
      for key, value in self.__dict__.iteritems()]
12350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12351 
 
12352 
  def __eq__(self, other):
12353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12354 
 
12355 
  def __ne__(self, other):
12356 
    return not (self == other)
4008 mandeep.dh 12357 
 
12358 
class getTransactionsRequiringExtraProcessing_args:
12359 
  """
12360 
  Attributes:
12361 
   - category
12362 
  """
12363 
 
12364 
  thrift_spec = (
12365 
    None, # 0
12366 
    (1, TType.I32, 'category', None, None, ), # 1
12367 
  )
12368 
 
12369 
  def __init__(self, category=None,):
12370 
    self.category = category
12371 
 
12372 
  def read(self, iprot):
12373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12375 
      return
12376 
    iprot.readStructBegin()
12377 
    while True:
12378 
      (fname, ftype, fid) = iprot.readFieldBegin()
12379 
      if ftype == TType.STOP:
12380 
        break
12381 
      if fid == 1:
12382 
        if ftype == TType.I32:
12383 
          self.category = iprot.readI32();
12384 
        else:
12385 
          iprot.skip(ftype)
12386 
      else:
12387 
        iprot.skip(ftype)
12388 
      iprot.readFieldEnd()
12389 
    iprot.readStructEnd()
12390 
 
12391 
  def write(self, oprot):
12392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12394 
      return
12395 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
12396 
    if self.category is not None:
12397 
      oprot.writeFieldBegin('category', TType.I32, 1)
12398 
      oprot.writeI32(self.category)
12399 
      oprot.writeFieldEnd()
12400 
    oprot.writeFieldStop()
12401 
    oprot.writeStructEnd()
12402 
 
12403 
  def validate(self):
12404 
    return
12405 
 
12406 
 
12407 
  def __repr__(self):
12408 
    L = ['%s=%r' % (key, value)
12409 
      for key, value in self.__dict__.iteritems()]
12410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12411 
 
12412 
  def __eq__(self, other):
12413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12414 
 
12415 
  def __ne__(self, other):
12416 
    return not (self == other)
12417 
 
12418 
class getTransactionsRequiringExtraProcessing_result:
12419 
  """
12420 
  Attributes:
12421 
   - success
12422 
  """
12423 
 
12424 
  thrift_spec = (
12425 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12426 
  )
12427 
 
12428 
  def __init__(self, success=None,):
12429 
    self.success = success
12430 
 
12431 
  def read(self, iprot):
12432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12434 
      return
12435 
    iprot.readStructBegin()
12436 
    while True:
12437 
      (fname, ftype, fid) = iprot.readFieldBegin()
12438 
      if ftype == TType.STOP:
12439 
        break
12440 
      if fid == 0:
12441 
        if ftype == TType.LIST:
12442 
          self.success = []
4133 chandransh 12443 
          (_etype234, _size231) = iprot.readListBegin()
12444 
          for _i235 in xrange(_size231):
12445 
            _elem236 = iprot.readI64();
12446 
            self.success.append(_elem236)
4008 mandeep.dh 12447 
          iprot.readListEnd()
12448 
        else:
12449 
          iprot.skip(ftype)
12450 
      else:
12451 
        iprot.skip(ftype)
12452 
      iprot.readFieldEnd()
12453 
    iprot.readStructEnd()
12454 
 
12455 
  def write(self, oprot):
12456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12458 
      return
12459 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
12460 
    if self.success is not None:
12461 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12462 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 12463 
      for iter237 in self.success:
12464 
        oprot.writeI64(iter237)
4008 mandeep.dh 12465 
      oprot.writeListEnd()
12466 
      oprot.writeFieldEnd()
12467 
    oprot.writeFieldStop()
12468 
    oprot.writeStructEnd()
12469 
 
12470 
  def validate(self):
12471 
    return
12472 
 
12473 
 
12474 
  def __repr__(self):
12475 
    L = ['%s=%r' % (key, value)
12476 
      for key, value in self.__dict__.iteritems()]
12477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12478 
 
12479 
  def __eq__(self, other):
12480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12481 
 
12482 
  def __ne__(self, other):
12483 
    return not (self == other)
12484 
 
12485 
class markTransactionAsProcessed_args:
12486 
  """
12487 
  Attributes:
12488 
   - transactionId
12489 
   - category
12490 
  """
12491 
 
12492 
  thrift_spec = (
12493 
    None, # 0
12494 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12495 
    (2, TType.I32, 'category', None, None, ), # 2
12496 
  )
12497 
 
12498 
  def __init__(self, transactionId=None, category=None,):
12499 
    self.transactionId = transactionId
12500 
    self.category = category
12501 
 
12502 
  def read(self, iprot):
12503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12505 
      return
12506 
    iprot.readStructBegin()
12507 
    while True:
12508 
      (fname, ftype, fid) = iprot.readFieldBegin()
12509 
      if ftype == TType.STOP:
12510 
        break
12511 
      if fid == 1:
12512 
        if ftype == TType.I64:
12513 
          self.transactionId = iprot.readI64();
12514 
        else:
12515 
          iprot.skip(ftype)
12516 
      elif fid == 2:
12517 
        if ftype == TType.I32:
12518 
          self.category = iprot.readI32();
12519 
        else:
12520 
          iprot.skip(ftype)
12521 
      else:
12522 
        iprot.skip(ftype)
12523 
      iprot.readFieldEnd()
12524 
    iprot.readStructEnd()
12525 
 
12526 
  def write(self, oprot):
12527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12529 
      return
12530 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
12531 
    if self.transactionId is not None:
12532 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12533 
      oprot.writeI64(self.transactionId)
12534 
      oprot.writeFieldEnd()
12535 
    if self.category is not None:
12536 
      oprot.writeFieldBegin('category', TType.I32, 2)
12537 
      oprot.writeI32(self.category)
12538 
      oprot.writeFieldEnd()
12539 
    oprot.writeFieldStop()
12540 
    oprot.writeStructEnd()
12541 
 
12542 
  def validate(self):
12543 
    return
12544 
 
12545 
 
12546 
  def __repr__(self):
12547 
    L = ['%s=%r' % (key, value)
12548 
      for key, value in self.__dict__.iteritems()]
12549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12550 
 
12551 
  def __eq__(self, other):
12552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12553 
 
12554 
  def __ne__(self, other):
12555 
    return not (self == other)
12556 
 
12557 
class markTransactionAsProcessed_result:
12558 
 
12559 
  thrift_spec = (
12560 
  )
12561 
 
12562 
  def read(self, iprot):
12563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12565 
      return
12566 
    iprot.readStructBegin()
12567 
    while True:
12568 
      (fname, ftype, fid) = iprot.readFieldBegin()
12569 
      if ftype == TType.STOP:
12570 
        break
12571 
      else:
12572 
        iprot.skip(ftype)
12573 
      iprot.readFieldEnd()
12574 
    iprot.readStructEnd()
12575 
 
12576 
  def write(self, oprot):
12577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12579 
      return
12580 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
12581 
    oprot.writeFieldStop()
12582 
    oprot.writeStructEnd()
12583 
 
12584 
  def validate(self):
12585 
    return
12586 
 
12587 
 
12588 
  def __repr__(self):
12589 
    L = ['%s=%r' % (key, value)
12590 
      for key, value in self.__dict__.iteritems()]
12591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12592 
 
12593 
  def __eq__(self, other):
12594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12595 
 
12596 
  def __ne__(self, other):
12597 
    return not (self == other)
4018 chandransh 12598 
 
12599 
class getItemWiseRiskyOrdersCount_args:
12600 
 
12601 
  thrift_spec = (
12602 
  )
12603 
 
12604 
  def read(self, iprot):
12605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12607 
      return
12608 
    iprot.readStructBegin()
12609 
    while True:
12610 
      (fname, ftype, fid) = iprot.readFieldBegin()
12611 
      if ftype == TType.STOP:
12612 
        break
12613 
      else:
12614 
        iprot.skip(ftype)
12615 
      iprot.readFieldEnd()
12616 
    iprot.readStructEnd()
12617 
 
12618 
  def write(self, oprot):
12619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12621 
      return
12622 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
12623 
    oprot.writeFieldStop()
12624 
    oprot.writeStructEnd()
12625 
 
12626 
  def validate(self):
12627 
    return
12628 
 
12629 
 
12630 
  def __repr__(self):
12631 
    L = ['%s=%r' % (key, value)
12632 
      for key, value in self.__dict__.iteritems()]
12633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12634 
 
12635 
  def __eq__(self, other):
12636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12637 
 
12638 
  def __ne__(self, other):
12639 
    return not (self == other)
12640 
 
12641 
class getItemWiseRiskyOrdersCount_result:
12642 
  """
12643 
  Attributes:
12644 
   - success
12645 
  """
12646 
 
12647 
  thrift_spec = (
12648 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
12649 
  )
12650 
 
12651 
  def __init__(self, success=None,):
12652 
    self.success = success
12653 
 
12654 
  def read(self, iprot):
12655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12657 
      return
12658 
    iprot.readStructBegin()
12659 
    while True:
12660 
      (fname, ftype, fid) = iprot.readFieldBegin()
12661 
      if ftype == TType.STOP:
12662 
        break
12663 
      if fid == 0:
12664 
        if ftype == TType.MAP:
12665 
          self.success = {}
4133 chandransh 12666 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
12667 
          for _i242 in xrange(_size238):
12668 
            _key243 = iprot.readI64();
12669 
            _val244 = iprot.readI64();
12670 
            self.success[_key243] = _val244
4018 chandransh 12671 
          iprot.readMapEnd()
12672 
        else:
12673 
          iprot.skip(ftype)
12674 
      else:
12675 
        iprot.skip(ftype)
12676 
      iprot.readFieldEnd()
12677 
    iprot.readStructEnd()
12678 
 
12679 
  def write(self, oprot):
12680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12682 
      return
12683 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
12684 
    if self.success is not None:
12685 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12686 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 12687 
      for kiter245,viter246 in self.success.items():
12688 
        oprot.writeI64(kiter245)
12689 
        oprot.writeI64(viter246)
4018 chandransh 12690 
      oprot.writeMapEnd()
12691 
      oprot.writeFieldEnd()
12692 
    oprot.writeFieldStop()
12693 
    oprot.writeStructEnd()
12694 
 
12695 
  def validate(self):
12696 
    return
12697 
 
12698 
 
12699 
  def __repr__(self):
12700 
    L = ['%s=%r' % (key, value)
12701 
      for key, value in self.__dict__.iteritems()]
12702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12703 
 
12704 
  def __eq__(self, other):
12705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12706 
 
12707 
  def __ne__(self, other):
12708 
    return not (self == other)
4247 rajveer 12709 
 
12710 
class markOrderCancellationRequestReceived_args:
12711 
  """
12712 
  Attributes:
12713 
   - orderId
12714 
  """
12715 
 
12716 
  thrift_spec = (
12717 
    None, # 0
12718 
    (1, TType.I64, 'orderId', None, None, ), # 1
12719 
  )
12720 
 
12721 
  def __init__(self, orderId=None,):
12722 
    self.orderId = orderId
12723 
 
12724 
  def read(self, iprot):
12725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12727 
      return
12728 
    iprot.readStructBegin()
12729 
    while True:
12730 
      (fname, ftype, fid) = iprot.readFieldBegin()
12731 
      if ftype == TType.STOP:
12732 
        break
12733 
      if fid == 1:
12734 
        if ftype == TType.I64:
12735 
          self.orderId = iprot.readI64();
12736 
        else:
12737 
          iprot.skip(ftype)
12738 
      else:
12739 
        iprot.skip(ftype)
12740 
      iprot.readFieldEnd()
12741 
    iprot.readStructEnd()
12742 
 
12743 
  def write(self, oprot):
12744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12746 
      return
12747 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
12748 
    if self.orderId is not None:
12749 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12750 
      oprot.writeI64(self.orderId)
12751 
      oprot.writeFieldEnd()
12752 
    oprot.writeFieldStop()
12753 
    oprot.writeStructEnd()
12754 
 
12755 
  def validate(self):
12756 
    return
12757 
 
12758 
 
12759 
  def __repr__(self):
12760 
    L = ['%s=%r' % (key, value)
12761 
      for key, value in self.__dict__.iteritems()]
12762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12763 
 
12764 
  def __eq__(self, other):
12765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12766 
 
12767 
  def __ne__(self, other):
12768 
    return not (self == other)
12769 
 
12770 
class markOrderCancellationRequestReceived_result:
12771 
  """
12772 
  Attributes:
12773 
   - ex
12774 
  """
12775 
 
12776 
  thrift_spec = (
12777 
    None, # 0
12778 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12779 
  )
12780 
 
12781 
  def __init__(self, ex=None,):
12782 
    self.ex = ex
12783 
 
12784 
  def read(self, iprot):
12785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12787 
      return
12788 
    iprot.readStructBegin()
12789 
    while True:
12790 
      (fname, ftype, fid) = iprot.readFieldBegin()
12791 
      if ftype == TType.STOP:
12792 
        break
12793 
      if fid == 1:
12794 
        if ftype == TType.STRUCT:
12795 
          self.ex = TransactionServiceException()
12796 
          self.ex.read(iprot)
12797 
        else:
12798 
          iprot.skip(ftype)
12799 
      else:
12800 
        iprot.skip(ftype)
12801 
      iprot.readFieldEnd()
12802 
    iprot.readStructEnd()
12803 
 
12804 
  def write(self, oprot):
12805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12807 
      return
12808 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
12809 
    if self.ex is not None:
12810 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12811 
      self.ex.write(oprot)
12812 
      oprot.writeFieldEnd()
12813 
    oprot.writeFieldStop()
12814 
    oprot.writeStructEnd()
12815 
 
12816 
  def validate(self):
12817 
    return
12818 
 
12819 
 
12820 
  def __repr__(self):
12821 
    L = ['%s=%r' % (key, value)
12822 
      for key, value in self.__dict__.iteritems()]
12823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12824 
 
12825 
  def __eq__(self, other):
12826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12827 
 
12828 
  def __ne__(self, other):
12829 
    return not (self == other)
12830 
 
12831 
class markOrderCancellationRequestConfirmed_args:
12832 
  """
12833 
  Attributes:
12834 
   - orderId
12835 
  """
12836 
 
12837 
  thrift_spec = (
12838 
    None, # 0
12839 
    (1, TType.I64, 'orderId', None, None, ), # 1
12840 
  )
12841 
 
12842 
  def __init__(self, orderId=None,):
12843 
    self.orderId = orderId
12844 
 
12845 
  def read(self, iprot):
12846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12848 
      return
12849 
    iprot.readStructBegin()
12850 
    while True:
12851 
      (fname, ftype, fid) = iprot.readFieldBegin()
12852 
      if ftype == TType.STOP:
12853 
        break
12854 
      if fid == 1:
12855 
        if ftype == TType.I64:
12856 
          self.orderId = iprot.readI64();
12857 
        else:
12858 
          iprot.skip(ftype)
12859 
      else:
12860 
        iprot.skip(ftype)
12861 
      iprot.readFieldEnd()
12862 
    iprot.readStructEnd()
12863 
 
12864 
  def write(self, oprot):
12865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12867 
      return
12868 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
12869 
    if self.orderId is not None:
12870 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12871 
      oprot.writeI64(self.orderId)
12872 
      oprot.writeFieldEnd()
12873 
    oprot.writeFieldStop()
12874 
    oprot.writeStructEnd()
12875 
 
12876 
  def validate(self):
12877 
    return
12878 
 
12879 
 
12880 
  def __repr__(self):
12881 
    L = ['%s=%r' % (key, value)
12882 
      for key, value in self.__dict__.iteritems()]
12883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12884 
 
12885 
  def __eq__(self, other):
12886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12887 
 
12888 
  def __ne__(self, other):
12889 
    return not (self == other)
12890 
 
12891 
class markOrderCancellationRequestConfirmed_result:
12892 
  """
12893 
  Attributes:
12894 
   - ex
12895 
  """
12896 
 
12897 
  thrift_spec = (
12898 
    None, # 0
12899 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12900 
  )
12901 
 
12902 
  def __init__(self, ex=None,):
12903 
    self.ex = ex
12904 
 
12905 
  def read(self, iprot):
12906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12908 
      return
12909 
    iprot.readStructBegin()
12910 
    while True:
12911 
      (fname, ftype, fid) = iprot.readFieldBegin()
12912 
      if ftype == TType.STOP:
12913 
        break
12914 
      if fid == 1:
12915 
        if ftype == TType.STRUCT:
12916 
          self.ex = TransactionServiceException()
12917 
          self.ex.read(iprot)
12918 
        else:
12919 
          iprot.skip(ftype)
12920 
      else:
12921 
        iprot.skip(ftype)
12922 
      iprot.readFieldEnd()
12923 
    iprot.readStructEnd()
12924 
 
12925 
  def write(self, oprot):
12926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12928 
      return
12929 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
12930 
    if self.ex is not None:
12931 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12932 
      self.ex.write(oprot)
12933 
      oprot.writeFieldEnd()
12934 
    oprot.writeFieldStop()
12935 
    oprot.writeStructEnd()
12936 
 
12937 
  def validate(self):
12938 
    return
12939 
 
12940 
 
12941 
  def __repr__(self):
12942 
    L = ['%s=%r' % (key, value)
12943 
      for key, value in self.__dict__.iteritems()]
12944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12945 
 
12946 
  def __eq__(self, other):
12947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12948 
 
12949 
  def __ne__(self, other):
12950 
    return not (self == other)
12951 
 
12952 
class markOrderCancellationRequestDenied_args:
12953 
  """
12954 
  Attributes:
12955 
   - orderId
12956 
  """
12957 
 
12958 
  thrift_spec = (
12959 
    None, # 0
12960 
    (1, TType.I64, 'orderId', None, None, ), # 1
12961 
  )
12962 
 
12963 
  def __init__(self, orderId=None,):
12964 
    self.orderId = orderId
12965 
 
12966 
  def read(self, iprot):
12967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12969 
      return
12970 
    iprot.readStructBegin()
12971 
    while True:
12972 
      (fname, ftype, fid) = iprot.readFieldBegin()
12973 
      if ftype == TType.STOP:
12974 
        break
12975 
      if fid == 1:
12976 
        if ftype == TType.I64:
12977 
          self.orderId = iprot.readI64();
12978 
        else:
12979 
          iprot.skip(ftype)
12980 
      else:
12981 
        iprot.skip(ftype)
12982 
      iprot.readFieldEnd()
12983 
    iprot.readStructEnd()
12984 
 
12985 
  def write(self, oprot):
12986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12988 
      return
12989 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
12990 
    if self.orderId is not None:
12991 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12992 
      oprot.writeI64(self.orderId)
12993 
      oprot.writeFieldEnd()
12994 
    oprot.writeFieldStop()
12995 
    oprot.writeStructEnd()
12996 
 
12997 
  def validate(self):
12998 
    return
12999 
 
13000 
 
13001 
  def __repr__(self):
13002 
    L = ['%s=%r' % (key, value)
13003 
      for key, value in self.__dict__.iteritems()]
13004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13005 
 
13006 
  def __eq__(self, other):
13007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13008 
 
13009 
  def __ne__(self, other):
13010 
    return not (self == other)
13011 
 
13012 
class markOrderCancellationRequestDenied_result:
13013 
  """
13014 
  Attributes:
13015 
   - ex
13016 
  """
13017 
 
13018 
  thrift_spec = (
13019 
    None, # 0
13020 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13021 
  )
13022 
 
13023 
  def __init__(self, ex=None,):
13024 
    self.ex = ex
13025 
 
13026 
  def read(self, iprot):
13027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13029 
      return
13030 
    iprot.readStructBegin()
13031 
    while True:
13032 
      (fname, ftype, fid) = iprot.readFieldBegin()
13033 
      if ftype == TType.STOP:
13034 
        break
13035 
      if fid == 1:
13036 
        if ftype == TType.STRUCT:
13037 
          self.ex = TransactionServiceException()
13038 
          self.ex.read(iprot)
13039 
        else:
13040 
          iprot.skip(ftype)
13041 
      else:
13042 
        iprot.skip(ftype)
13043 
      iprot.readFieldEnd()
13044 
    iprot.readStructEnd()
13045 
 
13046 
  def write(self, oprot):
13047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13049 
      return
13050 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
13051 
    if self.ex is not None:
13052 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13053 
      self.ex.write(oprot)
13054 
      oprot.writeFieldEnd()
13055 
    oprot.writeFieldStop()
13056 
    oprot.writeStructEnd()
13057 
 
13058 
  def validate(self):
13059 
    return
13060 
 
13061 
 
13062 
  def __repr__(self):
13063 
    L = ['%s=%r' % (key, value)
13064 
      for key, value in self.__dict__.iteritems()]
13065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13066 
 
13067 
  def __eq__(self, other):
13068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13069 
 
13070 
  def __ne__(self, other):
13071 
    return not (self == other)
13072 
 
4258 rajveer 13073 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 13074 
  """
13075 
  Attributes:
4258 rajveer 13076 
   - transactionId
4247 rajveer 13077 
  """
13078 
 
13079 
  thrift_spec = (
13080 
    None, # 0
4258 rajveer 13081 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 13082 
  )
13083 
 
4258 rajveer 13084 
  def __init__(self, transactionId=None,):
13085 
    self.transactionId = transactionId
4247 rajveer 13086 
 
13087 
  def read(self, iprot):
13088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13090 
      return
13091 
    iprot.readStructBegin()
13092 
    while True:
13093 
      (fname, ftype, fid) = iprot.readFieldBegin()
13094 
      if ftype == TType.STOP:
13095 
        break
13096 
      if fid == 1:
13097 
        if ftype == TType.I64:
4258 rajveer 13098 
          self.transactionId = iprot.readI64();
4247 rajveer 13099 
        else:
13100 
          iprot.skip(ftype)
13101 
      else:
13102 
        iprot.skip(ftype)
13103 
      iprot.readFieldEnd()
13104 
    iprot.readStructEnd()
13105 
 
13106 
  def write(self, oprot):
13107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13109 
      return
4258 rajveer 13110 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
13111 
    if self.transactionId is not None:
13112 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13113 
      oprot.writeI64(self.transactionId)
4247 rajveer 13114 
      oprot.writeFieldEnd()
13115 
    oprot.writeFieldStop()
13116 
    oprot.writeStructEnd()
13117 
 
13118 
  def validate(self):
13119 
    return
13120 
 
13121 
 
13122 
  def __repr__(self):
13123 
    L = ['%s=%r' % (key, value)
13124 
      for key, value in self.__dict__.iteritems()]
13125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13126 
 
13127 
  def __eq__(self, other):
13128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13129 
 
13130 
  def __ne__(self, other):
13131 
    return not (self == other)
13132 
 
4258 rajveer 13133 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 13134 
  """
13135 
  Attributes:
13136 
   - ex
13137 
  """
13138 
 
13139 
  thrift_spec = (
13140 
    None, # 0
13141 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13142 
  )
13143 
 
13144 
  def __init__(self, ex=None,):
13145 
    self.ex = ex
13146 
 
13147 
  def read(self, iprot):
13148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13150 
      return
13151 
    iprot.readStructBegin()
13152 
    while True:
13153 
      (fname, ftype, fid) = iprot.readFieldBegin()
13154 
      if ftype == TType.STOP:
13155 
        break
13156 
      if fid == 1:
13157 
        if ftype == TType.STRUCT:
13158 
          self.ex = TransactionServiceException()
13159 
          self.ex.read(iprot)
13160 
        else:
13161 
          iprot.skip(ftype)
13162 
      else:
13163 
        iprot.skip(ftype)
13164 
      iprot.readFieldEnd()
13165 
    iprot.readStructEnd()
13166 
 
13167 
  def write(self, oprot):
13168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13170 
      return
4258 rajveer 13171 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 13172 
    if self.ex is not None:
13173 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13174 
      self.ex.write(oprot)
13175 
      oprot.writeFieldEnd()
13176 
    oprot.writeFieldStop()
13177 
    oprot.writeStructEnd()
13178 
 
13179 
  def validate(self):
13180 
    return
13181 
 
13182 
 
13183 
  def __repr__(self):
13184 
    L = ['%s=%r' % (key, value)
13185 
      for key, value in self.__dict__.iteritems()]
13186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13187 
 
13188 
  def __eq__(self, other):
13189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13190 
 
13191 
  def __ne__(self, other):
13192 
    return not (self == other)
4259 anupam.sin 13193 
 
13194 
class refundTransaction_args:
13195 
  """
13196 
  Attributes:
13197 
   - transactionId
13198 
   - refundedBy
13199 
   - reason
13200 
  """
13201 
 
13202 
  thrift_spec = (
13203 
    None, # 0
13204 
    (1, TType.I64, 'transactionId', None, None, ), # 1
13205 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13206 
    (3, TType.STRING, 'reason', None, None, ), # 3
13207 
  )
13208 
 
13209 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
13210 
    self.transactionId = transactionId
13211 
    self.refundedBy = refundedBy
13212 
    self.reason = reason
13213 
 
13214 
  def read(self, iprot):
13215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13217 
      return
13218 
    iprot.readStructBegin()
13219 
    while True:
13220 
      (fname, ftype, fid) = iprot.readFieldBegin()
13221 
      if ftype == TType.STOP:
13222 
        break
13223 
      if fid == 1:
13224 
        if ftype == TType.I64:
13225 
          self.transactionId = iprot.readI64();
13226 
        else:
13227 
          iprot.skip(ftype)
13228 
      elif fid == 2:
13229 
        if ftype == TType.STRING:
13230 
          self.refundedBy = iprot.readString();
13231 
        else:
13232 
          iprot.skip(ftype)
13233 
      elif fid == 3:
13234 
        if ftype == TType.STRING:
13235 
          self.reason = iprot.readString();
13236 
        else:
13237 
          iprot.skip(ftype)
13238 
      else:
13239 
        iprot.skip(ftype)
13240 
      iprot.readFieldEnd()
13241 
    iprot.readStructEnd()
13242 
 
13243 
  def write(self, oprot):
13244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13246 
      return
13247 
    oprot.writeStructBegin('refundTransaction_args')
13248 
    if self.transactionId is not None:
13249 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13250 
      oprot.writeI64(self.transactionId)
13251 
      oprot.writeFieldEnd()
13252 
    if self.refundedBy is not None:
13253 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13254 
      oprot.writeString(self.refundedBy)
13255 
      oprot.writeFieldEnd()
13256 
    if self.reason is not None:
13257 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13258 
      oprot.writeString(self.reason)
13259 
      oprot.writeFieldEnd()
13260 
    oprot.writeFieldStop()
13261 
    oprot.writeStructEnd()
13262 
 
13263 
  def validate(self):
13264 
    return
13265 
 
13266 
 
13267 
  def __repr__(self):
13268 
    L = ['%s=%r' % (key, value)
13269 
      for key, value in self.__dict__.iteritems()]
13270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13271 
 
13272 
  def __eq__(self, other):
13273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13274 
 
13275 
  def __ne__(self, other):
13276 
    return not (self == other)
13277 
 
13278 
class refundTransaction_result:
13279 
  """
13280 
  Attributes:
13281 
   - ex
13282 
  """
13283 
 
13284 
  thrift_spec = (
13285 
    None, # 0
13286 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13287 
  )
13288 
 
13289 
  def __init__(self, ex=None,):
13290 
    self.ex = ex
13291 
 
13292 
  def read(self, iprot):
13293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13295 
      return
13296 
    iprot.readStructBegin()
13297 
    while True:
13298 
      (fname, ftype, fid) = iprot.readFieldBegin()
13299 
      if ftype == TType.STOP:
13300 
        break
13301 
      if fid == 1:
13302 
        if ftype == TType.STRUCT:
13303 
          self.ex = TransactionServiceException()
13304 
          self.ex.read(iprot)
13305 
        else:
13306 
          iprot.skip(ftype)
13307 
      else:
13308 
        iprot.skip(ftype)
13309 
      iprot.readFieldEnd()
13310 
    iprot.readStructEnd()
13311 
 
13312 
  def write(self, oprot):
13313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13315 
      return
13316 
    oprot.writeStructBegin('refundTransaction_result')
13317 
    if self.ex is not None:
13318 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13319 
      self.ex.write(oprot)
13320 
      oprot.writeFieldEnd()
13321 
    oprot.writeFieldStop()
13322 
    oprot.writeStructEnd()
13323 
 
13324 
  def validate(self):
13325 
    return
13326 
 
13327 
 
13328 
  def __repr__(self):
13329 
    L = ['%s=%r' % (key, value)
13330 
      for key, value in self.__dict__.iteritems()]
13331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13332 
 
13333 
  def __eq__(self, other):
13334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13335 
 
13336 
  def __ne__(self, other):
13337 
    return not (self == other)