Subversion Repositories SmartDukaan

Rev

Rev 3427 | Rev 3451 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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