Subversion Repositories SmartDukaan

Rev

Rev 4789 | Rev 4815 | 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 
 
4801 anupam.sin 74 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
4801 anupam.sin 77 
     - statuses
483 rajveer 78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
4444 rajveer 219 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 220 
    """
221 
    Parameters:
4394 rajveer 222 
     - type
4444 rajveer 223 
     - warehouseId
4394 rajveer 224 
     - status
225 
     - timestamp
3064 chandransh 226 
    """
227 
    pass
228 
 
4444 rajveer 229 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 230 
    """
231 
    Parameters:
232 
     - type
4444 rajveer 233 
     - warehouseId
4394 rajveer 234 
     - description
3064 chandransh 235 
    """
236 
    pass
237 
 
4444 rajveer 238 
  def markAlertsAsSeen(self, warehouseId):
239 
    """
240 
    Parameters:
241 
     - warehouseId
242 
    """
243 
    pass
244 
 
3064 chandransh 245 
  def getValidOrderCount(self, ):
246 
    """
247 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
248 
    """
249 
    pass
250 
 
251 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
252 
    """
253 
    Returns the number of distinct customers who have done successful transactions
254 
    """
255 
    pass
256 
 
257 
  def getValidOrdersAmountRange(self, ):
258 
    """
259 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
260 
    List contains two values, first minimum amount and second maximum amount.
261 
    """
262 
    pass
263 
 
264 
  def getValidOrders(self, limit):
265 
    """
266 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
267 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 268 
 
3064 chandransh 269 
    Parameters:
270 
     - limit
271 
    """
272 
    pass
273 
 
1220 chandransh 274 
  def batchOrders(self, warehouseId):
275 
    """
276 
    Create a batch of all the pending orders for the given warehouse.
277 
    The returned list is orderd by created_timestamp.
278 
    If there are no pending orders, an empty list is returned.
3431 rajveer 279 
 
1220 chandransh 280 
    Parameters:
281 
     - warehouseId
282 
    """
283 
    pass
284 
 
1208 chandransh 285 
  def markOrderAsOutOfStock(self, orderId):
286 
    """
287 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 288 
 
1208 chandransh 289 
    Parameters:
290 
     - orderId
291 
    """
292 
    pass
293 
 
3064 chandransh 294 
  def verifyOrder(self, orderId):
759 chandransh 295 
    """
3064 chandransh 296 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
297 
    timestamp. It is intended to be used for COD orders but can be harmlessly
298 
    used for all other orders as well.
299 
    Throws an exception if no such order exists.
3431 rajveer 300 
 
759 chandransh 301 
    Parameters:
3064 chandransh 302 
     - orderId
303 
    """
304 
    pass
305 
 
306 
  def acceptOrder(self, orderId):
307 
    """
308 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
309 
    given order is not a COD order, it also captures the payment if the same has
310 
    not been captured.
311 
    Throws an exception if no such order exists.
3431 rajveer 312 
 
3064 chandransh 313 
    Parameters:
314 
     - orderId
315 
    """
316 
    pass
317 
 
4763 rajveer 318 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 319 
    """
320 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 321 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 322 
    the IMEI no. if a -1 is supplied.
323 
    Also, it generates an invoice number for the order, marks the order as
324 
    BILLED and sets the billing timestamp.
325 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 326 
 
3064 chandransh 327 
    Parameters:
328 
     - orderId
4283 anupam.sin 329 
     - invoice_number
4658 mandeep.dh 330 
     - serialNumber
3064 chandransh 331 
     - itemNumber
4283 anupam.sin 332 
     - billed_by
333 
     - jacketNumber
3064 chandransh 334 
     - billingType
4283 anupam.sin 335 
     - vendorId
4763 rajveer 336 
     - authorize
3064 chandransh 337 
    """
338 
    pass
339 
 
4763 rajveer 340 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 341 
    """
342 
    Add the invoice number to the order.
343 
 
344 
    Parameters:
345 
     - orderId
346 
     - invoiceNumber
4763 rajveer 347 
     - color
4579 rajveer 348 
    """
349 
    pass
350 
 
3064 chandransh 351 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
352 
    """
353 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 354 
    given warehouse and were picked up by the given provider as MANIFESTED.
355 
 
356 
    Parameters:
357 
     - warehouseId
358 
     - providerId
359 
     - cod
360 
    """
361 
    pass
362 
 
4789 rajveer 363 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
4410 rajveer 364 
    """
365 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
3064 chandransh 366 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 367 
 
3064 chandransh 368 
    Parameters:
759 chandransh 369 
     - warehouseId
370 
     - providerId
3064 chandransh 371 
     - cod
4789 rajveer 372 
     - orderIds
759 chandransh 373 
    """
374 
    pass
375 
 
1113 chandransh 376 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
377 
    """
378 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
379 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
380 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 381 
 
1113 chandransh 382 
    Parameters:
383 
     - providerId
384 
     - pickupDetails
385 
    """
386 
    pass
387 
 
1132 chandransh 388 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
389 
    """
390 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
391 
    the name of the receiver.
392 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 393 
 
1132 chandransh 394 
    Parameters:
395 
     - providerId
396 
     - deliveredOrders
397 
    """
398 
    pass
399 
 
1135 chandransh 400 
  def markOrdersAsFailed(self, providerId, returnedOrders):
401 
    """
402 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
403 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 404 
 
1135 chandransh 405 
    Parameters:
406 
     - providerId
407 
     - returnedOrders
408 
    """
409 
    pass
410 
 
1246 chandransh 411 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
412 
    """
413 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 414 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 415 
 
1246 chandransh 416 
    Parameters:
417 
     - providerId
418 
     - undeliveredOrders
419 
    """
420 
    pass
421 
 
1408 ankur.sing 422 
  def getUndeliveredOrders(self, providerId, warehouseId):
423 
    """
424 
    Returns the list of orders whose delivery time has passed but have not been
425 
    delivered yet for the given provider and warehouse. To get a complete list of
426 
    undelivered orders, pass them as -1.
427 
    Returns an empty list if no such orders exist.
3431 rajveer 428 
 
1408 ankur.sing 429 
    Parameters:
430 
     - providerId
431 
     - warehouseId
432 
    """
433 
    pass
434 
 
4783 phani.kuma 435 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
436 
    """
437 
    Returns the list of orders whose expected delivery date has passed but have not been
438 
    delivered yet.
439 
    Returns an empty list if no such orders exist.
440 
    """
441 
    pass
442 
 
2536 chandransh 443 
  def toggleDOAFlag(self, orderId):
444 
    """
445 
    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.
446 
    Returns the final flag status.
447 
    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 448 
 
2536 chandransh 449 
    Parameters:
450 
     - orderId
451 
    """
452 
    pass
1886 ankur.sing 453 
 
4712 rajveer 454 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
455 
    """
456 
    Parameters:
457 
     - orderId
458 
     - deliveryTimestamp
459 
     - receiver
460 
    """
461 
    pass
462 
 
4454 rajveer 463 
  def markOrderDoaRequestReceived(self, orderId):
464 
    """
465 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
466 
 
467 
    Parameters:
468 
     - orderId
469 
    """
470 
    pass
471 
 
472 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
473 
    """
474 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
475 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
476 
 
477 
    Parameters:
478 
     - orderId
479 
     - isAuthorized
480 
    """
481 
    pass
482 
 
4488 rajveer 483 
  def markOrderReturnRequestReceived(self, orderId):
484 
    """
485 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
486 
 
487 
    Parameters:
488 
     - orderId
489 
    """
490 
    pass
491 
 
492 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
493 
    """
494 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
495 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
496 
 
497 
    Parameters:
498 
     - orderId
499 
     - isAuthorized
500 
    """
501 
    pass
502 
 
4579 rajveer 503 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 504 
    """
505 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 506 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
507 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 508 
    For any other status, it returns false.
509 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 510 
 
2536 chandransh 511 
    Parameters:
512 
     - orderId
4579 rajveer 513 
     - providerId
2536 chandransh 514 
    """
515 
    pass
516 
 
4602 rajveer 517 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 518 
    """
4452 rajveer 519 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 520 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
521 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
522 
    	3. Returns true
2591 chandransh 523 
    If the order is in any other status, it returns false.
2536 chandransh 524 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 525 
 
2536 chandransh 526 
    Parameters:
527 
     - orderId
528 
     - pickupNumber
4602 rajveer 529 
     - providerId
2536 chandransh 530 
    """
531 
    pass
532 
 
2764 chandransh 533 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
534 
    """
535 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
536 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 537 
 
2764 chandransh 538 
    Parameters:
539 
     - providerId
540 
     - pickupDetails
541 
    """
542 
    pass
543 
 
4741 phani.kuma 544 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
545 
    """
546 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
547 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
548 
 
549 
    Parameters:
550 
     - providerId
551 
     - pickupDetails
552 
    """
553 
    pass
554 
 
4479 rajveer 555 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 556 
    """
4452 rajveer 557 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 558 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 559 
    If the order is in any other state, it returns false.
560 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 561 
 
2591 chandransh 562 
    Parameters:
563 
     - orderId
4479 rajveer 564 
     - receiveCondition
2591 chandransh 565 
    """
566 
    pass
2536 chandransh 567 
 
2591 chandransh 568 
  def validateDoa(self, orderId, isValid):
569 
    """
4452 rajveer 570 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 571 
    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 572 
    If the order is in any other state, it returns false.
573 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 574 
 
2591 chandransh 575 
    Parameters:
576 
     - orderId
577 
     - isValid
578 
    """
579 
    pass
580 
 
4495 rajveer 581 
  def validateReturnProduct(self, orderId, isUsable):
582 
    """
583 
    Parameters:
584 
     - orderId
585 
     - isUsable
586 
    """
587 
    pass
588 
 
2616 chandransh 589 
  def reshipOrder(self, orderId):
590 
    """
4484 rajveer 591 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 592 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 593 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 594 
 
595 
    If the order is in DOA_CERT_VALID state, it does the following:
596 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
597 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 598 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 599 
 
2616 chandransh 600 
    Returns the id of the newly created order.
3431 rajveer 601 
 
2616 chandransh 602 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 603 
 
2616 chandransh 604 
    Parameters:
605 
     - orderId
606 
    """
607 
    pass
2591 chandransh 608 
 
3226 chandransh 609 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 610 
    """
4484 rajveer 611 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 612 
    	1. Creates a refund request for batch processing.
613 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 614 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 615 
 
2616 chandransh 616 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
617 
    	1. Creates a refund request for batch processing.
3226 chandransh 618 
    	2. Cancels the reservation of the item in the warehouse.
619 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 620 
 
3226 chandransh 621 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
622 
    	1. Cancels the reservation of the item in the warehouse.
623 
    	2. Marks the current order as CANCELED.
624 
 
625 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
626 
 
2616 chandransh 627 
    Returns True if it is successful, False otherwise.
3431 rajveer 628 
 
2616 chandransh 629 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 630 
 
2616 chandransh 631 
    Parameters:
632 
     - orderId
3226 chandransh 633 
     - refundedBy
634 
     - reason
2616 chandransh 635 
    """
636 
    pass
637 
 
2690 chandransh 638 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
639 
    """
640 
    Get all return orders created between the from and to dates for the given warehouse.
641 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 642 
 
2690 chandransh 643 
    Parameters:
644 
     - warehouseId
645 
     - fromDate
646 
     - toDate
647 
    """
648 
    pass
2616 chandransh 649 
 
2700 chandransh 650 
  def getReturnOrder(self, id):
651 
    """
652 
    Returns the ReturnOrder corresponding to the given id.
653 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 654 
 
2700 chandransh 655 
    Parameters:
656 
     - id
657 
    """
658 
    pass
659 
 
2690 chandransh 660 
  def processReturn(self, returnOrderId):
661 
    """
662 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 663 
 
2690 chandransh 664 
    Parameters:
665 
     - returnOrderId
666 
    """
667 
    pass
668 
 
3451 chandransh 669 
  def updateWeight(self, orderId, weight):
670 
    """
671 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 672 
 
3451 chandransh 673 
    Parameters:
674 
     - orderId
675 
     - weight
676 
    """
677 
    pass
678 
 
3469 chandransh 679 
  def changeItem(self, orderId, itemId):
680 
    """
681 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
682 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 683 
 
3469 chandransh 684 
    Parameters:
685 
     - orderId
686 
     - itemId
687 
    """
688 
    pass
689 
 
690 
  def shiftToWarehouse(self, orderId, warehouseId):
691 
    """
692 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
693 
 
694 
    Parameters:
695 
     - orderId
696 
     - warehouseId
697 
    """
698 
    pass
699 
 
4647 rajveer 700 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 701 
    """
702 
    Adds the given delay reason to the given order.
3986 chandransh 703 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 704 
    Raises an exception if no order with the given id can be found.
3469 chandransh 705 
 
3553 chandransh 706 
    Parameters:
707 
     - orderId
708 
     - delayReason
3986 chandransh 709 
     - furtherDelay
4647 rajveer 710 
     - delayReasonText
3553 chandransh 711 
    """
712 
    pass
713 
 
3956 chandransh 714 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
715 
    """
716 
    Marks the COD orders with given AWB nos. as having been processed.
717 
    Updates the captured amount for the corresponding payment.
3553 chandransh 718 
 
3956 chandransh 719 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
720 
    1. There is no order corresponding to an AWB number.
721 
    2. The captured amount for a payment exceeds the total payment.
722 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
723 
 
724 
    Parameters:
725 
     - collectedAmountMap
726 
     - xferBy
727 
     - xferTxnId
728 
     - xferDate
729 
    """
730 
    pass
731 
 
4008 mandeep.dh 732 
  def getTransactionsRequiringExtraProcessing(self, category):
733 
    """
4065 mandeep.dh 734 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 735 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 736 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 737 
 
4008 mandeep.dh 738 
    Parameters:
739 
     - category
740 
    """
741 
    pass
742 
 
743 
  def markTransactionAsProcessed(self, transactionId, category):
744 
    """
745 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 746 
    It essentially deletes the transaction id record for a particular
747 
    processing type category (if present) from DB.
748 
    This is currently used by CRM application.
4008 mandeep.dh 749 
 
750 
    Parameters:
751 
     - transactionId
752 
     - category
753 
    """
754 
    pass
755 
 
4018 chandransh 756 
  def getItemWiseRiskyOrdersCount(self, ):
757 
    """
758 
    Returns a map containing the number of risky orders keyed by item id. A risky order
759 
    is defined as one whose shipping date is about to expire.
760 
    """
761 
    pass
4008 mandeep.dh 762 
 
4295 varun.gupt 763 
  def getOrdersForItemIds(self, itemIds):
764 
    """
765 
    Returns a list of all orders which have items with given id
766 
 
767 
    Parameters:
768 
     - itemIds
769 
    """
770 
    pass
771 
 
4247 rajveer 772 
  def markOrderCancellationRequestReceived(self, orderId):
773 
    """
774 
    Mark order as cancellation request received. If customer sends request of cancellation of
775 
    a particular order, this method will be called. It will just change status of the order
776 
    depending on its current status. It also records the previous status, so that we can move
777 
    back to that status if cancellation request is denied.
4018 chandransh 778 
 
4247 rajveer 779 
    Parameters:
780 
     - orderId
781 
    """
782 
    pass
783 
 
784 
  def markOrderCancellationRequestConfirmed(self, orderId):
785 
    """
786 
    If we decide to to cancel order, CRM will call this method to move the status of order to
787 
    cancellation request confirmed. After this OM will be able to cancel the order.
788 
 
789 
    Parameters:
790 
     - orderId
791 
    """
792 
    pass
793 
 
794 
  def markOrderCancellationRequestDenied(self, orderId):
795 
    """
796 
    If we decide to not to cancel order, we will move the order ro previous status.
797 
 
798 
    Parameters:
799 
     - orderId
800 
    """
801 
    pass
802 
 
4258 rajveer 803 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 804 
    """
4258 rajveer 805 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
806 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 807 
 
808 
    Parameters:
4258 rajveer 809 
     - transactionId
4247 rajveer 810 
    """
811 
    pass
812 
 
4259 anupam.sin 813 
  def refundTransaction(self, transactionId, refundedBy, reason):
814 
    """
815 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
816 
    need to be cancelled
4247 rajveer 817 
 
4259 anupam.sin 818 
    Parameters:
819 
     - transactionId
820 
     - refundedBy
821 
     - reason
822 
    """
823 
    pass
824 
 
4324 mandeep.dh 825 
  def updateShipmentAddress(self, orderId, addressId):
826 
    """
827 
    Updates shipment address of an order. Delivery and shipping date estimates
828 
    etc. are also updated here.
829 
 
830 
    Throws TransactionServiceException in case address change is not
831 
    possible due to certain reasons such as new pincode in address is
832 
    not serviceable etc.
833 
 
834 
    Parameters:
835 
     - orderId
836 
     - addressId
837 
    """
838 
    pass
839 
 
4285 rajveer 840 
  def acceptOrdersForItemId(self, itemId, inventory):
841 
    """
842 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
843 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 844 
 
4285 rajveer 845 
    Parameters:
846 
     - itemId
847 
     - inventory
848 
    """
849 
    pass
850 
 
4369 rajveer 851 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 852 
    """
853 
    Parameters:
854 
     - vendorId
855 
     - itemId
856 
     - quantity
857 
     - estimate
4369 rajveer 858 
     - isReminder
4303 rajveer 859 
    """
860 
    pass
4285 rajveer 861 
 
4369 rajveer 862 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 863 
    """
864 
    Parameters:
865 
     - vendorId
866 
     - itemId
867 
     - quantity
868 
     - estimate
4369 rajveer 869 
     - isReminder
4303 rajveer 870 
    """
871 
    pass
872 
 
4369 rajveer 873 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 874 
    """
875 
    Parameters:
876 
     - vendorId
877 
     - itemId
878 
     - quantity
879 
     - estimate
4369 rajveer 880 
     - isReminder
4303 rajveer 881 
    """
882 
    pass
883 
 
4369 rajveer 884 
  def markOrdersAsTimeout(self, vendorId):
885 
    """
886 
    Parameters:
887 
     - vendorId
888 
    """
889 
    pass
4303 rajveer 890 
 
4662 rajveer 891 
  def markOrderAsLostInTransit(self, orderId):
892 
    """
893 
    Mark order as LOST_IN_TRANSIT
894 
 
895 
    Parameters:
896 
     - orderId
897 
    """
898 
    pass
899 
 
4386 anupam.sin 900 
  def getOrderForAwb(self, awb):
901 
    """
902 
    Returns the order corresponding to an AWB number
4369 rajveer 903 
 
4386 anupam.sin 904 
    Parameters:
905 
     - awb
906 
    """
907 
    pass
908 
 
4506 phani.kuma 909 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
910 
    """
911 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 912 
 
4506 phani.kuma 913 
    Parameters:
914 
     - logistics_provider_id
915 
     - order_status
916 
    """
917 
    pass
918 
 
4600 varun.gupt 919 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
920 
    """
921 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 922 
 
4600 varun.gupt 923 
    Parameters:
924 
     - vendorId
925 
     - billingDateFrom
926 
     - billingDateTo
927 
    """
928 
    pass
929 
 
4607 rajveer 930 
  def getSlippedSippingDateOrders(self, ):
931 
    pass
932 
 
4709 rajveer 933 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
934 
    """
935 
    Parameters:
936 
     - cancelDateFrom
937 
     - cancelDateTo
938 
    """
939 
    pass
940 
 
4600 varun.gupt 941 
  def saveBluedartSettlements(self, mapAWBAndAmount):
942 
    """
943 
    Parameters:
944 
     - mapAWBAndAmount
945 
    """
946 
    pass
947 
 
948 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
949 
    """
950 
    Parameters:
951 
     - settlementDate
952 
     - paymentGatewayId
953 
     - paymentId
954 
     - serviceTax
955 
     - otherCharges
956 
     - netCollection
957 
    """
958 
    pass
959 
 
960 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
961 
    """
962 
    Parameters:
963 
     - settlementId
964 
     - settlementDate
965 
     - transactionDateFrom
966 
     - transactionDateTo
967 
     - amount
968 
    """
969 
    pass
970 
 
971 
  def getSettlementForPaymentId(self, paymentId):
972 
    """
973 
    Parameters:
974 
     - paymentId
975 
    """
976 
    pass
977 
 
978 
  def getEBSSettlementSummaries(self, ):
979 
    pass
980 
 
981 
  def markEBSSettlementUploaded(self, settlementId):
982 
    """
983 
    Parameters:
984 
     - settlementId
985 
    """
986 
    pass
987 
 
988 
  def getEBSSettlementDate(self, settlementId):
989 
    """
990 
    Parameters:
991 
     - settlementId
992 
    """
993 
    pass
994 
 
4715 varun.gupt 995 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
996 
    """
997 
    Parameters:
998 
     - settlementDateFrom
999 
     - settlementDateTo
1000 
     - isRefund
1001 
    """
1002 
    pass
4600 varun.gupt 1003 
 
4715 varun.gupt 1004 
  def getReshippedOrderIds(self, orderIds):
1005 
    """
1006 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1007 
 
1008 
    Parameters:
1009 
     - orderIds
1010 
    """
1011 
    pass
1012 
 
4757 mandeep.dh 1013 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
1014 
    """
1015 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
1016 
    the quantities for which the PO is raised.
4715 varun.gupt 1017 
 
4757 mandeep.dh 1018 
    Parameters:
1019 
     - itemIdQuantityMap
1020 
     - purchaseOrderId
1021 
     - warehouseId
1022 
    """
1023 
    pass
1024 
 
1025 
 
3376 rajveer 1026 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1027 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1028 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1029 
 
1030 
  def createTransaction(self, transaction):
1031 
    """
1032 
    Parameters:
1033 
     - transaction
1034 
    """
1035 
    self.send_createTransaction(transaction)
132 ashish 1036 
    return self.recv_createTransaction()
94 ashish 1037 
 
1038 
  def send_createTransaction(self, transaction):
1039 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1040 
    args = createTransaction_args()
1041 
    args.transaction = transaction
1042 
    args.write(self._oprot)
1043 
    self._oprot.writeMessageEnd()
1044 
    self._oprot.trans.flush()
1045 
 
1046 
  def recv_createTransaction(self, ):
1047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1048 
    if mtype == TMessageType.EXCEPTION:
1049 
      x = TApplicationException()
1050 
      x.read(self._iprot)
1051 
      self._iprot.readMessageEnd()
1052 
      raise x
1053 
    result = createTransaction_result()
1054 
    result.read(self._iprot)
1055 
    self._iprot.readMessageEnd()
3431 rajveer 1056 
    if result.success is not None:
132 ashish 1057 
      return result.success
3431 rajveer 1058 
    if result.ex is not None:
94 ashish 1059 
      raise result.ex
132 ashish 1060 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1061 
 
1062 
  def getTransaction(self, id):
1063 
    """
1064 
    Parameters:
1065 
     - id
1066 
    """
1067 
    self.send_getTransaction(id)
1068 
    return self.recv_getTransaction()
1069 
 
1070 
  def send_getTransaction(self, id):
1071 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1072 
    args = getTransaction_args()
1073 
    args.id = id
1074 
    args.write(self._oprot)
1075 
    self._oprot.writeMessageEnd()
1076 
    self._oprot.trans.flush()
1077 
 
1078 
  def recv_getTransaction(self, ):
1079 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1080 
    if mtype == TMessageType.EXCEPTION:
1081 
      x = TApplicationException()
1082 
      x.read(self._iprot)
1083 
      self._iprot.readMessageEnd()
1084 
      raise x
1085 
    result = getTransaction_result()
1086 
    result.read(self._iprot)
1087 
    self._iprot.readMessageEnd()
3431 rajveer 1088 
    if result.success is not None:
94 ashish 1089 
      return result.success
3431 rajveer 1090 
    if result.ex is not None:
94 ashish 1091 
      raise result.ex
1092 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1093 
 
1094 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1095 
    """
1096 
    Parameters:
1097 
     - customerId
1098 
     - from_date
1099 
     - to_date
1100 
     - status
1101 
    """
1102 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1103 
    return self.recv_getTransactionsForCustomer()
1104 
 
1105 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1106 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1107 
    args = getTransactionsForCustomer_args()
1108 
    args.customerId = customerId
1109 
    args.from_date = from_date
1110 
    args.to_date = to_date
1111 
    args.status = status
1112 
    args.write(self._oprot)
1113 
    self._oprot.writeMessageEnd()
1114 
    self._oprot.trans.flush()
1115 
 
1116 
  def recv_getTransactionsForCustomer(self, ):
1117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1118 
    if mtype == TMessageType.EXCEPTION:
1119 
      x = TApplicationException()
1120 
      x.read(self._iprot)
1121 
      self._iprot.readMessageEnd()
1122 
      raise x
1123 
    result = getTransactionsForCustomer_result()
1124 
    result.read(self._iprot)
1125 
    self._iprot.readMessageEnd()
3431 rajveer 1126 
    if result.success is not None:
94 ashish 1127 
      return result.success
3431 rajveer 1128 
    if result.ex is not None:
94 ashish 1129 
      raise result.ex
1130 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1131 
 
132 ashish 1132 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1133 
    """
1134 
    Parameters:
1135 
     - shoppingCartId
1136 
    """
1137 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1138 
    return self.recv_getTransactionsForShoppingCartId()
1139 
 
1140 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1141 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1142 
    args = getTransactionsForShoppingCartId_args()
1143 
    args.shoppingCartId = shoppingCartId
1144 
    args.write(self._oprot)
1145 
    self._oprot.writeMessageEnd()
1146 
    self._oprot.trans.flush()
1147 
 
1148 
  def recv_getTransactionsForShoppingCartId(self, ):
1149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1150 
    if mtype == TMessageType.EXCEPTION:
1151 
      x = TApplicationException()
1152 
      x.read(self._iprot)
1153 
      self._iprot.readMessageEnd()
1154 
      raise x
1155 
    result = getTransactionsForShoppingCartId_result()
1156 
    result.read(self._iprot)
1157 
    self._iprot.readMessageEnd()
3431 rajveer 1158 
    if result.success is not None:
132 ashish 1159 
      return result.success
3431 rajveer 1160 
    if result.ex is not None:
132 ashish 1161 
      raise result.ex
1162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1163 
 
94 ashish 1164 
  def getTransactionStatus(self, transactionId):
1165 
    """
1166 
    Parameters:
1167 
     - transactionId
1168 
    """
1169 
    self.send_getTransactionStatus(transactionId)
1170 
    return self.recv_getTransactionStatus()
1171 
 
1172 
  def send_getTransactionStatus(self, transactionId):
1173 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1174 
    args = getTransactionStatus_args()
1175 
    args.transactionId = transactionId
1176 
    args.write(self._oprot)
1177 
    self._oprot.writeMessageEnd()
1178 
    self._oprot.trans.flush()
1179 
 
1180 
  def recv_getTransactionStatus(self, ):
1181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1182 
    if mtype == TMessageType.EXCEPTION:
1183 
      x = TApplicationException()
1184 
      x.read(self._iprot)
1185 
      self._iprot.readMessageEnd()
1186 
      raise x
1187 
    result = getTransactionStatus_result()
1188 
    result.read(self._iprot)
1189 
    self._iprot.readMessageEnd()
3431 rajveer 1190 
    if result.success is not None:
94 ashish 1191 
      return result.success
3431 rajveer 1192 
    if result.ex is not None:
94 ashish 1193 
      raise result.ex
1194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1195 
 
1196 
  def changeTransactionStatus(self, transactionId, status, description):
1197 
    """
1198 
    Parameters:
1199 
     - transactionId
1200 
     - status
1201 
     - description
1202 
    """
1203 
    self.send_changeTransactionStatus(transactionId, status, description)
1204 
    return self.recv_changeTransactionStatus()
1205 
 
1206 
  def send_changeTransactionStatus(self, transactionId, status, description):
1207 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1208 
    args = changeTransactionStatus_args()
1209 
    args.transactionId = transactionId
1210 
    args.status = status
1211 
    args.description = description
1212 
    args.write(self._oprot)
1213 
    self._oprot.writeMessageEnd()
1214 
    self._oprot.trans.flush()
1215 
 
1216 
  def recv_changeTransactionStatus(self, ):
1217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1218 
    if mtype == TMessageType.EXCEPTION:
1219 
      x = TApplicationException()
1220 
      x.read(self._iprot)
1221 
      self._iprot.readMessageEnd()
1222 
      raise x
1223 
    result = changeTransactionStatus_result()
1224 
    result.read(self._iprot)
1225 
    self._iprot.readMessageEnd()
3431 rajveer 1226 
    if result.success is not None:
94 ashish 1227 
      return result.success
3431 rajveer 1228 
    if result.ex is not None:
94 ashish 1229 
      raise result.ex
1230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1231 
 
1398 varun.gupt 1232 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1233 
    """
1234 
    Parameters:
1235 
     - transactionId
1236 
    """
1398 varun.gupt 1237 
    self.send_enqueueTransactionInfoEmail(transactionId)
1238 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1239 
 
1398 varun.gupt 1240 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1241 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1242 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1243 
    args.transactionId = transactionId
1244 
    args.write(self._oprot)
1245 
    self._oprot.writeMessageEnd()
1246 
    self._oprot.trans.flush()
1247 
 
1398 varun.gupt 1248 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1250 
    if mtype == TMessageType.EXCEPTION:
1251 
      x = TApplicationException()
1252 
      x.read(self._iprot)
1253 
      self._iprot.readMessageEnd()
1254 
      raise x
1398 varun.gupt 1255 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1256 
    result.read(self._iprot)
1257 
    self._iprot.readMessageEnd()
3431 rajveer 1258 
    if result.success is not None:
1382 varun.gupt 1259 
      return result.success
3431 rajveer 1260 
    if result.ex is not None:
1382 varun.gupt 1261 
      raise result.ex
1398 varun.gupt 1262 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1263 
 
4801 anupam.sin 1264 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1265 
    """
1266 
    Parameters:
4801 anupam.sin 1267 
     - statuses
483 rajveer 1268 
     - from_date
1269 
     - to_date
1270 
     - warehouse_id
94 ashish 1271 
    """
4801 anupam.sin 1272 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1273 
    return self.recv_getAllOrders()
94 ashish 1274 
 
4801 anupam.sin 1275 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1276 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1277 
    args = getAllOrders_args()
4801 anupam.sin 1278 
    args.statuses = statuses
483 rajveer 1279 
    args.from_date = from_date
1280 
    args.to_date = to_date
1281 
    args.warehouse_id = warehouse_id
94 ashish 1282 
    args.write(self._oprot)
1283 
    self._oprot.writeMessageEnd()
1284 
    self._oprot.trans.flush()
1285 
 
483 rajveer 1286 
  def recv_getAllOrders(self, ):
94 ashish 1287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1288 
    if mtype == TMessageType.EXCEPTION:
1289 
      x = TApplicationException()
1290 
      x.read(self._iprot)
1291 
      self._iprot.readMessageEnd()
1292 
      raise x
483 rajveer 1293 
    result = getAllOrders_result()
94 ashish 1294 
    result.read(self._iprot)
1295 
    self._iprot.readMessageEnd()
3431 rajveer 1296 
    if result.success is not None:
94 ashish 1297 
      return result.success
3431 rajveer 1298 
    if result.ex is not None:
94 ashish 1299 
      raise result.ex
483 rajveer 1300 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1301 
 
4133 chandransh 1302 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1303 
    """
1304 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1305 
    Pass the status as null and the limit as 0 to ignore them.
1306 
 
1307 
    Parameters:
1308 
     - statuses
1309 
     - offset
1310 
     - limit
1311 
     - warehouse_id
1312 
    """
1313 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1314 
    return self.recv_getOrdersInBatch()
1315 
 
1316 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1317 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1318 
    args = getOrdersInBatch_args()
1319 
    args.statuses = statuses
1320 
    args.offset = offset
1321 
    args.limit = limit
1322 
    args.warehouse_id = warehouse_id
1323 
    args.write(self._oprot)
1324 
    self._oprot.writeMessageEnd()
1325 
    self._oprot.trans.flush()
1326 
 
1327 
  def recv_getOrdersInBatch(self, ):
1328 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1329 
    if mtype == TMessageType.EXCEPTION:
1330 
      x = TApplicationException()
1331 
      x.read(self._iprot)
1332 
      self._iprot.readMessageEnd()
1333 
      raise x
1334 
    result = getOrdersInBatch_result()
1335 
    result.read(self._iprot)
1336 
    self._iprot.readMessageEnd()
1337 
    if result.success is not None:
1338 
      return result.success
1339 
    if result.ex is not None:
1340 
      raise result.ex
1341 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1342 
 
1343 
  def getOrderCount(self, statuses, warehouseId):
1344 
    """
1345 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1346 
 
1347 
    Parameters:
1348 
     - statuses
1349 
     - warehouseId
1350 
    """
1351 
    self.send_getOrderCount(statuses, warehouseId)
1352 
    return self.recv_getOrderCount()
1353 
 
1354 
  def send_getOrderCount(self, statuses, warehouseId):
1355 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1356 
    args = getOrderCount_args()
1357 
    args.statuses = statuses
1358 
    args.warehouseId = warehouseId
1359 
    args.write(self._oprot)
1360 
    self._oprot.writeMessageEnd()
1361 
    self._oprot.trans.flush()
1362 
 
1363 
  def recv_getOrderCount(self, ):
1364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1365 
    if mtype == TMessageType.EXCEPTION:
1366 
      x = TApplicationException()
1367 
      x.read(self._iprot)
1368 
      self._iprot.readMessageEnd()
1369 
      raise x
1370 
    result = getOrderCount_result()
1371 
    result.read(self._iprot)
1372 
    self._iprot.readMessageEnd()
1373 
    if result.success is not None:
1374 
      return result.success
1375 
    if result.ex is not None:
1376 
      raise result.ex
1377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1378 
 
999 varun.gupt 1379 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1380 
    """
1132 chandransh 1381 
    Returns orders within a range of their billing dates
3431 rajveer 1382 
 
999 varun.gupt 1383 
    Parameters:
1384 
     - status
1385 
     - start_billing_date
1386 
     - end_billing_date
1387 
     - warehouse_id
1388 
    """
1389 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1390 
    return self.recv_getOrdersByBillingDate()
1391 
 
1392 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1393 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1394 
    args = getOrdersByBillingDate_args()
1395 
    args.status = status
1396 
    args.start_billing_date = start_billing_date
1397 
    args.end_billing_date = end_billing_date
1398 
    args.warehouse_id = warehouse_id
1399 
    args.write(self._oprot)
1400 
    self._oprot.writeMessageEnd()
1401 
    self._oprot.trans.flush()
1402 
 
1403 
  def recv_getOrdersByBillingDate(self, ):
1404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1405 
    if mtype == TMessageType.EXCEPTION:
1406 
      x = TApplicationException()
1407 
      x.read(self._iprot)
1408 
      self._iprot.readMessageEnd()
1409 
      raise x
1410 
    result = getOrdersByBillingDate_result()
1411 
    result.read(self._iprot)
1412 
    self._iprot.readMessageEnd()
3431 rajveer 1413 
    if result.success is not None:
999 varun.gupt 1414 
      return result.success
3431 rajveer 1415 
    if result.ex is not None:
999 varun.gupt 1416 
      raise result.ex
1417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1418 
 
3451 chandransh 1419 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1420 
    """
1421 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1422 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1423 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1424 
 
3427 chandransh 1425 
    Parameters:
1426 
     - fromShippingDate
1427 
     - toShippingDate
1428 
     - providerId
1429 
     - warehouseId
3451 chandransh 1430 
     - cod
3427 chandransh 1431 
    """
3451 chandransh 1432 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1433 
    return self.recv_getOrdersByShippingDate()
1434 
 
3451 chandransh 1435 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1436 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1437 
    args = getOrdersByShippingDate_args()
1438 
    args.fromShippingDate = fromShippingDate
1439 
    args.toShippingDate = toShippingDate
1440 
    args.providerId = providerId
1441 
    args.warehouseId = warehouseId
3451 chandransh 1442 
    args.cod = cod
3427 chandransh 1443 
    args.write(self._oprot)
1444 
    self._oprot.writeMessageEnd()
1445 
    self._oprot.trans.flush()
1446 
 
1447 
  def recv_getOrdersByShippingDate(self, ):
1448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1449 
    if mtype == TMessageType.EXCEPTION:
1450 
      x = TApplicationException()
1451 
      x.read(self._iprot)
1452 
      self._iprot.readMessageEnd()
1453 
      raise x
1454 
    result = getOrdersByShippingDate_result()
1455 
    result.read(self._iprot)
1456 
    self._iprot.readMessageEnd()
3431 rajveer 1457 
    if result.success is not None:
3427 chandransh 1458 
      return result.success
3431 rajveer 1459 
    if result.ex is not None:
3427 chandransh 1460 
      raise result.ex
1461 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1462 
 
1382 varun.gupt 1463 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1464 
    """
1465 
    Returns order ids for orders which can be returned
3431 rajveer 1466 
 
1382 varun.gupt 1467 
    Parameters:
1468 
     - customer_id
1469 
     - limit
1470 
    """
1471 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1472 
    return self.recv_getReturnableOrdersForCustomer()
1473 
 
1474 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1475 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1476 
    args = getReturnableOrdersForCustomer_args()
1477 
    args.customer_id = customer_id
1478 
    args.limit = limit
1479 
    args.write(self._oprot)
1480 
    self._oprot.writeMessageEnd()
1481 
    self._oprot.trans.flush()
1482 
 
1483 
  def recv_getReturnableOrdersForCustomer(self, ):
1484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1485 
    if mtype == TMessageType.EXCEPTION:
1486 
      x = TApplicationException()
1487 
      x.read(self._iprot)
1488 
      self._iprot.readMessageEnd()
1489 
      raise x
1490 
    result = getReturnableOrdersForCustomer_result()
1491 
    result.read(self._iprot)
1492 
    self._iprot.readMessageEnd()
3431 rajveer 1493 
    if result.success is not None:
1382 varun.gupt 1494 
      return result.success
3431 rajveer 1495 
    if result.ex is not None:
1382 varun.gupt 1496 
      raise result.ex
1497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1498 
 
1499 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1500 
    """
1501 
    Returns order ids for orders which can be cancelled
3431 rajveer 1502 
 
1382 varun.gupt 1503 
    Parameters:
1504 
     - customer_id
1505 
     - limit
1506 
    """
1507 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1508 
    return self.recv_getCancellableOrdersForCustomer()
1509 
 
1510 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1511 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1512 
    args = getCancellableOrdersForCustomer_args()
1513 
    args.customer_id = customer_id
1514 
    args.limit = limit
1515 
    args.write(self._oprot)
1516 
    self._oprot.writeMessageEnd()
1517 
    self._oprot.trans.flush()
1518 
 
1519 
  def recv_getCancellableOrdersForCustomer(self, ):
1520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1521 
    if mtype == TMessageType.EXCEPTION:
1522 
      x = TApplicationException()
1523 
      x.read(self._iprot)
1524 
      self._iprot.readMessageEnd()
1525 
      raise x
1526 
    result = getCancellableOrdersForCustomer_result()
1527 
    result.read(self._iprot)
1528 
    self._iprot.readMessageEnd()
3431 rajveer 1529 
    if result.success is not None:
1382 varun.gupt 1530 
      return result.success
3431 rajveer 1531 
    if result.ex is not None:
1382 varun.gupt 1532 
      raise result.ex
1533 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1534 
 
483 rajveer 1535 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1536 
    """
1537 
    Parameters:
483 rajveer 1538 
     - orderId
1539 
     - status
1540 
     - description
94 ashish 1541 
    """
483 rajveer 1542 
    self.send_changeOrderStatus(orderId, status, description)
1543 
    return self.recv_changeOrderStatus()
94 ashish 1544 
 
483 rajveer 1545 
  def send_changeOrderStatus(self, orderId, status, description):
1546 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1547 
    args = changeOrderStatus_args()
1548 
    args.orderId = orderId
1549 
    args.status = status
1550 
    args.description = description
94 ashish 1551 
    args.write(self._oprot)
1552 
    self._oprot.writeMessageEnd()
1553 
    self._oprot.trans.flush()
1554 
 
483 rajveer 1555 
  def recv_changeOrderStatus(self, ):
94 ashish 1556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1557 
    if mtype == TMessageType.EXCEPTION:
1558 
      x = TApplicationException()
1559 
      x.read(self._iprot)
1560 
      self._iprot.readMessageEnd()
1561 
      raise x
483 rajveer 1562 
    result = changeOrderStatus_result()
94 ashish 1563 
    result.read(self._iprot)
1564 
    self._iprot.readMessageEnd()
3431 rajveer 1565 
    if result.success is not None:
94 ashish 1566 
      return result.success
3431 rajveer 1567 
    if result.ex is not None:
94 ashish 1568 
      raise result.ex
483 rajveer 1569 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1570 
 
1528 ankur.sing 1571 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1572 
    """
1528 ankur.sing 1573 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1574 
    only user who owns the transaction can view its order details.
3431 rajveer 1575 
 
94 ashish 1576 
    Parameters:
1577 
     - transactionId
1528 ankur.sing 1578 
     - customerId
94 ashish 1579 
    """
1528 ankur.sing 1580 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1581 
    return self.recv_getOrdersForTransaction()
94 ashish 1582 
 
1528 ankur.sing 1583 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1584 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1585 
    args = getOrdersForTransaction_args()
94 ashish 1586 
    args.transactionId = transactionId
1528 ankur.sing 1587 
    args.customerId = customerId
94 ashish 1588 
    args.write(self._oprot)
1589 
    self._oprot.writeMessageEnd()
1590 
    self._oprot.trans.flush()
1591 
 
483 rajveer 1592 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1594 
    if mtype == TMessageType.EXCEPTION:
1595 
      x = TApplicationException()
1596 
      x.read(self._iprot)
1597 
      self._iprot.readMessageEnd()
1598 
      raise x
483 rajveer 1599 
    result = getOrdersForTransaction_result()
94 ashish 1600 
    result.read(self._iprot)
1601 
    self._iprot.readMessageEnd()
3431 rajveer 1602 
    if result.success is not None:
94 ashish 1603 
      return result.success
3431 rajveer 1604 
    if result.ex is not None:
94 ashish 1605 
      raise result.ex
483 rajveer 1606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1607 
 
3014 chandransh 1608 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1609 
    """
3014 chandransh 1610 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1611 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1612 
 
94 ashish 1613 
    Parameters:
483 rajveer 1614 
     - customerId
1615 
     - from_date
1616 
     - to_date
3014 chandransh 1617 
     - statuses
94 ashish 1618 
    """
3014 chandransh 1619 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1620 
    return self.recv_getOrdersForCustomer()
94 ashish 1621 
 
3014 chandransh 1622 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1623 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1624 
    args = getOrdersForCustomer_args()
1625 
    args.customerId = customerId
1626 
    args.from_date = from_date
1627 
    args.to_date = to_date
3014 chandransh 1628 
    args.statuses = statuses
94 ashish 1629 
    args.write(self._oprot)
1630 
    self._oprot.writeMessageEnd()
1631 
    self._oprot.trans.flush()
1632 
 
483 rajveer 1633 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1635 
    if mtype == TMessageType.EXCEPTION:
1636 
      x = TApplicationException()
1637 
      x.read(self._iprot)
1638 
      self._iprot.readMessageEnd()
1639 
      raise x
483 rajveer 1640 
    result = getOrdersForCustomer_result()
94 ashish 1641 
    result.read(self._iprot)
1642 
    self._iprot.readMessageEnd()
3431 rajveer 1643 
    if result.success is not None:
94 ashish 1644 
      return result.success
3431 rajveer 1645 
    if result.ex is not None:
94 ashish 1646 
      raise result.ex
483 rajveer 1647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1648 
 
483 rajveer 1649 
  def createOrder(self, order):
94 ashish 1650 
    """
1651 
    Parameters:
483 rajveer 1652 
     - order
94 ashish 1653 
    """
483 rajveer 1654 
    self.send_createOrder(order)
1655 
    return self.recv_createOrder()
94 ashish 1656 
 
483 rajveer 1657 
  def send_createOrder(self, order):
1658 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1659 
    args = createOrder_args()
1660 
    args.order = order
94 ashish 1661 
    args.write(self._oprot)
1662 
    self._oprot.writeMessageEnd()
1663 
    self._oprot.trans.flush()
1664 
 
483 rajveer 1665 
  def recv_createOrder(self, ):
94 ashish 1666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1667 
    if mtype == TMessageType.EXCEPTION:
1668 
      x = TApplicationException()
1669 
      x.read(self._iprot)
1670 
      self._iprot.readMessageEnd()
1671 
      raise x
483 rajveer 1672 
    result = createOrder_result()
94 ashish 1673 
    result.read(self._iprot)
1674 
    self._iprot.readMessageEnd()
3431 rajveer 1675 
    if result.success is not None:
94 ashish 1676 
      return result.success
3431 rajveer 1677 
    if result.ex is not None:
94 ashish 1678 
      raise result.ex
483 rajveer 1679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1680 
 
483 rajveer 1681 
  def getOrder(self, id):
94 ashish 1682 
    """
1683 
    Parameters:
483 rajveer 1684 
     - id
94 ashish 1685 
    """
483 rajveer 1686 
    self.send_getOrder(id)
1687 
    return self.recv_getOrder()
94 ashish 1688 
 
483 rajveer 1689 
  def send_getOrder(self, id):
1690 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1691 
    args = getOrder_args()
1692 
    args.id = id
94 ashish 1693 
    args.write(self._oprot)
1694 
    self._oprot.writeMessageEnd()
1695 
    self._oprot.trans.flush()
1696 
 
483 rajveer 1697 
  def recv_getOrder(self, ):
94 ashish 1698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1699 
    if mtype == TMessageType.EXCEPTION:
1700 
      x = TApplicationException()
1701 
      x.read(self._iprot)
1702 
      self._iprot.readMessageEnd()
1703 
      raise x
483 rajveer 1704 
    result = getOrder_result()
94 ashish 1705 
    result.read(self._iprot)
1706 
    self._iprot.readMessageEnd()
3431 rajveer 1707 
    if result.success is not None:
94 ashish 1708 
      return result.success
3431 rajveer 1709 
    if result.ex is not None:
94 ashish 1710 
      raise result.ex
483 rajveer 1711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1712 
 
483 rajveer 1713 
  def getLineItemsForOrder(self, orderId):
94 ashish 1714 
    """
1715 
    Parameters:
483 rajveer 1716 
     - orderId
94 ashish 1717 
    """
483 rajveer 1718 
    self.send_getLineItemsForOrder(orderId)
1719 
    return self.recv_getLineItemsForOrder()
94 ashish 1720 
 
483 rajveer 1721 
  def send_getLineItemsForOrder(self, orderId):
1722 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1723 
    args = getLineItemsForOrder_args()
1724 
    args.orderId = orderId
94 ashish 1725 
    args.write(self._oprot)
1726 
    self._oprot.writeMessageEnd()
1727 
    self._oprot.trans.flush()
1728 
 
483 rajveer 1729 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1731 
    if mtype == TMessageType.EXCEPTION:
1732 
      x = TApplicationException()
1733 
      x.read(self._iprot)
1734 
      self._iprot.readMessageEnd()
1735 
      raise x
483 rajveer 1736 
    result = getLineItemsForOrder_result()
94 ashish 1737 
    result.read(self._iprot)
1738 
    self._iprot.readMessageEnd()
3431 rajveer 1739 
    if result.success is not None:
94 ashish 1740 
      return result.success
3431 rajveer 1741 
    if result.ex is not None:
94 ashish 1742 
      raise result.ex
483 rajveer 1743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1744 
 
1528 ankur.sing 1745 
  def getOrderForCustomer(self, orderId, customerId):
1746 
    """
1747 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1748 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1749 
 
1528 ankur.sing 1750 
    Parameters:
1751 
     - orderId
1752 
     - customerId
1753 
    """
1754 
    self.send_getOrderForCustomer(orderId, customerId)
1755 
    return self.recv_getOrderForCustomer()
1756 
 
1757 
  def send_getOrderForCustomer(self, orderId, customerId):
1758 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1759 
    args = getOrderForCustomer_args()
1760 
    args.orderId = orderId
1761 
    args.customerId = customerId
1762 
    args.write(self._oprot)
1763 
    self._oprot.writeMessageEnd()
1764 
    self._oprot.trans.flush()
1765 
 
1766 
  def recv_getOrderForCustomer(self, ):
1767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1768 
    if mtype == TMessageType.EXCEPTION:
1769 
      x = TApplicationException()
1770 
      x.read(self._iprot)
1771 
      self._iprot.readMessageEnd()
1772 
      raise x
1773 
    result = getOrderForCustomer_result()
1774 
    result.read(self._iprot)
1775 
    self._iprot.readMessageEnd()
3431 rajveer 1776 
    if result.success is not None:
1528 ankur.sing 1777 
      return result.success
3431 rajveer 1778 
    if result.ex is not None:
1528 ankur.sing 1779 
      raise result.ex
1780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1781 
 
4444 rajveer 1782 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1783 
    """
1784 
    Parameters:
4394 rajveer 1785 
     - type
4444 rajveer 1786 
     - warehouseId
4394 rajveer 1787 
     - status
1788 
     - timestamp
3064 chandransh 1789 
    """
4444 rajveer 1790 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1791 
    return self.recv_getAlerts()
1792 
 
4444 rajveer 1793 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1794 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1795 
    args = getAlerts_args()
4394 rajveer 1796 
    args.type = type
4444 rajveer 1797 
    args.warehouseId = warehouseId
4394 rajveer 1798 
    args.status = status
1799 
    args.timestamp = timestamp
3064 chandransh 1800 
    args.write(self._oprot)
1801 
    self._oprot.writeMessageEnd()
1802 
    self._oprot.trans.flush()
1803 
 
1804 
  def recv_getAlerts(self, ):
1805 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1806 
    if mtype == TMessageType.EXCEPTION:
1807 
      x = TApplicationException()
1808 
      x.read(self._iprot)
1809 
      self._iprot.readMessageEnd()
1810 
      raise x
1811 
    result = getAlerts_result()
1812 
    result.read(self._iprot)
1813 
    self._iprot.readMessageEnd()
3431 rajveer 1814 
    if result.success is not None:
3064 chandransh 1815 
      return result.success
1816 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1817 
 
4444 rajveer 1818 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1819 
    """
1820 
    Parameters:
1821 
     - type
4444 rajveer 1822 
     - warehouseId
4394 rajveer 1823 
     - description
3064 chandransh 1824 
    """
4444 rajveer 1825 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1826 
    self.recv_addAlert()
3064 chandransh 1827 
 
4444 rajveer 1828 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1829 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1830 
    args = addAlert_args()
3064 chandransh 1831 
    args.type = type
4444 rajveer 1832 
    args.warehouseId = warehouseId
4394 rajveer 1833 
    args.description = description
3064 chandransh 1834 
    args.write(self._oprot)
1835 
    self._oprot.writeMessageEnd()
1836 
    self._oprot.trans.flush()
1837 
 
4394 rajveer 1838 
  def recv_addAlert(self, ):
3064 chandransh 1839 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1840 
    if mtype == TMessageType.EXCEPTION:
1841 
      x = TApplicationException()
1842 
      x.read(self._iprot)
1843 
      self._iprot.readMessageEnd()
1844 
      raise x
4394 rajveer 1845 
    result = addAlert_result()
3064 chandransh 1846 
    result.read(self._iprot)
1847 
    self._iprot.readMessageEnd()
1848 
    return
1849 
 
4444 rajveer 1850 
  def markAlertsAsSeen(self, warehouseId):
1851 
    """
1852 
    Parameters:
1853 
     - warehouseId
1854 
    """
1855 
    self.send_markAlertsAsSeen(warehouseId)
1856 
    self.recv_markAlertsAsSeen()
1857 
 
1858 
  def send_markAlertsAsSeen(self, warehouseId):
1859 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1860 
    args = markAlertsAsSeen_args()
1861 
    args.warehouseId = warehouseId
1862 
    args.write(self._oprot)
1863 
    self._oprot.writeMessageEnd()
1864 
    self._oprot.trans.flush()
1865 
 
1866 
  def recv_markAlertsAsSeen(self, ):
1867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1868 
    if mtype == TMessageType.EXCEPTION:
1869 
      x = TApplicationException()
1870 
      x.read(self._iprot)
1871 
      self._iprot.readMessageEnd()
1872 
      raise x
1873 
    result = markAlertsAsSeen_result()
1874 
    result.read(self._iprot)
1875 
    self._iprot.readMessageEnd()
1876 
    return
1877 
 
3064 chandransh 1878 
  def getValidOrderCount(self, ):
1879 
    """
1880 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1881 
    """
1882 
    self.send_getValidOrderCount()
1883 
    return self.recv_getValidOrderCount()
1884 
 
1885 
  def send_getValidOrderCount(self, ):
1886 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1887 
    args = getValidOrderCount_args()
1888 
    args.write(self._oprot)
1889 
    self._oprot.writeMessageEnd()
1890 
    self._oprot.trans.flush()
1891 
 
1892 
  def recv_getValidOrderCount(self, ):
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
1899 
    result = getValidOrderCount_result()
1900 
    result.read(self._iprot)
1901 
    self._iprot.readMessageEnd()
3431 rajveer 1902 
    if result.success is not None:
3064 chandransh 1903 
      return result.success
1904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1905 
 
1906 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1907 
    """
1908 
    Returns the number of distinct customers who have done successful transactions
1909 
    """
1910 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1911 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1912 
 
1913 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1914 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1915 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1916 
    args.write(self._oprot)
1917 
    self._oprot.writeMessageEnd()
1918 
    self._oprot.trans.flush()
1919 
 
1920 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1922 
    if mtype == TMessageType.EXCEPTION:
1923 
      x = TApplicationException()
1924 
      x.read(self._iprot)
1925 
      self._iprot.readMessageEnd()
1926 
      raise x
1927 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1928 
    result.read(self._iprot)
1929 
    self._iprot.readMessageEnd()
3431 rajveer 1930 
    if result.success is not None:
3064 chandransh 1931 
      return result.success
1932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1933 
 
1934 
  def getValidOrdersAmountRange(self, ):
1935 
    """
1936 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1937 
    List contains two values, first minimum amount and second maximum amount.
1938 
    """
1939 
    self.send_getValidOrdersAmountRange()
1940 
    return self.recv_getValidOrdersAmountRange()
1941 
 
1942 
  def send_getValidOrdersAmountRange(self, ):
1943 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1944 
    args = getValidOrdersAmountRange_args()
1945 
    args.write(self._oprot)
1946 
    self._oprot.writeMessageEnd()
1947 
    self._oprot.trans.flush()
1948 
 
1949 
  def recv_getValidOrdersAmountRange(self, ):
1950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1951 
    if mtype == TMessageType.EXCEPTION:
1952 
      x = TApplicationException()
1953 
      x.read(self._iprot)
1954 
      self._iprot.readMessageEnd()
1955 
      raise x
1956 
    result = getValidOrdersAmountRange_result()
1957 
    result.read(self._iprot)
1958 
    self._iprot.readMessageEnd()
3431 rajveer 1959 
    if result.success is not None:
3064 chandransh 1960 
      return result.success
1961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1962 
 
1963 
  def getValidOrders(self, limit):
1964 
    """
1965 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1966 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1967 
 
3064 chandransh 1968 
    Parameters:
1969 
     - limit
1970 
    """
1971 
    self.send_getValidOrders(limit)
1972 
    return self.recv_getValidOrders()
1973 
 
1974 
  def send_getValidOrders(self, limit):
1975 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1976 
    args = getValidOrders_args()
1977 
    args.limit = limit
1978 
    args.write(self._oprot)
1979 
    self._oprot.writeMessageEnd()
1980 
    self._oprot.trans.flush()
1981 
 
1982 
  def recv_getValidOrders(self, ):
1983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1984 
    if mtype == TMessageType.EXCEPTION:
1985 
      x = TApplicationException()
1986 
      x.read(self._iprot)
1987 
      self._iprot.readMessageEnd()
1988 
      raise x
1989 
    result = getValidOrders_result()
1990 
    result.read(self._iprot)
1991 
    self._iprot.readMessageEnd()
3431 rajveer 1992 
    if result.success is not None:
3064 chandransh 1993 
      return result.success
1994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1995 
 
1220 chandransh 1996 
  def batchOrders(self, warehouseId):
1997 
    """
1998 
    Create a batch of all the pending orders for the given warehouse.
1999 
    The returned list is orderd by created_timestamp.
2000 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2001 
 
1220 chandransh 2002 
    Parameters:
2003 
     - warehouseId
2004 
    """
2005 
    self.send_batchOrders(warehouseId)
2006 
    return self.recv_batchOrders()
2007 
 
2008 
  def send_batchOrders(self, warehouseId):
2009 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2010 
    args = batchOrders_args()
2011 
    args.warehouseId = warehouseId
2012 
    args.write(self._oprot)
2013 
    self._oprot.writeMessageEnd()
2014 
    self._oprot.trans.flush()
2015 
 
2016 
  def recv_batchOrders(self, ):
2017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2018 
    if mtype == TMessageType.EXCEPTION:
2019 
      x = TApplicationException()
2020 
      x.read(self._iprot)
2021 
      self._iprot.readMessageEnd()
2022 
      raise x
2023 
    result = batchOrders_result()
2024 
    result.read(self._iprot)
2025 
    self._iprot.readMessageEnd()
3431 rajveer 2026 
    if result.success is not None:
1220 chandransh 2027 
      return result.success
3431 rajveer 2028 
    if result.ex is not None:
1220 chandransh 2029 
      raise result.ex
2030 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2031 
 
1208 chandransh 2032 
  def markOrderAsOutOfStock(self, orderId):
2033 
    """
2034 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2035 
 
1208 chandransh 2036 
    Parameters:
2037 
     - orderId
2038 
    """
2039 
    self.send_markOrderAsOutOfStock(orderId)
2040 
    return self.recv_markOrderAsOutOfStock()
2041 
 
2042 
  def send_markOrderAsOutOfStock(self, orderId):
2043 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2044 
    args = markOrderAsOutOfStock_args()
2045 
    args.orderId = orderId
2046 
    args.write(self._oprot)
2047 
    self._oprot.writeMessageEnd()
2048 
    self._oprot.trans.flush()
2049 
 
2050 
  def recv_markOrderAsOutOfStock(self, ):
2051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2052 
    if mtype == TMessageType.EXCEPTION:
2053 
      x = TApplicationException()
2054 
      x.read(self._iprot)
2055 
      self._iprot.readMessageEnd()
2056 
      raise x
2057 
    result = markOrderAsOutOfStock_result()
2058 
    result.read(self._iprot)
2059 
    self._iprot.readMessageEnd()
3431 rajveer 2060 
    if result.success is not None:
1208 chandransh 2061 
      return result.success
3431 rajveer 2062 
    if result.ex is not None:
1208 chandransh 2063 
      raise result.ex
2064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2065 
 
3064 chandransh 2066 
  def verifyOrder(self, orderId):
759 chandransh 2067 
    """
3064 chandransh 2068 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2069 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2070 
    used for all other orders as well.
2071 
    Throws an exception if no such order exists.
3431 rajveer 2072 
 
759 chandransh 2073 
    Parameters:
3064 chandransh 2074 
     - orderId
759 chandransh 2075 
    """
3064 chandransh 2076 
    self.send_verifyOrder(orderId)
2077 
    return self.recv_verifyOrder()
759 chandransh 2078 
 
3064 chandransh 2079 
  def send_verifyOrder(self, orderId):
2080 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2081 
    args = verifyOrder_args()
2082 
    args.orderId = orderId
759 chandransh 2083 
    args.write(self._oprot)
2084 
    self._oprot.writeMessageEnd()
2085 
    self._oprot.trans.flush()
2086 
 
3064 chandransh 2087 
  def recv_verifyOrder(self, ):
759 chandransh 2088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2089 
    if mtype == TMessageType.EXCEPTION:
2090 
      x = TApplicationException()
2091 
      x.read(self._iprot)
2092 
      self._iprot.readMessageEnd()
2093 
      raise x
3064 chandransh 2094 
    result = verifyOrder_result()
759 chandransh 2095 
    result.read(self._iprot)
2096 
    self._iprot.readMessageEnd()
3431 rajveer 2097 
    if result.success is not None:
759 chandransh 2098 
      return result.success
3431 rajveer 2099 
    if result.ex is not None:
759 chandransh 2100 
      raise result.ex
3064 chandransh 2101 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2102 
 
3064 chandransh 2103 
  def acceptOrder(self, orderId):
1113 chandransh 2104 
    """
3064 chandransh 2105 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2106 
    given order is not a COD order, it also captures the payment if the same has
2107 
    not been captured.
2108 
    Throws an exception if no such order exists.
3431 rajveer 2109 
 
1113 chandransh 2110 
    Parameters:
3064 chandransh 2111 
     - orderId
1113 chandransh 2112 
    """
3064 chandransh 2113 
    self.send_acceptOrder(orderId)
2114 
    return self.recv_acceptOrder()
1113 chandransh 2115 
 
3064 chandransh 2116 
  def send_acceptOrder(self, orderId):
2117 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2118 
    args = acceptOrder_args()
2119 
    args.orderId = orderId
1113 chandransh 2120 
    args.write(self._oprot)
2121 
    self._oprot.writeMessageEnd()
2122 
    self._oprot.trans.flush()
2123 
 
3064 chandransh 2124 
  def recv_acceptOrder(self, ):
1113 chandransh 2125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2126 
    if mtype == TMessageType.EXCEPTION:
2127 
      x = TApplicationException()
2128 
      x.read(self._iprot)
2129 
      self._iprot.readMessageEnd()
2130 
      raise x
3064 chandransh 2131 
    result = acceptOrder_result()
1113 chandransh 2132 
    result.read(self._iprot)
2133 
    self._iprot.readMessageEnd()
3431 rajveer 2134 
    if result.success is not None:
1113 chandransh 2135 
      return result.success
3431 rajveer 2136 
    if result.ex is not None:
1113 chandransh 2137 
      raise result.ex
3064 chandransh 2138 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2139 
 
4763 rajveer 2140 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
1132 chandransh 2141 
    """
3064 chandransh 2142 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2143 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2144 
    the IMEI no. if a -1 is supplied.
2145 
    Also, it generates an invoice number for the order, marks the order as
2146 
    BILLED and sets the billing timestamp.
2147 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2148 
 
1135 chandransh 2149 
    Parameters:
3064 chandransh 2150 
     - orderId
2151 
     - invoice_number
4658 mandeep.dh 2152 
     - serialNumber
4283 anupam.sin 2153 
     - itemNumber
3064 chandransh 2154 
     - billed_by
4264 rajveer 2155 
     - jacketNumber
4283 anupam.sin 2156 
     - billingType
2157 
     - vendorId
4763 rajveer 2158 
     - authorize
1135 chandransh 2159 
    """
4763 rajveer 2160 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize)
3064 chandransh 2161 
    return self.recv_addBillingDetails()
1135 chandransh 2162 
 
4763 rajveer 2163 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 2164 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2165 
    args = addBillingDetails_args()
2166 
    args.orderId = orderId
2167 
    args.invoice_number = invoice_number
4658 mandeep.dh 2168 
    args.serialNumber = serialNumber
4283 anupam.sin 2169 
    args.itemNumber = itemNumber
3064 chandransh 2170 
    args.billed_by = billed_by
4264 rajveer 2171 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2172 
    args.billingType = billingType
2173 
    args.vendorId = vendorId
4763 rajveer 2174 
    args.authorize = authorize
1135 chandransh 2175 
    args.write(self._oprot)
2176 
    self._oprot.writeMessageEnd()
2177 
    self._oprot.trans.flush()
2178 
 
3064 chandransh 2179 
  def recv_addBillingDetails(self, ):
1135 chandransh 2180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2181 
    if mtype == TMessageType.EXCEPTION:
2182 
      x = TApplicationException()
2183 
      x.read(self._iprot)
2184 
      self._iprot.readMessageEnd()
2185 
      raise x
3064 chandransh 2186 
    result = addBillingDetails_result()
1135 chandransh 2187 
    result.read(self._iprot)
2188 
    self._iprot.readMessageEnd()
3431 rajveer 2189 
    if result.success is not None:
3064 chandransh 2190 
      return result.success
3431 rajveer 2191 
    if result.ex is not None:
1135 chandransh 2192 
      raise result.ex
3064 chandransh 2193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2194 
 
4763 rajveer 2195 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2196 
    """
2197 
    Add the invoice number to the order.
2198 
 
2199 
    Parameters:
2200 
     - orderId
2201 
     - invoiceNumber
4763 rajveer 2202 
     - color
4579 rajveer 2203 
    """
4763 rajveer 2204 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2205 
    self.recv_addInvoiceNumber()
2206 
 
4763 rajveer 2207 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2208 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2209 
    args = addInvoiceNumber_args()
2210 
    args.orderId = orderId
2211 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2212 
    args.color = color
4579 rajveer 2213 
    args.write(self._oprot)
2214 
    self._oprot.writeMessageEnd()
2215 
    self._oprot.trans.flush()
2216 
 
2217 
  def recv_addInvoiceNumber(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 = addInvoiceNumber_result()
2225 
    result.read(self._iprot)
2226 
    self._iprot.readMessageEnd()
2227 
    if result.ex is not None:
2228 
      raise result.ex
2229 
    return
2230 
 
3064 chandransh 2231 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2232 
    """
3064 chandransh 2233 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2234 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2235 
 
1408 ankur.sing 2236 
    Parameters:
3064 chandransh 2237 
     - warehouseId
1408 ankur.sing 2238 
     - providerId
3064 chandransh 2239 
     - cod
1408 ankur.sing 2240 
    """
3064 chandransh 2241 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2242 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2243 
 
3064 chandransh 2244 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2245 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2246 
    args = markOrdersAsManifested_args()
2247 
    args.warehouseId = warehouseId
1408 ankur.sing 2248 
    args.providerId = providerId
3064 chandransh 2249 
    args.cod = cod
1408 ankur.sing 2250 
    args.write(self._oprot)
2251 
    self._oprot.writeMessageEnd()
2252 
    self._oprot.trans.flush()
2253 
 
3064 chandransh 2254 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2256 
    if mtype == TMessageType.EXCEPTION:
2257 
      x = TApplicationException()
2258 
      x.read(self._iprot)
2259 
      self._iprot.readMessageEnd()
2260 
      raise x
3064 chandransh 2261 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2262 
    result.read(self._iprot)
2263 
    self._iprot.readMessageEnd()
3431 rajveer 2264 
    if result.success is not None:
1408 ankur.sing 2265 
      return result.success
3431 rajveer 2266 
    if result.ex is not None:
3064 chandransh 2267 
      raise result.ex
2268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2269 
 
4789 rajveer 2270 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
4410 rajveer 2271 
    """
2272 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2273 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2274 
 
2275 
    Parameters:
2276 
     - warehouseId
2277 
     - providerId
2278 
     - cod
4789 rajveer 2279 
     - orderIds
4410 rajveer 2280 
    """
4789 rajveer 2281 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
4410 rajveer 2282 
    return self.recv_markOrdersAsShippedFromWarehouse()
2283 
 
4789 rajveer 2284 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
4410 rajveer 2285 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2286 
    args = markOrdersAsShippedFromWarehouse_args()
2287 
    args.warehouseId = warehouseId
2288 
    args.providerId = providerId
2289 
    args.cod = cod
4789 rajveer 2290 
    args.orderIds = orderIds
4410 rajveer 2291 
    args.write(self._oprot)
2292 
    self._oprot.writeMessageEnd()
2293 
    self._oprot.trans.flush()
2294 
 
2295 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2297 
    if mtype == TMessageType.EXCEPTION:
2298 
      x = TApplicationException()
2299 
      x.read(self._iprot)
2300 
      self._iprot.readMessageEnd()
2301 
      raise x
2302 
    result = markOrdersAsShippedFromWarehouse_result()
2303 
    result.read(self._iprot)
2304 
    self._iprot.readMessageEnd()
2305 
    if result.success is not None:
2306 
      return result.success
2307 
    if result.ex is not None:
2308 
      raise result.ex
2309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2310 
 
3064 chandransh 2311 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2312 
    """
3064 chandransh 2313 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2314 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2315 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2316 
 
94 ashish 2317 
    Parameters:
3064 chandransh 2318 
     - providerId
2319 
     - pickupDetails
304 ashish 2320 
    """
3064 chandransh 2321 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2322 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2323 
 
3064 chandransh 2324 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2325 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2326 
    args = markOrdersAsPickedUp_args()
2327 
    args.providerId = providerId
2328 
    args.pickupDetails = pickupDetails
304 ashish 2329 
    args.write(self._oprot)
2330 
    self._oprot.writeMessageEnd()
2331 
    self._oprot.trans.flush()
2332 
 
3064 chandransh 2333 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2335 
    if mtype == TMessageType.EXCEPTION:
2336 
      x = TApplicationException()
2337 
      x.read(self._iprot)
2338 
      self._iprot.readMessageEnd()
2339 
      raise x
3064 chandransh 2340 
    result = markOrdersAsPickedUp_result()
304 ashish 2341 
    result.read(self._iprot)
2342 
    self._iprot.readMessageEnd()
3431 rajveer 2343 
    if result.success is not None:
304 ashish 2344 
      return result.success
3431 rajveer 2345 
    if result.ex is not None:
3064 chandransh 2346 
      raise result.ex
2347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2348 
 
3064 chandransh 2349 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2350 
    """
3064 chandransh 2351 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2352 
    the name of the receiver.
2353 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2354 
 
304 ashish 2355 
    Parameters:
3064 chandransh 2356 
     - providerId
2357 
     - deliveredOrders
304 ashish 2358 
    """
3064 chandransh 2359 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2360 
    self.recv_markOrdersAsDelivered()
304 ashish 2361 
 
3064 chandransh 2362 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2363 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2364 
    args = markOrdersAsDelivered_args()
2365 
    args.providerId = providerId
2366 
    args.deliveredOrders = deliveredOrders
304 ashish 2367 
    args.write(self._oprot)
2368 
    self._oprot.writeMessageEnd()
2369 
    self._oprot.trans.flush()
2370 
 
3064 chandransh 2371 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2373 
    if mtype == TMessageType.EXCEPTION:
2374 
      x = TApplicationException()
2375 
      x.read(self._iprot)
2376 
      self._iprot.readMessageEnd()
2377 
      raise x
3064 chandransh 2378 
    result = markOrdersAsDelivered_result()
304 ashish 2379 
    result.read(self._iprot)
2380 
    self._iprot.readMessageEnd()
3431 rajveer 2381 
    if result.ex is not None:
3064 chandransh 2382 
      raise result.ex
304 ashish 2383 
    return
2384 
 
3064 chandransh 2385 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2386 
    """
3064 chandransh 2387 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2388 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2389 
 
3064 chandransh 2390 
    Parameters:
2391 
     - providerId
2392 
     - returnedOrders
1596 ankur.sing 2393 
    """
3064 chandransh 2394 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2395 
    self.recv_markOrdersAsFailed()
304 ashish 2396 
 
3064 chandransh 2397 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2398 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2399 
    args = markOrdersAsFailed_args()
2400 
    args.providerId = providerId
2401 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2402 
    args.write(self._oprot)
2403 
    self._oprot.writeMessageEnd()
2404 
    self._oprot.trans.flush()
2405 
 
3064 chandransh 2406 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2408 
    if mtype == TMessageType.EXCEPTION:
2409 
      x = TApplicationException()
2410 
      x.read(self._iprot)
2411 
      self._iprot.readMessageEnd()
2412 
      raise x
3064 chandransh 2413 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2414 
    result.read(self._iprot)
2415 
    self._iprot.readMessageEnd()
3431 rajveer 2416 
    if result.ex is not None:
3064 chandransh 2417 
      raise result.ex
2418 
    return
1596 ankur.sing 2419 
 
3064 chandransh 2420 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2421 
    """
3064 chandransh 2422 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2423 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2424 
 
3064 chandransh 2425 
    Parameters:
2426 
     - providerId
2427 
     - undeliveredOrders
1627 ankur.sing 2428 
    """
3064 chandransh 2429 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2430 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2431 
 
3064 chandransh 2432 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2433 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2434 
    args = updateNonDeliveryReason_args()
2435 
    args.providerId = providerId
2436 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2437 
    args.write(self._oprot)
2438 
    self._oprot.writeMessageEnd()
2439 
    self._oprot.trans.flush()
2440 
 
3064 chandransh 2441 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2443 
    if mtype == TMessageType.EXCEPTION:
2444 
      x = TApplicationException()
2445 
      x.read(self._iprot)
2446 
      self._iprot.readMessageEnd()
2447 
      raise x
3064 chandransh 2448 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2449 
    result.read(self._iprot)
2450 
    self._iprot.readMessageEnd()
4581 phani.kuma 2451 
    if result.success is not None:
2452 
      return result.success
3431 rajveer 2453 
    if result.ex is not None:
3064 chandransh 2454 
      raise result.ex
4581 phani.kuma 2455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2456 
 
3064 chandransh 2457 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2458 
    """
3064 chandransh 2459 
    Returns the list of orders whose delivery time has passed but have not been
2460 
    delivered yet for the given provider and warehouse. To get a complete list of
2461 
    undelivered orders, pass them as -1.
2462 
    Returns an empty list if no such orders exist.
3431 rajveer 2463 
 
1886 ankur.sing 2464 
    Parameters:
3064 chandransh 2465 
     - providerId
2466 
     - warehouseId
1886 ankur.sing 2467 
    """
3064 chandransh 2468 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2469 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2470 
 
3064 chandransh 2471 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2472 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2473 
    args = getUndeliveredOrders_args()
2474 
    args.providerId = providerId
2475 
    args.warehouseId = warehouseId
1886 ankur.sing 2476 
    args.write(self._oprot)
2477 
    self._oprot.writeMessageEnd()
2478 
    self._oprot.trans.flush()
2479 
 
3064 chandransh 2480 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2482 
    if mtype == TMessageType.EXCEPTION:
2483 
      x = TApplicationException()
2484 
      x.read(self._iprot)
2485 
      self._iprot.readMessageEnd()
2486 
      raise x
3064 chandransh 2487 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2488 
    result.read(self._iprot)
2489 
    self._iprot.readMessageEnd()
3431 rajveer 2490 
    if result.success is not None:
1886 ankur.sing 2491 
      return result.success
3064 chandransh 2492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2493 
 
4783 phani.kuma 2494 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2495 
    """
2496 
    Returns the list of orders whose expected delivery date has passed but have not been
2497 
    delivered yet.
2498 
    Returns an empty list if no such orders exist.
2499 
    """
2500 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2501 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2502 
 
2503 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2504 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2505 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2506 
    args.write(self._oprot)
2507 
    self._oprot.writeMessageEnd()
2508 
    self._oprot.trans.flush()
2509 
 
2510 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2512 
    if mtype == TMessageType.EXCEPTION:
2513 
      x = TApplicationException()
2514 
      x.read(self._iprot)
2515 
      self._iprot.readMessageEnd()
2516 
      raise x
2517 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2518 
    result.read(self._iprot)
2519 
    self._iprot.readMessageEnd()
2520 
    if result.success is not None:
2521 
      return result.success
2522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2523 
 
2536 chandransh 2524 
  def toggleDOAFlag(self, orderId):
2525 
    """
2526 
    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.
2527 
    Returns the final flag status.
2528 
    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 2529 
 
2536 chandransh 2530 
    Parameters:
2531 
     - orderId
2532 
    """
2533 
    self.send_toggleDOAFlag(orderId)
2534 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2535 
 
2536 chandransh 2536 
  def send_toggleDOAFlag(self, orderId):
2537 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2538 
    args = toggleDOAFlag_args()
2539 
    args.orderId = orderId
2540 
    args.write(self._oprot)
2541 
    self._oprot.writeMessageEnd()
2542 
    self._oprot.trans.flush()
2543 
 
2544 
  def recv_toggleDOAFlag(self, ):
2545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2546 
    if mtype == TMessageType.EXCEPTION:
2547 
      x = TApplicationException()
2548 
      x.read(self._iprot)
2549 
      self._iprot.readMessageEnd()
2550 
      raise x
2551 
    result = toggleDOAFlag_result()
2552 
    result.read(self._iprot)
2553 
    self._iprot.readMessageEnd()
3431 rajveer 2554 
    if result.success is not None:
2536 chandransh 2555 
      return result.success
3431 rajveer 2556 
    if result.ex is not None:
2536 chandransh 2557 
      raise result.ex
2558 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2559 
 
4712 rajveer 2560 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2561 
    """
2562 
    Parameters:
2563 
     - orderId
2564 
     - deliveryTimestamp
2565 
     - receiver
2566 
    """
2567 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2568 
    self.recv_markOrderAsDelivered()
2569 
 
2570 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2571 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2572 
    args = markOrderAsDelivered_args()
2573 
    args.orderId = orderId
2574 
    args.deliveryTimestamp = deliveryTimestamp
2575 
    args.receiver = receiver
2576 
    args.write(self._oprot)
2577 
    self._oprot.writeMessageEnd()
2578 
    self._oprot.trans.flush()
2579 
 
2580 
  def recv_markOrderAsDelivered(self, ):
2581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2582 
    if mtype == TMessageType.EXCEPTION:
2583 
      x = TApplicationException()
2584 
      x.read(self._iprot)
2585 
      self._iprot.readMessageEnd()
2586 
      raise x
2587 
    result = markOrderAsDelivered_result()
2588 
    result.read(self._iprot)
2589 
    self._iprot.readMessageEnd()
2590 
    if result.ex is not None:
2591 
      raise result.ex
2592 
    return
2593 
 
4454 rajveer 2594 
  def markOrderDoaRequestReceived(self, orderId):
2595 
    """
2596 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2597 
 
2598 
    Parameters:
2599 
     - orderId
2600 
    """
2601 
    self.send_markOrderDoaRequestReceived(orderId)
2602 
    return self.recv_markOrderDoaRequestReceived()
2603 
 
2604 
  def send_markOrderDoaRequestReceived(self, orderId):
2605 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2606 
    args = markOrderDoaRequestReceived_args()
2607 
    args.orderId = orderId
2608 
    args.write(self._oprot)
2609 
    self._oprot.writeMessageEnd()
2610 
    self._oprot.trans.flush()
2611 
 
2612 
  def recv_markOrderDoaRequestReceived(self, ):
2613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2614 
    if mtype == TMessageType.EXCEPTION:
2615 
      x = TApplicationException()
2616 
      x.read(self._iprot)
2617 
      self._iprot.readMessageEnd()
2618 
      raise x
2619 
    result = markOrderDoaRequestReceived_result()
2620 
    result.read(self._iprot)
2621 
    self._iprot.readMessageEnd()
2622 
    if result.success is not None:
2623 
      return result.success
2624 
    if result.ex is not None:
2625 
      raise result.ex
2626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2627 
 
2628 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2629 
    """
2630 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2631 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2632 
 
2633 
    Parameters:
2634 
     - orderId
2635 
     - isAuthorized
2636 
    """
2637 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2638 
    return self.recv_markOrderDoaRequestAuthorized()
2639 
 
2640 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2641 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2642 
    args = markOrderDoaRequestAuthorized_args()
2643 
    args.orderId = orderId
2644 
    args.isAuthorized = isAuthorized
2645 
    args.write(self._oprot)
2646 
    self._oprot.writeMessageEnd()
2647 
    self._oprot.trans.flush()
2648 
 
2649 
  def recv_markOrderDoaRequestAuthorized(self, ):
2650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2651 
    if mtype == TMessageType.EXCEPTION:
2652 
      x = TApplicationException()
2653 
      x.read(self._iprot)
2654 
      self._iprot.readMessageEnd()
2655 
      raise x
2656 
    result = markOrderDoaRequestAuthorized_result()
2657 
    result.read(self._iprot)
2658 
    self._iprot.readMessageEnd()
2659 
    if result.success is not None:
2660 
      return result.success
2661 
    if result.ex is not None:
2662 
      raise result.ex
2663 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2664 
 
4488 rajveer 2665 
  def markOrderReturnRequestReceived(self, orderId):
2666 
    """
2667 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2668 
 
2669 
    Parameters:
2670 
     - orderId
2671 
    """
2672 
    self.send_markOrderReturnRequestReceived(orderId)
2673 
    return self.recv_markOrderReturnRequestReceived()
2674 
 
2675 
  def send_markOrderReturnRequestReceived(self, orderId):
2676 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2677 
    args = markOrderReturnRequestReceived_args()
2678 
    args.orderId = orderId
2679 
    args.write(self._oprot)
2680 
    self._oprot.writeMessageEnd()
2681 
    self._oprot.trans.flush()
2682 
 
2683 
  def recv_markOrderReturnRequestReceived(self, ):
2684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2685 
    if mtype == TMessageType.EXCEPTION:
2686 
      x = TApplicationException()
2687 
      x.read(self._iprot)
2688 
      self._iprot.readMessageEnd()
2689 
      raise x
2690 
    result = markOrderReturnRequestReceived_result()
2691 
    result.read(self._iprot)
2692 
    self._iprot.readMessageEnd()
2693 
    if result.success is not None:
2694 
      return result.success
2695 
    if result.ex is not None:
2696 
      raise result.ex
2697 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2698 
 
2699 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2700 
    """
2701 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2702 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2703 
 
2704 
    Parameters:
2705 
     - orderId
2706 
     - isAuthorized
2707 
    """
2708 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2709 
    return self.recv_markOrderReturnRequestAuthorized()
2710 
 
2711 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2712 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2713 
    args = markOrderReturnRequestAuthorized_args()
2714 
    args.orderId = orderId
2715 
    args.isAuthorized = isAuthorized
2716 
    args.write(self._oprot)
2717 
    self._oprot.writeMessageEnd()
2718 
    self._oprot.trans.flush()
2719 
 
2720 
  def recv_markOrderReturnRequestAuthorized(self, ):
2721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2722 
    if mtype == TMessageType.EXCEPTION:
2723 
      x = TApplicationException()
2724 
      x.read(self._iprot)
2725 
      self._iprot.readMessageEnd()
2726 
      raise x
2727 
    result = markOrderReturnRequestAuthorized_result()
2728 
    result.read(self._iprot)
2729 
    self._iprot.readMessageEnd()
2730 
    if result.success is not None:
2731 
      return result.success
2732 
    if result.ex is not None:
2733 
      raise result.ex
2734 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2735 
 
4579 rajveer 2736 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2737 
    """
2738 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2739 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2740 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2741 
    For any other status, it returns false.
2742 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2743 
 
2536 chandransh 2744 
    Parameters:
2745 
     - orderId
4579 rajveer 2746 
     - providerId
2536 chandransh 2747 
    """
4579 rajveer 2748 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2749 
    return self.recv_requestPickupNumber()
2750 
 
4579 rajveer 2751 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2752 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2753 
    args = requestPickupNumber_args()
2754 
    args.orderId = orderId
4579 rajveer 2755 
    args.providerId = providerId
2536 chandransh 2756 
    args.write(self._oprot)
2757 
    self._oprot.writeMessageEnd()
2758 
    self._oprot.trans.flush()
2759 
 
2760 
  def recv_requestPickupNumber(self, ):
2761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2762 
    if mtype == TMessageType.EXCEPTION:
2763 
      x = TApplicationException()
2764 
      x.read(self._iprot)
2765 
      self._iprot.readMessageEnd()
2766 
      raise x
2767 
    result = requestPickupNumber_result()
2768 
    result.read(self._iprot)
2769 
    self._iprot.readMessageEnd()
3431 rajveer 2770 
    if result.success is not None:
2536 chandransh 2771 
      return result.success
3431 rajveer 2772 
    if result.ex is not None:
2536 chandransh 2773 
      raise result.ex
2774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2775 
 
4602 rajveer 2776 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2777 
    """
4452 rajveer 2778 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2779 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2780 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2781 
    	3. Returns true
2591 chandransh 2782 
    If the order is in any other status, it returns false.
2536 chandransh 2783 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2784 
 
2536 chandransh 2785 
    Parameters:
2786 
     - orderId
2787 
     - pickupNumber
4602 rajveer 2788 
     - providerId
2536 chandransh 2789 
    """
4602 rajveer 2790 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 2791 
    return self.recv_authorizePickup()
2792 
 
4602 rajveer 2793 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2794 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2795 
    args = authorizePickup_args()
2796 
    args.orderId = orderId
2797 
    args.pickupNumber = pickupNumber
4602 rajveer 2798 
    args.providerId = providerId
2536 chandransh 2799 
    args.write(self._oprot)
2800 
    self._oprot.writeMessageEnd()
2801 
    self._oprot.trans.flush()
2802 
 
2803 
  def recv_authorizePickup(self, ):
2804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2805 
    if mtype == TMessageType.EXCEPTION:
2806 
      x = TApplicationException()
2807 
      x.read(self._iprot)
2808 
      self._iprot.readMessageEnd()
2809 
      raise x
2810 
    result = authorizePickup_result()
2811 
    result.read(self._iprot)
2812 
    self._iprot.readMessageEnd()
3431 rajveer 2813 
    if result.success is not None:
2536 chandransh 2814 
      return result.success
3431 rajveer 2815 
    if result.ex is not None:
2536 chandransh 2816 
      raise result.ex
2817 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2818 
 
2764 chandransh 2819 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2820 
    """
2821 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2822 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2823 
 
2764 chandransh 2824 
    Parameters:
2825 
     - providerId
2826 
     - pickupDetails
2827 
    """
2828 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2829 
    return self.recv_markDoasAsPickedUp()
2830 
 
2831 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2832 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2833 
    args = markDoasAsPickedUp_args()
2834 
    args.providerId = providerId
2835 
    args.pickupDetails = pickupDetails
2836 
    args.write(self._oprot)
2837 
    self._oprot.writeMessageEnd()
2838 
    self._oprot.trans.flush()
2839 
 
2840 
  def recv_markDoasAsPickedUp(self, ):
2841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2842 
    if mtype == TMessageType.EXCEPTION:
2843 
      x = TApplicationException()
2844 
      x.read(self._iprot)
2845 
      self._iprot.readMessageEnd()
2846 
      raise x
2847 
    result = markDoasAsPickedUp_result()
2848 
    result.read(self._iprot)
2849 
    self._iprot.readMessageEnd()
3431 rajveer 2850 
    if result.success is not None:
2764 chandransh 2851 
      return result.success
2852 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2853 
 
4741 phani.kuma 2854 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
2855 
    """
2856 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
2857 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
2858 
 
2859 
    Parameters:
2860 
     - providerId
2861 
     - pickupDetails
2862 
    """
2863 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
2864 
    return self.recv_markReturnOrdersAsPickedUp()
2865 
 
2866 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
2867 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2868 
    args = markReturnOrdersAsPickedUp_args()
2869 
    args.providerId = providerId
2870 
    args.pickupDetails = pickupDetails
2871 
    args.write(self._oprot)
2872 
    self._oprot.writeMessageEnd()
2873 
    self._oprot.trans.flush()
2874 
 
2875 
  def recv_markReturnOrdersAsPickedUp(self, ):
2876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2877 
    if mtype == TMessageType.EXCEPTION:
2878 
      x = TApplicationException()
2879 
      x.read(self._iprot)
2880 
      self._iprot.readMessageEnd()
2881 
      raise x
2882 
    result = markReturnOrdersAsPickedUp_result()
2883 
    result.read(self._iprot)
2884 
    self._iprot.readMessageEnd()
2885 
    if result.success is not None:
2886 
      return result.success
2887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markReturnOrdersAsPickedUp failed: unknown result");
2888 
 
4479 rajveer 2889 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2890 
    """
4452 rajveer 2891 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 2892 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2893 
    If the order is in any other state, it returns false.
2894 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2895 
 
2591 chandransh 2896 
    Parameters:
2897 
     - orderId
4479 rajveer 2898 
     - receiveCondition
2591 chandransh 2899 
    """
4479 rajveer 2900 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2901 
    return self.recv_receiveReturn()
2536 chandransh 2902 
 
4479 rajveer 2903 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2904 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2905 
    args = receiveReturn_args()
2591 chandransh 2906 
    args.orderId = orderId
4479 rajveer 2907 
    args.receiveCondition = receiveCondition
2591 chandransh 2908 
    args.write(self._oprot)
2909 
    self._oprot.writeMessageEnd()
2910 
    self._oprot.trans.flush()
2911 
 
2616 chandransh 2912 
  def recv_receiveReturn(self, ):
2591 chandransh 2913 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2914 
    if mtype == TMessageType.EXCEPTION:
2915 
      x = TApplicationException()
2916 
      x.read(self._iprot)
2917 
      self._iprot.readMessageEnd()
2918 
      raise x
2616 chandransh 2919 
    result = receiveReturn_result()
2591 chandransh 2920 
    result.read(self._iprot)
2921 
    self._iprot.readMessageEnd()
3431 rajveer 2922 
    if result.success is not None:
2591 chandransh 2923 
      return result.success
3431 rajveer 2924 
    if result.ex is not None:
2591 chandransh 2925 
      raise result.ex
2616 chandransh 2926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2927 
 
2928 
  def validateDoa(self, orderId, isValid):
2929 
    """
4452 rajveer 2930 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2931 
    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 2932 
    If the order is in any other state, it returns false.
2933 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2934 
 
2591 chandransh 2935 
    Parameters:
2936 
     - orderId
2937 
     - isValid
2938 
    """
2939 
    self.send_validateDoa(orderId, isValid)
2940 
    return self.recv_validateDoa()
2941 
 
2942 
  def send_validateDoa(self, orderId, isValid):
2943 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2944 
    args = validateDoa_args()
2945 
    args.orderId = orderId
2946 
    args.isValid = isValid
2947 
    args.write(self._oprot)
2948 
    self._oprot.writeMessageEnd()
2949 
    self._oprot.trans.flush()
2950 
 
2951 
  def recv_validateDoa(self, ):
2952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2953 
    if mtype == TMessageType.EXCEPTION:
2954 
      x = TApplicationException()
2955 
      x.read(self._iprot)
2956 
      self._iprot.readMessageEnd()
2957 
      raise x
2958 
    result = validateDoa_result()
2959 
    result.read(self._iprot)
2960 
    self._iprot.readMessageEnd()
3431 rajveer 2961 
    if result.success is not None:
2591 chandransh 2962 
      return result.success
3431 rajveer 2963 
    if result.ex is not None:
2591 chandransh 2964 
      raise result.ex
2965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2966 
 
4495 rajveer 2967 
  def validateReturnProduct(self, orderId, isUsable):
2968 
    """
2969 
    Parameters:
2970 
     - orderId
2971 
     - isUsable
2972 
    """
2973 
    self.send_validateReturnProduct(orderId, isUsable)
2974 
    return self.recv_validateReturnProduct()
2975 
 
2976 
  def send_validateReturnProduct(self, orderId, isUsable):
2977 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2978 
    args = validateReturnProduct_args()
2979 
    args.orderId = orderId
2980 
    args.isUsable = isUsable
2981 
    args.write(self._oprot)
2982 
    self._oprot.writeMessageEnd()
2983 
    self._oprot.trans.flush()
2984 
 
2985 
  def recv_validateReturnProduct(self, ):
2986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2987 
    if mtype == TMessageType.EXCEPTION:
2988 
      x = TApplicationException()
2989 
      x.read(self._iprot)
2990 
      self._iprot.readMessageEnd()
2991 
      raise x
2992 
    result = validateReturnProduct_result()
2993 
    result.read(self._iprot)
2994 
    self._iprot.readMessageEnd()
2995 
    if result.success is not None:
2996 
      return result.success
2997 
    if result.ex is not None:
2998 
      raise result.ex
2999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3000 
 
2616 chandransh 3001 
  def reshipOrder(self, orderId):
3002 
    """
4484 rajveer 3003 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3004 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3005 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 3006 
 
3007 
    If the order is in DOA_CERT_VALID state, it does the following:
3008 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3009 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3010 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3011 
 
2616 chandransh 3012 
    Returns the id of the newly created order.
3431 rajveer 3013 
 
2616 chandransh 3014 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3015 
 
2616 chandransh 3016 
    Parameters:
3017 
     - orderId
3018 
    """
3019 
    self.send_reshipOrder(orderId)
3020 
    return self.recv_reshipOrder()
2591 chandransh 3021 
 
2616 chandransh 3022 
  def send_reshipOrder(self, orderId):
3023 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3024 
    args = reshipOrder_args()
3025 
    args.orderId = orderId
3026 
    args.write(self._oprot)
3027 
    self._oprot.writeMessageEnd()
3028 
    self._oprot.trans.flush()
3029 
 
3030 
  def recv_reshipOrder(self, ):
3031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3032 
    if mtype == TMessageType.EXCEPTION:
3033 
      x = TApplicationException()
3034 
      x.read(self._iprot)
3035 
      self._iprot.readMessageEnd()
3036 
      raise x
3037 
    result = reshipOrder_result()
3038 
    result.read(self._iprot)
3039 
    self._iprot.readMessageEnd()
3431 rajveer 3040 
    if result.success is not None:
2616 chandransh 3041 
      return result.success
3431 rajveer 3042 
    if result.ex is not None:
2616 chandransh 3043 
      raise result.ex
3044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3045 
 
3226 chandransh 3046 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3047 
    """
4484 rajveer 3048 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3049 
    	1. Creates a refund request for batch processing.
3050 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3051 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3052 
 
2616 chandransh 3053 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3054 
    	1. Creates a refund request for batch processing.
3226 chandransh 3055 
    	2. Cancels the reservation of the item in the warehouse.
3056 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3057 
 
3226 chandransh 3058 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3059 
    	1. Cancels the reservation of the item in the warehouse.
3060 
    	2. Marks the current order as CANCELED.
3061 
 
3062 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3063 
 
2616 chandransh 3064 
    Returns True if it is successful, False otherwise.
3431 rajveer 3065 
 
2616 chandransh 3066 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3067 
 
2616 chandransh 3068 
    Parameters:
3069 
     - orderId
3226 chandransh 3070 
     - refundedBy
3071 
     - reason
2616 chandransh 3072 
    """
3226 chandransh 3073 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3074 
    return self.recv_refundOrder()
3075 
 
3226 chandransh 3076 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3077 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3078 
    args = refundOrder_args()
3079 
    args.orderId = orderId
3226 chandransh 3080 
    args.refundedBy = refundedBy
3081 
    args.reason = reason
2616 chandransh 3082 
    args.write(self._oprot)
3083 
    self._oprot.writeMessageEnd()
3084 
    self._oprot.trans.flush()
3085 
 
3086 
  def recv_refundOrder(self, ):
3087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3088 
    if mtype == TMessageType.EXCEPTION:
3089 
      x = TApplicationException()
3090 
      x.read(self._iprot)
3091 
      self._iprot.readMessageEnd()
3092 
      raise x
3093 
    result = refundOrder_result()
3094 
    result.read(self._iprot)
3095 
    self._iprot.readMessageEnd()
3431 rajveer 3096 
    if result.success is not None:
2616 chandransh 3097 
      return result.success
3431 rajveer 3098 
    if result.ex is not None:
2616 chandransh 3099 
      raise result.ex
3100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3101 
 
2690 chandransh 3102 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3103 
    """
3104 
    Get all return orders created between the from and to dates for the given warehouse.
3105 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3106 
 
2690 chandransh 3107 
    Parameters:
3108 
     - warehouseId
3109 
     - fromDate
3110 
     - toDate
3111 
    """
3112 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3113 
    return self.recv_getReturnOrders()
2616 chandransh 3114 
 
2690 chandransh 3115 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3116 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3117 
    args = getReturnOrders_args()
3118 
    args.warehouseId = warehouseId
3119 
    args.fromDate = fromDate
3120 
    args.toDate = toDate
3121 
    args.write(self._oprot)
3122 
    self._oprot.writeMessageEnd()
3123 
    self._oprot.trans.flush()
3124 
 
3125 
  def recv_getReturnOrders(self, ):
3126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3127 
    if mtype == TMessageType.EXCEPTION:
3128 
      x = TApplicationException()
3129 
      x.read(self._iprot)
3130 
      self._iprot.readMessageEnd()
3131 
      raise x
3132 
    result = getReturnOrders_result()
3133 
    result.read(self._iprot)
3134 
    self._iprot.readMessageEnd()
3431 rajveer 3135 
    if result.success is not None:
2690 chandransh 3136 
      return result.success
3137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3138 
 
2700 chandransh 3139 
  def getReturnOrder(self, id):
3140 
    """
3141 
    Returns the ReturnOrder corresponding to the given id.
3142 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3143 
 
2700 chandransh 3144 
    Parameters:
3145 
     - id
3146 
    """
3147 
    self.send_getReturnOrder(id)
3148 
    return self.recv_getReturnOrder()
3149 
 
3150 
  def send_getReturnOrder(self, id):
3151 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3152 
    args = getReturnOrder_args()
3153 
    args.id = id
3154 
    args.write(self._oprot)
3155 
    self._oprot.writeMessageEnd()
3156 
    self._oprot.trans.flush()
3157 
 
3158 
  def recv_getReturnOrder(self, ):
3159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3160 
    if mtype == TMessageType.EXCEPTION:
3161 
      x = TApplicationException()
3162 
      x.read(self._iprot)
3163 
      self._iprot.readMessageEnd()
3164 
      raise x
3165 
    result = getReturnOrder_result()
3166 
    result.read(self._iprot)
3167 
    self._iprot.readMessageEnd()
3431 rajveer 3168 
    if result.success is not None:
2700 chandransh 3169 
      return result.success
3431 rajveer 3170 
    if result.ex is not None:
2700 chandransh 3171 
      raise result.ex
3172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3173 
 
2690 chandransh 3174 
  def processReturn(self, returnOrderId):
3175 
    """
3176 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3177 
 
2690 chandransh 3178 
    Parameters:
3179 
     - returnOrderId
3180 
    """
3181 
    self.send_processReturn(returnOrderId)
3182 
    self.recv_processReturn()
3183 
 
3184 
  def send_processReturn(self, returnOrderId):
3185 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3186 
    args = processReturn_args()
3187 
    args.returnOrderId = returnOrderId
3188 
    args.write(self._oprot)
3189 
    self._oprot.writeMessageEnd()
3190 
    self._oprot.trans.flush()
3191 
 
3192 
  def recv_processReturn(self, ):
3193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3194 
    if mtype == TMessageType.EXCEPTION:
3195 
      x = TApplicationException()
3196 
      x.read(self._iprot)
3197 
      self._iprot.readMessageEnd()
3198 
      raise x
3199 
    result = processReturn_result()
3200 
    result.read(self._iprot)
3201 
    self._iprot.readMessageEnd()
3431 rajveer 3202 
    if result.ex is not None:
2690 chandransh 3203 
      raise result.ex
3204 
    return
3205 
 
3451 chandransh 3206 
  def updateWeight(self, orderId, weight):
3207 
    """
3208 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 3209 
 
3451 chandransh 3210 
    Parameters:
3211 
     - orderId
3212 
     - weight
3213 
    """
3214 
    self.send_updateWeight(orderId, weight)
3215 
    return self.recv_updateWeight()
3216 
 
3217 
  def send_updateWeight(self, orderId, weight):
3218 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3219 
    args = updateWeight_args()
3220 
    args.orderId = orderId
3221 
    args.weight = weight
3222 
    args.write(self._oprot)
3223 
    self._oprot.writeMessageEnd()
3224 
    self._oprot.trans.flush()
3225 
 
3226 
  def recv_updateWeight(self, ):
3227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3228 
    if mtype == TMessageType.EXCEPTION:
3229 
      x = TApplicationException()
3230 
      x.read(self._iprot)
3231 
      self._iprot.readMessageEnd()
3232 
      raise x
3233 
    result = updateWeight_result()
3234 
    result.read(self._iprot)
3235 
    self._iprot.readMessageEnd()
3236 
    if result.success is not None:
3237 
      return result.success
3238 
    if result.ex is not None:
3239 
      raise result.ex
3240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3241 
 
3469 chandransh 3242 
  def changeItem(self, orderId, itemId):
3243 
    """
3244 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3245 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3246 
 
3469 chandransh 3247 
    Parameters:
3248 
     - orderId
3249 
     - itemId
3250 
    """
3251 
    self.send_changeItem(orderId, itemId)
3252 
    return self.recv_changeItem()
3253 
 
3254 
  def send_changeItem(self, orderId, itemId):
3255 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3256 
    args = changeItem_args()
3257 
    args.orderId = orderId
3258 
    args.itemId = itemId
3259 
    args.write(self._oprot)
3260 
    self._oprot.writeMessageEnd()
3261 
    self._oprot.trans.flush()
3262 
 
3263 
  def recv_changeItem(self, ):
3264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3265 
    if mtype == TMessageType.EXCEPTION:
3266 
      x = TApplicationException()
3267 
      x.read(self._iprot)
3268 
      self._iprot.readMessageEnd()
3269 
      raise x
3270 
    result = changeItem_result()
3271 
    result.read(self._iprot)
3272 
    self._iprot.readMessageEnd()
3273 
    if result.success is not None:
3274 
      return result.success
3275 
    if result.ex is not None:
3276 
      raise result.ex
3277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3278 
 
3279 
  def shiftToWarehouse(self, orderId, warehouseId):
3280 
    """
3281 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3282 
 
3283 
    Parameters:
3284 
     - orderId
3285 
     - warehouseId
3286 
    """
3287 
    self.send_shiftToWarehouse(orderId, warehouseId)
3288 
    return self.recv_shiftToWarehouse()
3289 
 
3290 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3291 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3292 
    args = shiftToWarehouse_args()
3293 
    args.orderId = orderId
3294 
    args.warehouseId = warehouseId
3295 
    args.write(self._oprot)
3296 
    self._oprot.writeMessageEnd()
3297 
    self._oprot.trans.flush()
3298 
 
3299 
  def recv_shiftToWarehouse(self, ):
3300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3301 
    if mtype == TMessageType.EXCEPTION:
3302 
      x = TApplicationException()
3303 
      x.read(self._iprot)
3304 
      self._iprot.readMessageEnd()
3305 
      raise x
3306 
    result = shiftToWarehouse_result()
3307 
    result.read(self._iprot)
3308 
    self._iprot.readMessageEnd()
3309 
    if result.success is not None:
3310 
      return result.success
3311 
    if result.ex is not None:
3312 
      raise result.ex
3313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3314 
 
4647 rajveer 3315 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3316 
    """
3317 
    Adds the given delay reason to the given order.
3986 chandransh 3318 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3319 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3320 
 
3553 chandransh 3321 
    Parameters:
3322 
     - orderId
3323 
     - delayReason
3986 chandransh 3324 
     - furtherDelay
4647 rajveer 3325 
     - delayReasonText
3553 chandransh 3326 
    """
4647 rajveer 3327 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3328 
    return self.recv_addDelayReason()
3329 
 
4647 rajveer 3330 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3331 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3332 
    args = addDelayReason_args()
3333 
    args.orderId = orderId
3334 
    args.delayReason = delayReason
3986 chandransh 3335 
    args.furtherDelay = furtherDelay
4647 rajveer 3336 
    args.delayReasonText = delayReasonText
3553 chandransh 3337 
    args.write(self._oprot)
3338 
    self._oprot.writeMessageEnd()
3339 
    self._oprot.trans.flush()
3340 
 
3341 
  def recv_addDelayReason(self, ):
3342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3343 
    if mtype == TMessageType.EXCEPTION:
3344 
      x = TApplicationException()
3345 
      x.read(self._iprot)
3346 
      self._iprot.readMessageEnd()
3347 
      raise x
3348 
    result = addDelayReason_result()
3349 
    result.read(self._iprot)
3350 
    self._iprot.readMessageEnd()
3351 
    if result.success is not None:
3352 
      return result.success
3353 
    if result.ex is not None:
3354 
      raise result.ex
3355 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3356 
 
3956 chandransh 3357 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3358 
    """
3359 
    Marks the COD orders with given AWB nos. as having been processed.
3360 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3361 
 
3956 chandransh 3362 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3363 
    1. There is no order corresponding to an AWB number.
3364 
    2. The captured amount for a payment exceeds the total payment.
3365 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3366 
 
3367 
    Parameters:
3368 
     - collectedAmountMap
3369 
     - xferBy
3370 
     - xferTxnId
3371 
     - xferDate
3372 
    """
3373 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3374 
    return self.recv_reconcileCodCollection()
3375 
 
3376 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3377 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3378 
    args = reconcileCodCollection_args()
3379 
    args.collectedAmountMap = collectedAmountMap
3380 
    args.xferBy = xferBy
3381 
    args.xferTxnId = xferTxnId
3382 
    args.xferDate = xferDate
3383 
    args.write(self._oprot)
3384 
    self._oprot.writeMessageEnd()
3385 
    self._oprot.trans.flush()
3386 
 
3387 
  def recv_reconcileCodCollection(self, ):
3388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3389 
    if mtype == TMessageType.EXCEPTION:
3390 
      x = TApplicationException()
3391 
      x.read(self._iprot)
3392 
      self._iprot.readMessageEnd()
3393 
      raise x
3394 
    result = reconcileCodCollection_result()
3395 
    result.read(self._iprot)
3396 
    self._iprot.readMessageEnd()
3397 
    if result.success is not None:
3398 
      return result.success
3399 
    if result.ex is not None:
3400 
      raise result.ex
3401 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3402 
 
4008 mandeep.dh 3403 
  def getTransactionsRequiringExtraProcessing(self, category):
3404 
    """
4065 mandeep.dh 3405 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3406 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3407 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3408 
 
4008 mandeep.dh 3409 
    Parameters:
3410 
     - category
3411 
    """
3412 
    self.send_getTransactionsRequiringExtraProcessing(category)
3413 
    return self.recv_getTransactionsRequiringExtraProcessing()
3414 
 
3415 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3416 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3417 
    args = getTransactionsRequiringExtraProcessing_args()
3418 
    args.category = category
3419 
    args.write(self._oprot)
3420 
    self._oprot.writeMessageEnd()
3421 
    self._oprot.trans.flush()
3422 
 
3423 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3425 
    if mtype == TMessageType.EXCEPTION:
3426 
      x = TApplicationException()
3427 
      x.read(self._iprot)
3428 
      self._iprot.readMessageEnd()
3429 
      raise x
3430 
    result = getTransactionsRequiringExtraProcessing_result()
3431 
    result.read(self._iprot)
3432 
    self._iprot.readMessageEnd()
3433 
    if result.success is not None:
3434 
      return result.success
3435 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3436 
 
3437 
  def markTransactionAsProcessed(self, transactionId, category):
3438 
    """
3439 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3440 
    It essentially deletes the transaction id record for a particular
3441 
    processing type category (if present) from DB.
3442 
    This is currently used by CRM application.
4008 mandeep.dh 3443 
 
3444 
    Parameters:
3445 
     - transactionId
3446 
     - category
3447 
    """
3448 
    self.send_markTransactionAsProcessed(transactionId, category)
3449 
    self.recv_markTransactionAsProcessed()
3450 
 
3451 
  def send_markTransactionAsProcessed(self, transactionId, category):
3452 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3453 
    args = markTransactionAsProcessed_args()
3454 
    args.transactionId = transactionId
3455 
    args.category = category
3456 
    args.write(self._oprot)
3457 
    self._oprot.writeMessageEnd()
3458 
    self._oprot.trans.flush()
3459 
 
3460 
  def recv_markTransactionAsProcessed(self, ):
3461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3462 
    if mtype == TMessageType.EXCEPTION:
3463 
      x = TApplicationException()
3464 
      x.read(self._iprot)
3465 
      self._iprot.readMessageEnd()
3466 
      raise x
3467 
    result = markTransactionAsProcessed_result()
3468 
    result.read(self._iprot)
3469 
    self._iprot.readMessageEnd()
3470 
    return
3471 
 
4018 chandransh 3472 
  def getItemWiseRiskyOrdersCount(self, ):
3473 
    """
3474 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3475 
    is defined as one whose shipping date is about to expire.
3476 
    """
3477 
    self.send_getItemWiseRiskyOrdersCount()
3478 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3479 
 
4018 chandransh 3480 
  def send_getItemWiseRiskyOrdersCount(self, ):
3481 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3482 
    args = getItemWiseRiskyOrdersCount_args()
3483 
    args.write(self._oprot)
3484 
    self._oprot.writeMessageEnd()
3485 
    self._oprot.trans.flush()
3486 
 
3487 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3488 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3489 
    if mtype == TMessageType.EXCEPTION:
3490 
      x = TApplicationException()
3491 
      x.read(self._iprot)
3492 
      self._iprot.readMessageEnd()
3493 
      raise x
3494 
    result = getItemWiseRiskyOrdersCount_result()
3495 
    result.read(self._iprot)
3496 
    self._iprot.readMessageEnd()
3497 
    if result.success is not None:
3498 
      return result.success
3499 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3500 
 
4295 varun.gupt 3501 
  def getOrdersForItemIds(self, itemIds):
3502 
    """
3503 
    Returns a list of all orders which have items with given id
3504 
 
3505 
    Parameters:
3506 
     - itemIds
3507 
    """
3508 
    self.send_getOrdersForItemIds(itemIds)
3509 
    return self.recv_getOrdersForItemIds()
3510 
 
3511 
  def send_getOrdersForItemIds(self, itemIds):
3512 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3513 
    args = getOrdersForItemIds_args()
3514 
    args.itemIds = itemIds
3515 
    args.write(self._oprot)
3516 
    self._oprot.writeMessageEnd()
3517 
    self._oprot.trans.flush()
3518 
 
3519 
  def recv_getOrdersForItemIds(self, ):
3520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3521 
    if mtype == TMessageType.EXCEPTION:
3522 
      x = TApplicationException()
3523 
      x.read(self._iprot)
3524 
      self._iprot.readMessageEnd()
3525 
      raise x
3526 
    result = getOrdersForItemIds_result()
3527 
    result.read(self._iprot)
3528 
    self._iprot.readMessageEnd()
3529 
    if result.success is not None:
3530 
      return result.success
3531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3532 
 
4247 rajveer 3533 
  def markOrderCancellationRequestReceived(self, orderId):
3534 
    """
3535 
    Mark order as cancellation request received. If customer sends request of cancellation of
3536 
    a particular order, this method will be called. It will just change status of the order
3537 
    depending on its current status. It also records the previous status, so that we can move
3538 
    back to that status if cancellation request is denied.
4018 chandransh 3539 
 
4247 rajveer 3540 
    Parameters:
3541 
     - orderId
3542 
    """
3543 
    self.send_markOrderCancellationRequestReceived(orderId)
3544 
    self.recv_markOrderCancellationRequestReceived()
3545 
 
3546 
  def send_markOrderCancellationRequestReceived(self, orderId):
3547 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3548 
    args = markOrderCancellationRequestReceived_args()
3549 
    args.orderId = orderId
3550 
    args.write(self._oprot)
3551 
    self._oprot.writeMessageEnd()
3552 
    self._oprot.trans.flush()
3553 
 
3554 
  def recv_markOrderCancellationRequestReceived(self, ):
3555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3556 
    if mtype == TMessageType.EXCEPTION:
3557 
      x = TApplicationException()
3558 
      x.read(self._iprot)
3559 
      self._iprot.readMessageEnd()
3560 
      raise x
3561 
    result = markOrderCancellationRequestReceived_result()
3562 
    result.read(self._iprot)
3563 
    self._iprot.readMessageEnd()
3564 
    if result.ex is not None:
3565 
      raise result.ex
3566 
    return
3567 
 
3568 
  def markOrderCancellationRequestConfirmed(self, orderId):
3569 
    """
3570 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3571 
    cancellation request confirmed. After this OM will be able to cancel the order.
3572 
 
3573 
    Parameters:
3574 
     - orderId
3575 
    """
3576 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3577 
    self.recv_markOrderCancellationRequestConfirmed()
3578 
 
3579 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3580 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3581 
    args = markOrderCancellationRequestConfirmed_args()
3582 
    args.orderId = orderId
3583 
    args.write(self._oprot)
3584 
    self._oprot.writeMessageEnd()
3585 
    self._oprot.trans.flush()
3586 
 
3587 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3589 
    if mtype == TMessageType.EXCEPTION:
3590 
      x = TApplicationException()
3591 
      x.read(self._iprot)
3592 
      self._iprot.readMessageEnd()
3593 
      raise x
3594 
    result = markOrderCancellationRequestConfirmed_result()
3595 
    result.read(self._iprot)
3596 
    self._iprot.readMessageEnd()
3597 
    if result.ex is not None:
3598 
      raise result.ex
3599 
    return
3600 
 
3601 
  def markOrderCancellationRequestDenied(self, orderId):
3602 
    """
3603 
    If we decide to not to cancel order, we will move the order ro previous status.
3604 
 
3605 
    Parameters:
3606 
     - orderId
3607 
    """
3608 
    self.send_markOrderCancellationRequestDenied(orderId)
3609 
    self.recv_markOrderCancellationRequestDenied()
3610 
 
3611 
  def send_markOrderCancellationRequestDenied(self, orderId):
3612 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3613 
    args = markOrderCancellationRequestDenied_args()
3614 
    args.orderId = orderId
3615 
    args.write(self._oprot)
3616 
    self._oprot.writeMessageEnd()
3617 
    self._oprot.trans.flush()
3618 
 
3619 
  def recv_markOrderCancellationRequestDenied(self, ):
3620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3621 
    if mtype == TMessageType.EXCEPTION:
3622 
      x = TApplicationException()
3623 
      x.read(self._iprot)
3624 
      self._iprot.readMessageEnd()
3625 
      raise x
3626 
    result = markOrderCancellationRequestDenied_result()
3627 
    result.read(self._iprot)
3628 
    self._iprot.readMessageEnd()
3629 
    if result.ex is not None:
3630 
      raise result.ex
3631 
    return
3632 
 
4258 rajveer 3633 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3634 
    """
4258 rajveer 3635 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3636 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3637 
 
3638 
    Parameters:
4258 rajveer 3639 
     - transactionId
4247 rajveer 3640 
    """
4258 rajveer 3641 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3642 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3643 
 
4258 rajveer 3644 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3645 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3646 
    args = markTransactionAsPaymentFlagRemoved_args()
3647 
    args.transactionId = transactionId
4247 rajveer 3648 
    args.write(self._oprot)
3649 
    self._oprot.writeMessageEnd()
3650 
    self._oprot.trans.flush()
3651 
 
4258 rajveer 3652 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3654 
    if mtype == TMessageType.EXCEPTION:
3655 
      x = TApplicationException()
3656 
      x.read(self._iprot)
3657 
      self._iprot.readMessageEnd()
3658 
      raise x
4258 rajveer 3659 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3660 
    result.read(self._iprot)
3661 
    self._iprot.readMessageEnd()
3662 
    if result.ex is not None:
3663 
      raise result.ex
3664 
    return
3665 
 
4259 anupam.sin 3666 
  def refundTransaction(self, transactionId, refundedBy, reason):
3667 
    """
3668 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3669 
    need to be cancelled
4247 rajveer 3670 
 
4259 anupam.sin 3671 
    Parameters:
3672 
     - transactionId
3673 
     - refundedBy
3674 
     - reason
3675 
    """
3676 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3677 
    self.recv_refundTransaction()
3678 
 
3679 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3680 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3681 
    args = refundTransaction_args()
3682 
    args.transactionId = transactionId
3683 
    args.refundedBy = refundedBy
3684 
    args.reason = reason
3685 
    args.write(self._oprot)
3686 
    self._oprot.writeMessageEnd()
3687 
    self._oprot.trans.flush()
3688 
 
3689 
  def recv_refundTransaction(self, ):
3690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3691 
    if mtype == TMessageType.EXCEPTION:
3692 
      x = TApplicationException()
3693 
      x.read(self._iprot)
3694 
      self._iprot.readMessageEnd()
3695 
      raise x
3696 
    result = refundTransaction_result()
3697 
    result.read(self._iprot)
3698 
    self._iprot.readMessageEnd()
3699 
    if result.ex is not None:
3700 
      raise result.ex
3701 
    return
3702 
 
4324 mandeep.dh 3703 
  def updateShipmentAddress(self, orderId, addressId):
3704 
    """
3705 
    Updates shipment address of an order. Delivery and shipping date estimates
3706 
    etc. are also updated here.
3707 
 
3708 
    Throws TransactionServiceException in case address change is not
3709 
    possible due to certain reasons such as new pincode in address is
3710 
    not serviceable etc.
3711 
 
3712 
    Parameters:
3713 
     - orderId
3714 
     - addressId
3715 
    """
3716 
    self.send_updateShipmentAddress(orderId, addressId)
3717 
    self.recv_updateShipmentAddress()
3718 
 
3719 
  def send_updateShipmentAddress(self, orderId, addressId):
3720 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3721 
    args = updateShipmentAddress_args()
3722 
    args.orderId = orderId
3723 
    args.addressId = addressId
3724 
    args.write(self._oprot)
3725 
    self._oprot.writeMessageEnd()
3726 
    self._oprot.trans.flush()
3727 
 
3728 
  def recv_updateShipmentAddress(self, ):
3729 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3730 
    if mtype == TMessageType.EXCEPTION:
3731 
      x = TApplicationException()
3732 
      x.read(self._iprot)
3733 
      self._iprot.readMessageEnd()
3734 
      raise x
3735 
    result = updateShipmentAddress_result()
3736 
    result.read(self._iprot)
3737 
    self._iprot.readMessageEnd()
3738 
    if result.ex is not None:
3739 
      raise result.ex
3740 
    return
3741 
 
4285 rajveer 3742 
  def acceptOrdersForItemId(self, itemId, inventory):
3743 
    """
3744 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3745 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3746 
 
4285 rajveer 3747 
    Parameters:
3748 
     - itemId
3749 
     - inventory
3750 
    """
3751 
    self.send_acceptOrdersForItemId(itemId, inventory)
3752 
    return self.recv_acceptOrdersForItemId()
3753 
 
3754 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3755 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3756 
    args = acceptOrdersForItemId_args()
3757 
    args.itemId = itemId
3758 
    args.inventory = inventory
3759 
    args.write(self._oprot)
3760 
    self._oprot.writeMessageEnd()
3761 
    self._oprot.trans.flush()
3762 
 
3763 
  def recv_acceptOrdersForItemId(self, ):
3764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3765 
    if mtype == TMessageType.EXCEPTION:
3766 
      x = TApplicationException()
3767 
      x.read(self._iprot)
3768 
      self._iprot.readMessageEnd()
3769 
      raise x
3770 
    result = acceptOrdersForItemId_result()
3771 
    result.read(self._iprot)
3772 
    self._iprot.readMessageEnd()
3773 
    if result.success is not None:
3774 
      return result.success
3775 
    if result.ex is not None:
3776 
      raise result.ex
3777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3778 
 
4369 rajveer 3779 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3780 
    """
3781 
    Parameters:
3782 
     - vendorId
3783 
     - itemId
3784 
     - quantity
3785 
     - estimate
4369 rajveer 3786 
     - isReminder
4303 rajveer 3787 
    """
4369 rajveer 3788 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3789 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3790 
 
4369 rajveer 3791 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3792 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3793 
    args = markOrdersAsPORaised_args()
3794 
    args.vendorId = vendorId
3795 
    args.itemId = itemId
3796 
    args.quantity = quantity
3797 
    args.estimate = estimate
4369 rajveer 3798 
    args.isReminder = isReminder
4303 rajveer 3799 
    args.write(self._oprot)
3800 
    self._oprot.writeMessageEnd()
3801 
    self._oprot.trans.flush()
3802 
 
3803 
  def recv_markOrdersAsPORaised(self, ):
3804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3805 
    if mtype == TMessageType.EXCEPTION:
3806 
      x = TApplicationException()
3807 
      x.read(self._iprot)
3808 
      self._iprot.readMessageEnd()
3809 
      raise x
3810 
    result = markOrdersAsPORaised_result()
3811 
    result.read(self._iprot)
3812 
    self._iprot.readMessageEnd()
3813 
    if result.ex is not None:
3814 
      raise result.ex
3815 
    return
3816 
 
4369 rajveer 3817 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3818 
    """
3819 
    Parameters:
3820 
     - vendorId
3821 
     - itemId
3822 
     - quantity
3823 
     - estimate
4369 rajveer 3824 
     - isReminder
4303 rajveer 3825 
    """
4369 rajveer 3826 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3827 
    self.recv_markOrdersAsReversalInitiated()
3828 
 
4369 rajveer 3829 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3830 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3831 
    args = markOrdersAsReversalInitiated_args()
3832 
    args.vendorId = vendorId
3833 
    args.itemId = itemId
3834 
    args.quantity = quantity
3835 
    args.estimate = estimate
4369 rajveer 3836 
    args.isReminder = isReminder
4303 rajveer 3837 
    args.write(self._oprot)
3838 
    self._oprot.writeMessageEnd()
3839 
    self._oprot.trans.flush()
3840 
 
3841 
  def recv_markOrdersAsReversalInitiated(self, ):
3842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3843 
    if mtype == TMessageType.EXCEPTION:
3844 
      x = TApplicationException()
3845 
      x.read(self._iprot)
3846 
      self._iprot.readMessageEnd()
3847 
      raise x
3848 
    result = markOrdersAsReversalInitiated_result()
3849 
    result.read(self._iprot)
3850 
    self._iprot.readMessageEnd()
3851 
    if result.ex is not None:
3852 
      raise result.ex
3853 
    return
3854 
 
4369 rajveer 3855 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3856 
    """
3857 
    Parameters:
3858 
     - vendorId
3859 
     - itemId
3860 
     - quantity
3861 
     - estimate
4369 rajveer 3862 
     - isReminder
4303 rajveer 3863 
    """
4369 rajveer 3864 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3865 
    self.recv_markOrdersAsNotAvailabke()
3866 
 
4369 rajveer 3867 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3868 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3869 
    args = markOrdersAsNotAvailabke_args()
3870 
    args.vendorId = vendorId
3871 
    args.itemId = itemId
3872 
    args.quantity = quantity
3873 
    args.estimate = estimate
4369 rajveer 3874 
    args.isReminder = isReminder
4303 rajveer 3875 
    args.write(self._oprot)
3876 
    self._oprot.writeMessageEnd()
3877 
    self._oprot.trans.flush()
3878 
 
3879 
  def recv_markOrdersAsNotAvailabke(self, ):
3880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3881 
    if mtype == TMessageType.EXCEPTION:
3882 
      x = TApplicationException()
3883 
      x.read(self._iprot)
3884 
      self._iprot.readMessageEnd()
3885 
      raise x
3886 
    result = markOrdersAsNotAvailabke_result()
3887 
    result.read(self._iprot)
3888 
    self._iprot.readMessageEnd()
3889 
    if result.ex is not None:
3890 
      raise result.ex
3891 
    return
3892 
 
4369 rajveer 3893 
  def markOrdersAsTimeout(self, vendorId):
3894 
    """
3895 
    Parameters:
3896 
     - vendorId
3897 
    """
3898 
    self.send_markOrdersAsTimeout(vendorId)
3899 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3900 
 
4369 rajveer 3901 
  def send_markOrdersAsTimeout(self, vendorId):
3902 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3903 
    args = markOrdersAsTimeout_args()
3904 
    args.vendorId = vendorId
3905 
    args.write(self._oprot)
3906 
    self._oprot.writeMessageEnd()
3907 
    self._oprot.trans.flush()
3908 
 
3909 
  def recv_markOrdersAsTimeout(self, ):
3910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3911 
    if mtype == TMessageType.EXCEPTION:
3912 
      x = TApplicationException()
3913 
      x.read(self._iprot)
3914 
      self._iprot.readMessageEnd()
3915 
      raise x
3916 
    result = markOrdersAsTimeout_result()
3917 
    result.read(self._iprot)
3918 
    self._iprot.readMessageEnd()
3919 
    if result.success is not None:
3920 
      return result.success
3921 
    if result.ex is not None:
3922 
      raise result.ex
3923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3924 
 
4662 rajveer 3925 
  def markOrderAsLostInTransit(self, orderId):
3926 
    """
3927 
    Mark order as LOST_IN_TRANSIT
3928 
 
3929 
    Parameters:
3930 
     - orderId
3931 
    """
3932 
    self.send_markOrderAsLostInTransit(orderId)
3933 
    return self.recv_markOrderAsLostInTransit()
3934 
 
3935 
  def send_markOrderAsLostInTransit(self, orderId):
3936 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
3937 
    args = markOrderAsLostInTransit_args()
3938 
    args.orderId = orderId
3939 
    args.write(self._oprot)
3940 
    self._oprot.writeMessageEnd()
3941 
    self._oprot.trans.flush()
3942 
 
3943 
  def recv_markOrderAsLostInTransit(self, ):
3944 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3945 
    if mtype == TMessageType.EXCEPTION:
3946 
      x = TApplicationException()
3947 
      x.read(self._iprot)
3948 
      self._iprot.readMessageEnd()
3949 
      raise x
3950 
    result = markOrderAsLostInTransit_result()
3951 
    result.read(self._iprot)
3952 
    self._iprot.readMessageEnd()
3953 
    if result.success is not None:
3954 
      return result.success
3955 
    if result.ex is not None:
3956 
      raise result.ex
3957 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
3958 
 
4386 anupam.sin 3959 
  def getOrderForAwb(self, awb):
3960 
    """
3961 
    Returns the order corresponding to an AWB number
4369 rajveer 3962 
 
4386 anupam.sin 3963 
    Parameters:
3964 
     - awb
3965 
    """
3966 
    self.send_getOrderForAwb(awb)
3967 
    return self.recv_getOrderForAwb()
3968 
 
3969 
  def send_getOrderForAwb(self, awb):
3970 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3971 
    args = getOrderForAwb_args()
3972 
    args.awb = awb
3973 
    args.write(self._oprot)
3974 
    self._oprot.writeMessageEnd()
3975 
    self._oprot.trans.flush()
3976 
 
3977 
  def recv_getOrderForAwb(self, ):
3978 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3979 
    if mtype == TMessageType.EXCEPTION:
3980 
      x = TApplicationException()
3981 
      x.read(self._iprot)
3982 
      self._iprot.readMessageEnd()
3983 
      raise x
3984 
    result = getOrderForAwb_result()
3985 
    result.read(self._iprot)
3986 
    self._iprot.readMessageEnd()
3987 
    if result.success is not None:
3988 
      return result.success
3989 
    if result.ex is not None:
3990 
      raise result.ex
3991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3992 
 
4506 phani.kuma 3993 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3994 
    """
3995 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3996 
 
4506 phani.kuma 3997 
    Parameters:
3998 
     - logistics_provider_id
3999 
     - order_status
4000 
    """
4001 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
4002 
    return self.recv_getOrdersForProviderForStatus()
4003 
 
4004 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
4005 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4006 
    args = getOrdersForProviderForStatus_args()
4007 
    args.logistics_provider_id = logistics_provider_id
4008 
    args.order_status = order_status
4009 
    args.write(self._oprot)
4010 
    self._oprot.writeMessageEnd()
4011 
    self._oprot.trans.flush()
4012 
 
4013 
  def recv_getOrdersForProviderForStatus(self, ):
4014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4015 
    if mtype == TMessageType.EXCEPTION:
4016 
      x = TApplicationException()
4017 
      x.read(self._iprot)
4018 
      self._iprot.readMessageEnd()
4019 
      raise x
4020 
    result = getOrdersForProviderForStatus_result()
4021 
    result.read(self._iprot)
4022 
    self._iprot.readMessageEnd()
4023 
    if result.success is not None:
4024 
      return result.success
4025 
    if result.ex is not None:
4026 
      raise result.ex
4027 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4028 
 
4600 varun.gupt 4029 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4030 
    """
4031 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4032 
 
4600 varun.gupt 4033 
    Parameters:
4034 
     - vendorId
4035 
     - billingDateFrom
4036 
     - billingDateTo
4037 
    """
4038 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4039 
    return self.recv_getBilledOrdersForVendor()
4040 
 
4041 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4042 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4043 
    args = getBilledOrdersForVendor_args()
4044 
    args.vendorId = vendorId
4045 
    args.billingDateFrom = billingDateFrom
4046 
    args.billingDateTo = billingDateTo
4047 
    args.write(self._oprot)
4048 
    self._oprot.writeMessageEnd()
4049 
    self._oprot.trans.flush()
4050 
 
4051 
  def recv_getBilledOrdersForVendor(self, ):
4052 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4053 
    if mtype == TMessageType.EXCEPTION:
4054 
      x = TApplicationException()
4055 
      x.read(self._iprot)
4056 
      self._iprot.readMessageEnd()
4057 
      raise x
4058 
    result = getBilledOrdersForVendor_result()
4059 
    result.read(self._iprot)
4060 
    self._iprot.readMessageEnd()
4061 
    if result.success is not None:
4062 
      return result.success
4063 
    if result.ex is not None:
4064 
      raise result.ex
4065 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4066 
 
4607 rajveer 4067 
  def getSlippedSippingDateOrders(self, ):
4068 
    self.send_getSlippedSippingDateOrders()
4069 
    return self.recv_getSlippedSippingDateOrders()
4070 
 
4071 
  def send_getSlippedSippingDateOrders(self, ):
4072 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4073 
    args = getSlippedSippingDateOrders_args()
4074 
    args.write(self._oprot)
4075 
    self._oprot.writeMessageEnd()
4076 
    self._oprot.trans.flush()
4077 
 
4078 
  def recv_getSlippedSippingDateOrders(self, ):
4079 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4080 
    if mtype == TMessageType.EXCEPTION:
4081 
      x = TApplicationException()
4082 
      x.read(self._iprot)
4083 
      self._iprot.readMessageEnd()
4084 
      raise x
4085 
    result = getSlippedSippingDateOrders_result()
4086 
    result.read(self._iprot)
4087 
    self._iprot.readMessageEnd()
4088 
    if result.success is not None:
4089 
      return result.success
4090 
    if result.ex is not None:
4091 
      raise result.ex
4092 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4093 
 
4709 rajveer 4094 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4095 
    """
4096 
    Parameters:
4097 
     - cancelDateFrom
4098 
     - cancelDateTo
4099 
    """
4100 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4101 
    return self.recv_getCancelledOrders()
4102 
 
4103 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4104 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4105 
    args = getCancelledOrders_args()
4106 
    args.cancelDateFrom = cancelDateFrom
4107 
    args.cancelDateTo = cancelDateTo
4108 
    args.write(self._oprot)
4109 
    self._oprot.writeMessageEnd()
4110 
    self._oprot.trans.flush()
4111 
 
4112 
  def recv_getCancelledOrders(self, ):
4113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4114 
    if mtype == TMessageType.EXCEPTION:
4115 
      x = TApplicationException()
4116 
      x.read(self._iprot)
4117 
      self._iprot.readMessageEnd()
4118 
      raise x
4119 
    result = getCancelledOrders_result()
4120 
    result.read(self._iprot)
4121 
    self._iprot.readMessageEnd()
4122 
    if result.success is not None:
4123 
      return result.success
4124 
    if result.ex is not None:
4125 
      raise result.ex
4126 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4127 
 
4600 varun.gupt 4128 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4129 
    """
4130 
    Parameters:
4131 
     - mapAWBAndAmount
4132 
    """
4133 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4134 
    self.recv_saveBluedartSettlements()
4135 
 
4136 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4137 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4138 
    args = saveBluedartSettlements_args()
4139 
    args.mapAWBAndAmount = mapAWBAndAmount
4140 
    args.write(self._oprot)
4141 
    self._oprot.writeMessageEnd()
4142 
    self._oprot.trans.flush()
4143 
 
4144 
  def recv_saveBluedartSettlements(self, ):
4145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4146 
    if mtype == TMessageType.EXCEPTION:
4147 
      x = TApplicationException()
4148 
      x.read(self._iprot)
4149 
      self._iprot.readMessageEnd()
4150 
      raise x
4151 
    result = saveBluedartSettlements_result()
4152 
    result.read(self._iprot)
4153 
    self._iprot.readMessageEnd()
4154 
    if result.ex is not None:
4155 
      raise result.ex
4156 
    return
4157 
 
4158 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4159 
    """
4160 
    Parameters:
4161 
     - settlementDate
4162 
     - paymentGatewayId
4163 
     - paymentId
4164 
     - serviceTax
4165 
     - otherCharges
4166 
     - netCollection
4167 
    """
4168 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection)
4169 
    self.recv_savePaymentSettlements()
4170 
 
4171 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4172 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4173 
    args = savePaymentSettlements_args()
4174 
    args.settlementDate = settlementDate
4175 
    args.paymentGatewayId = paymentGatewayId
4176 
    args.paymentId = paymentId
4177 
    args.serviceTax = serviceTax
4178 
    args.otherCharges = otherCharges
4179 
    args.netCollection = netCollection
4180 
    args.write(self._oprot)
4181 
    self._oprot.writeMessageEnd()
4182 
    self._oprot.trans.flush()
4183 
 
4184 
  def recv_savePaymentSettlements(self, ):
4185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4186 
    if mtype == TMessageType.EXCEPTION:
4187 
      x = TApplicationException()
4188 
      x.read(self._iprot)
4189 
      self._iprot.readMessageEnd()
4190 
      raise x
4191 
    result = savePaymentSettlements_result()
4192 
    result.read(self._iprot)
4193 
    self._iprot.readMessageEnd()
4194 
    if result.ex is not None:
4195 
      raise result.ex
4196 
    return
4197 
 
4198 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4199 
    """
4200 
    Parameters:
4201 
     - settlementId
4202 
     - settlementDate
4203 
     - transactionDateFrom
4204 
     - transactionDateTo
4205 
     - amount
4206 
    """
4207 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4208 
    self.recv_saveEBSSettlementSummary()
4209 
 
4210 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4211 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4212 
    args = saveEBSSettlementSummary_args()
4213 
    args.settlementId = settlementId
4214 
    args.settlementDate = settlementDate
4215 
    args.transactionDateFrom = transactionDateFrom
4216 
    args.transactionDateTo = transactionDateTo
4217 
    args.amount = amount
4218 
    args.write(self._oprot)
4219 
    self._oprot.writeMessageEnd()
4220 
    self._oprot.trans.flush()
4221 
 
4222 
  def recv_saveEBSSettlementSummary(self, ):
4223 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4224 
    if mtype == TMessageType.EXCEPTION:
4225 
      x = TApplicationException()
4226 
      x.read(self._iprot)
4227 
      self._iprot.readMessageEnd()
4228 
      raise x
4229 
    result = saveEBSSettlementSummary_result()
4230 
    result.read(self._iprot)
4231 
    self._iprot.readMessageEnd()
4232 
    if result.ex is not None:
4233 
      raise result.ex
4234 
    return
4235 
 
4236 
  def getSettlementForPaymentId(self, paymentId):
4237 
    """
4238 
    Parameters:
4239 
     - paymentId
4240 
    """
4241 
    self.send_getSettlementForPaymentId(paymentId)
4242 
    return self.recv_getSettlementForPaymentId()
4243 
 
4244 
  def send_getSettlementForPaymentId(self, paymentId):
4245 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4246 
    args = getSettlementForPaymentId_args()
4247 
    args.paymentId = paymentId
4248 
    args.write(self._oprot)
4249 
    self._oprot.writeMessageEnd()
4250 
    self._oprot.trans.flush()
4251 
 
4252 
  def recv_getSettlementForPaymentId(self, ):
4253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4254 
    if mtype == TMessageType.EXCEPTION:
4255 
      x = TApplicationException()
4256 
      x.read(self._iprot)
4257 
      self._iprot.readMessageEnd()
4258 
      raise x
4259 
    result = getSettlementForPaymentId_result()
4260 
    result.read(self._iprot)
4261 
    self._iprot.readMessageEnd()
4262 
    if result.success is not None:
4263 
      return result.success
4264 
    if result.ex is not None:
4265 
      raise result.ex
4266 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4267 
 
4268 
  def getEBSSettlementSummaries(self, ):
4269 
    self.send_getEBSSettlementSummaries()
4270 
    return self.recv_getEBSSettlementSummaries()
4271 
 
4272 
  def send_getEBSSettlementSummaries(self, ):
4273 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4274 
    args = getEBSSettlementSummaries_args()
4275 
    args.write(self._oprot)
4276 
    self._oprot.writeMessageEnd()
4277 
    self._oprot.trans.flush()
4278 
 
4279 
  def recv_getEBSSettlementSummaries(self, ):
4280 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4281 
    if mtype == TMessageType.EXCEPTION:
4282 
      x = TApplicationException()
4283 
      x.read(self._iprot)
4284 
      self._iprot.readMessageEnd()
4285 
      raise x
4286 
    result = getEBSSettlementSummaries_result()
4287 
    result.read(self._iprot)
4288 
    self._iprot.readMessageEnd()
4289 
    if result.success is not None:
4290 
      return result.success
4291 
    if result.ex is not None:
4292 
      raise result.ex
4293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4294 
 
4295 
  def markEBSSettlementUploaded(self, settlementId):
4296 
    """
4297 
    Parameters:
4298 
     - settlementId
4299 
    """
4300 
    self.send_markEBSSettlementUploaded(settlementId)
4301 
    self.recv_markEBSSettlementUploaded()
4302 
 
4303 
  def send_markEBSSettlementUploaded(self, settlementId):
4304 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4305 
    args = markEBSSettlementUploaded_args()
4306 
    args.settlementId = settlementId
4307 
    args.write(self._oprot)
4308 
    self._oprot.writeMessageEnd()
4309 
    self._oprot.trans.flush()
4310 
 
4311 
  def recv_markEBSSettlementUploaded(self, ):
4312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4313 
    if mtype == TMessageType.EXCEPTION:
4314 
      x = TApplicationException()
4315 
      x.read(self._iprot)
4316 
      self._iprot.readMessageEnd()
4317 
      raise x
4318 
    result = markEBSSettlementUploaded_result()
4319 
    result.read(self._iprot)
4320 
    self._iprot.readMessageEnd()
4321 
    if result.ex is not None:
4322 
      raise result.ex
4323 
    return
4324 
 
4325 
  def getEBSSettlementDate(self, settlementId):
4326 
    """
4327 
    Parameters:
4328 
     - settlementId
4329 
    """
4330 
    self.send_getEBSSettlementDate(settlementId)
4331 
    return self.recv_getEBSSettlementDate()
4332 
 
4333 
  def send_getEBSSettlementDate(self, settlementId):
4334 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4335 
    args = getEBSSettlementDate_args()
4336 
    args.settlementId = settlementId
4337 
    args.write(self._oprot)
4338 
    self._oprot.writeMessageEnd()
4339 
    self._oprot.trans.flush()
4340 
 
4341 
  def recv_getEBSSettlementDate(self, ):
4342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4343 
    if mtype == TMessageType.EXCEPTION:
4344 
      x = TApplicationException()
4345 
      x.read(self._iprot)
4346 
      self._iprot.readMessageEnd()
4347 
      raise x
4348 
    result = getEBSSettlementDate_result()
4349 
    result.read(self._iprot)
4350 
    self._iprot.readMessageEnd()
4351 
    if result.success is not None:
4352 
      return result.success
4353 
    if result.ex is not None:
4354 
      raise result.ex
4355 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4356 
 
4715 varun.gupt 4357 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4358 
    """
4359 
    Parameters:
4360 
     - settlementDateFrom
4361 
     - settlementDateTo
4362 
     - isRefund
4363 
    """
4364 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4365 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4366 
 
4715 varun.gupt 4367 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4368 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4369 
    args = getSettlementsByDate_args()
4370 
    args.settlementDateFrom = settlementDateFrom
4371 
    args.settlementDateTo = settlementDateTo
4372 
    args.isRefund = isRefund
4373 
    args.write(self._oprot)
4374 
    self._oprot.writeMessageEnd()
4375 
    self._oprot.trans.flush()
4376 
 
4377 
  def recv_getSettlementsByDate(self, ):
4378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4379 
    if mtype == TMessageType.EXCEPTION:
4380 
      x = TApplicationException()
4381 
      x.read(self._iprot)
4382 
      self._iprot.readMessageEnd()
4383 
      raise x
4384 
    result = getSettlementsByDate_result()
4385 
    result.read(self._iprot)
4386 
    self._iprot.readMessageEnd()
4387 
    if result.success is not None:
4388 
      return result.success
4389 
    if result.ex is not None:
4390 
      raise result.ex
4391 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4392 
 
4393 
  def getReshippedOrderIds(self, orderIds):
4394 
    """
4395 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4396 
 
4397 
    Parameters:
4398 
     - orderIds
4399 
    """
4400 
    self.send_getReshippedOrderIds(orderIds)
4401 
    return self.recv_getReshippedOrderIds()
4402 
 
4403 
  def send_getReshippedOrderIds(self, orderIds):
4404 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4405 
    args = getReshippedOrderIds_args()
4406 
    args.orderIds = orderIds
4407 
    args.write(self._oprot)
4408 
    self._oprot.writeMessageEnd()
4409 
    self._oprot.trans.flush()
4410 
 
4411 
  def recv_getReshippedOrderIds(self, ):
4412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4413 
    if mtype == TMessageType.EXCEPTION:
4414 
      x = TApplicationException()
4415 
      x.read(self._iprot)
4416 
      self._iprot.readMessageEnd()
4417 
      raise x
4418 
    result = getReshippedOrderIds_result()
4419 
    result.read(self._iprot)
4420 
    self._iprot.readMessageEnd()
4421 
    if result.success is not None:
4422 
      return result.success
4423 
    if result.ex is not None:
4424 
      raise result.ex
4425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4426 
 
4757 mandeep.dh 4427 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4428 
    """
4429 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
4430 
    the quantities for which the PO is raised.
4715 varun.gupt 4431 
 
4757 mandeep.dh 4432 
    Parameters:
4433 
     - itemIdQuantityMap
4434 
     - purchaseOrderId
4435 
     - warehouseId
4436 
    """
4437 
    self.send_updateOrdersAsPORaised(itemIdQuantityMap, purchaseOrderId, warehouseId)
4438 
    self.recv_updateOrdersAsPORaised()
4439 
 
4440 
  def send_updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4441 
    self._oprot.writeMessageBegin('updateOrdersAsPORaised', TMessageType.CALL, self._seqid)
4442 
    args = updateOrdersAsPORaised_args()
4443 
    args.itemIdQuantityMap = itemIdQuantityMap
4444 
    args.purchaseOrderId = purchaseOrderId
4445 
    args.warehouseId = warehouseId
4446 
    args.write(self._oprot)
4447 
    self._oprot.writeMessageEnd()
4448 
    self._oprot.trans.flush()
4449 
 
4450 
  def recv_updateOrdersAsPORaised(self, ):
4451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4452 
    if mtype == TMessageType.EXCEPTION:
4453 
      x = TApplicationException()
4454 
      x.read(self._iprot)
4455 
      self._iprot.readMessageEnd()
4456 
      raise x
4457 
    result = updateOrdersAsPORaised_result()
4458 
    result.read(self._iprot)
4459 
    self._iprot.readMessageEnd()
4460 
    if result.ex is not None:
4461 
      raise result.ex
4462 
    return
4463 
 
4464 
 
3376 rajveer 4465 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4466 
  def __init__(self, handler):
3376 rajveer 4467 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4468 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4469 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4470 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4471 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4472 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4473 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4474 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4475 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4476 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4477 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4478 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4479 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4480 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4481 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4482 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4483 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4484 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4485 
    self._processMap["createOrder"] = Processor.process_createOrder
4486 
    self._processMap["getOrder"] = Processor.process_getOrder
4487 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4488 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4489 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4490 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4491 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4492 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4493 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4494 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4495 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4496 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4497 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4498 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4499 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4500 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4501 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 4502 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 4503 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4504 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 4505 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 4506 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 4507 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 4508 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 4509 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 4510 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 4511 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 4512 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4513 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4514 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4515 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4516 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4517 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4518 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4741 phani.kuma 4519 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
2616 chandransh 4520 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4521 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4522 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4523 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4524 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4525 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4526 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4527 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 4528 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4529 
    self._processMap["changeItem"] = Processor.process_changeItem
4530 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4531 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4532 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4533 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4534 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4535 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4536 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4537 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4538 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4539 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4540 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4541 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4542 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4543 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4544 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4545 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4546 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4547 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 4548 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 4549 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4550 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4551 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4552 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 4553 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 4554 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4555 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4556 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4557 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4558 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4559 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4560 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 4561 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
4562 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4757 mandeep.dh 4563 
    self._processMap["updateOrdersAsPORaised"] = Processor.process_updateOrdersAsPORaised
94 ashish 4564 
 
4565 
  def process(self, iprot, oprot):
4566 
    (name, type, seqid) = iprot.readMessageBegin()
4567 
    if name not in self._processMap:
4568 
      iprot.skip(TType.STRUCT)
4569 
      iprot.readMessageEnd()
4570 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4571 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4572 
      x.write(oprot)
4573 
      oprot.writeMessageEnd()
4574 
      oprot.trans.flush()
4575 
      return
4576 
    else:
4577 
      self._processMap[name](self, seqid, iprot, oprot)
4578 
    return True
4579 
 
4580 
  def process_createTransaction(self, seqid, iprot, oprot):
4581 
    args = createTransaction_args()
4582 
    args.read(iprot)
4583 
    iprot.readMessageEnd()
4584 
    result = createTransaction_result()
4585 
    try:
132 ashish 4586 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4587 
    except TransactionServiceException, ex:
4588 
      result.ex = ex
4589 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4590 
    result.write(oprot)
4591 
    oprot.writeMessageEnd()
4592 
    oprot.trans.flush()
4593 
 
4594 
  def process_getTransaction(self, seqid, iprot, oprot):
4595 
    args = getTransaction_args()
4596 
    args.read(iprot)
4597 
    iprot.readMessageEnd()
4598 
    result = getTransaction_result()
4599 
    try:
4600 
      result.success = self._handler.getTransaction(args.id)
4601 
    except TransactionServiceException, ex:
4602 
      result.ex = ex
4603 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4604 
    result.write(oprot)
4605 
    oprot.writeMessageEnd()
4606 
    oprot.trans.flush()
4607 
 
4608 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4609 
    args = getTransactionsForCustomer_args()
4610 
    args.read(iprot)
4611 
    iprot.readMessageEnd()
4612 
    result = getTransactionsForCustomer_result()
4613 
    try:
4614 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4615 
    except TransactionServiceException, ex:
4616 
      result.ex = ex
4617 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4618 
    result.write(oprot)
4619 
    oprot.writeMessageEnd()
4620 
    oprot.trans.flush()
4621 
 
132 ashish 4622 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4623 
    args = getTransactionsForShoppingCartId_args()
4624 
    args.read(iprot)
4625 
    iprot.readMessageEnd()
4626 
    result = getTransactionsForShoppingCartId_result()
4627 
    try:
4628 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4629 
    except TransactionServiceException, ex:
4630 
      result.ex = ex
4631 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4632 
    result.write(oprot)
4633 
    oprot.writeMessageEnd()
4634 
    oprot.trans.flush()
4635 
 
94 ashish 4636 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4637 
    args = getTransactionStatus_args()
4638 
    args.read(iprot)
4639 
    iprot.readMessageEnd()
4640 
    result = getTransactionStatus_result()
4641 
    try:
4642 
      result.success = self._handler.getTransactionStatus(args.transactionId)
4643 
    except TransactionServiceException, ex:
4644 
      result.ex = ex
4645 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
4646 
    result.write(oprot)
4647 
    oprot.writeMessageEnd()
4648 
    oprot.trans.flush()
4649 
 
4650 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
4651 
    args = changeTransactionStatus_args()
4652 
    args.read(iprot)
4653 
    iprot.readMessageEnd()
4654 
    result = changeTransactionStatus_result()
4655 
    try:
4656 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
4657 
    except TransactionServiceException, ex:
4658 
      result.ex = ex
4659 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
4660 
    result.write(oprot)
4661 
    oprot.writeMessageEnd()
4662 
    oprot.trans.flush()
4663 
 
1398 varun.gupt 4664 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
4665 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 4666 
    args.read(iprot)
4667 
    iprot.readMessageEnd()
1398 varun.gupt 4668 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 4669 
    try:
1398 varun.gupt 4670 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 4671 
    except TransactionServiceException, ex:
4672 
      result.ex = ex
1398 varun.gupt 4673 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 4674 
    result.write(oprot)
4675 
    oprot.writeMessageEnd()
4676 
    oprot.trans.flush()
4677 
 
483 rajveer 4678 
  def process_getAllOrders(self, seqid, iprot, oprot):
4679 
    args = getAllOrders_args()
94 ashish 4680 
    args.read(iprot)
4681 
    iprot.readMessageEnd()
483 rajveer 4682 
    result = getAllOrders_result()
94 ashish 4683 
    try:
4801 anupam.sin 4684 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 4685 
    except TransactionServiceException, ex:
4686 
      result.ex = ex
483 rajveer 4687 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 4688 
    result.write(oprot)
4689 
    oprot.writeMessageEnd()
4690 
    oprot.trans.flush()
4691 
 
4133 chandransh 4692 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
4693 
    args = getOrdersInBatch_args()
4694 
    args.read(iprot)
4695 
    iprot.readMessageEnd()
4696 
    result = getOrdersInBatch_result()
4697 
    try:
4698 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4699 
    except TransactionServiceException, ex:
4700 
      result.ex = ex
4701 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4702 
    result.write(oprot)
4703 
    oprot.writeMessageEnd()
4704 
    oprot.trans.flush()
4705 
 
4706 
  def process_getOrderCount(self, seqid, iprot, oprot):
4707 
    args = getOrderCount_args()
4708 
    args.read(iprot)
4709 
    iprot.readMessageEnd()
4710 
    result = getOrderCount_result()
4711 
    try:
4712 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4713 
    except TransactionServiceException, ex:
4714 
      result.ex = ex
4715 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4716 
    result.write(oprot)
4717 
    oprot.writeMessageEnd()
4718 
    oprot.trans.flush()
4719 
 
999 varun.gupt 4720 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4721 
    args = getOrdersByBillingDate_args()
4722 
    args.read(iprot)
4723 
    iprot.readMessageEnd()
4724 
    result = getOrdersByBillingDate_result()
4725 
    try:
4726 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4727 
    except TransactionServiceException, ex:
4728 
      result.ex = ex
4729 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4730 
    result.write(oprot)
4731 
    oprot.writeMessageEnd()
4732 
    oprot.trans.flush()
4733 
 
3427 chandransh 4734 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4735 
    args = getOrdersByShippingDate_args()
4736 
    args.read(iprot)
4737 
    iprot.readMessageEnd()
4738 
    result = getOrdersByShippingDate_result()
4739 
    try:
3451 chandransh 4740 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4741 
    except TransactionServiceException, ex:
4742 
      result.ex = ex
4743 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4744 
    result.write(oprot)
4745 
    oprot.writeMessageEnd()
4746 
    oprot.trans.flush()
4747 
 
1382 varun.gupt 4748 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4749 
    args = getReturnableOrdersForCustomer_args()
4750 
    args.read(iprot)
4751 
    iprot.readMessageEnd()
4752 
    result = getReturnableOrdersForCustomer_result()
4753 
    try:
4754 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4755 
    except TransactionServiceException, ex:
4756 
      result.ex = ex
4757 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4758 
    result.write(oprot)
4759 
    oprot.writeMessageEnd()
4760 
    oprot.trans.flush()
4761 
 
4762 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4763 
    args = getCancellableOrdersForCustomer_args()
4764 
    args.read(iprot)
4765 
    iprot.readMessageEnd()
4766 
    result = getCancellableOrdersForCustomer_result()
4767 
    try:
4768 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4769 
    except TransactionServiceException, ex:
4770 
      result.ex = ex
4771 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4772 
    result.write(oprot)
4773 
    oprot.writeMessageEnd()
4774 
    oprot.trans.flush()
4775 
 
483 rajveer 4776 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4777 
    args = changeOrderStatus_args()
94 ashish 4778 
    args.read(iprot)
4779 
    iprot.readMessageEnd()
483 rajveer 4780 
    result = changeOrderStatus_result()
94 ashish 4781 
    try:
483 rajveer 4782 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4783 
    except TransactionServiceException, ex:
4784 
      result.ex = ex
483 rajveer 4785 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4786 
    result.write(oprot)
4787 
    oprot.writeMessageEnd()
4788 
    oprot.trans.flush()
4789 
 
483 rajveer 4790 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4791 
    args = getOrdersForTransaction_args()
94 ashish 4792 
    args.read(iprot)
4793 
    iprot.readMessageEnd()
483 rajveer 4794 
    result = getOrdersForTransaction_result()
94 ashish 4795 
    try:
1528 ankur.sing 4796 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4797 
    except TransactionServiceException, ex:
4798 
      result.ex = ex
483 rajveer 4799 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4800 
    result.write(oprot)
4801 
    oprot.writeMessageEnd()
4802 
    oprot.trans.flush()
4803 
 
483 rajveer 4804 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4805 
    args = getOrdersForCustomer_args()
94 ashish 4806 
    args.read(iprot)
4807 
    iprot.readMessageEnd()
483 rajveer 4808 
    result = getOrdersForCustomer_result()
94 ashish 4809 
    try:
3014 chandransh 4810 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4811 
    except TransactionServiceException, ex:
4812 
      result.ex = ex
483 rajveer 4813 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4814 
    result.write(oprot)
4815 
    oprot.writeMessageEnd()
4816 
    oprot.trans.flush()
4817 
 
483 rajveer 4818 
  def process_createOrder(self, seqid, iprot, oprot):
4819 
    args = createOrder_args()
94 ashish 4820 
    args.read(iprot)
4821 
    iprot.readMessageEnd()
483 rajveer 4822 
    result = createOrder_result()
94 ashish 4823 
    try:
483 rajveer 4824 
      result.success = self._handler.createOrder(args.order)
94 ashish 4825 
    except TransactionServiceException, ex:
4826 
      result.ex = ex
483 rajveer 4827 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4828 
    result.write(oprot)
4829 
    oprot.writeMessageEnd()
4830 
    oprot.trans.flush()
4831 
 
483 rajveer 4832 
  def process_getOrder(self, seqid, iprot, oprot):
4833 
    args = getOrder_args()
94 ashish 4834 
    args.read(iprot)
4835 
    iprot.readMessageEnd()
483 rajveer 4836 
    result = getOrder_result()
94 ashish 4837 
    try:
483 rajveer 4838 
      result.success = self._handler.getOrder(args.id)
94 ashish 4839 
    except TransactionServiceException, ex:
4840 
      result.ex = ex
483 rajveer 4841 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4842 
    result.write(oprot)
4843 
    oprot.writeMessageEnd()
4844 
    oprot.trans.flush()
4845 
 
483 rajveer 4846 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4847 
    args = getLineItemsForOrder_args()
94 ashish 4848 
    args.read(iprot)
4849 
    iprot.readMessageEnd()
483 rajveer 4850 
    result = getLineItemsForOrder_result()
94 ashish 4851 
    try:
483 rajveer 4852 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4853 
    except TransactionServiceException, ex:
4854 
      result.ex = ex
483 rajveer 4855 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4856 
    result.write(oprot)
4857 
    oprot.writeMessageEnd()
4858 
    oprot.trans.flush()
4859 
 
1528 ankur.sing 4860 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4861 
    args = getOrderForCustomer_args()
4862 
    args.read(iprot)
4863 
    iprot.readMessageEnd()
4864 
    result = getOrderForCustomer_result()
4865 
    try:
4866 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4867 
    except TransactionServiceException, ex:
4868 
      result.ex = ex
4869 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4870 
    result.write(oprot)
4871 
    oprot.writeMessageEnd()
4872 
    oprot.trans.flush()
4873 
 
3064 chandransh 4874 
  def process_getAlerts(self, seqid, iprot, oprot):
4875 
    args = getAlerts_args()
4876 
    args.read(iprot)
4877 
    iprot.readMessageEnd()
4878 
    result = getAlerts_result()
4444 rajveer 4879 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4880 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4881 
    result.write(oprot)
4882 
    oprot.writeMessageEnd()
4883 
    oprot.trans.flush()
4884 
 
4394 rajveer 4885 
  def process_addAlert(self, seqid, iprot, oprot):
4886 
    args = addAlert_args()
3064 chandransh 4887 
    args.read(iprot)
4888 
    iprot.readMessageEnd()
4394 rajveer 4889 
    result = addAlert_result()
4444 rajveer 4890 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4891 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4892 
    result.write(oprot)
4893 
    oprot.writeMessageEnd()
4894 
    oprot.trans.flush()
4895 
 
4444 rajveer 4896 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4897 
    args = markAlertsAsSeen_args()
4898 
    args.read(iprot)
4899 
    iprot.readMessageEnd()
4900 
    result = markAlertsAsSeen_result()
4901 
    self._handler.markAlertsAsSeen(args.warehouseId)
4902 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4903 
    result.write(oprot)
4904 
    oprot.writeMessageEnd()
4905 
    oprot.trans.flush()
4906 
 
3064 chandransh 4907 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4908 
    args = getValidOrderCount_args()
4909 
    args.read(iprot)
4910 
    iprot.readMessageEnd()
4911 
    result = getValidOrderCount_result()
4912 
    result.success = self._handler.getValidOrderCount()
4913 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4914 
    result.write(oprot)
4915 
    oprot.writeMessageEnd()
4916 
    oprot.trans.flush()
4917 
 
4918 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4919 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4920 
    args.read(iprot)
4921 
    iprot.readMessageEnd()
4922 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4923 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4924 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4925 
    result.write(oprot)
4926 
    oprot.writeMessageEnd()
4927 
    oprot.trans.flush()
4928 
 
4929 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4930 
    args = getValidOrdersAmountRange_args()
4931 
    args.read(iprot)
4932 
    iprot.readMessageEnd()
4933 
    result = getValidOrdersAmountRange_result()
4934 
    result.success = self._handler.getValidOrdersAmountRange()
4935 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4936 
    result.write(oprot)
4937 
    oprot.writeMessageEnd()
4938 
    oprot.trans.flush()
4939 
 
4940 
  def process_getValidOrders(self, seqid, iprot, oprot):
4941 
    args = getValidOrders_args()
4942 
    args.read(iprot)
4943 
    iprot.readMessageEnd()
4944 
    result = getValidOrders_result()
4945 
    result.success = self._handler.getValidOrders(args.limit)
4946 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4947 
    result.write(oprot)
4948 
    oprot.writeMessageEnd()
4949 
    oprot.trans.flush()
4950 
 
1220 chandransh 4951 
  def process_batchOrders(self, seqid, iprot, oprot):
4952 
    args = batchOrders_args()
4953 
    args.read(iprot)
4954 
    iprot.readMessageEnd()
4955 
    result = batchOrders_result()
4956 
    try:
4957 
      result.success = self._handler.batchOrders(args.warehouseId)
4958 
    except TransactionServiceException, ex:
4959 
      result.ex = ex
4960 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4961 
    result.write(oprot)
4962 
    oprot.writeMessageEnd()
4963 
    oprot.trans.flush()
4964 
 
1208 chandransh 4965 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4966 
    args = markOrderAsOutOfStock_args()
4967 
    args.read(iprot)
4968 
    iprot.readMessageEnd()
4969 
    result = markOrderAsOutOfStock_result()
4970 
    try:
4971 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4972 
    except TransactionServiceException, ex:
4973 
      result.ex = ex
4974 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4975 
    result.write(oprot)
4976 
    oprot.writeMessageEnd()
4977 
    oprot.trans.flush()
4978 
 
3064 chandransh 4979 
  def process_verifyOrder(self, seqid, iprot, oprot):
4980 
    args = verifyOrder_args()
759 chandransh 4981 
    args.read(iprot)
4982 
    iprot.readMessageEnd()
3064 chandransh 4983 
    result = verifyOrder_result()
759 chandransh 4984 
    try:
3064 chandransh 4985 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4986 
    except TransactionServiceException, ex:
4987 
      result.ex = ex
3064 chandransh 4988 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4989 
    result.write(oprot)
4990 
    oprot.writeMessageEnd()
4991 
    oprot.trans.flush()
4992 
 
3064 chandransh 4993 
  def process_acceptOrder(self, seqid, iprot, oprot):
4994 
    args = acceptOrder_args()
1113 chandransh 4995 
    args.read(iprot)
4996 
    iprot.readMessageEnd()
3064 chandransh 4997 
    result = acceptOrder_result()
1113 chandransh 4998 
    try:
3064 chandransh 4999 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5000 
    except TransactionServiceException, ex:
5001 
      result.ex = ex
3064 chandransh 5002 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5003 
    result.write(oprot)
5004 
    oprot.writeMessageEnd()
5005 
    oprot.trans.flush()
5006 
 
3064 chandransh 5007 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5008 
    args = addBillingDetails_args()
1135 chandransh 5009 
    args.read(iprot)
5010 
    iprot.readMessageEnd()
3064 chandransh 5011 
    result = addBillingDetails_result()
1135 chandransh 5012 
    try:
4763 rajveer 5013 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.serialNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.vendorId, args.authorize)
1135 chandransh 5014 
    except TransactionServiceException, ex:
5015 
      result.ex = ex
3064 chandransh 5016 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5017 
    result.write(oprot)
5018 
    oprot.writeMessageEnd()
5019 
    oprot.trans.flush()
5020 
 
4579 rajveer 5021 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5022 
    args = addInvoiceNumber_args()
5023 
    args.read(iprot)
5024 
    iprot.readMessageEnd()
5025 
    result = addInvoiceNumber_result()
5026 
    try:
4763 rajveer 5027 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5028 
    except TransactionServiceException, ex:
5029 
      result.ex = ex
5030 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5031 
    result.write(oprot)
5032 
    oprot.writeMessageEnd()
5033 
    oprot.trans.flush()
5034 
 
3064 chandransh 5035 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
5036 
    args = markOrdersAsManifested_args()
1408 ankur.sing 5037 
    args.read(iprot)
5038 
    iprot.readMessageEnd()
3064 chandransh 5039 
    result = markOrdersAsManifested_result()
5040 
    try:
5041 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
5042 
    except TransactionServiceException, ex:
5043 
      result.ex = ex
5044 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 5045 
    result.write(oprot)
5046 
    oprot.writeMessageEnd()
5047 
    oprot.trans.flush()
5048 
 
4410 rajveer 5049 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5050 
    args = markOrdersAsShippedFromWarehouse_args()
5051 
    args.read(iprot)
5052 
    iprot.readMessageEnd()
5053 
    result = markOrdersAsShippedFromWarehouse_result()
5054 
    try:
4789 rajveer 5055 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5056 
    except TransactionServiceException, ex:
5057 
      result.ex = ex
5058 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5059 
    result.write(oprot)
5060 
    oprot.writeMessageEnd()
5061 
    oprot.trans.flush()
5062 
 
3064 chandransh 5063 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5064 
    args = markOrdersAsPickedUp_args()
304 ashish 5065 
    args.read(iprot)
5066 
    iprot.readMessageEnd()
3064 chandransh 5067 
    result = markOrdersAsPickedUp_result()
5068 
    try:
5069 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
5070 
    except TransactionServiceException, ex:
5071 
      result.ex = ex
5072 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5073 
    result.write(oprot)
5074 
    oprot.writeMessageEnd()
5075 
    oprot.trans.flush()
94 ashish 5076 
 
3064 chandransh 5077 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5078 
    args = markOrdersAsDelivered_args()
304 ashish 5079 
    args.read(iprot)
5080 
    iprot.readMessageEnd()
3064 chandransh 5081 
    result = markOrdersAsDelivered_result()
5082 
    try:
5083 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5084 
    except TransactionServiceException, ex:
5085 
      result.ex = ex
5086 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5087 
    result.write(oprot)
5088 
    oprot.writeMessageEnd()
5089 
    oprot.trans.flush()
5090 
 
3064 chandransh 5091 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
5092 
    args = markOrdersAsFailed_args()
1596 ankur.sing 5093 
    args.read(iprot)
5094 
    iprot.readMessageEnd()
3064 chandransh 5095 
    result = markOrdersAsFailed_result()
5096 
    try:
5097 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
5098 
    except TransactionServiceException, ex:
5099 
      result.ex = ex
5100 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 5101 
    result.write(oprot)
5102 
    oprot.writeMessageEnd()
5103 
    oprot.trans.flush()
304 ashish 5104 
 
3064 chandransh 5105 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5106 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5107 
    args.read(iprot)
5108 
    iprot.readMessageEnd()
3064 chandransh 5109 
    result = updateNonDeliveryReason_result()
5110 
    try:
4581 phani.kuma 5111 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5112 
    except TransactionServiceException, ex:
5113 
      result.ex = ex
5114 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5115 
    result.write(oprot)
5116 
    oprot.writeMessageEnd()
5117 
    oprot.trans.flush()
1596 ankur.sing 5118 
 
3064 chandransh 5119 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5120 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5121 
    args.read(iprot)
5122 
    iprot.readMessageEnd()
3064 chandransh 5123 
    result = getUndeliveredOrders_result()
5124 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5125 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5126 
    result.write(oprot)
5127 
    oprot.writeMessageEnd()
5128 
    oprot.trans.flush()
5129 
 
4783 phani.kuma 5130 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5131 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5132 
    args.read(iprot)
5133 
    iprot.readMessageEnd()
5134 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5135 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5136 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5137 
    result.write(oprot)
5138 
    oprot.writeMessageEnd()
5139 
    oprot.trans.flush()
5140 
 
2536 chandransh 5141 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5142 
    args = toggleDOAFlag_args()
5143 
    args.read(iprot)
5144 
    iprot.readMessageEnd()
5145 
    result = toggleDOAFlag_result()
5146 
    try:
5147 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5148 
    except TransactionServiceException, ex:
5149 
      result.ex = ex
5150 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5151 
    result.write(oprot)
5152 
    oprot.writeMessageEnd()
5153 
    oprot.trans.flush()
1886 ankur.sing 5154 
 
4712 rajveer 5155 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5156 
    args = markOrderAsDelivered_args()
5157 
    args.read(iprot)
5158 
    iprot.readMessageEnd()
5159 
    result = markOrderAsDelivered_result()
5160 
    try:
5161 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5162 
    except TransactionServiceException, ex:
5163 
      result.ex = ex
5164 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5165 
    result.write(oprot)
5166 
    oprot.writeMessageEnd()
5167 
    oprot.trans.flush()
5168 
 
4454 rajveer 5169 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5170 
    args = markOrderDoaRequestReceived_args()
5171 
    args.read(iprot)
5172 
    iprot.readMessageEnd()
5173 
    result = markOrderDoaRequestReceived_result()
5174 
    try:
5175 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5176 
    except TransactionServiceException, ex:
5177 
      result.ex = ex
5178 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5179 
    result.write(oprot)
5180 
    oprot.writeMessageEnd()
5181 
    oprot.trans.flush()
5182 
 
5183 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5184 
    args = markOrderDoaRequestAuthorized_args()
5185 
    args.read(iprot)
5186 
    iprot.readMessageEnd()
5187 
    result = markOrderDoaRequestAuthorized_result()
5188 
    try:
5189 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5190 
    except TransactionServiceException, ex:
5191 
      result.ex = ex
5192 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5193 
    result.write(oprot)
5194 
    oprot.writeMessageEnd()
5195 
    oprot.trans.flush()
5196 
 
4488 rajveer 5197 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5198 
    args = markOrderReturnRequestReceived_args()
5199 
    args.read(iprot)
5200 
    iprot.readMessageEnd()
5201 
    result = markOrderReturnRequestReceived_result()
5202 
    try:
5203 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5204 
    except TransactionServiceException, ex:
5205 
      result.ex = ex
5206 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5207 
    result.write(oprot)
5208 
    oprot.writeMessageEnd()
5209 
    oprot.trans.flush()
5210 
 
5211 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5212 
    args = markOrderReturnRequestAuthorized_args()
5213 
    args.read(iprot)
5214 
    iprot.readMessageEnd()
5215 
    result = markOrderReturnRequestAuthorized_result()
5216 
    try:
5217 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5218 
    except TransactionServiceException, ex:
5219 
      result.ex = ex
5220 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5221 
    result.write(oprot)
5222 
    oprot.writeMessageEnd()
5223 
    oprot.trans.flush()
5224 
 
2536 chandransh 5225 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5226 
    args = requestPickupNumber_args()
5227 
    args.read(iprot)
5228 
    iprot.readMessageEnd()
5229 
    result = requestPickupNumber_result()
5230 
    try:
4579 rajveer 5231 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5232 
    except TransactionServiceException, ex:
5233 
      result.ex = ex
5234 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5235 
    result.write(oprot)
5236 
    oprot.writeMessageEnd()
5237 
    oprot.trans.flush()
5238 
 
5239 
  def process_authorizePickup(self, seqid, iprot, oprot):
5240 
    args = authorizePickup_args()
5241 
    args.read(iprot)
5242 
    iprot.readMessageEnd()
5243 
    result = authorizePickup_result()
5244 
    try:
4602 rajveer 5245 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5246 
    except TransactionServiceException, ex:
5247 
      result.ex = ex
5248 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5249 
    result.write(oprot)
5250 
    oprot.writeMessageEnd()
5251 
    oprot.trans.flush()
5252 
 
2764 chandransh 5253 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5254 
    args = markDoasAsPickedUp_args()
5255 
    args.read(iprot)
5256 
    iprot.readMessageEnd()
5257 
    result = markDoasAsPickedUp_result()
5258 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
5259 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5260 
    result.write(oprot)
5261 
    oprot.writeMessageEnd()
5262 
    oprot.trans.flush()
5263 
 
4741 phani.kuma 5264 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5265 
    args = markReturnOrdersAsPickedUp_args()
5266 
    args.read(iprot)
5267 
    iprot.readMessageEnd()
5268 
    result = markReturnOrdersAsPickedUp_result()
5269 
    result.success = self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
5270 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5271 
    result.write(oprot)
5272 
    oprot.writeMessageEnd()
5273 
    oprot.trans.flush()
5274 
 
2616 chandransh 5275 
  def process_receiveReturn(self, seqid, iprot, oprot):
5276 
    args = receiveReturn_args()
2591 chandransh 5277 
    args.read(iprot)
5278 
    iprot.readMessageEnd()
2616 chandransh 5279 
    result = receiveReturn_result()
2591 chandransh 5280 
    try:
4479 rajveer 5281 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5282 
    except TransactionServiceException, ex:
5283 
      result.ex = ex
2616 chandransh 5284 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5285 
    result.write(oprot)
5286 
    oprot.writeMessageEnd()
5287 
    oprot.trans.flush()
2536 chandransh 5288 
 
2591 chandransh 5289 
  def process_validateDoa(self, seqid, iprot, oprot):
5290 
    args = validateDoa_args()
5291 
    args.read(iprot)
5292 
    iprot.readMessageEnd()
5293 
    result = validateDoa_result()
5294 
    try:
5295 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5296 
    except TransactionServiceException, ex:
5297 
      result.ex = ex
5298 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5299 
    result.write(oprot)
5300 
    oprot.writeMessageEnd()
5301 
    oprot.trans.flush()
5302 
 
4495 rajveer 5303 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5304 
    args = validateReturnProduct_args()
5305 
    args.read(iprot)
5306 
    iprot.readMessageEnd()
5307 
    result = validateReturnProduct_result()
5308 
    try:
5309 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5310 
    except TransactionServiceException, ex:
5311 
      result.ex = ex
5312 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5313 
    result.write(oprot)
5314 
    oprot.writeMessageEnd()
5315 
    oprot.trans.flush()
5316 
 
2616 chandransh 5317 
  def process_reshipOrder(self, seqid, iprot, oprot):
5318 
    args = reshipOrder_args()
5319 
    args.read(iprot)
5320 
    iprot.readMessageEnd()
5321 
    result = reshipOrder_result()
5322 
    try:
5323 
      result.success = self._handler.reshipOrder(args.orderId)
5324 
    except TransactionServiceException, ex:
5325 
      result.ex = ex
5326 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5327 
    result.write(oprot)
5328 
    oprot.writeMessageEnd()
5329 
    oprot.trans.flush()
2591 chandransh 5330 
 
2616 chandransh 5331 
  def process_refundOrder(self, seqid, iprot, oprot):
5332 
    args = refundOrder_args()
5333 
    args.read(iprot)
5334 
    iprot.readMessageEnd()
5335 
    result = refundOrder_result()
5336 
    try:
3226 chandransh 5337 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5338 
    except TransactionServiceException, ex:
5339 
      result.ex = ex
5340 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5341 
    result.write(oprot)
5342 
    oprot.writeMessageEnd()
5343 
    oprot.trans.flush()
5344 
 
2690 chandransh 5345 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5346 
    args = getReturnOrders_args()
5347 
    args.read(iprot)
5348 
    iprot.readMessageEnd()
5349 
    result = getReturnOrders_result()
5350 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5351 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5352 
    result.write(oprot)
5353 
    oprot.writeMessageEnd()
5354 
    oprot.trans.flush()
2616 chandransh 5355 
 
2700 chandransh 5356 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5357 
    args = getReturnOrder_args()
5358 
    args.read(iprot)
5359 
    iprot.readMessageEnd()
5360 
    result = getReturnOrder_result()
5361 
    try:
5362 
      result.success = self._handler.getReturnOrder(args.id)
5363 
    except TransactionServiceException, ex:
5364 
      result.ex = ex
5365 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5366 
    result.write(oprot)
5367 
    oprot.writeMessageEnd()
5368 
    oprot.trans.flush()
5369 
 
2690 chandransh 5370 
  def process_processReturn(self, seqid, iprot, oprot):
5371 
    args = processReturn_args()
5372 
    args.read(iprot)
5373 
    iprot.readMessageEnd()
5374 
    result = processReturn_result()
5375 
    try:
5376 
      self._handler.processReturn(args.returnOrderId)
5377 
    except TransactionServiceException, ex:
5378 
      result.ex = ex
5379 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5380 
    result.write(oprot)
5381 
    oprot.writeMessageEnd()
5382 
    oprot.trans.flush()
5383 
 
3451 chandransh 5384 
  def process_updateWeight(self, seqid, iprot, oprot):
5385 
    args = updateWeight_args()
5386 
    args.read(iprot)
5387 
    iprot.readMessageEnd()
5388 
    result = updateWeight_result()
5389 
    try:
5390 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5391 
    except TransactionServiceException, ex:
5392 
      result.ex = ex
5393 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5394 
    result.write(oprot)
5395 
    oprot.writeMessageEnd()
5396 
    oprot.trans.flush()
2819 chandransh 5397 
 
3469 chandransh 5398 
  def process_changeItem(self, seqid, iprot, oprot):
5399 
    args = changeItem_args()
5400 
    args.read(iprot)
5401 
    iprot.readMessageEnd()
5402 
    result = changeItem_result()
5403 
    try:
5404 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5405 
    except TransactionServiceException, ex:
5406 
      result.ex = ex
5407 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5408 
    result.write(oprot)
5409 
    oprot.writeMessageEnd()
5410 
    oprot.trans.flush()
3451 chandransh 5411 
 
3469 chandransh 5412 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5413 
    args = shiftToWarehouse_args()
5414 
    args.read(iprot)
5415 
    iprot.readMessageEnd()
5416 
    result = shiftToWarehouse_result()
5417 
    try:
5418 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5419 
    except TransactionServiceException, ex:
5420 
      result.ex = ex
5421 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5422 
    result.write(oprot)
5423 
    oprot.writeMessageEnd()
5424 
    oprot.trans.flush()
5425 
 
3553 chandransh 5426 
  def process_addDelayReason(self, seqid, iprot, oprot):
5427 
    args = addDelayReason_args()
5428 
    args.read(iprot)
5429 
    iprot.readMessageEnd()
5430 
    result = addDelayReason_result()
5431 
    try:
4647 rajveer 5432 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 5433 
    except TransactionServiceException, ex:
5434 
      result.ex = ex
5435 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5436 
    result.write(oprot)
5437 
    oprot.writeMessageEnd()
5438 
    oprot.trans.flush()
3469 chandransh 5439 
 
3956 chandransh 5440 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5441 
    args = reconcileCodCollection_args()
5442 
    args.read(iprot)
5443 
    iprot.readMessageEnd()
5444 
    result = reconcileCodCollection_result()
5445 
    try:
5446 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5447 
    except TransactionServiceException, ex:
5448 
      result.ex = ex
5449 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5450 
    result.write(oprot)
5451 
    oprot.writeMessageEnd()
5452 
    oprot.trans.flush()
3553 chandransh 5453 
 
4008 mandeep.dh 5454 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5455 
    args = getTransactionsRequiringExtraProcessing_args()
5456 
    args.read(iprot)
5457 
    iprot.readMessageEnd()
5458 
    result = getTransactionsRequiringExtraProcessing_result()
5459 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5460 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5461 
    result.write(oprot)
5462 
    oprot.writeMessageEnd()
5463 
    oprot.trans.flush()
3956 chandransh 5464 
 
4008 mandeep.dh 5465 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5466 
    args = markTransactionAsProcessed_args()
5467 
    args.read(iprot)
5468 
    iprot.readMessageEnd()
5469 
    result = markTransactionAsProcessed_result()
5470 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5471 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5472 
    result.write(oprot)
5473 
    oprot.writeMessageEnd()
5474 
    oprot.trans.flush()
5475 
 
4018 chandransh 5476 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5477 
    args = getItemWiseRiskyOrdersCount_args()
5478 
    args.read(iprot)
5479 
    iprot.readMessageEnd()
5480 
    result = getItemWiseRiskyOrdersCount_result()
5481 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5482 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5483 
    result.write(oprot)
5484 
    oprot.writeMessageEnd()
5485 
    oprot.trans.flush()
4008 mandeep.dh 5486 
 
4295 varun.gupt 5487 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5488 
    args = getOrdersForItemIds_args()
5489 
    args.read(iprot)
5490 
    iprot.readMessageEnd()
5491 
    result = getOrdersForItemIds_result()
5492 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5493 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5494 
    result.write(oprot)
5495 
    oprot.writeMessageEnd()
5496 
    oprot.trans.flush()
5497 
 
4247 rajveer 5498 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5499 
    args = markOrderCancellationRequestReceived_args()
5500 
    args.read(iprot)
5501 
    iprot.readMessageEnd()
5502 
    result = markOrderCancellationRequestReceived_result()
5503 
    try:
5504 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5505 
    except TransactionServiceException, ex:
5506 
      result.ex = ex
5507 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5508 
    result.write(oprot)
5509 
    oprot.writeMessageEnd()
5510 
    oprot.trans.flush()
4018 chandransh 5511 
 
4247 rajveer 5512 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5513 
    args = markOrderCancellationRequestConfirmed_args()
5514 
    args.read(iprot)
5515 
    iprot.readMessageEnd()
5516 
    result = markOrderCancellationRequestConfirmed_result()
5517 
    try:
5518 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5519 
    except TransactionServiceException, ex:
5520 
      result.ex = ex
5521 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5522 
    result.write(oprot)
5523 
    oprot.writeMessageEnd()
5524 
    oprot.trans.flush()
5525 
 
5526 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5527 
    args = markOrderCancellationRequestDenied_args()
5528 
    args.read(iprot)
5529 
    iprot.readMessageEnd()
5530 
    result = markOrderCancellationRequestDenied_result()
5531 
    try:
5532 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5533 
    except TransactionServiceException, ex:
5534 
      result.ex = ex
5535 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5536 
    result.write(oprot)
5537 
    oprot.writeMessageEnd()
5538 
    oprot.trans.flush()
5539 
 
4258 rajveer 5540 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5541 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5542 
    args.read(iprot)
5543 
    iprot.readMessageEnd()
4258 rajveer 5544 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5545 
    try:
4258 rajveer 5546 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 5547 
    except TransactionServiceException, ex:
5548 
      result.ex = ex
4258 rajveer 5549 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 5550 
    result.write(oprot)
5551 
    oprot.writeMessageEnd()
5552 
    oprot.trans.flush()
5553 
 
4259 anupam.sin 5554 
  def process_refundTransaction(self, seqid, iprot, oprot):
5555 
    args = refundTransaction_args()
5556 
    args.read(iprot)
5557 
    iprot.readMessageEnd()
5558 
    result = refundTransaction_result()
5559 
    try:
5560 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
5561 
    except TransactionServiceException, ex:
5562 
      result.ex = ex
5563 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
5564 
    result.write(oprot)
5565 
    oprot.writeMessageEnd()
5566 
    oprot.trans.flush()
4247 rajveer 5567 
 
4324 mandeep.dh 5568 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
5569 
    args = updateShipmentAddress_args()
5570 
    args.read(iprot)
5571 
    iprot.readMessageEnd()
5572 
    result = updateShipmentAddress_result()
5573 
    try:
5574 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
5575 
    except TransactionServiceException, ex:
5576 
      result.ex = ex
5577 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
5578 
    result.write(oprot)
5579 
    oprot.writeMessageEnd()
5580 
    oprot.trans.flush()
5581 
 
4285 rajveer 5582 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
5583 
    args = acceptOrdersForItemId_args()
5584 
    args.read(iprot)
5585 
    iprot.readMessageEnd()
5586 
    result = acceptOrdersForItemId_result()
5587 
    try:
5588 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
5589 
    except TransactionServiceException, ex:
5590 
      result.ex = ex
5591 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
5592 
    result.write(oprot)
5593 
    oprot.writeMessageEnd()
5594 
    oprot.trans.flush()
4259 anupam.sin 5595 
 
4303 rajveer 5596 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
5597 
    args = markOrdersAsPORaised_args()
5598 
    args.read(iprot)
5599 
    iprot.readMessageEnd()
5600 
    result = markOrdersAsPORaised_result()
5601 
    try:
4369 rajveer 5602 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5603 
    except TransactionServiceException, ex:
5604 
      result.ex = ex
5605 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
5606 
    result.write(oprot)
5607 
    oprot.writeMessageEnd()
5608 
    oprot.trans.flush()
4285 rajveer 5609 
 
4303 rajveer 5610 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
5611 
    args = markOrdersAsReversalInitiated_args()
5612 
    args.read(iprot)
5613 
    iprot.readMessageEnd()
5614 
    result = markOrdersAsReversalInitiated_result()
5615 
    try:
4369 rajveer 5616 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5617 
    except TransactionServiceException, ex:
5618 
      result.ex = ex
5619 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
5620 
    result.write(oprot)
5621 
    oprot.writeMessageEnd()
5622 
    oprot.trans.flush()
5623 
 
5624 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
5625 
    args = markOrdersAsNotAvailabke_args()
5626 
    args.read(iprot)
5627 
    iprot.readMessageEnd()
5628 
    result = markOrdersAsNotAvailabke_result()
5629 
    try:
4369 rajveer 5630 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5631 
    except TransactionServiceException, ex:
5632 
      result.ex = ex
5633 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
5634 
    result.write(oprot)
5635 
    oprot.writeMessageEnd()
5636 
    oprot.trans.flush()
5637 
 
4369 rajveer 5638 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
5639 
    args = markOrdersAsTimeout_args()
5640 
    args.read(iprot)
5641 
    iprot.readMessageEnd()
5642 
    result = markOrdersAsTimeout_result()
5643 
    try:
5644 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
5645 
    except TransactionServiceException, ex:
5646 
      result.ex = ex
5647 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
5648 
    result.write(oprot)
5649 
    oprot.writeMessageEnd()
5650 
    oprot.trans.flush()
4303 rajveer 5651 
 
4662 rajveer 5652 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
5653 
    args = markOrderAsLostInTransit_args()
5654 
    args.read(iprot)
5655 
    iprot.readMessageEnd()
5656 
    result = markOrderAsLostInTransit_result()
5657 
    try:
5658 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
5659 
    except TransactionServiceException, ex:
5660 
      result.ex = ex
5661 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
5662 
    result.write(oprot)
5663 
    oprot.writeMessageEnd()
5664 
    oprot.trans.flush()
5665 
 
4386 anupam.sin 5666 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
5667 
    args = getOrderForAwb_args()
5668 
    args.read(iprot)
5669 
    iprot.readMessageEnd()
5670 
    result = getOrderForAwb_result()
5671 
    try:
5672 
      result.success = self._handler.getOrderForAwb(args.awb)
5673 
    except TransactionServiceException, ex:
5674 
      result.ex = ex
5675 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
5676 
    result.write(oprot)
5677 
    oprot.writeMessageEnd()
5678 
    oprot.trans.flush()
4369 rajveer 5679 
 
4506 phani.kuma 5680 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
5681 
    args = getOrdersForProviderForStatus_args()
5682 
    args.read(iprot)
5683 
    iprot.readMessageEnd()
5684 
    result = getOrdersForProviderForStatus_result()
5685 
    try:
5686 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
5687 
    except TransactionServiceException, ex:
5688 
      result.ex = ex
5689 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
5690 
    result.write(oprot)
5691 
    oprot.writeMessageEnd()
5692 
    oprot.trans.flush()
4386 anupam.sin 5693 
 
4600 varun.gupt 5694 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
5695 
    args = getBilledOrdersForVendor_args()
5696 
    args.read(iprot)
5697 
    iprot.readMessageEnd()
5698 
    result = getBilledOrdersForVendor_result()
5699 
    try:
5700 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
5701 
    except TransactionServiceException, ex:
5702 
      result.ex = ex
5703 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
5704 
    result.write(oprot)
5705 
    oprot.writeMessageEnd()
5706 
    oprot.trans.flush()
4506 phani.kuma 5707 
 
4607 rajveer 5708 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
5709 
    args = getSlippedSippingDateOrders_args()
5710 
    args.read(iprot)
5711 
    iprot.readMessageEnd()
5712 
    result = getSlippedSippingDateOrders_result()
5713 
    try:
5714 
      result.success = self._handler.getSlippedSippingDateOrders()
5715 
    except TransactionServiceException, ex:
5716 
      result.ex = ex
5717 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
5718 
    result.write(oprot)
5719 
    oprot.writeMessageEnd()
5720 
    oprot.trans.flush()
5721 
 
4709 rajveer 5722 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
5723 
    args = getCancelledOrders_args()
5724 
    args.read(iprot)
5725 
    iprot.readMessageEnd()
5726 
    result = getCancelledOrders_result()
5727 
    try:
5728 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
5729 
    except TransactionServiceException, ex:
5730 
      result.ex = ex
5731 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
5732 
    result.write(oprot)
5733 
    oprot.writeMessageEnd()
5734 
    oprot.trans.flush()
5735 
 
4600 varun.gupt 5736 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
5737 
    args = saveBluedartSettlements_args()
5738 
    args.read(iprot)
5739 
    iprot.readMessageEnd()
5740 
    result = saveBluedartSettlements_result()
5741 
    try:
5742 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
5743 
    except TransactionServiceException, ex:
5744 
      result.ex = ex
5745 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
5746 
    result.write(oprot)
5747 
    oprot.writeMessageEnd()
5748 
    oprot.trans.flush()
5749 
 
5750 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
5751 
    args = savePaymentSettlements_args()
5752 
    args.read(iprot)
5753 
    iprot.readMessageEnd()
5754 
    result = savePaymentSettlements_result()
5755 
    try:
5756 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.paymentId, args.serviceTax, args.otherCharges, args.netCollection)
5757 
    except TransactionServiceException, ex:
5758 
      result.ex = ex
5759 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
5760 
    result.write(oprot)
5761 
    oprot.writeMessageEnd()
5762 
    oprot.trans.flush()
5763 
 
5764 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
5765 
    args = saveEBSSettlementSummary_args()
5766 
    args.read(iprot)
5767 
    iprot.readMessageEnd()
5768 
    result = saveEBSSettlementSummary_result()
5769 
    try:
5770 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
5771 
    except TransactionServiceException, ex:
5772 
      result.ex = ex
5773 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
5774 
    result.write(oprot)
5775 
    oprot.writeMessageEnd()
5776 
    oprot.trans.flush()
5777 
 
5778 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
5779 
    args = getSettlementForPaymentId_args()
5780 
    args.read(iprot)
5781 
    iprot.readMessageEnd()
5782 
    result = getSettlementForPaymentId_result()
5783 
    try:
5784 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
5785 
    except TransactionServiceException, ex:
5786 
      result.ex = ex
5787 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
5788 
    result.write(oprot)
5789 
    oprot.writeMessageEnd()
5790 
    oprot.trans.flush()
5791 
 
5792 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
5793 
    args = getEBSSettlementSummaries_args()
5794 
    args.read(iprot)
5795 
    iprot.readMessageEnd()
5796 
    result = getEBSSettlementSummaries_result()
5797 
    try:
5798 
      result.success = self._handler.getEBSSettlementSummaries()
5799 
    except TransactionServiceException, ex:
5800 
      result.ex = ex
5801 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
5802 
    result.write(oprot)
5803 
    oprot.writeMessageEnd()
5804 
    oprot.trans.flush()
5805 
 
5806 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
5807 
    args = markEBSSettlementUploaded_args()
5808 
    args.read(iprot)
5809 
    iprot.readMessageEnd()
5810 
    result = markEBSSettlementUploaded_result()
5811 
    try:
5812 
      self._handler.markEBSSettlementUploaded(args.settlementId)
5813 
    except TransactionServiceException, ex:
5814 
      result.ex = ex
5815 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
5816 
    result.write(oprot)
5817 
    oprot.writeMessageEnd()
5818 
    oprot.trans.flush()
5819 
 
5820 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
5821 
    args = getEBSSettlementDate_args()
5822 
    args.read(iprot)
5823 
    iprot.readMessageEnd()
5824 
    result = getEBSSettlementDate_result()
5825 
    try:
5826 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
5827 
    except TransactionServiceException, ex:
5828 
      result.ex = ex
5829 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
5830 
    result.write(oprot)
5831 
    oprot.writeMessageEnd()
5832 
    oprot.trans.flush()
5833 
 
4715 varun.gupt 5834 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
5835 
    args = getSettlementsByDate_args()
5836 
    args.read(iprot)
5837 
    iprot.readMessageEnd()
5838 
    result = getSettlementsByDate_result()
5839 
    try:
5840 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
5841 
    except TransactionServiceException, ex:
5842 
      result.ex = ex
5843 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
5844 
    result.write(oprot)
5845 
    oprot.writeMessageEnd()
5846 
    oprot.trans.flush()
4600 varun.gupt 5847 
 
4715 varun.gupt 5848 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
5849 
    args = getReshippedOrderIds_args()
5850 
    args.read(iprot)
5851 
    iprot.readMessageEnd()
5852 
    result = getReshippedOrderIds_result()
5853 
    try:
5854 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
5855 
    except TransactionServiceException, ex:
5856 
      result.ex = ex
5857 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
5858 
    result.write(oprot)
5859 
    oprot.writeMessageEnd()
5860 
    oprot.trans.flush()
5861 
 
4757 mandeep.dh 5862 
  def process_updateOrdersAsPORaised(self, seqid, iprot, oprot):
5863 
    args = updateOrdersAsPORaised_args()
5864 
    args.read(iprot)
5865 
    iprot.readMessageEnd()
5866 
    result = updateOrdersAsPORaised_result()
5867 
    try:
5868 
      self._handler.updateOrdersAsPORaised(args.itemIdQuantityMap, args.purchaseOrderId, args.warehouseId)
5869 
    except TransactionServiceException, ex:
5870 
      result.ex = ex
5871 
    oprot.writeMessageBegin("updateOrdersAsPORaised", TMessageType.REPLY, seqid)
5872 
    result.write(oprot)
5873 
    oprot.writeMessageEnd()
5874 
    oprot.trans.flush()
4715 varun.gupt 5875 
 
4757 mandeep.dh 5876 
 
94 ashish 5877 
# HELPER FUNCTIONS AND STRUCTURES
5878 
 
5879 
class createTransaction_args:
5880 
  """
5881 
  Attributes:
5882 
   - transaction
5883 
  """
5884 
 
5885 
  thrift_spec = (
5886 
    None, # 0
5887 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
5888 
  )
5889 
 
5890 
  def __init__(self, transaction=None,):
5891 
    self.transaction = transaction
5892 
 
5893 
  def read(self, iprot):
5894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5896 
      return
5897 
    iprot.readStructBegin()
5898 
    while True:
5899 
      (fname, ftype, fid) = iprot.readFieldBegin()
5900 
      if ftype == TType.STOP:
5901 
        break
5902 
      if fid == 1:
5903 
        if ftype == TType.STRUCT:
5904 
          self.transaction = Transaction()
5905 
          self.transaction.read(iprot)
5906 
        else:
5907 
          iprot.skip(ftype)
5908 
      else:
5909 
        iprot.skip(ftype)
5910 
      iprot.readFieldEnd()
5911 
    iprot.readStructEnd()
5912 
 
5913 
  def write(self, oprot):
5914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5916 
      return
5917 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 5918 
    if self.transaction is not None:
94 ashish 5919 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5920 
      self.transaction.write(oprot)
5921 
      oprot.writeFieldEnd()
5922 
    oprot.writeFieldStop()
5923 
    oprot.writeStructEnd()
5924 
 
3431 rajveer 5925 
  def validate(self):
5926 
    return
5927 
 
5928 
 
94 ashish 5929 
  def __repr__(self):
5930 
    L = ['%s=%r' % (key, value)
5931 
      for key, value in self.__dict__.iteritems()]
5932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5933 
 
5934 
  def __eq__(self, other):
5935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5936 
 
5937 
  def __ne__(self, other):
5938 
    return not (self == other)
5939 
 
5940 
class createTransaction_result:
5941 
  """
5942 
  Attributes:
132 ashish 5943 
   - success
94 ashish 5944 
   - ex
5945 
  """
5946 
 
5947 
  thrift_spec = (
132 ashish 5948 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5949 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5950 
  )
5951 
 
132 ashish 5952 
  def __init__(self, success=None, ex=None,):
5953 
    self.success = success
94 ashish 5954 
    self.ex = ex
5955 
 
5956 
  def read(self, iprot):
5957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5959 
      return
5960 
    iprot.readStructBegin()
5961 
    while True:
5962 
      (fname, ftype, fid) = iprot.readFieldBegin()
5963 
      if ftype == TType.STOP:
5964 
        break
132 ashish 5965 
      if fid == 0:
5966 
        if ftype == TType.I64:
5967 
          self.success = iprot.readI64();
5968 
        else:
5969 
          iprot.skip(ftype)
5970 
      elif fid == 1:
94 ashish 5971 
        if ftype == TType.STRUCT:
5972 
          self.ex = TransactionServiceException()
5973 
          self.ex.read(iprot)
5974 
        else:
5975 
          iprot.skip(ftype)
5976 
      else:
5977 
        iprot.skip(ftype)
5978 
      iprot.readFieldEnd()
5979 
    iprot.readStructEnd()
5980 
 
5981 
  def write(self, oprot):
5982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5984 
      return
5985 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5986 
    if self.success is not None:
132 ashish 5987 
      oprot.writeFieldBegin('success', TType.I64, 0)
5988 
      oprot.writeI64(self.success)
5989 
      oprot.writeFieldEnd()
3431 rajveer 5990 
    if self.ex is not None:
94 ashish 5991 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5992 
      self.ex.write(oprot)
5993 
      oprot.writeFieldEnd()
5994 
    oprot.writeFieldStop()
5995 
    oprot.writeStructEnd()
5996 
 
3431 rajveer 5997 
  def validate(self):
5998 
    return
5999 
 
6000 
 
94 ashish 6001 
  def __repr__(self):
6002 
    L = ['%s=%r' % (key, value)
6003 
      for key, value in self.__dict__.iteritems()]
6004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6005 
 
6006 
  def __eq__(self, other):
6007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6008 
 
6009 
  def __ne__(self, other):
6010 
    return not (self == other)
6011 
 
6012 
class getTransaction_args:
6013 
  """
6014 
  Attributes:
6015 
   - id
6016 
  """
6017 
 
6018 
  thrift_spec = (
6019 
    None, # 0
6020 
    (1, TType.I64, 'id', None, None, ), # 1
6021 
  )
6022 
 
6023 
  def __init__(self, id=None,):
6024 
    self.id = id
6025 
 
6026 
  def read(self, iprot):
6027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6029 
      return
6030 
    iprot.readStructBegin()
6031 
    while True:
6032 
      (fname, ftype, fid) = iprot.readFieldBegin()
6033 
      if ftype == TType.STOP:
6034 
        break
6035 
      if fid == 1:
6036 
        if ftype == TType.I64:
6037 
          self.id = iprot.readI64();
6038 
        else:
6039 
          iprot.skip(ftype)
6040 
      else:
6041 
        iprot.skip(ftype)
6042 
      iprot.readFieldEnd()
6043 
    iprot.readStructEnd()
6044 
 
6045 
  def write(self, oprot):
6046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6048 
      return
6049 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6050 
    if self.id is not None:
94 ashish 6051 
      oprot.writeFieldBegin('id', TType.I64, 1)
6052 
      oprot.writeI64(self.id)
6053 
      oprot.writeFieldEnd()
6054 
    oprot.writeFieldStop()
6055 
    oprot.writeStructEnd()
6056 
 
3431 rajveer 6057 
  def validate(self):
6058 
    return
6059 
 
6060 
 
94 ashish 6061 
  def __repr__(self):
6062 
    L = ['%s=%r' % (key, value)
6063 
      for key, value in self.__dict__.iteritems()]
6064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6065 
 
6066 
  def __eq__(self, other):
6067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6068 
 
6069 
  def __ne__(self, other):
6070 
    return not (self == other)
6071 
 
6072 
class getTransaction_result:
6073 
  """
6074 
  Attributes:
6075 
   - success
6076 
   - ex
6077 
  """
6078 
 
6079 
  thrift_spec = (
6080 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6081 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6082 
  )
6083 
 
6084 
  def __init__(self, success=None, ex=None,):
6085 
    self.success = success
6086 
    self.ex = ex
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:
6098 
        if ftype == TType.STRUCT:
6099 
          self.success = Transaction()
6100 
          self.success.read(iprot)
6101 
        else:
6102 
          iprot.skip(ftype)
6103 
      elif fid == 1:
6104 
        if ftype == TType.STRUCT:
6105 
          self.ex = TransactionServiceException()
6106 
          self.ex.read(iprot)
6107 
        else:
6108 
          iprot.skip(ftype)
6109 
      else:
6110 
        iprot.skip(ftype)
6111 
      iprot.readFieldEnd()
6112 
    iprot.readStructEnd()
6113 
 
6114 
  def write(self, oprot):
6115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6117 
      return
6118 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6119 
    if self.success is not None:
94 ashish 6120 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6121 
      self.success.write(oprot)
6122 
      oprot.writeFieldEnd()
3431 rajveer 6123 
    if self.ex is not None:
94 ashish 6124 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6125 
      self.ex.write(oprot)
6126 
      oprot.writeFieldEnd()
6127 
    oprot.writeFieldStop()
6128 
    oprot.writeStructEnd()
6129 
 
3431 rajveer 6130 
  def validate(self):
6131 
    return
6132 
 
6133 
 
94 ashish 6134 
  def __repr__(self):
6135 
    L = ['%s=%r' % (key, value)
6136 
      for key, value in self.__dict__.iteritems()]
6137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6138 
 
6139 
  def __eq__(self, other):
6140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6141 
 
6142 
  def __ne__(self, other):
6143 
    return not (self == other)
6144 
 
6145 
class getTransactionsForCustomer_args:
6146 
  """
6147 
  Attributes:
6148 
   - customerId
6149 
   - from_date
6150 
   - to_date
6151 
   - status
6152 
  """
6153 
 
6154 
  thrift_spec = (
6155 
    None, # 0
6156 
    (1, TType.I64, 'customerId', None, None, ), # 1
6157 
    (2, TType.I64, 'from_date', None, None, ), # 2
6158 
    (3, TType.I64, 'to_date', None, None, ), # 3
6159 
    (4, TType.I32, 'status', None, None, ), # 4
6160 
  )
6161 
 
6162 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6163 
    self.customerId = customerId
6164 
    self.from_date = from_date
6165 
    self.to_date = to_date
6166 
    self.status = status
6167 
 
6168 
  def read(self, iprot):
6169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6171 
      return
6172 
    iprot.readStructBegin()
6173 
    while True:
6174 
      (fname, ftype, fid) = iprot.readFieldBegin()
6175 
      if ftype == TType.STOP:
6176 
        break
6177 
      if fid == 1:
6178 
        if ftype == TType.I64:
6179 
          self.customerId = iprot.readI64();
6180 
        else:
6181 
          iprot.skip(ftype)
6182 
      elif fid == 2:
6183 
        if ftype == TType.I64:
6184 
          self.from_date = iprot.readI64();
6185 
        else:
6186 
          iprot.skip(ftype)
6187 
      elif fid == 3:
6188 
        if ftype == TType.I64:
6189 
          self.to_date = iprot.readI64();
6190 
        else:
6191 
          iprot.skip(ftype)
6192 
      elif fid == 4:
6193 
        if ftype == TType.I32:
6194 
          self.status = iprot.readI32();
6195 
        else:
6196 
          iprot.skip(ftype)
6197 
      else:
6198 
        iprot.skip(ftype)
6199 
      iprot.readFieldEnd()
6200 
    iprot.readStructEnd()
6201 
 
6202 
  def write(self, oprot):
6203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6205 
      return
6206 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6207 
    if self.customerId is not None:
94 ashish 6208 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6209 
      oprot.writeI64(self.customerId)
6210 
      oprot.writeFieldEnd()
3431 rajveer 6211 
    if self.from_date is not None:
94 ashish 6212 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6213 
      oprot.writeI64(self.from_date)
6214 
      oprot.writeFieldEnd()
3431 rajveer 6215 
    if self.to_date is not None:
94 ashish 6216 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6217 
      oprot.writeI64(self.to_date)
6218 
      oprot.writeFieldEnd()
3431 rajveer 6219 
    if self.status is not None:
94 ashish 6220 
      oprot.writeFieldBegin('status', TType.I32, 4)
6221 
      oprot.writeI32(self.status)
6222 
      oprot.writeFieldEnd()
6223 
    oprot.writeFieldStop()
6224 
    oprot.writeStructEnd()
6225 
 
3431 rajveer 6226 
  def validate(self):
6227 
    return
6228 
 
6229 
 
94 ashish 6230 
  def __repr__(self):
6231 
    L = ['%s=%r' % (key, value)
6232 
      for key, value in self.__dict__.iteritems()]
6233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6234 
 
6235 
  def __eq__(self, other):
6236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6237 
 
6238 
  def __ne__(self, other):
6239 
    return not (self == other)
6240 
 
6241 
class getTransactionsForCustomer_result:
6242 
  """
6243 
  Attributes:
6244 
   - success
6245 
   - ex
6246 
  """
6247 
 
6248 
  thrift_spec = (
6249 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6250 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6251 
  )
6252 
 
6253 
  def __init__(self, success=None, ex=None,):
6254 
    self.success = success
6255 
    self.ex = ex
6256 
 
6257 
  def read(self, iprot):
6258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6260 
      return
6261 
    iprot.readStructBegin()
6262 
    while True:
6263 
      (fname, ftype, fid) = iprot.readFieldBegin()
6264 
      if ftype == TType.STOP:
6265 
        break
6266 
      if fid == 0:
6267 
        if ftype == TType.LIST:
6268 
          self.success = []
685 chandransh 6269 
          (_etype17, _size14) = iprot.readListBegin()
6270 
          for _i18 in xrange(_size14):
6271 
            _elem19 = Transaction()
6272 
            _elem19.read(iprot)
6273 
            self.success.append(_elem19)
94 ashish 6274 
          iprot.readListEnd()
6275 
        else:
6276 
          iprot.skip(ftype)
6277 
      elif fid == 1:
6278 
        if ftype == TType.STRUCT:
6279 
          self.ex = TransactionServiceException()
6280 
          self.ex.read(iprot)
6281 
        else:
6282 
          iprot.skip(ftype)
6283 
      else:
6284 
        iprot.skip(ftype)
6285 
      iprot.readFieldEnd()
6286 
    iprot.readStructEnd()
6287 
 
6288 
  def write(self, oprot):
6289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6291 
      return
6292 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6293 
    if self.success is not None:
94 ashish 6294 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6295 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6296 
      for iter20 in self.success:
6297 
        iter20.write(oprot)
94 ashish 6298 
      oprot.writeListEnd()
6299 
      oprot.writeFieldEnd()
3431 rajveer 6300 
    if self.ex is not None:
94 ashish 6301 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6302 
      self.ex.write(oprot)
6303 
      oprot.writeFieldEnd()
6304 
    oprot.writeFieldStop()
6305 
    oprot.writeStructEnd()
6306 
 
3431 rajveer 6307 
  def validate(self):
6308 
    return
6309 
 
6310 
 
94 ashish 6311 
  def __repr__(self):
6312 
    L = ['%s=%r' % (key, value)
6313 
      for key, value in self.__dict__.iteritems()]
6314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6315 
 
6316 
  def __eq__(self, other):
6317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6318 
 
6319 
  def __ne__(self, other):
6320 
    return not (self == other)
6321 
 
132 ashish 6322 
class getTransactionsForShoppingCartId_args:
6323 
  """
6324 
  Attributes:
6325 
   - shoppingCartId
6326 
  """
6327 
 
6328 
  thrift_spec = (
6329 
    None, # 0
6330 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
6331 
  )
6332 
 
6333 
  def __init__(self, shoppingCartId=None,):
6334 
    self.shoppingCartId = shoppingCartId
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 == 1:
6346 
        if ftype == TType.I64:
6347 
          self.shoppingCartId = iprot.readI64();
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
6359 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 6360 
    if self.shoppingCartId is not None:
132 ashish 6361 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
6362 
      oprot.writeI64(self.shoppingCartId)
6363 
      oprot.writeFieldEnd()
6364 
    oprot.writeFieldStop()
6365 
    oprot.writeStructEnd()
6366 
 
3431 rajveer 6367 
  def validate(self):
6368 
    return
6369 
 
6370 
 
132 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 
 
6382 
class getTransactionsForShoppingCartId_result:
6383 
  """
6384 
  Attributes:
6385 
   - success
6386 
   - ex
6387 
  """
6388 
 
6389 
  thrift_spec = (
6390 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6391 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6392 
  )
6393 
 
6394 
  def __init__(self, success=None, ex=None,):
6395 
    self.success = success
6396 
    self.ex = ex
6397 
 
6398 
  def read(self, iprot):
6399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6401 
      return
6402 
    iprot.readStructBegin()
6403 
    while True:
6404 
      (fname, ftype, fid) = iprot.readFieldBegin()
6405 
      if ftype == TType.STOP:
6406 
        break
6407 
      if fid == 0:
6408 
        if ftype == TType.LIST:
6409 
          self.success = []
685 chandransh 6410 
          (_etype24, _size21) = iprot.readListBegin()
6411 
          for _i25 in xrange(_size21):
6412 
            _elem26 = Transaction()
6413 
            _elem26.read(iprot)
6414 
            self.success.append(_elem26)
132 ashish 6415 
          iprot.readListEnd()
6416 
        else:
6417 
          iprot.skip(ftype)
6418 
      elif fid == 1:
6419 
        if ftype == TType.STRUCT:
6420 
          self.ex = TransactionServiceException()
6421 
          self.ex.read(iprot)
6422 
        else:
6423 
          iprot.skip(ftype)
6424 
      else:
6425 
        iprot.skip(ftype)
6426 
      iprot.readFieldEnd()
6427 
    iprot.readStructEnd()
6428 
 
6429 
  def write(self, oprot):
6430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6432 
      return
6433 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 6434 
    if self.success is not None:
132 ashish 6435 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6436 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6437 
      for iter27 in self.success:
6438 
        iter27.write(oprot)
132 ashish 6439 
      oprot.writeListEnd()
6440 
      oprot.writeFieldEnd()
3431 rajveer 6441 
    if self.ex is not None:
132 ashish 6442 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6443 
      self.ex.write(oprot)
6444 
      oprot.writeFieldEnd()
6445 
    oprot.writeFieldStop()
6446 
    oprot.writeStructEnd()
6447 
 
3431 rajveer 6448 
  def validate(self):
6449 
    return
6450 
 
6451 
 
132 ashish 6452 
  def __repr__(self):
6453 
    L = ['%s=%r' % (key, value)
6454 
      for key, value in self.__dict__.iteritems()]
6455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6456 
 
6457 
  def __eq__(self, other):
6458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6459 
 
6460 
  def __ne__(self, other):
6461 
    return not (self == other)
6462 
 
94 ashish 6463 
class getTransactionStatus_args:
6464 
  """
6465 
  Attributes:
6466 
   - transactionId
6467 
  """
6468 
 
6469 
  thrift_spec = (
6470 
    None, # 0
6471 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6472 
  )
6473 
 
6474 
  def __init__(self, transactionId=None,):
6475 
    self.transactionId = transactionId
6476 
 
6477 
  def read(self, iprot):
6478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6480 
      return
6481 
    iprot.readStructBegin()
6482 
    while True:
6483 
      (fname, ftype, fid) = iprot.readFieldBegin()
6484 
      if ftype == TType.STOP:
6485 
        break
6486 
      if fid == 1:
6487 
        if ftype == TType.I64:
6488 
          self.transactionId = iprot.readI64();
6489 
        else:
6490 
          iprot.skip(ftype)
6491 
      else:
6492 
        iprot.skip(ftype)
6493 
      iprot.readFieldEnd()
6494 
    iprot.readStructEnd()
6495 
 
6496 
  def write(self, oprot):
6497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6499 
      return
6500 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6501 
    if self.transactionId is not None:
94 ashish 6502 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6503 
      oprot.writeI64(self.transactionId)
6504 
      oprot.writeFieldEnd()
6505 
    oprot.writeFieldStop()
6506 
    oprot.writeStructEnd()
6507 
 
3431 rajveer 6508 
  def validate(self):
6509 
    return
6510 
 
6511 
 
94 ashish 6512 
  def __repr__(self):
6513 
    L = ['%s=%r' % (key, value)
6514 
      for key, value in self.__dict__.iteritems()]
6515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6516 
 
6517 
  def __eq__(self, other):
6518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6519 
 
6520 
  def __ne__(self, other):
6521 
    return not (self == other)
6522 
 
6523 
class getTransactionStatus_result:
6524 
  """
6525 
  Attributes:
6526 
   - success
6527 
   - ex
6528 
  """
6529 
 
6530 
  thrift_spec = (
6531 
    (0, TType.I32, 'success', None, None, ), # 0
6532 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6533 
  )
6534 
 
6535 
  def __init__(self, success=None, ex=None,):
6536 
    self.success = success
6537 
    self.ex = ex
6538 
 
6539 
  def read(self, iprot):
6540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6542 
      return
6543 
    iprot.readStructBegin()
6544 
    while True:
6545 
      (fname, ftype, fid) = iprot.readFieldBegin()
6546 
      if ftype == TType.STOP:
6547 
        break
6548 
      if fid == 0:
6549 
        if ftype == TType.I32:
6550 
          self.success = iprot.readI32();
6551 
        else:
6552 
          iprot.skip(ftype)
6553 
      elif fid == 1:
6554 
        if ftype == TType.STRUCT:
6555 
          self.ex = TransactionServiceException()
6556 
          self.ex.read(iprot)
6557 
        else:
6558 
          iprot.skip(ftype)
6559 
      else:
6560 
        iprot.skip(ftype)
6561 
      iprot.readFieldEnd()
6562 
    iprot.readStructEnd()
6563 
 
6564 
  def write(self, oprot):
6565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6567 
      return
6568 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 6569 
    if self.success is not None:
94 ashish 6570 
      oprot.writeFieldBegin('success', TType.I32, 0)
6571 
      oprot.writeI32(self.success)
6572 
      oprot.writeFieldEnd()
3431 rajveer 6573 
    if self.ex is not None:
94 ashish 6574 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6575 
      self.ex.write(oprot)
6576 
      oprot.writeFieldEnd()
6577 
    oprot.writeFieldStop()
6578 
    oprot.writeStructEnd()
6579 
 
3431 rajveer 6580 
  def validate(self):
6581 
    return
6582 
 
6583 
 
94 ashish 6584 
  def __repr__(self):
6585 
    L = ['%s=%r' % (key, value)
6586 
      for key, value in self.__dict__.iteritems()]
6587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6588 
 
6589 
  def __eq__(self, other):
6590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6591 
 
6592 
  def __ne__(self, other):
6593 
    return not (self == other)
6594 
 
6595 
class changeTransactionStatus_args:
6596 
  """
6597 
  Attributes:
6598 
   - transactionId
6599 
   - status
6600 
   - description
6601 
  """
6602 
 
6603 
  thrift_spec = (
6604 
    None, # 0
6605 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6606 
    (2, TType.I32, 'status', None, None, ), # 2
6607 
    (3, TType.STRING, 'description', None, None, ), # 3
6608 
  )
6609 
 
6610 
  def __init__(self, transactionId=None, status=None, description=None,):
6611 
    self.transactionId = transactionId
6612 
    self.status = status
6613 
    self.description = description
6614 
 
6615 
  def read(self, iprot):
6616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6618 
      return
6619 
    iprot.readStructBegin()
6620 
    while True:
6621 
      (fname, ftype, fid) = iprot.readFieldBegin()
6622 
      if ftype == TType.STOP:
6623 
        break
6624 
      if fid == 1:
6625 
        if ftype == TType.I64:
6626 
          self.transactionId = iprot.readI64();
6627 
        else:
6628 
          iprot.skip(ftype)
6629 
      elif fid == 2:
6630 
        if ftype == TType.I32:
6631 
          self.status = iprot.readI32();
6632 
        else:
6633 
          iprot.skip(ftype)
6634 
      elif fid == 3:
6635 
        if ftype == TType.STRING:
6636 
          self.description = iprot.readString();
6637 
        else:
6638 
          iprot.skip(ftype)
6639 
      else:
6640 
        iprot.skip(ftype)
6641 
      iprot.readFieldEnd()
6642 
    iprot.readStructEnd()
6643 
 
6644 
  def write(self, oprot):
6645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6647 
      return
6648 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 6649 
    if self.transactionId is not None:
94 ashish 6650 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6651 
      oprot.writeI64(self.transactionId)
6652 
      oprot.writeFieldEnd()
3431 rajveer 6653 
    if self.status is not None:
94 ashish 6654 
      oprot.writeFieldBegin('status', TType.I32, 2)
6655 
      oprot.writeI32(self.status)
6656 
      oprot.writeFieldEnd()
3431 rajveer 6657 
    if self.description is not None:
94 ashish 6658 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6659 
      oprot.writeString(self.description)
6660 
      oprot.writeFieldEnd()
6661 
    oprot.writeFieldStop()
6662 
    oprot.writeStructEnd()
6663 
 
3431 rajveer 6664 
  def validate(self):
6665 
    return
6666 
 
6667 
 
94 ashish 6668 
  def __repr__(self):
6669 
    L = ['%s=%r' % (key, value)
6670 
      for key, value in self.__dict__.iteritems()]
6671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6672 
 
6673 
  def __eq__(self, other):
6674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6675 
 
6676 
  def __ne__(self, other):
6677 
    return not (self == other)
6678 
 
6679 
class changeTransactionStatus_result:
6680 
  """
6681 
  Attributes:
6682 
   - success
6683 
   - ex
6684 
  """
6685 
 
6686 
  thrift_spec = (
6687 
    (0, TType.BOOL, 'success', None, None, ), # 0
6688 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6689 
  )
6690 
 
6691 
  def __init__(self, success=None, ex=None,):
6692 
    self.success = success
6693 
    self.ex = ex
6694 
 
6695 
  def read(self, iprot):
6696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6698 
      return
6699 
    iprot.readStructBegin()
6700 
    while True:
6701 
      (fname, ftype, fid) = iprot.readFieldBegin()
6702 
      if ftype == TType.STOP:
6703 
        break
6704 
      if fid == 0:
6705 
        if ftype == TType.BOOL:
6706 
          self.success = iprot.readBool();
6707 
        else:
6708 
          iprot.skip(ftype)
6709 
      elif fid == 1:
6710 
        if ftype == TType.STRUCT:
6711 
          self.ex = TransactionServiceException()
6712 
          self.ex.read(iprot)
6713 
        else:
6714 
          iprot.skip(ftype)
6715 
      else:
6716 
        iprot.skip(ftype)
6717 
      iprot.readFieldEnd()
6718 
    iprot.readStructEnd()
6719 
 
6720 
  def write(self, oprot):
6721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6723 
      return
6724 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 6725 
    if self.success is not None:
94 ashish 6726 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6727 
      oprot.writeBool(self.success)
6728 
      oprot.writeFieldEnd()
3431 rajveer 6729 
    if self.ex is not None:
94 ashish 6730 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6731 
      self.ex.write(oprot)
6732 
      oprot.writeFieldEnd()
6733 
    oprot.writeFieldStop()
6734 
    oprot.writeStructEnd()
6735 
 
3431 rajveer 6736 
  def validate(self):
6737 
    return
6738 
 
6739 
 
94 ashish 6740 
  def __repr__(self):
6741 
    L = ['%s=%r' % (key, value)
6742 
      for key, value in self.__dict__.iteritems()]
6743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6744 
 
6745 
  def __eq__(self, other):
6746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6747 
 
6748 
  def __ne__(self, other):
6749 
    return not (self == other)
6750 
 
1398 varun.gupt 6751 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 6752 
  """
6753 
  Attributes:
6754 
   - transactionId
6755 
  """
6756 
 
6757 
  thrift_spec = (
6758 
    None, # 0
6759 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6760 
  )
6761 
 
6762 
  def __init__(self, transactionId=None,):
6763 
    self.transactionId = transactionId
6764 
 
6765 
  def read(self, iprot):
6766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6768 
      return
6769 
    iprot.readStructBegin()
6770 
    while True:
6771 
      (fname, ftype, fid) = iprot.readFieldBegin()
6772 
      if ftype == TType.STOP:
6773 
        break
6774 
      if fid == 1:
6775 
        if ftype == TType.I64:
6776 
          self.transactionId = iprot.readI64();
6777 
        else:
6778 
          iprot.skip(ftype)
6779 
      else:
6780 
        iprot.skip(ftype)
6781 
      iprot.readFieldEnd()
6782 
    iprot.readStructEnd()
6783 
 
6784 
  def write(self, oprot):
6785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6787 
      return
1398 varun.gupt 6788 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 6789 
    if self.transactionId is not None:
1382 varun.gupt 6790 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6791 
      oprot.writeI64(self.transactionId)
6792 
      oprot.writeFieldEnd()
6793 
    oprot.writeFieldStop()
6794 
    oprot.writeStructEnd()
6795 
 
3431 rajveer 6796 
  def validate(self):
6797 
    return
6798 
 
6799 
 
1382 varun.gupt 6800 
  def __repr__(self):
6801 
    L = ['%s=%r' % (key, value)
6802 
      for key, value in self.__dict__.iteritems()]
6803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6804 
 
6805 
  def __eq__(self, other):
6806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6807 
 
6808 
  def __ne__(self, other):
6809 
    return not (self == other)
6810 
 
1398 varun.gupt 6811 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 6812 
  """
6813 
  Attributes:
6814 
   - success
6815 
   - ex
6816 
  """
6817 
 
6818 
  thrift_spec = (
6819 
    (0, TType.BOOL, 'success', None, None, ), # 0
6820 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6821 
  )
6822 
 
6823 
  def __init__(self, success=None, ex=None,):
6824 
    self.success = success
6825 
    self.ex = ex
6826 
 
6827 
  def read(self, iprot):
6828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6830 
      return
6831 
    iprot.readStructBegin()
6832 
    while True:
6833 
      (fname, ftype, fid) = iprot.readFieldBegin()
6834 
      if ftype == TType.STOP:
6835 
        break
6836 
      if fid == 0:
6837 
        if ftype == TType.BOOL:
6838 
          self.success = iprot.readBool();
6839 
        else:
6840 
          iprot.skip(ftype)
6841 
      elif fid == 1:
6842 
        if ftype == TType.STRUCT:
6843 
          self.ex = TransactionServiceException()
6844 
          self.ex.read(iprot)
6845 
        else:
6846 
          iprot.skip(ftype)
6847 
      else:
6848 
        iprot.skip(ftype)
6849 
      iprot.readFieldEnd()
6850 
    iprot.readStructEnd()
6851 
 
6852 
  def write(self, oprot):
6853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6855 
      return
1398 varun.gupt 6856 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 6857 
    if self.success is not None:
1382 varun.gupt 6858 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6859 
      oprot.writeBool(self.success)
6860 
      oprot.writeFieldEnd()
3431 rajveer 6861 
    if self.ex is not None:
1382 varun.gupt 6862 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6863 
      self.ex.write(oprot)
6864 
      oprot.writeFieldEnd()
6865 
    oprot.writeFieldStop()
6866 
    oprot.writeStructEnd()
6867 
 
3431 rajveer 6868 
  def validate(self):
6869 
    return
6870 
 
6871 
 
1382 varun.gupt 6872 
  def __repr__(self):
6873 
    L = ['%s=%r' % (key, value)
6874 
      for key, value in self.__dict__.iteritems()]
6875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6876 
 
6877 
  def __eq__(self, other):
6878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6879 
 
6880 
  def __ne__(self, other):
6881 
    return not (self == other)
6882 
 
483 rajveer 6883 
class getAllOrders_args:
94 ashish 6884 
  """
6885 
  Attributes:
4801 anupam.sin 6886 
   - statuses
483 rajveer 6887 
   - from_date
6888 
   - to_date
6889 
   - warehouse_id
94 ashish 6890 
  """
6891 
 
6892 
  thrift_spec = (
6893 
    None, # 0
4801 anupam.sin 6894 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 6895 
    (2, TType.I64, 'from_date', None, None, ), # 2
6896 
    (3, TType.I64, 'to_date', None, None, ), # 3
6897 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 6898 
  )
6899 
 
4801 anupam.sin 6900 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
6901 
    self.statuses = statuses
483 rajveer 6902 
    self.from_date = from_date
6903 
    self.to_date = to_date
6904 
    self.warehouse_id = warehouse_id
94 ashish 6905 
 
6906 
  def read(self, iprot):
6907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6909 
      return
6910 
    iprot.readStructBegin()
6911 
    while True:
6912 
      (fname, ftype, fid) = iprot.readFieldBegin()
6913 
      if ftype == TType.STOP:
6914 
        break
6915 
      if fid == 1:
4801 anupam.sin 6916 
        if ftype == TType.LIST:
6917 
          self.statuses = []
6918 
          (_etype31, _size28) = iprot.readListBegin()
6919 
          for _i32 in xrange(_size28):
6920 
            _elem33 = iprot.readI32();
6921 
            self.statuses.append(_elem33)
6922 
          iprot.readListEnd()
94 ashish 6923 
        else:
6924 
          iprot.skip(ftype)
483 rajveer 6925 
      elif fid == 2:
6926 
        if ftype == TType.I64:
6927 
          self.from_date = iprot.readI64();
94 ashish 6928 
        else:
6929 
          iprot.skip(ftype)
483 rajveer 6930 
      elif fid == 3:
6931 
        if ftype == TType.I64:
6932 
          self.to_date = iprot.readI64();
94 ashish 6933 
        else:
6934 
          iprot.skip(ftype)
483 rajveer 6935 
      elif fid == 4:
94 ashish 6936 
        if ftype == TType.I64:
483 rajveer 6937 
          self.warehouse_id = iprot.readI64();
94 ashish 6938 
        else:
6939 
          iprot.skip(ftype)
6940 
      else:
6941 
        iprot.skip(ftype)
6942 
      iprot.readFieldEnd()
6943 
    iprot.readStructEnd()
6944 
 
6945 
  def write(self, oprot):
6946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6948 
      return
483 rajveer 6949 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 6950 
    if self.statuses is not None:
6951 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6952 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6953 
      for iter34 in self.statuses:
6954 
        oprot.writeI32(iter34)
6955 
      oprot.writeListEnd()
94 ashish 6956 
      oprot.writeFieldEnd()
3431 rajveer 6957 
    if self.from_date is not None:
483 rajveer 6958 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6959 
      oprot.writeI64(self.from_date)
94 ashish 6960 
      oprot.writeFieldEnd()
3431 rajveer 6961 
    if self.to_date is not None:
483 rajveer 6962 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6963 
      oprot.writeI64(self.to_date)
94 ashish 6964 
      oprot.writeFieldEnd()
3431 rajveer 6965 
    if self.warehouse_id is not None:
483 rajveer 6966 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6967 
      oprot.writeI64(self.warehouse_id)
94 ashish 6968 
      oprot.writeFieldEnd()
6969 
    oprot.writeFieldStop()
6970 
    oprot.writeStructEnd()
6971 
 
3431 rajveer 6972 
  def validate(self):
6973 
    return
6974 
 
6975 
 
94 ashish 6976 
  def __repr__(self):
6977 
    L = ['%s=%r' % (key, value)
6978 
      for key, value in self.__dict__.iteritems()]
6979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6980 
 
6981 
  def __eq__(self, other):
6982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6983 
 
6984 
  def __ne__(self, other):
6985 
    return not (self == other)
6986 
 
483 rajveer 6987 
class getAllOrders_result:
94 ashish 6988 
  """
6989 
  Attributes:
6990 
   - success
6991 
   - ex
6992 
  """
6993 
 
6994 
  thrift_spec = (
483 rajveer 6995 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6996 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6997 
  )
6998 
 
6999 
  def __init__(self, success=None, ex=None,):
7000 
    self.success = success
7001 
    self.ex = ex
7002 
 
7003 
  def read(self, iprot):
7004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7006 
      return
7007 
    iprot.readStructBegin()
7008 
    while True:
7009 
      (fname, ftype, fid) = iprot.readFieldBegin()
7010 
      if ftype == TType.STOP:
7011 
        break
7012 
      if fid == 0:
483 rajveer 7013 
        if ftype == TType.LIST:
7014 
          self.success = []
4801 anupam.sin 7015 
          (_etype38, _size35) = iprot.readListBegin()
7016 
          for _i39 in xrange(_size35):
7017 
            _elem40 = Order()
7018 
            _elem40.read(iprot)
7019 
            self.success.append(_elem40)
483 rajveer 7020 
          iprot.readListEnd()
94 ashish 7021 
        else:
7022 
          iprot.skip(ftype)
7023 
      elif fid == 1:
7024 
        if ftype == TType.STRUCT:
7025 
          self.ex = TransactionServiceException()
7026 
          self.ex.read(iprot)
7027 
        else:
7028 
          iprot.skip(ftype)
7029 
      else:
7030 
        iprot.skip(ftype)
7031 
      iprot.readFieldEnd()
7032 
    iprot.readStructEnd()
7033 
 
7034 
  def write(self, oprot):
7035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7037 
      return
483 rajveer 7038 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7039 
    if self.success is not None:
483 rajveer 7040 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7041 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 7042 
      for iter41 in self.success:
7043 
        iter41.write(oprot)
483 rajveer 7044 
      oprot.writeListEnd()
94 ashish 7045 
      oprot.writeFieldEnd()
3431 rajveer 7046 
    if self.ex is not None:
94 ashish 7047 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7048 
      self.ex.write(oprot)
7049 
      oprot.writeFieldEnd()
7050 
    oprot.writeFieldStop()
7051 
    oprot.writeStructEnd()
7052 
 
3431 rajveer 7053 
  def validate(self):
7054 
    return
7055 
 
7056 
 
94 ashish 7057 
  def __repr__(self):
7058 
    L = ['%s=%r' % (key, value)
7059 
      for key, value in self.__dict__.iteritems()]
7060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7061 
 
7062 
  def __eq__(self, other):
7063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7064 
 
7065 
  def __ne__(self, other):
7066 
    return not (self == other)
7067 
 
4133 chandransh 7068 
class getOrdersInBatch_args:
7069 
  """
7070 
  Attributes:
7071 
   - statuses
7072 
   - offset
7073 
   - limit
7074 
   - warehouse_id
7075 
  """
7076 
 
7077 
  thrift_spec = (
7078 
    None, # 0
7079 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7080 
    (2, TType.I64, 'offset', None, None, ), # 2
7081 
    (3, TType.I64, 'limit', None, None, ), # 3
7082 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7083 
  )
7084 
 
7085 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7086 
    self.statuses = statuses
7087 
    self.offset = offset
7088 
    self.limit = limit
7089 
    self.warehouse_id = warehouse_id
7090 
 
7091 
  def read(self, iprot):
7092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7094 
      return
7095 
    iprot.readStructBegin()
7096 
    while True:
7097 
      (fname, ftype, fid) = iprot.readFieldBegin()
7098 
      if ftype == TType.STOP:
7099 
        break
7100 
      if fid == 1:
7101 
        if ftype == TType.LIST:
7102 
          self.statuses = []
4801 anupam.sin 7103 
          (_etype45, _size42) = iprot.readListBegin()
7104 
          for _i46 in xrange(_size42):
7105 
            _elem47 = iprot.readI32();
7106 
            self.statuses.append(_elem47)
4133 chandransh 7107 
          iprot.readListEnd()
7108 
        else:
7109 
          iprot.skip(ftype)
7110 
      elif fid == 2:
7111 
        if ftype == TType.I64:
7112 
          self.offset = iprot.readI64();
7113 
        else:
7114 
          iprot.skip(ftype)
7115 
      elif fid == 3:
7116 
        if ftype == TType.I64:
7117 
          self.limit = iprot.readI64();
7118 
        else:
7119 
          iprot.skip(ftype)
7120 
      elif fid == 4:
7121 
        if ftype == TType.I64:
7122 
          self.warehouse_id = iprot.readI64();
7123 
        else:
7124 
          iprot.skip(ftype)
7125 
      else:
7126 
        iprot.skip(ftype)
7127 
      iprot.readFieldEnd()
7128 
    iprot.readStructEnd()
7129 
 
7130 
  def write(self, oprot):
7131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7133 
      return
7134 
    oprot.writeStructBegin('getOrdersInBatch_args')
7135 
    if self.statuses is not None:
7136 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7137 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4801 anupam.sin 7138 
      for iter48 in self.statuses:
7139 
        oprot.writeI32(iter48)
4133 chandransh 7140 
      oprot.writeListEnd()
7141 
      oprot.writeFieldEnd()
7142 
    if self.offset is not None:
7143 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7144 
      oprot.writeI64(self.offset)
7145 
      oprot.writeFieldEnd()
7146 
    if self.limit is not None:
7147 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7148 
      oprot.writeI64(self.limit)
7149 
      oprot.writeFieldEnd()
7150 
    if self.warehouse_id is not None:
7151 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7152 
      oprot.writeI64(self.warehouse_id)
7153 
      oprot.writeFieldEnd()
7154 
    oprot.writeFieldStop()
7155 
    oprot.writeStructEnd()
7156 
 
7157 
  def validate(self):
7158 
    return
7159 
 
7160 
 
7161 
  def __repr__(self):
7162 
    L = ['%s=%r' % (key, value)
7163 
      for key, value in self.__dict__.iteritems()]
7164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7165 
 
7166 
  def __eq__(self, other):
7167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7168 
 
7169 
  def __ne__(self, other):
7170 
    return not (self == other)
7171 
 
7172 
class getOrdersInBatch_result:
7173 
  """
7174 
  Attributes:
7175 
   - success
7176 
   - ex
7177 
  """
7178 
 
7179 
  thrift_spec = (
7180 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7181 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7182 
  )
7183 
 
7184 
  def __init__(self, success=None, ex=None,):
7185 
    self.success = success
7186 
    self.ex = ex
7187 
 
7188 
  def read(self, iprot):
7189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7191 
      return
7192 
    iprot.readStructBegin()
7193 
    while True:
7194 
      (fname, ftype, fid) = iprot.readFieldBegin()
7195 
      if ftype == TType.STOP:
7196 
        break
7197 
      if fid == 0:
7198 
        if ftype == TType.LIST:
7199 
          self.success = []
4801 anupam.sin 7200 
          (_etype52, _size49) = iprot.readListBegin()
7201 
          for _i53 in xrange(_size49):
7202 
            _elem54 = Order()
7203 
            _elem54.read(iprot)
7204 
            self.success.append(_elem54)
4133 chandransh 7205 
          iprot.readListEnd()
7206 
        else:
7207 
          iprot.skip(ftype)
7208 
      elif fid == 1:
7209 
        if ftype == TType.STRUCT:
7210 
          self.ex = TransactionServiceException()
7211 
          self.ex.read(iprot)
7212 
        else:
7213 
          iprot.skip(ftype)
7214 
      else:
7215 
        iprot.skip(ftype)
7216 
      iprot.readFieldEnd()
7217 
    iprot.readStructEnd()
7218 
 
7219 
  def write(self, oprot):
7220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7222 
      return
7223 
    oprot.writeStructBegin('getOrdersInBatch_result')
7224 
    if self.success is not None:
7225 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7226 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 7227 
      for iter55 in self.success:
7228 
        iter55.write(oprot)
4133 chandransh 7229 
      oprot.writeListEnd()
7230 
      oprot.writeFieldEnd()
7231 
    if self.ex is not None:
7232 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7233 
      self.ex.write(oprot)
7234 
      oprot.writeFieldEnd()
7235 
    oprot.writeFieldStop()
7236 
    oprot.writeStructEnd()
7237 
 
7238 
  def validate(self):
7239 
    return
7240 
 
7241 
 
7242 
  def __repr__(self):
7243 
    L = ['%s=%r' % (key, value)
7244 
      for key, value in self.__dict__.iteritems()]
7245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7246 
 
7247 
  def __eq__(self, other):
7248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7249 
 
7250 
  def __ne__(self, other):
7251 
    return not (self == other)
7252 
 
7253 
class getOrderCount_args:
7254 
  """
7255 
  Attributes:
7256 
   - statuses
7257 
   - warehouseId
7258 
  """
7259 
 
7260 
  thrift_spec = (
7261 
    None, # 0
7262 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7263 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7264 
  )
7265 
 
7266 
  def __init__(self, statuses=None, warehouseId=None,):
7267 
    self.statuses = statuses
7268 
    self.warehouseId = warehouseId
7269 
 
7270 
  def read(self, iprot):
7271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7273 
      return
7274 
    iprot.readStructBegin()
7275 
    while True:
7276 
      (fname, ftype, fid) = iprot.readFieldBegin()
7277 
      if ftype == TType.STOP:
7278 
        break
7279 
      if fid == 1:
7280 
        if ftype == TType.LIST:
7281 
          self.statuses = []
4801 anupam.sin 7282 
          (_etype59, _size56) = iprot.readListBegin()
7283 
          for _i60 in xrange(_size56):
7284 
            _elem61 = iprot.readI32();
7285 
            self.statuses.append(_elem61)
4133 chandransh 7286 
          iprot.readListEnd()
7287 
        else:
7288 
          iprot.skip(ftype)
7289 
      elif fid == 2:
7290 
        if ftype == TType.I64:
7291 
          self.warehouseId = iprot.readI64();
7292 
        else:
7293 
          iprot.skip(ftype)
7294 
      else:
7295 
        iprot.skip(ftype)
7296 
      iprot.readFieldEnd()
7297 
    iprot.readStructEnd()
7298 
 
7299 
  def write(self, oprot):
7300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7302 
      return
7303 
    oprot.writeStructBegin('getOrderCount_args')
7304 
    if self.statuses is not None:
7305 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7306 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4801 anupam.sin 7307 
      for iter62 in self.statuses:
7308 
        oprot.writeI32(iter62)
4133 chandransh 7309 
      oprot.writeListEnd()
7310 
      oprot.writeFieldEnd()
7311 
    if self.warehouseId is not None:
7312 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7313 
      oprot.writeI64(self.warehouseId)
7314 
      oprot.writeFieldEnd()
7315 
    oprot.writeFieldStop()
7316 
    oprot.writeStructEnd()
7317 
 
7318 
  def validate(self):
7319 
    return
7320 
 
7321 
 
7322 
  def __repr__(self):
7323 
    L = ['%s=%r' % (key, value)
7324 
      for key, value in self.__dict__.iteritems()]
7325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7326 
 
7327 
  def __eq__(self, other):
7328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7329 
 
7330 
  def __ne__(self, other):
7331 
    return not (self == other)
7332 
 
7333 
class getOrderCount_result:
7334 
  """
7335 
  Attributes:
7336 
   - success
7337 
   - ex
7338 
  """
7339 
 
7340 
  thrift_spec = (
7341 
    (0, TType.I32, 'success', None, None, ), # 0
7342 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7343 
  )
7344 
 
7345 
  def __init__(self, success=None, ex=None,):
7346 
    self.success = success
7347 
    self.ex = ex
7348 
 
7349 
  def read(self, iprot):
7350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7352 
      return
7353 
    iprot.readStructBegin()
7354 
    while True:
7355 
      (fname, ftype, fid) = iprot.readFieldBegin()
7356 
      if ftype == TType.STOP:
7357 
        break
7358 
      if fid == 0:
7359 
        if ftype == TType.I32:
7360 
          self.success = iprot.readI32();
7361 
        else:
7362 
          iprot.skip(ftype)
7363 
      elif fid == 1:
7364 
        if ftype == TType.STRUCT:
7365 
          self.ex = TransactionServiceException()
7366 
          self.ex.read(iprot)
7367 
        else:
7368 
          iprot.skip(ftype)
7369 
      else:
7370 
        iprot.skip(ftype)
7371 
      iprot.readFieldEnd()
7372 
    iprot.readStructEnd()
7373 
 
7374 
  def write(self, oprot):
7375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7377 
      return
7378 
    oprot.writeStructBegin('getOrderCount_result')
7379 
    if self.success is not None:
7380 
      oprot.writeFieldBegin('success', TType.I32, 0)
7381 
      oprot.writeI32(self.success)
7382 
      oprot.writeFieldEnd()
7383 
    if self.ex is not None:
7384 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7385 
      self.ex.write(oprot)
7386 
      oprot.writeFieldEnd()
7387 
    oprot.writeFieldStop()
7388 
    oprot.writeStructEnd()
7389 
 
7390 
  def validate(self):
7391 
    return
7392 
 
7393 
 
7394 
  def __repr__(self):
7395 
    L = ['%s=%r' % (key, value)
7396 
      for key, value in self.__dict__.iteritems()]
7397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7398 
 
7399 
  def __eq__(self, other):
7400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7401 
 
7402 
  def __ne__(self, other):
7403 
    return not (self == other)
7404 
 
999 varun.gupt 7405 
class getOrdersByBillingDate_args:
7406 
  """
7407 
  Attributes:
7408 
   - status
7409 
   - start_billing_date
7410 
   - end_billing_date
7411 
   - warehouse_id
7412 
  """
7413 
 
7414 
  thrift_spec = (
7415 
    None, # 0
7416 
    (1, TType.I32, 'status', None, None, ), # 1
7417 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
7418 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
7419 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7420 
  )
7421 
 
7422 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7423 
    self.status = status
7424 
    self.start_billing_date = start_billing_date
7425 
    self.end_billing_date = end_billing_date
7426 
    self.warehouse_id = warehouse_id
7427 
 
7428 
  def read(self, iprot):
7429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7431 
      return
7432 
    iprot.readStructBegin()
7433 
    while True:
7434 
      (fname, ftype, fid) = iprot.readFieldBegin()
7435 
      if ftype == TType.STOP:
7436 
        break
7437 
      if fid == 1:
7438 
        if ftype == TType.I32:
7439 
          self.status = iprot.readI32();
7440 
        else:
7441 
          iprot.skip(ftype)
7442 
      elif fid == 2:
7443 
        if ftype == TType.I64:
7444 
          self.start_billing_date = iprot.readI64();
7445 
        else:
7446 
          iprot.skip(ftype)
7447 
      elif fid == 3:
7448 
        if ftype == TType.I64:
7449 
          self.end_billing_date = iprot.readI64();
7450 
        else:
7451 
          iprot.skip(ftype)
7452 
      elif fid == 4:
7453 
        if ftype == TType.I64:
7454 
          self.warehouse_id = iprot.readI64();
7455 
        else:
7456 
          iprot.skip(ftype)
7457 
      else:
7458 
        iprot.skip(ftype)
7459 
      iprot.readFieldEnd()
7460 
    iprot.readStructEnd()
7461 
 
7462 
  def write(self, oprot):
7463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7465 
      return
7466 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7467 
    if self.status is not None:
999 varun.gupt 7468 
      oprot.writeFieldBegin('status', TType.I32, 1)
7469 
      oprot.writeI32(self.status)
7470 
      oprot.writeFieldEnd()
3431 rajveer 7471 
    if self.start_billing_date is not None:
999 varun.gupt 7472 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7473 
      oprot.writeI64(self.start_billing_date)
7474 
      oprot.writeFieldEnd()
3431 rajveer 7475 
    if self.end_billing_date is not None:
999 varun.gupt 7476 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7477 
      oprot.writeI64(self.end_billing_date)
7478 
      oprot.writeFieldEnd()
3431 rajveer 7479 
    if self.warehouse_id is not None:
999 varun.gupt 7480 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7481 
      oprot.writeI64(self.warehouse_id)
7482 
      oprot.writeFieldEnd()
7483 
    oprot.writeFieldStop()
7484 
    oprot.writeStructEnd()
7485 
 
3431 rajveer 7486 
  def validate(self):
7487 
    return
7488 
 
7489 
 
999 varun.gupt 7490 
  def __repr__(self):
7491 
    L = ['%s=%r' % (key, value)
7492 
      for key, value in self.__dict__.iteritems()]
7493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7494 
 
7495 
  def __eq__(self, other):
7496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7497 
 
7498 
  def __ne__(self, other):
7499 
    return not (self == other)
7500 
 
7501 
class getOrdersByBillingDate_result:
7502 
  """
7503 
  Attributes:
7504 
   - success
7505 
   - ex
7506 
  """
7507 
 
7508 
  thrift_spec = (
7509 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7510 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7511 
  )
7512 
 
7513 
  def __init__(self, success=None, ex=None,):
7514 
    self.success = success
7515 
    self.ex = ex
7516 
 
7517 
  def read(self, iprot):
7518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7520 
      return
7521 
    iprot.readStructBegin()
7522 
    while True:
7523 
      (fname, ftype, fid) = iprot.readFieldBegin()
7524 
      if ftype == TType.STOP:
7525 
        break
7526 
      if fid == 0:
7527 
        if ftype == TType.LIST:
7528 
          self.success = []
4801 anupam.sin 7529 
          (_etype66, _size63) = iprot.readListBegin()
7530 
          for _i67 in xrange(_size63):
7531 
            _elem68 = Order()
7532 
            _elem68.read(iprot)
7533 
            self.success.append(_elem68)
999 varun.gupt 7534 
          iprot.readListEnd()
7535 
        else:
7536 
          iprot.skip(ftype)
7537 
      elif fid == 1:
7538 
        if ftype == TType.STRUCT:
7539 
          self.ex = TransactionServiceException()
7540 
          self.ex.read(iprot)
7541 
        else:
7542 
          iprot.skip(ftype)
7543 
      else:
7544 
        iprot.skip(ftype)
7545 
      iprot.readFieldEnd()
7546 
    iprot.readStructEnd()
7547 
 
7548 
  def write(self, oprot):
7549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7551 
      return
7552 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 7553 
    if self.success is not None:
999 varun.gupt 7554 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7555 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 7556 
      for iter69 in self.success:
7557 
        iter69.write(oprot)
999 varun.gupt 7558 
      oprot.writeListEnd()
7559 
      oprot.writeFieldEnd()
3431 rajveer 7560 
    if self.ex is not None:
999 varun.gupt 7561 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7562 
      self.ex.write(oprot)
7563 
      oprot.writeFieldEnd()
7564 
    oprot.writeFieldStop()
7565 
    oprot.writeStructEnd()
7566 
 
3431 rajveer 7567 
  def validate(self):
7568 
    return
7569 
 
7570 
 
999 varun.gupt 7571 
  def __repr__(self):
7572 
    L = ['%s=%r' % (key, value)
7573 
      for key, value in self.__dict__.iteritems()]
7574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7575 
 
7576 
  def __eq__(self, other):
7577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7578 
 
7579 
  def __ne__(self, other):
7580 
    return not (self == other)
7581 
 
3427 chandransh 7582 
class getOrdersByShippingDate_args:
7583 
  """
7584 
  Attributes:
7585 
   - fromShippingDate
7586 
   - toShippingDate
7587 
   - providerId
7588 
   - warehouseId
3451 chandransh 7589 
   - cod
3427 chandransh 7590 
  """
7591 
 
7592 
  thrift_spec = (
7593 
    None, # 0
7594 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
7595 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
7596 
    (3, TType.I64, 'providerId', None, None, ), # 3
7597 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 7598 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 7599 
  )
7600 
 
3451 chandransh 7601 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 7602 
    self.fromShippingDate = fromShippingDate
7603 
    self.toShippingDate = toShippingDate
7604 
    self.providerId = providerId
7605 
    self.warehouseId = warehouseId
3451 chandransh 7606 
    self.cod = cod
3427 chandransh 7607 
 
7608 
  def read(self, iprot):
7609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7611 
      return
7612 
    iprot.readStructBegin()
7613 
    while True:
7614 
      (fname, ftype, fid) = iprot.readFieldBegin()
7615 
      if ftype == TType.STOP:
7616 
        break
7617 
      if fid == 1:
7618 
        if ftype == TType.I64:
7619 
          self.fromShippingDate = iprot.readI64();
7620 
        else:
7621 
          iprot.skip(ftype)
7622 
      elif fid == 2:
7623 
        if ftype == TType.I64:
7624 
          self.toShippingDate = iprot.readI64();
7625 
        else:
7626 
          iprot.skip(ftype)
7627 
      elif fid == 3:
7628 
        if ftype == TType.I64:
7629 
          self.providerId = iprot.readI64();
7630 
        else:
7631 
          iprot.skip(ftype)
7632 
      elif fid == 4:
7633 
        if ftype == TType.I64:
7634 
          self.warehouseId = iprot.readI64();
7635 
        else:
7636 
          iprot.skip(ftype)
3451 chandransh 7637 
      elif fid == 5:
7638 
        if ftype == TType.BOOL:
7639 
          self.cod = iprot.readBool();
7640 
        else:
7641 
          iprot.skip(ftype)
3427 chandransh 7642 
      else:
7643 
        iprot.skip(ftype)
7644 
      iprot.readFieldEnd()
7645 
    iprot.readStructEnd()
7646 
 
7647 
  def write(self, oprot):
7648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7650 
      return
7651 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 7652 
    if self.fromShippingDate is not None:
3427 chandransh 7653 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
7654 
      oprot.writeI64(self.fromShippingDate)
7655 
      oprot.writeFieldEnd()
3431 rajveer 7656 
    if self.toShippingDate is not None:
3427 chandransh 7657 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
7658 
      oprot.writeI64(self.toShippingDate)
7659 
      oprot.writeFieldEnd()
3431 rajveer 7660 
    if self.providerId is not None:
3427 chandransh 7661 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
7662 
      oprot.writeI64(self.providerId)
7663 
      oprot.writeFieldEnd()
3431 rajveer 7664 
    if self.warehouseId is not None:
3427 chandransh 7665 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
7666 
      oprot.writeI64(self.warehouseId)
7667 
      oprot.writeFieldEnd()
3451 chandransh 7668 
    if self.cod is not None:
7669 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
7670 
      oprot.writeBool(self.cod)
7671 
      oprot.writeFieldEnd()
3427 chandransh 7672 
    oprot.writeFieldStop()
7673 
    oprot.writeStructEnd()
7674 
 
3431 rajveer 7675 
  def validate(self):
7676 
    return
7677 
 
7678 
 
3427 chandransh 7679 
  def __repr__(self):
7680 
    L = ['%s=%r' % (key, value)
7681 
      for key, value in self.__dict__.iteritems()]
7682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7683 
 
7684 
  def __eq__(self, other):
7685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7686 
 
7687 
  def __ne__(self, other):
7688 
    return not (self == other)
7689 
 
7690 
class getOrdersByShippingDate_result:
7691 
  """
7692 
  Attributes:
7693 
   - success
7694 
   - ex
7695 
  """
7696 
 
7697 
  thrift_spec = (
7698 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7699 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7700 
  )
7701 
 
7702 
  def __init__(self, success=None, ex=None,):
7703 
    self.success = success
7704 
    self.ex = ex
7705 
 
7706 
  def read(self, iprot):
7707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7709 
      return
7710 
    iprot.readStructBegin()
7711 
    while True:
7712 
      (fname, ftype, fid) = iprot.readFieldBegin()
7713 
      if ftype == TType.STOP:
7714 
        break
7715 
      if fid == 0:
7716 
        if ftype == TType.LIST:
7717 
          self.success = []
4801 anupam.sin 7718 
          (_etype73, _size70) = iprot.readListBegin()
7719 
          for _i74 in xrange(_size70):
7720 
            _elem75 = Order()
7721 
            _elem75.read(iprot)
7722 
            self.success.append(_elem75)
3427 chandransh 7723 
          iprot.readListEnd()
7724 
        else:
7725 
          iprot.skip(ftype)
7726 
      elif fid == 1:
7727 
        if ftype == TType.STRUCT:
7728 
          self.ex = TransactionServiceException()
7729 
          self.ex.read(iprot)
7730 
        else:
7731 
          iprot.skip(ftype)
7732 
      else:
7733 
        iprot.skip(ftype)
7734 
      iprot.readFieldEnd()
7735 
    iprot.readStructEnd()
7736 
 
7737 
  def write(self, oprot):
7738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7740 
      return
7741 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 7742 
    if self.success is not None:
3427 chandransh 7743 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7744 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 7745 
      for iter76 in self.success:
7746 
        iter76.write(oprot)
3427 chandransh 7747 
      oprot.writeListEnd()
7748 
      oprot.writeFieldEnd()
3431 rajveer 7749 
    if self.ex is not None:
3427 chandransh 7750 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7751 
      self.ex.write(oprot)
7752 
      oprot.writeFieldEnd()
7753 
    oprot.writeFieldStop()
7754 
    oprot.writeStructEnd()
7755 
 
3431 rajveer 7756 
  def validate(self):
7757 
    return
7758 
 
7759 
 
3427 chandransh 7760 
  def __repr__(self):
7761 
    L = ['%s=%r' % (key, value)
7762 
      for key, value in self.__dict__.iteritems()]
7763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7764 
 
7765 
  def __eq__(self, other):
7766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7767 
 
7768 
  def __ne__(self, other):
7769 
    return not (self == other)
7770 
 
1382 varun.gupt 7771 
class getReturnableOrdersForCustomer_args:
7772 
  """
7773 
  Attributes:
7774 
   - customer_id
7775 
   - limit
7776 
  """
7777 
 
7778 
  thrift_spec = (
7779 
    None, # 0
7780 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7781 
    (2, TType.I64, 'limit', None, None, ), # 2
7782 
  )
7783 
 
7784 
  def __init__(self, customer_id=None, limit=None,):
7785 
    self.customer_id = customer_id
7786 
    self.limit = limit
7787 
 
7788 
  def read(self, iprot):
7789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7791 
      return
7792 
    iprot.readStructBegin()
7793 
    while True:
7794 
      (fname, ftype, fid) = iprot.readFieldBegin()
7795 
      if ftype == TType.STOP:
7796 
        break
7797 
      if fid == 1:
7798 
        if ftype == TType.I64:
7799 
          self.customer_id = iprot.readI64();
7800 
        else:
7801 
          iprot.skip(ftype)
7802 
      elif fid == 2:
7803 
        if ftype == TType.I64:
7804 
          self.limit = iprot.readI64();
7805 
        else:
7806 
          iprot.skip(ftype)
7807 
      else:
7808 
        iprot.skip(ftype)
7809 
      iprot.readFieldEnd()
7810 
    iprot.readStructEnd()
7811 
 
7812 
  def write(self, oprot):
7813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7815 
      return
7816 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 7817 
    if self.customer_id is not None:
1382 varun.gupt 7818 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7819 
      oprot.writeI64(self.customer_id)
7820 
      oprot.writeFieldEnd()
3431 rajveer 7821 
    if self.limit is not None:
1382 varun.gupt 7822 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7823 
      oprot.writeI64(self.limit)
7824 
      oprot.writeFieldEnd()
7825 
    oprot.writeFieldStop()
7826 
    oprot.writeStructEnd()
7827 
 
3431 rajveer 7828 
  def validate(self):
7829 
    return
7830 
 
7831 
 
1382 varun.gupt 7832 
  def __repr__(self):
7833 
    L = ['%s=%r' % (key, value)
7834 
      for key, value in self.__dict__.iteritems()]
7835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7836 
 
7837 
  def __eq__(self, other):
7838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7839 
 
7840 
  def __ne__(self, other):
7841 
    return not (self == other)
7842 
 
7843 
class getReturnableOrdersForCustomer_result:
7844 
  """
7845 
  Attributes:
7846 
   - success
7847 
   - ex
7848 
  """
7849 
 
7850 
  thrift_spec = (
7851 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7852 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7853 
  )
7854 
 
7855 
  def __init__(self, success=None, ex=None,):
7856 
    self.success = success
7857 
    self.ex = ex
7858 
 
7859 
  def read(self, iprot):
7860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7862 
      return
7863 
    iprot.readStructBegin()
7864 
    while True:
7865 
      (fname, ftype, fid) = iprot.readFieldBegin()
7866 
      if ftype == TType.STOP:
7867 
        break
7868 
      if fid == 0:
7869 
        if ftype == TType.LIST:
7870 
          self.success = []
4801 anupam.sin 7871 
          (_etype80, _size77) = iprot.readListBegin()
7872 
          for _i81 in xrange(_size77):
7873 
            _elem82 = iprot.readI64();
7874 
            self.success.append(_elem82)
1382 varun.gupt 7875 
          iprot.readListEnd()
7876 
        else:
7877 
          iprot.skip(ftype)
7878 
      elif fid == 1:
7879 
        if ftype == TType.STRUCT:
7880 
          self.ex = TransactionServiceException()
7881 
          self.ex.read(iprot)
7882 
        else:
7883 
          iprot.skip(ftype)
7884 
      else:
7885 
        iprot.skip(ftype)
7886 
      iprot.readFieldEnd()
7887 
    iprot.readStructEnd()
7888 
 
7889 
  def write(self, oprot):
7890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7892 
      return
7893 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 7894 
    if self.success is not None:
1382 varun.gupt 7895 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7896 
      oprot.writeListBegin(TType.I64, len(self.success))
4801 anupam.sin 7897 
      for iter83 in self.success:
7898 
        oprot.writeI64(iter83)
1382 varun.gupt 7899 
      oprot.writeListEnd()
7900 
      oprot.writeFieldEnd()
3431 rajveer 7901 
    if self.ex is not None:
1382 varun.gupt 7902 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7903 
      self.ex.write(oprot)
7904 
      oprot.writeFieldEnd()
7905 
    oprot.writeFieldStop()
7906 
    oprot.writeStructEnd()
7907 
 
3431 rajveer 7908 
  def validate(self):
7909 
    return
7910 
 
7911 
 
1382 varun.gupt 7912 
  def __repr__(self):
7913 
    L = ['%s=%r' % (key, value)
7914 
      for key, value in self.__dict__.iteritems()]
7915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7916 
 
7917 
  def __eq__(self, other):
7918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7919 
 
7920 
  def __ne__(self, other):
7921 
    return not (self == other)
7922 
 
7923 
class getCancellableOrdersForCustomer_args:
7924 
  """
7925 
  Attributes:
7926 
   - customer_id
7927 
   - limit
7928 
  """
7929 
 
7930 
  thrift_spec = (
7931 
    None, # 0
7932 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7933 
    (2, TType.I64, 'limit', None, None, ), # 2
7934 
  )
7935 
 
7936 
  def __init__(self, customer_id=None, limit=None,):
7937 
    self.customer_id = customer_id
7938 
    self.limit = limit
7939 
 
7940 
  def read(self, iprot):
7941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7943 
      return
7944 
    iprot.readStructBegin()
7945 
    while True:
7946 
      (fname, ftype, fid) = iprot.readFieldBegin()
7947 
      if ftype == TType.STOP:
7948 
        break
7949 
      if fid == 1:
7950 
        if ftype == TType.I64:
7951 
          self.customer_id = iprot.readI64();
7952 
        else:
7953 
          iprot.skip(ftype)
7954 
      elif fid == 2:
7955 
        if ftype == TType.I64:
7956 
          self.limit = iprot.readI64();
7957 
        else:
7958 
          iprot.skip(ftype)
7959 
      else:
7960 
        iprot.skip(ftype)
7961 
      iprot.readFieldEnd()
7962 
    iprot.readStructEnd()
7963 
 
7964 
  def write(self, oprot):
7965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7967 
      return
7968 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7969 
    if self.customer_id is not None:
1382 varun.gupt 7970 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7971 
      oprot.writeI64(self.customer_id)
7972 
      oprot.writeFieldEnd()
3431 rajveer 7973 
    if self.limit is not None:
1382 varun.gupt 7974 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7975 
      oprot.writeI64(self.limit)
7976 
      oprot.writeFieldEnd()
7977 
    oprot.writeFieldStop()
7978 
    oprot.writeStructEnd()
7979 
 
3431 rajveer 7980 
  def validate(self):
7981 
    return
7982 
 
7983 
 
1382 varun.gupt 7984 
  def __repr__(self):
7985 
    L = ['%s=%r' % (key, value)
7986 
      for key, value in self.__dict__.iteritems()]
7987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7988 
 
7989 
  def __eq__(self, other):
7990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7991 
 
7992 
  def __ne__(self, other):
7993 
    return not (self == other)
7994 
 
7995 
class getCancellableOrdersForCustomer_result:
7996 
  """
7997 
  Attributes:
7998 
   - success
7999 
   - ex
8000 
  """
8001 
 
8002 
  thrift_spec = (
8003 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8004 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8005 
  )
8006 
 
8007 
  def __init__(self, success=None, ex=None,):
8008 
    self.success = success
8009 
    self.ex = ex
8010 
 
8011 
  def read(self, iprot):
8012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8014 
      return
8015 
    iprot.readStructBegin()
8016 
    while True:
8017 
      (fname, ftype, fid) = iprot.readFieldBegin()
8018 
      if ftype == TType.STOP:
8019 
        break
8020 
      if fid == 0:
8021 
        if ftype == TType.LIST:
8022 
          self.success = []
4801 anupam.sin 8023 
          (_etype87, _size84) = iprot.readListBegin()
8024 
          for _i88 in xrange(_size84):
8025 
            _elem89 = iprot.readI64();
8026 
            self.success.append(_elem89)
1382 varun.gupt 8027 
          iprot.readListEnd()
8028 
        else:
8029 
          iprot.skip(ftype)
8030 
      elif fid == 1:
8031 
        if ftype == TType.STRUCT:
8032 
          self.ex = TransactionServiceException()
8033 
          self.ex.read(iprot)
8034 
        else:
8035 
          iprot.skip(ftype)
8036 
      else:
8037 
        iprot.skip(ftype)
8038 
      iprot.readFieldEnd()
8039 
    iprot.readStructEnd()
8040 
 
8041 
  def write(self, oprot):
8042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8044 
      return
8045 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8046 
    if self.success is not None:
1382 varun.gupt 8047 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8048 
      oprot.writeListBegin(TType.I64, len(self.success))
4801 anupam.sin 8049 
      for iter90 in self.success:
8050 
        oprot.writeI64(iter90)
1382 varun.gupt 8051 
      oprot.writeListEnd()
8052 
      oprot.writeFieldEnd()
3431 rajveer 8053 
    if self.ex is not None:
1382 varun.gupt 8054 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8055 
      self.ex.write(oprot)
8056 
      oprot.writeFieldEnd()
8057 
    oprot.writeFieldStop()
8058 
    oprot.writeStructEnd()
8059 
 
3431 rajveer 8060 
  def validate(self):
8061 
    return
8062 
 
8063 
 
1382 varun.gupt 8064 
  def __repr__(self):
8065 
    L = ['%s=%r' % (key, value)
8066 
      for key, value in self.__dict__.iteritems()]
8067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8068 
 
8069 
  def __eq__(self, other):
8070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8071 
 
8072 
  def __ne__(self, other):
8073 
    return not (self == other)
8074 
 
483 rajveer 8075 
class changeOrderStatus_args:
94 ashish 8076 
  """
8077 
  Attributes:
483 rajveer 8078 
   - orderId
8079 
   - status
8080 
   - description
94 ashish 8081 
  """
8082 
 
8083 
  thrift_spec = (
8084 
    None, # 0
483 rajveer 8085 
    (1, TType.I64, 'orderId', None, None, ), # 1
8086 
    (2, TType.I32, 'status', None, None, ), # 2
8087 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8088 
  )
8089 
 
483 rajveer 8090 
  def __init__(self, orderId=None, status=None, description=None,):
8091 
    self.orderId = orderId
8092 
    self.status = status
8093 
    self.description = description
94 ashish 8094 
 
8095 
  def read(self, iprot):
8096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8098 
      return
8099 
    iprot.readStructBegin()
8100 
    while True:
8101 
      (fname, ftype, fid) = iprot.readFieldBegin()
8102 
      if ftype == TType.STOP:
8103 
        break
8104 
      if fid == 1:
8105 
        if ftype == TType.I64:
483 rajveer 8106 
          self.orderId = iprot.readI64();
94 ashish 8107 
        else:
8108 
          iprot.skip(ftype)
8109 
      elif fid == 2:
483 rajveer 8110 
        if ftype == TType.I32:
8111 
          self.status = iprot.readI32();
94 ashish 8112 
        else:
8113 
          iprot.skip(ftype)
483 rajveer 8114 
      elif fid == 3:
8115 
        if ftype == TType.STRING:
8116 
          self.description = iprot.readString();
8117 
        else:
8118 
          iprot.skip(ftype)
94 ashish 8119 
      else:
8120 
        iprot.skip(ftype)
8121 
      iprot.readFieldEnd()
8122 
    iprot.readStructEnd()
8123 
 
8124 
  def write(self, oprot):
8125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8127 
      return
483 rajveer 8128 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8129 
    if self.orderId is not None:
483 rajveer 8130 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8131 
      oprot.writeI64(self.orderId)
94 ashish 8132 
      oprot.writeFieldEnd()
3431 rajveer 8133 
    if self.status is not None:
483 rajveer 8134 
      oprot.writeFieldBegin('status', TType.I32, 2)
8135 
      oprot.writeI32(self.status)
94 ashish 8136 
      oprot.writeFieldEnd()
3431 rajveer 8137 
    if self.description is not None:
483 rajveer 8138 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8139 
      oprot.writeString(self.description)
8140 
      oprot.writeFieldEnd()
94 ashish 8141 
    oprot.writeFieldStop()
8142 
    oprot.writeStructEnd()
8143 
 
3431 rajveer 8144 
  def validate(self):
8145 
    return
8146 
 
8147 
 
94 ashish 8148 
  def __repr__(self):
8149 
    L = ['%s=%r' % (key, value)
8150 
      for key, value in self.__dict__.iteritems()]
8151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8152 
 
8153 
  def __eq__(self, other):
8154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8155 
 
8156 
  def __ne__(self, other):
8157 
    return not (self == other)
8158 
 
483 rajveer 8159 
class changeOrderStatus_result:
94 ashish 8160 
  """
8161 
  Attributes:
8162 
   - success
8163 
   - ex
8164 
  """
8165 
 
8166 
  thrift_spec = (
8167 
    (0, TType.BOOL, 'success', None, None, ), # 0
8168 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8169 
  )
8170 
 
8171 
  def __init__(self, success=None, ex=None,):
8172 
    self.success = success
8173 
    self.ex = ex
8174 
 
8175 
  def read(self, iprot):
8176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8178 
      return
8179 
    iprot.readStructBegin()
8180 
    while True:
8181 
      (fname, ftype, fid) = iprot.readFieldBegin()
8182 
      if ftype == TType.STOP:
8183 
        break
8184 
      if fid == 0:
8185 
        if ftype == TType.BOOL:
8186 
          self.success = iprot.readBool();
8187 
        else:
8188 
          iprot.skip(ftype)
8189 
      elif fid == 1:
8190 
        if ftype == TType.STRUCT:
8191 
          self.ex = TransactionServiceException()
8192 
          self.ex.read(iprot)
8193 
        else:
8194 
          iprot.skip(ftype)
8195 
      else:
8196 
        iprot.skip(ftype)
8197 
      iprot.readFieldEnd()
8198 
    iprot.readStructEnd()
8199 
 
8200 
  def write(self, oprot):
8201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8203 
      return
483 rajveer 8204 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8205 
    if self.success is not None:
94 ashish 8206 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8207 
      oprot.writeBool(self.success)
8208 
      oprot.writeFieldEnd()
3431 rajveer 8209 
    if self.ex is not None:
94 ashish 8210 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8211 
      self.ex.write(oprot)
8212 
      oprot.writeFieldEnd()
8213 
    oprot.writeFieldStop()
8214 
    oprot.writeStructEnd()
8215 
 
3431 rajveer 8216 
  def validate(self):
8217 
    return
8218 
 
8219 
 
94 ashish 8220 
  def __repr__(self):
8221 
    L = ['%s=%r' % (key, value)
8222 
      for key, value in self.__dict__.iteritems()]
8223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8224 
 
8225 
  def __eq__(self, other):
8226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8227 
 
8228 
  def __ne__(self, other):
8229 
    return not (self == other)
8230 
 
3064 chandransh 8231 
class getOrdersForTransaction_args:
494 rajveer 8232 
  """
8233 
  Attributes:
3064 chandransh 8234 
   - transactionId
8235 
   - customerId
494 rajveer 8236 
  """
8237 
 
8238 
  thrift_spec = (
8239 
    None, # 0
3064 chandransh 8240 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8241 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8242 
  )
8243 
 
3064 chandransh 8244 
  def __init__(self, transactionId=None, customerId=None,):
8245 
    self.transactionId = transactionId
8246 
    self.customerId = customerId
494 rajveer 8247 
 
8248 
  def read(self, iprot):
8249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8251 
      return
8252 
    iprot.readStructBegin()
8253 
    while True:
8254 
      (fname, ftype, fid) = iprot.readFieldBegin()
8255 
      if ftype == TType.STOP:
8256 
        break
8257 
      if fid == 1:
8258 
        if ftype == TType.I64:
3064 chandransh 8259 
          self.transactionId = iprot.readI64();
494 rajveer 8260 
        else:
8261 
          iprot.skip(ftype)
8262 
      elif fid == 2:
3064 chandransh 8263 
        if ftype == TType.I64:
8264 
          self.customerId = iprot.readI64();
494 rajveer 8265 
        else:
8266 
          iprot.skip(ftype)
8267 
      else:
8268 
        iprot.skip(ftype)
8269 
      iprot.readFieldEnd()
8270 
    iprot.readStructEnd()
8271 
 
8272 
  def write(self, oprot):
8273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8275 
      return
3064 chandransh 8276 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8277 
    if self.transactionId is not None:
3064 chandransh 8278 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8279 
      oprot.writeI64(self.transactionId)
494 rajveer 8280 
      oprot.writeFieldEnd()
3431 rajveer 8281 
    if self.customerId is not None:
3064 chandransh 8282 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8283 
      oprot.writeI64(self.customerId)
494 rajveer 8284 
      oprot.writeFieldEnd()
8285 
    oprot.writeFieldStop()
8286 
    oprot.writeStructEnd()
8287 
 
3431 rajveer 8288 
  def validate(self):
8289 
    return
8290 
 
8291 
 
494 rajveer 8292 
  def __repr__(self):
8293 
    L = ['%s=%r' % (key, value)
8294 
      for key, value in self.__dict__.iteritems()]
8295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8296 
 
8297 
  def __eq__(self, other):
8298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8299 
 
8300 
  def __ne__(self, other):
8301 
    return not (self == other)
8302 
 
3064 chandransh 8303 
class getOrdersForTransaction_result:
494 rajveer 8304 
  """
8305 
  Attributes:
8306 
   - success
8307 
   - ex
8308 
  """
8309 
 
8310 
  thrift_spec = (
3064 chandransh 8311 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8312 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8313 
  )
8314 
 
8315 
  def __init__(self, success=None, ex=None,):
8316 
    self.success = success
8317 
    self.ex = ex
8318 
 
8319 
  def read(self, iprot):
8320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8322 
      return
8323 
    iprot.readStructBegin()
8324 
    while True:
8325 
      (fname, ftype, fid) = iprot.readFieldBegin()
8326 
      if ftype == TType.STOP:
8327 
        break
8328 
      if fid == 0:
3064 chandransh 8329 
        if ftype == TType.LIST:
8330 
          self.success = []
4801 anupam.sin 8331 
          (_etype94, _size91) = iprot.readListBegin()
8332 
          for _i95 in xrange(_size91):
8333 
            _elem96 = Order()
8334 
            _elem96.read(iprot)
8335 
            self.success.append(_elem96)
3064 chandransh 8336 
          iprot.readListEnd()
494 rajveer 8337 
        else:
8338 
          iprot.skip(ftype)
8339 
      elif fid == 1:
8340 
        if ftype == TType.STRUCT:
8341 
          self.ex = TransactionServiceException()
8342 
          self.ex.read(iprot)
8343 
        else:
8344 
          iprot.skip(ftype)
8345 
      else:
8346 
        iprot.skip(ftype)
8347 
      iprot.readFieldEnd()
8348 
    iprot.readStructEnd()
8349 
 
8350 
  def write(self, oprot):
8351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8353 
      return
3064 chandransh 8354 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 8355 
    if self.success is not None:
3064 chandransh 8356 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8357 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 8358 
      for iter97 in self.success:
8359 
        iter97.write(oprot)
3064 chandransh 8360 
      oprot.writeListEnd()
494 rajveer 8361 
      oprot.writeFieldEnd()
3431 rajveer 8362 
    if self.ex is not None:
494 rajveer 8363 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8364 
      self.ex.write(oprot)
8365 
      oprot.writeFieldEnd()
8366 
    oprot.writeFieldStop()
8367 
    oprot.writeStructEnd()
8368 
 
3431 rajveer 8369 
  def validate(self):
8370 
    return
8371 
 
8372 
 
494 rajveer 8373 
  def __repr__(self):
8374 
    L = ['%s=%r' % (key, value)
8375 
      for key, value in self.__dict__.iteritems()]
8376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8377 
 
8378 
  def __eq__(self, other):
8379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8380 
 
8381 
  def __ne__(self, other):
8382 
    return not (self == other)
8383 
 
3064 chandransh 8384 
class getOrdersForCustomer_args:
1149 chandransh 8385 
  """
8386 
  Attributes:
3064 chandransh 8387 
   - customerId
8388 
   - from_date
8389 
   - to_date
8390 
   - statuses
1149 chandransh 8391 
  """
8392 
 
8393 
  thrift_spec = (
8394 
    None, # 0
3064 chandransh 8395 
    (1, TType.I64, 'customerId', None, None, ), # 1
8396 
    (2, TType.I64, 'from_date', None, None, ), # 2
8397 
    (3, TType.I64, 'to_date', None, None, ), # 3
8398 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 8399 
  )
8400 
 
3064 chandransh 8401 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
8402 
    self.customerId = customerId
8403 
    self.from_date = from_date
8404 
    self.to_date = to_date
8405 
    self.statuses = statuses
1149 chandransh 8406 
 
8407 
  def read(self, iprot):
8408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8410 
      return
8411 
    iprot.readStructBegin()
8412 
    while True:
8413 
      (fname, ftype, fid) = iprot.readFieldBegin()
8414 
      if ftype == TType.STOP:
8415 
        break
8416 
      if fid == 1:
8417 
        if ftype == TType.I64:
3064 chandransh 8418 
          self.customerId = iprot.readI64();
1149 chandransh 8419 
        else:
8420 
          iprot.skip(ftype)
8421 
      elif fid == 2:
8422 
        if ftype == TType.I64:
3064 chandransh 8423 
          self.from_date = iprot.readI64();
1149 chandransh 8424 
        else:
8425 
          iprot.skip(ftype)
2783 chandransh 8426 
      elif fid == 3:
8427 
        if ftype == TType.I64:
3064 chandransh 8428 
          self.to_date = iprot.readI64();
2783 chandransh 8429 
        else:
8430 
          iprot.skip(ftype)
8431 
      elif fid == 4:
3064 chandransh 8432 
        if ftype == TType.LIST:
8433 
          self.statuses = []
4801 anupam.sin 8434 
          (_etype101, _size98) = iprot.readListBegin()
8435 
          for _i102 in xrange(_size98):
8436 
            _elem103 = iprot.readI32();
8437 
            self.statuses.append(_elem103)
3064 chandransh 8438 
          iprot.readListEnd()
2783 chandransh 8439 
        else:
8440 
          iprot.skip(ftype)
1149 chandransh 8441 
      else:
8442 
        iprot.skip(ftype)
8443 
      iprot.readFieldEnd()
8444 
    iprot.readStructEnd()
8445 
 
8446 
  def write(self, oprot):
8447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8449 
      return
3064 chandransh 8450 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 8451 
    if self.customerId is not None:
3064 chandransh 8452 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8453 
      oprot.writeI64(self.customerId)
1149 chandransh 8454 
      oprot.writeFieldEnd()
3431 rajveer 8455 
    if self.from_date is not None:
3064 chandransh 8456 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8457 
      oprot.writeI64(self.from_date)
1149 chandransh 8458 
      oprot.writeFieldEnd()
3431 rajveer 8459 
    if self.to_date is not None:
3064 chandransh 8460 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8461 
      oprot.writeI64(self.to_date)
2783 chandransh 8462 
      oprot.writeFieldEnd()
3431 rajveer 8463 
    if self.statuses is not None:
3064 chandransh 8464 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
8465 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4801 anupam.sin 8466 
      for iter104 in self.statuses:
8467 
        oprot.writeI32(iter104)
3064 chandransh 8468 
      oprot.writeListEnd()
2783 chandransh 8469 
      oprot.writeFieldEnd()
1149 chandransh 8470 
    oprot.writeFieldStop()
8471 
    oprot.writeStructEnd()
8472 
 
3431 rajveer 8473 
  def validate(self):
8474 
    return
8475 
 
8476 
 
1149 chandransh 8477 
  def __repr__(self):
8478 
    L = ['%s=%r' % (key, value)
8479 
      for key, value in self.__dict__.iteritems()]
8480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8481 
 
8482 
  def __eq__(self, other):
8483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8484 
 
8485 
  def __ne__(self, other):
8486 
    return not (self == other)
8487 
 
3064 chandransh 8488 
class getOrdersForCustomer_result:
1149 chandransh 8489 
  """
8490 
  Attributes:
8491 
   - success
8492 
   - ex
8493 
  """
8494 
 
8495 
  thrift_spec = (
3064 chandransh 8496 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8497 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8498 
  )
8499 
 
8500 
  def __init__(self, success=None, ex=None,):
8501 
    self.success = success
8502 
    self.ex = ex
8503 
 
8504 
  def read(self, iprot):
8505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8507 
      return
8508 
    iprot.readStructBegin()
8509 
    while True:
8510 
      (fname, ftype, fid) = iprot.readFieldBegin()
8511 
      if ftype == TType.STOP:
8512 
        break
8513 
      if fid == 0:
3064 chandransh 8514 
        if ftype == TType.LIST:
8515 
          self.success = []
4801 anupam.sin 8516 
          (_etype108, _size105) = iprot.readListBegin()
8517 
          for _i109 in xrange(_size105):
8518 
            _elem110 = Order()
8519 
            _elem110.read(iprot)
8520 
            self.success.append(_elem110)
3064 chandransh 8521 
          iprot.readListEnd()
1149 chandransh 8522 
        else:
8523 
          iprot.skip(ftype)
8524 
      elif fid == 1:
8525 
        if ftype == TType.STRUCT:
8526 
          self.ex = TransactionServiceException()
8527 
          self.ex.read(iprot)
8528 
        else:
8529 
          iprot.skip(ftype)
8530 
      else:
8531 
        iprot.skip(ftype)
8532 
      iprot.readFieldEnd()
8533 
    iprot.readStructEnd()
8534 
 
8535 
  def write(self, oprot):
8536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8538 
      return
3064 chandransh 8539 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 8540 
    if self.success is not None:
3064 chandransh 8541 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8542 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 8543 
      for iter111 in self.success:
8544 
        iter111.write(oprot)
3064 chandransh 8545 
      oprot.writeListEnd()
1149 chandransh 8546 
      oprot.writeFieldEnd()
3431 rajveer 8547 
    if self.ex is not None:
1149 chandransh 8548 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8549 
      self.ex.write(oprot)
8550 
      oprot.writeFieldEnd()
8551 
    oprot.writeFieldStop()
8552 
    oprot.writeStructEnd()
8553 
 
3431 rajveer 8554 
  def validate(self):
8555 
    return
8556 
 
8557 
 
1149 chandransh 8558 
  def __repr__(self):
8559 
    L = ['%s=%r' % (key, value)
8560 
      for key, value in self.__dict__.iteritems()]
8561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8562 
 
8563 
  def __eq__(self, other):
8564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8565 
 
8566 
  def __ne__(self, other):
8567 
    return not (self == other)
8568 
 
3064 chandransh 8569 
class createOrder_args:
921 rajveer 8570 
  """
8571 
  Attributes:
3064 chandransh 8572 
   - order
921 rajveer 8573 
  """
8574 
 
8575 
  thrift_spec = (
8576 
    None, # 0
3064 chandransh 8577 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 8578 
  )
8579 
 
3064 chandransh 8580 
  def __init__(self, order=None,):
8581 
    self.order = order
921 rajveer 8582 
 
8583 
  def read(self, iprot):
8584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8586 
      return
8587 
    iprot.readStructBegin()
8588 
    while True:
8589 
      (fname, ftype, fid) = iprot.readFieldBegin()
8590 
      if ftype == TType.STOP:
8591 
        break
8592 
      if fid == 1:
3064 chandransh 8593 
        if ftype == TType.STRUCT:
8594 
          self.order = Order()
8595 
          self.order.read(iprot)
921 rajveer 8596 
        else:
8597 
          iprot.skip(ftype)
8598 
      else:
8599 
        iprot.skip(ftype)
8600 
      iprot.readFieldEnd()
8601 
    iprot.readStructEnd()
8602 
 
8603 
  def write(self, oprot):
8604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8606 
      return
3064 chandransh 8607 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 8608 
    if self.order is not None:
3064 chandransh 8609 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
8610 
      self.order.write(oprot)
921 rajveer 8611 
      oprot.writeFieldEnd()
8612 
    oprot.writeFieldStop()
8613 
    oprot.writeStructEnd()
8614 
 
3431 rajveer 8615 
  def validate(self):
8616 
    return
8617 
 
8618 
 
921 rajveer 8619 
  def __repr__(self):
8620 
    L = ['%s=%r' % (key, value)
8621 
      for key, value in self.__dict__.iteritems()]
8622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8623 
 
8624 
  def __eq__(self, other):
8625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8626 
 
8627 
  def __ne__(self, other):
8628 
    return not (self == other)
8629 
 
3064 chandransh 8630 
class createOrder_result:
921 rajveer 8631 
  """
8632 
  Attributes:
8633 
   - success
8634 
   - ex
8635 
  """
8636 
 
8637 
  thrift_spec = (
3064 chandransh 8638 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 8639 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8640 
  )
8641 
 
8642 
  def __init__(self, success=None, ex=None,):
8643 
    self.success = success
8644 
    self.ex = ex
8645 
 
8646 
  def read(self, iprot):
8647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8649 
      return
8650 
    iprot.readStructBegin()
8651 
    while True:
8652 
      (fname, ftype, fid) = iprot.readFieldBegin()
8653 
      if ftype == TType.STOP:
8654 
        break
8655 
      if fid == 0:
3064 chandransh 8656 
        if ftype == TType.I64:
8657 
          self.success = iprot.readI64();
921 rajveer 8658 
        else:
8659 
          iprot.skip(ftype)
8660 
      elif fid == 1:
8661 
        if ftype == TType.STRUCT:
8662 
          self.ex = TransactionServiceException()
8663 
          self.ex.read(iprot)
8664 
        else:
8665 
          iprot.skip(ftype)
8666 
      else:
8667 
        iprot.skip(ftype)
8668 
      iprot.readFieldEnd()
8669 
    iprot.readStructEnd()
8670 
 
8671 
  def write(self, oprot):
8672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8674 
      return
3064 chandransh 8675 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 8676 
    if self.success is not None:
3064 chandransh 8677 
      oprot.writeFieldBegin('success', TType.I64, 0)
8678 
      oprot.writeI64(self.success)
921 rajveer 8679 
      oprot.writeFieldEnd()
3431 rajveer 8680 
    if self.ex is not None:
921 rajveer 8681 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8682 
      self.ex.write(oprot)
8683 
      oprot.writeFieldEnd()
8684 
    oprot.writeFieldStop()
8685 
    oprot.writeStructEnd()
8686 
 
3431 rajveer 8687 
  def validate(self):
8688 
    return
8689 
 
8690 
 
921 rajveer 8691 
  def __repr__(self):
8692 
    L = ['%s=%r' % (key, value)
8693 
      for key, value in self.__dict__.iteritems()]
8694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8695 
 
8696 
  def __eq__(self, other):
8697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8698 
 
8699 
  def __ne__(self, other):
8700 
    return not (self == other)
8701 
 
3064 chandransh 8702 
class getOrder_args:
921 rajveer 8703 
  """
8704 
  Attributes:
3064 chandransh 8705 
   - id
921 rajveer 8706 
  """
8707 
 
8708 
  thrift_spec = (
8709 
    None, # 0
3064 chandransh 8710 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 8711 
  )
8712 
 
3064 chandransh 8713 
  def __init__(self, id=None,):
8714 
    self.id = id
921 rajveer 8715 
 
8716 
  def read(self, iprot):
8717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8719 
      return
8720 
    iprot.readStructBegin()
8721 
    while True:
8722 
      (fname, ftype, fid) = iprot.readFieldBegin()
8723 
      if ftype == TType.STOP:
8724 
        break
8725 
      if fid == 1:
8726 
        if ftype == TType.I64:
3064 chandransh 8727 
          self.id = iprot.readI64();
921 rajveer 8728 
        else:
8729 
          iprot.skip(ftype)
8730 
      else:
8731 
        iprot.skip(ftype)
8732 
      iprot.readFieldEnd()
8733 
    iprot.readStructEnd()
8734 
 
8735 
  def write(self, oprot):
8736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8738 
      return
3064 chandransh 8739 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 8740 
    if self.id is not None:
3064 chandransh 8741 
      oprot.writeFieldBegin('id', TType.I64, 1)
8742 
      oprot.writeI64(self.id)
921 rajveer 8743 
      oprot.writeFieldEnd()
8744 
    oprot.writeFieldStop()
8745 
    oprot.writeStructEnd()
8746 
 
3431 rajveer 8747 
  def validate(self):
8748 
    return
8749 
 
8750 
 
921 rajveer 8751 
  def __repr__(self):
8752 
    L = ['%s=%r' % (key, value)
8753 
      for key, value in self.__dict__.iteritems()]
8754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8755 
 
8756 
  def __eq__(self, other):
8757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8758 
 
8759 
  def __ne__(self, other):
8760 
    return not (self == other)
8761 
 
3064 chandransh 8762 
class getOrder_result:
921 rajveer 8763 
  """
8764 
  Attributes:
8765 
   - success
8766 
   - ex
8767 
  """
8768 
 
8769 
  thrift_spec = (
3064 chandransh 8770 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 8771 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8772 
  )
8773 
 
8774 
  def __init__(self, success=None, ex=None,):
8775 
    self.success = success
8776 
    self.ex = ex
8777 
 
8778 
  def read(self, iprot):
8779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8781 
      return
8782 
    iprot.readStructBegin()
8783 
    while True:
8784 
      (fname, ftype, fid) = iprot.readFieldBegin()
8785 
      if ftype == TType.STOP:
8786 
        break
8787 
      if fid == 0:
3064 chandransh 8788 
        if ftype == TType.STRUCT:
8789 
          self.success = Order()
8790 
          self.success.read(iprot)
921 rajveer 8791 
        else:
8792 
          iprot.skip(ftype)
8793 
      elif fid == 1:
8794 
        if ftype == TType.STRUCT:
8795 
          self.ex = TransactionServiceException()
8796 
          self.ex.read(iprot)
8797 
        else:
8798 
          iprot.skip(ftype)
8799 
      else:
8800 
        iprot.skip(ftype)
8801 
      iprot.readFieldEnd()
8802 
    iprot.readStructEnd()
8803 
 
8804 
  def write(self, oprot):
8805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8807 
      return
3064 chandransh 8808 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 8809 
    if self.success is not None:
3064 chandransh 8810 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8811 
      self.success.write(oprot)
921 rajveer 8812 
      oprot.writeFieldEnd()
3431 rajveer 8813 
    if self.ex is not None:
921 rajveer 8814 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8815 
      self.ex.write(oprot)
8816 
      oprot.writeFieldEnd()
8817 
    oprot.writeFieldStop()
8818 
    oprot.writeStructEnd()
8819 
 
3431 rajveer 8820 
  def validate(self):
8821 
    return
8822 
 
8823 
 
921 rajveer 8824 
  def __repr__(self):
8825 
    L = ['%s=%r' % (key, value)
8826 
      for key, value in self.__dict__.iteritems()]
8827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8828 
 
8829 
  def __eq__(self, other):
8830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8831 
 
8832 
  def __ne__(self, other):
8833 
    return not (self == other)
8834 
 
3064 chandransh 8835 
class getLineItemsForOrder_args:
94 ashish 8836 
  """
8837 
  Attributes:
3064 chandransh 8838 
   - orderId
94 ashish 8839 
  """
8840 
 
8841 
  thrift_spec = (
8842 
    None, # 0
3064 chandransh 8843 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 8844 
  )
8845 
 
3064 chandransh 8846 
  def __init__(self, orderId=None,):
8847 
    self.orderId = orderId
94 ashish 8848 
 
8849 
  def read(self, iprot):
8850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8852 
      return
8853 
    iprot.readStructBegin()
8854 
    while True:
8855 
      (fname, ftype, fid) = iprot.readFieldBegin()
8856 
      if ftype == TType.STOP:
8857 
        break
8858 
      if fid == 1:
8859 
        if ftype == TType.I64:
3064 chandransh 8860 
          self.orderId = iprot.readI64();
94 ashish 8861 
        else:
8862 
          iprot.skip(ftype)
8863 
      else:
8864 
        iprot.skip(ftype)
8865 
      iprot.readFieldEnd()
8866 
    iprot.readStructEnd()
8867 
 
8868 
  def write(self, oprot):
8869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8871 
      return
3064 chandransh 8872 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 8873 
    if self.orderId is not None:
3064 chandransh 8874 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8875 
      oprot.writeI64(self.orderId)
94 ashish 8876 
      oprot.writeFieldEnd()
8877 
    oprot.writeFieldStop()
8878 
    oprot.writeStructEnd()
8879 
 
3431 rajveer 8880 
  def validate(self):
8881 
    return
8882 
 
8883 
 
94 ashish 8884 
  def __repr__(self):
8885 
    L = ['%s=%r' % (key, value)
8886 
      for key, value in self.__dict__.iteritems()]
8887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8888 
 
8889 
  def __eq__(self, other):
8890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8891 
 
8892 
  def __ne__(self, other):
8893 
    return not (self == other)
8894 
 
3064 chandransh 8895 
class getLineItemsForOrder_result:
94 ashish 8896 
  """
8897 
  Attributes:
8898 
   - success
8899 
   - ex
8900 
  """
8901 
 
8902 
  thrift_spec = (
3064 chandransh 8903 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 8904 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8905 
  )
8906 
 
8907 
  def __init__(self, success=None, ex=None,):
8908 
    self.success = success
8909 
    self.ex = ex
8910 
 
8911 
  def read(self, iprot):
8912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8914 
      return
8915 
    iprot.readStructBegin()
8916 
    while True:
8917 
      (fname, ftype, fid) = iprot.readFieldBegin()
8918 
      if ftype == TType.STOP:
8919 
        break
8920 
      if fid == 0:
483 rajveer 8921 
        if ftype == TType.LIST:
8922 
          self.success = []
4801 anupam.sin 8923 
          (_etype115, _size112) = iprot.readListBegin()
8924 
          for _i116 in xrange(_size112):
8925 
            _elem117 = LineItem()
8926 
            _elem117.read(iprot)
8927 
            self.success.append(_elem117)
483 rajveer 8928 
          iprot.readListEnd()
94 ashish 8929 
        else:
8930 
          iprot.skip(ftype)
8931 
      elif fid == 1:
8932 
        if ftype == TType.STRUCT:
8933 
          self.ex = TransactionServiceException()
8934 
          self.ex.read(iprot)
8935 
        else:
8936 
          iprot.skip(ftype)
8937 
      else:
8938 
        iprot.skip(ftype)
8939 
      iprot.readFieldEnd()
8940 
    iprot.readStructEnd()
8941 
 
8942 
  def write(self, oprot):
8943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8945 
      return
3064 chandransh 8946 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8947 
    if self.success is not None:
483 rajveer 8948 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8949 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 8950 
      for iter118 in self.success:
8951 
        iter118.write(oprot)
483 rajveer 8952 
      oprot.writeListEnd()
94 ashish 8953 
      oprot.writeFieldEnd()
3431 rajveer 8954 
    if self.ex is not None:
94 ashish 8955 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8956 
      self.ex.write(oprot)
8957 
      oprot.writeFieldEnd()
8958 
    oprot.writeFieldStop()
8959 
    oprot.writeStructEnd()
8960 
 
3431 rajveer 8961 
  def validate(self):
8962 
    return
8963 
 
8964 
 
94 ashish 8965 
  def __repr__(self):
8966 
    L = ['%s=%r' % (key, value)
8967 
      for key, value in self.__dict__.iteritems()]
8968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8969 
 
8970 
  def __eq__(self, other):
8971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8972 
 
8973 
  def __ne__(self, other):
8974 
    return not (self == other)
8975 
 
3064 chandransh 8976 
class getOrderForCustomer_args:
94 ashish 8977 
  """
8978 
  Attributes:
3064 chandransh 8979 
   - orderId
483 rajveer 8980 
   - customerId
94 ashish 8981 
  """
8982 
 
8983 
  thrift_spec = (
8984 
    None, # 0
3064 chandransh 8985 
    (1, TType.I64, 'orderId', None, None, ), # 1
8986 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8987 
  )
8988 
 
3064 chandransh 8989 
  def __init__(self, orderId=None, customerId=None,):
8990 
    self.orderId = orderId
483 rajveer 8991 
    self.customerId = customerId
94 ashish 8992 
 
8993 
  def read(self, iprot):
8994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8996 
      return
8997 
    iprot.readStructBegin()
8998 
    while True:
8999 
      (fname, ftype, fid) = iprot.readFieldBegin()
9000 
      if ftype == TType.STOP:
9001 
        break
9002 
      if fid == 1:
9003 
        if ftype == TType.I64:
3064 chandransh 9004 
          self.orderId = iprot.readI64();
94 ashish 9005 
        else:
9006 
          iprot.skip(ftype)
9007 
      elif fid == 2:
9008 
        if ftype == TType.I64:
3064 chandransh 9009 
          self.customerId = iprot.readI64();
94 ashish 9010 
        else:
9011 
          iprot.skip(ftype)
9012 
      else:
9013 
        iprot.skip(ftype)
9014 
      iprot.readFieldEnd()
9015 
    iprot.readStructEnd()
9016 
 
9017 
  def write(self, oprot):
9018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9020 
      return
3064 chandransh 9021 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 9022 
    if self.orderId is not None:
3064 chandransh 9023 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9024 
      oprot.writeI64(self.orderId)
9025 
      oprot.writeFieldEnd()
3431 rajveer 9026 
    if self.customerId is not None:
3064 chandransh 9027 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 9028 
      oprot.writeI64(self.customerId)
94 ashish 9029 
      oprot.writeFieldEnd()
9030 
    oprot.writeFieldStop()
9031 
    oprot.writeStructEnd()
9032 
 
3431 rajveer 9033 
  def validate(self):
9034 
    return
9035 
 
9036 
 
94 ashish 9037 
  def __repr__(self):
9038 
    L = ['%s=%r' % (key, value)
9039 
      for key, value in self.__dict__.iteritems()]
9040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9041 
 
9042 
  def __eq__(self, other):
9043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9044 
 
9045 
  def __ne__(self, other):
9046 
    return not (self == other)
9047 
 
3064 chandransh 9048 
class getOrderForCustomer_result:
94 ashish 9049 
  """
9050 
  Attributes:
9051 
   - success
9052 
   - ex
9053 
  """
9054 
 
9055 
  thrift_spec = (
3064 chandransh 9056 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 9057 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9058 
  )
9059 
 
9060 
  def __init__(self, success=None, ex=None,):
9061 
    self.success = success
9062 
    self.ex = ex
9063 
 
9064 
  def read(self, iprot):
9065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9067 
      return
9068 
    iprot.readStructBegin()
9069 
    while True:
9070 
      (fname, ftype, fid) = iprot.readFieldBegin()
9071 
      if ftype == TType.STOP:
9072 
        break
9073 
      if fid == 0:
3064 chandransh 9074 
        if ftype == TType.STRUCT:
9075 
          self.success = Order()
9076 
          self.success.read(iprot)
94 ashish 9077 
        else:
9078 
          iprot.skip(ftype)
9079 
      elif fid == 1:
9080 
        if ftype == TType.STRUCT:
9081 
          self.ex = TransactionServiceException()
9082 
          self.ex.read(iprot)
9083 
        else:
9084 
          iprot.skip(ftype)
9085 
      else:
9086 
        iprot.skip(ftype)
9087 
      iprot.readFieldEnd()
9088 
    iprot.readStructEnd()
9089 
 
9090 
  def write(self, oprot):
9091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9093 
      return
3064 chandransh 9094 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 9095 
    if self.success is not None:
3064 chandransh 9096 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9097 
      self.success.write(oprot)
94 ashish 9098 
      oprot.writeFieldEnd()
3431 rajveer 9099 
    if self.ex is not None:
94 ashish 9100 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9101 
      self.ex.write(oprot)
9102 
      oprot.writeFieldEnd()
9103 
    oprot.writeFieldStop()
9104 
    oprot.writeStructEnd()
9105 
 
3431 rajveer 9106 
  def validate(self):
9107 
    return
9108 
 
9109 
 
94 ashish 9110 
  def __repr__(self):
9111 
    L = ['%s=%r' % (key, value)
9112 
      for key, value in self.__dict__.iteritems()]
9113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9114 
 
9115 
  def __eq__(self, other):
9116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9117 
 
9118 
  def __ne__(self, other):
9119 
    return not (self == other)
9120 
 
3064 chandransh 9121 
class getAlerts_args:
94 ashish 9122 
  """
9123 
  Attributes:
4394 rajveer 9124 
   - type
4444 rajveer 9125 
   - warehouseId
4394 rajveer 9126 
   - status
9127 
   - timestamp
94 ashish 9128 
  """
9129 
 
9130 
  thrift_spec = (
9131 
    None, # 0
4394 rajveer 9132 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9133 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9134 
    (3, TType.I64, 'status', None, None, ), # 3
9135 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 9136 
  )
9137 
 
4444 rajveer 9138 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 9139 
    self.type = type
4444 rajveer 9140 
    self.warehouseId = warehouseId
4394 rajveer 9141 
    self.status = status
9142 
    self.timestamp = timestamp
94 ashish 9143 
 
9144 
  def read(self, iprot):
9145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9147 
      return
9148 
    iprot.readStructBegin()
9149 
    while True:
9150 
      (fname, ftype, fid) = iprot.readFieldBegin()
9151 
      if ftype == TType.STOP:
9152 
        break
9153 
      if fid == 1:
3064 chandransh 9154 
        if ftype == TType.I64:
4394 rajveer 9155 
          self.type = iprot.readI64();
94 ashish 9156 
        else:
9157 
          iprot.skip(ftype)
3064 chandransh 9158 
      elif fid == 2:
4394 rajveer 9159 
        if ftype == TType.I64:
4444 rajveer 9160 
          self.warehouseId = iprot.readI64();
3064 chandransh 9161 
        else:
9162 
          iprot.skip(ftype)
4394 rajveer 9163 
      elif fid == 3:
9164 
        if ftype == TType.I64:
4444 rajveer 9165 
          self.status = iprot.readI64();
9166 
        else:
9167 
          iprot.skip(ftype)
9168 
      elif fid == 4:
9169 
        if ftype == TType.I64:
4394 rajveer 9170 
          self.timestamp = iprot.readI64();
9171 
        else:
9172 
          iprot.skip(ftype)
94 ashish 9173 
      else:
9174 
        iprot.skip(ftype)
9175 
      iprot.readFieldEnd()
9176 
    iprot.readStructEnd()
9177 
 
9178 
  def write(self, oprot):
9179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9181 
      return
3064 chandransh 9182 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 9183 
    if self.type is not None:
9184 
      oprot.writeFieldBegin('type', TType.I64, 1)
9185 
      oprot.writeI64(self.type)
94 ashish 9186 
      oprot.writeFieldEnd()
4444 rajveer 9187 
    if self.warehouseId is not None:
9188 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9189 
      oprot.writeI64(self.warehouseId)
9190 
      oprot.writeFieldEnd()
4394 rajveer 9191 
    if self.status is not None:
4444 rajveer 9192 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 9193 
      oprot.writeI64(self.status)
3064 chandransh 9194 
      oprot.writeFieldEnd()
4394 rajveer 9195 
    if self.timestamp is not None:
4444 rajveer 9196 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 9197 
      oprot.writeI64(self.timestamp)
9198 
      oprot.writeFieldEnd()
94 ashish 9199 
    oprot.writeFieldStop()
9200 
    oprot.writeStructEnd()
9201 
 
3431 rajveer 9202 
  def validate(self):
9203 
    return
9204 
 
9205 
 
94 ashish 9206 
  def __repr__(self):
9207 
    L = ['%s=%r' % (key, value)
9208 
      for key, value in self.__dict__.iteritems()]
9209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9210 
 
9211 
  def __eq__(self, other):
9212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9213 
 
9214 
  def __ne__(self, other):
9215 
    return not (self == other)
9216 
 
3064 chandransh 9217 
class getAlerts_result:
94 ashish 9218 
  """
9219 
  Attributes:
9220 
   - success
9221 
  """
9222 
 
9223 
  thrift_spec = (
3064 chandransh 9224 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 9225 
  )
9226 
 
3064 chandransh 9227 
  def __init__(self, success=None,):
94 ashish 9228 
    self.success = success
9229 
 
9230 
  def read(self, iprot):
9231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9233 
      return
9234 
    iprot.readStructBegin()
9235 
    while True:
9236 
      (fname, ftype, fid) = iprot.readFieldBegin()
9237 
      if ftype == TType.STOP:
9238 
        break
9239 
      if fid == 0:
3064 chandransh 9240 
        if ftype == TType.LIST:
9241 
          self.success = []
4801 anupam.sin 9242 
          (_etype122, _size119) = iprot.readListBegin()
9243 
          for _i123 in xrange(_size119):
9244 
            _elem124 = Alert()
9245 
            _elem124.read(iprot)
9246 
            self.success.append(_elem124)
3064 chandransh 9247 
          iprot.readListEnd()
94 ashish 9248 
        else:
9249 
          iprot.skip(ftype)
9250 
      else:
9251 
        iprot.skip(ftype)
9252 
      iprot.readFieldEnd()
9253 
    iprot.readStructEnd()
9254 
 
9255 
  def write(self, oprot):
9256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9258 
      return
3064 chandransh 9259 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 9260 
    if self.success is not None:
3064 chandransh 9261 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9262 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 9263 
      for iter125 in self.success:
9264 
        iter125.write(oprot)
3064 chandransh 9265 
      oprot.writeListEnd()
94 ashish 9266 
      oprot.writeFieldEnd()
9267 
    oprot.writeFieldStop()
9268 
    oprot.writeStructEnd()
9269 
 
3431 rajveer 9270 
  def validate(self):
9271 
    return
9272 
 
9273 
 
94 ashish 9274 
  def __repr__(self):
9275 
    L = ['%s=%r' % (key, value)
9276 
      for key, value in self.__dict__.iteritems()]
9277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9278 
 
9279 
  def __eq__(self, other):
9280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9281 
 
9282 
  def __ne__(self, other):
9283 
    return not (self == other)
9284 
 
4394 rajveer 9285 
class addAlert_args:
94 ashish 9286 
  """
9287 
  Attributes:
3064 chandransh 9288 
   - type
4444 rajveer 9289 
   - warehouseId
4394 rajveer 9290 
   - description
94 ashish 9291 
  """
9292 
 
9293 
  thrift_spec = (
9294 
    None, # 0
4394 rajveer 9295 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9296 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9297 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9298 
  )
9299 
 
4444 rajveer 9300 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 9301 
    self.type = type
4444 rajveer 9302 
    self.warehouseId = warehouseId
4394 rajveer 9303 
    self.description = description
94 ashish 9304 
 
9305 
  def read(self, iprot):
9306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9308 
      return
9309 
    iprot.readStructBegin()
9310 
    while True:
9311 
      (fname, ftype, fid) = iprot.readFieldBegin()
9312 
      if ftype == TType.STOP:
9313 
        break
9314 
      if fid == 1:
9315 
        if ftype == TType.I64:
4394 rajveer 9316 
          self.type = iprot.readI64();
94 ashish 9317 
        else:
9318 
          iprot.skip(ftype)
3064 chandransh 9319 
      elif fid == 2:
4444 rajveer 9320 
        if ftype == TType.I64:
9321 
          self.warehouseId = iprot.readI64();
9322 
        else:
9323 
          iprot.skip(ftype)
9324 
      elif fid == 3:
3064 chandransh 9325 
        if ftype == TType.STRING:
4394 rajveer 9326 
          self.description = iprot.readString();
3064 chandransh 9327 
        else:
9328 
          iprot.skip(ftype)
94 ashish 9329 
      else:
9330 
        iprot.skip(ftype)
9331 
      iprot.readFieldEnd()
9332 
    iprot.readStructEnd()
9333 
 
9334 
  def write(self, oprot):
9335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9337 
      return
4394 rajveer 9338 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 9339 
    if self.type is not None:
4394 rajveer 9340 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 9341 
      oprot.writeI64(self.type)
9342 
      oprot.writeFieldEnd()
4444 rajveer 9343 
    if self.warehouseId is not None:
9344 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9345 
      oprot.writeI64(self.warehouseId)
9346 
      oprot.writeFieldEnd()
4394 rajveer 9347 
    if self.description is not None:
4444 rajveer 9348 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 9349 
      oprot.writeString(self.description)
3064 chandransh 9350 
      oprot.writeFieldEnd()
94 ashish 9351 
    oprot.writeFieldStop()
9352 
    oprot.writeStructEnd()
9353 
 
3431 rajveer 9354 
  def validate(self):
9355 
    return
9356 
 
9357 
 
94 ashish 9358 
  def __repr__(self):
9359 
    L = ['%s=%r' % (key, value)
9360 
      for key, value in self.__dict__.iteritems()]
9361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9362 
 
9363 
  def __eq__(self, other):
9364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9365 
 
9366 
  def __ne__(self, other):
9367 
    return not (self == other)
9368 
 
4394 rajveer 9369 
class addAlert_result:
3064 chandransh 9370 
 
9371 
  thrift_spec = (
9372 
  )
9373 
 
9374 
  def read(self, iprot):
9375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9377 
      return
9378 
    iprot.readStructBegin()
9379 
    while True:
9380 
      (fname, ftype, fid) = iprot.readFieldBegin()
9381 
      if ftype == TType.STOP:
9382 
        break
9383 
      else:
9384 
        iprot.skip(ftype)
9385 
      iprot.readFieldEnd()
9386 
    iprot.readStructEnd()
9387 
 
9388 
  def write(self, oprot):
9389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9391 
      return
4394 rajveer 9392 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 9393 
    oprot.writeFieldStop()
9394 
    oprot.writeStructEnd()
9395 
 
3431 rajveer 9396 
  def validate(self):
9397 
    return
9398 
 
9399 
 
3064 chandransh 9400 
  def __repr__(self):
9401 
    L = ['%s=%r' % (key, value)
9402 
      for key, value in self.__dict__.iteritems()]
9403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9404 
 
9405 
  def __eq__(self, other):
9406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9407 
 
9408 
  def __ne__(self, other):
9409 
    return not (self == other)
9410 
 
4444 rajveer 9411 
class markAlertsAsSeen_args:
9412 
  """
9413 
  Attributes:
9414 
   - warehouseId
9415 
  """
9416 
 
9417 
  thrift_spec = (
9418 
    None, # 0
9419 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9420 
  )
9421 
 
9422 
  def __init__(self, warehouseId=None,):
9423 
    self.warehouseId = warehouseId
9424 
 
9425 
  def read(self, iprot):
9426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9428 
      return
9429 
    iprot.readStructBegin()
9430 
    while True:
9431 
      (fname, ftype, fid) = iprot.readFieldBegin()
9432 
      if ftype == TType.STOP:
9433 
        break
9434 
      if fid == 1:
9435 
        if ftype == TType.I64:
9436 
          self.warehouseId = iprot.readI64();
9437 
        else:
9438 
          iprot.skip(ftype)
9439 
      else:
9440 
        iprot.skip(ftype)
9441 
      iprot.readFieldEnd()
9442 
    iprot.readStructEnd()
9443 
 
9444 
  def write(self, oprot):
9445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9447 
      return
9448 
    oprot.writeStructBegin('markAlertsAsSeen_args')
9449 
    if self.warehouseId is not None:
9450 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9451 
      oprot.writeI64(self.warehouseId)
9452 
      oprot.writeFieldEnd()
9453 
    oprot.writeFieldStop()
9454 
    oprot.writeStructEnd()
9455 
 
9456 
  def validate(self):
9457 
    return
9458 
 
9459 
 
9460 
  def __repr__(self):
9461 
    L = ['%s=%r' % (key, value)
9462 
      for key, value in self.__dict__.iteritems()]
9463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9464 
 
9465 
  def __eq__(self, other):
9466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9467 
 
9468 
  def __ne__(self, other):
9469 
    return not (self == other)
9470 
 
9471 
class markAlertsAsSeen_result:
9472 
 
9473 
  thrift_spec = (
9474 
  )
9475 
 
9476 
  def read(self, iprot):
9477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9479 
      return
9480 
    iprot.readStructBegin()
9481 
    while True:
9482 
      (fname, ftype, fid) = iprot.readFieldBegin()
9483 
      if ftype == TType.STOP:
9484 
        break
9485 
      else:
9486 
        iprot.skip(ftype)
9487 
      iprot.readFieldEnd()
9488 
    iprot.readStructEnd()
9489 
 
9490 
  def write(self, oprot):
9491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9493 
      return
9494 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9495 
    oprot.writeFieldStop()
9496 
    oprot.writeStructEnd()
9497 
 
9498 
  def validate(self):
9499 
    return
9500 
 
9501 
 
9502 
  def __repr__(self):
9503 
    L = ['%s=%r' % (key, value)
9504 
      for key, value in self.__dict__.iteritems()]
9505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9506 
 
9507 
  def __eq__(self, other):
9508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9509 
 
9510 
  def __ne__(self, other):
9511 
    return not (self == other)
9512 
 
3064 chandransh 9513 
class getValidOrderCount_args:
9514 
 
9515 
  thrift_spec = (
9516 
  )
9517 
 
9518 
  def read(self, iprot):
9519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9521 
      return
9522 
    iprot.readStructBegin()
9523 
    while True:
9524 
      (fname, ftype, fid) = iprot.readFieldBegin()
9525 
      if ftype == TType.STOP:
9526 
        break
9527 
      else:
9528 
        iprot.skip(ftype)
9529 
      iprot.readFieldEnd()
9530 
    iprot.readStructEnd()
9531 
 
9532 
  def write(self, oprot):
9533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9535 
      return
9536 
    oprot.writeStructBegin('getValidOrderCount_args')
9537 
    oprot.writeFieldStop()
9538 
    oprot.writeStructEnd()
9539 
 
3431 rajveer 9540 
  def validate(self):
9541 
    return
9542 
 
9543 
 
3064 chandransh 9544 
  def __repr__(self):
9545 
    L = ['%s=%r' % (key, value)
9546 
      for key, value in self.__dict__.iteritems()]
9547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9548 
 
9549 
  def __eq__(self, other):
9550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9551 
 
9552 
  def __ne__(self, other):
9553 
    return not (self == other)
9554 
 
9555 
class getValidOrderCount_result:
94 ashish 9556 
  """
9557 
  Attributes:
9558 
   - success
9559 
  """
9560 
 
9561 
  thrift_spec = (
3064 chandransh 9562 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9563 
  )
9564 
 
3064 chandransh 9565 
  def __init__(self, success=None,):
94 ashish 9566 
    self.success = success
9567 
 
9568 
  def read(self, iprot):
9569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9571 
      return
9572 
    iprot.readStructBegin()
9573 
    while True:
9574 
      (fname, ftype, fid) = iprot.readFieldBegin()
9575 
      if ftype == TType.STOP:
9576 
        break
9577 
      if fid == 0:
3064 chandransh 9578 
        if ftype == TType.I64:
9579 
          self.success = iprot.readI64();
94 ashish 9580 
        else:
9581 
          iprot.skip(ftype)
9582 
      else:
9583 
        iprot.skip(ftype)
9584 
      iprot.readFieldEnd()
9585 
    iprot.readStructEnd()
9586 
 
9587 
  def write(self, oprot):
9588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9590 
      return
3064 chandransh 9591 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 9592 
    if self.success is not None:
3064 chandransh 9593 
      oprot.writeFieldBegin('success', TType.I64, 0)
9594 
      oprot.writeI64(self.success)
94 ashish 9595 
      oprot.writeFieldEnd()
9596 
    oprot.writeFieldStop()
9597 
    oprot.writeStructEnd()
9598 
 
3431 rajveer 9599 
  def validate(self):
9600 
    return
9601 
 
9602 
 
94 ashish 9603 
  def __repr__(self):
9604 
    L = ['%s=%r' % (key, value)
9605 
      for key, value in self.__dict__.iteritems()]
9606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9607 
 
9608 
  def __eq__(self, other):
9609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9610 
 
9611 
  def __ne__(self, other):
9612 
    return not (self == other)
9613 
 
3064 chandransh 9614 
class getNoOfCustomersWithSuccessfulTransaction_args:
9615 
 
9616 
  thrift_spec = (
9617 
  )
9618 
 
9619 
  def read(self, iprot):
9620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9622 
      return
9623 
    iprot.readStructBegin()
9624 
    while True:
9625 
      (fname, ftype, fid) = iprot.readFieldBegin()
9626 
      if ftype == TType.STOP:
9627 
        break
9628 
      else:
9629 
        iprot.skip(ftype)
9630 
      iprot.readFieldEnd()
9631 
    iprot.readStructEnd()
9632 
 
9633 
  def write(self, oprot):
9634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9636 
      return
9637 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
9638 
    oprot.writeFieldStop()
9639 
    oprot.writeStructEnd()
9640 
 
3431 rajveer 9641 
  def validate(self):
9642 
    return
9643 
 
9644 
 
3064 chandransh 9645 
  def __repr__(self):
9646 
    L = ['%s=%r' % (key, value)
9647 
      for key, value in self.__dict__.iteritems()]
9648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9649 
 
9650 
  def __eq__(self, other):
9651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9652 
 
9653 
  def __ne__(self, other):
9654 
    return not (self == other)
9655 
 
9656 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 9657 
  """
9658 
  Attributes:
3064 chandransh 9659 
   - success
94 ashish 9660 
  """
9661 
 
9662 
  thrift_spec = (
3064 chandransh 9663 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9664 
  )
9665 
 
3064 chandransh 9666 
  def __init__(self, success=None,):
9667 
    self.success = success
94 ashish 9668 
 
9669 
  def read(self, iprot):
9670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9672 
      return
9673 
    iprot.readStructBegin()
9674 
    while True:
9675 
      (fname, ftype, fid) = iprot.readFieldBegin()
9676 
      if ftype == TType.STOP:
9677 
        break
3064 chandransh 9678 
      if fid == 0:
94 ashish 9679 
        if ftype == TType.I64:
3064 chandransh 9680 
          self.success = iprot.readI64();
94 ashish 9681 
        else:
9682 
          iprot.skip(ftype)
9683 
      else:
9684 
        iprot.skip(ftype)
9685 
      iprot.readFieldEnd()
9686 
    iprot.readStructEnd()
9687 
 
9688 
  def write(self, oprot):
9689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9691 
      return
3064 chandransh 9692 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 9693 
    if self.success is not None:
3064 chandransh 9694 
      oprot.writeFieldBegin('success', TType.I64, 0)
9695 
      oprot.writeI64(self.success)
94 ashish 9696 
      oprot.writeFieldEnd()
9697 
    oprot.writeFieldStop()
9698 
    oprot.writeStructEnd()
9699 
 
3431 rajveer 9700 
  def validate(self):
9701 
    return
9702 
 
9703 
 
94 ashish 9704 
  def __repr__(self):
9705 
    L = ['%s=%r' % (key, value)
9706 
      for key, value in self.__dict__.iteritems()]
9707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9708 
 
9709 
  def __eq__(self, other):
9710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9711 
 
9712 
  def __ne__(self, other):
9713 
    return not (self == other)
9714 
 
3064 chandransh 9715 
class getValidOrdersAmountRange_args:
9716 
 
9717 
  thrift_spec = (
9718 
  )
9719 
 
9720 
  def read(self, iprot):
9721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9723 
      return
9724 
    iprot.readStructBegin()
9725 
    while True:
9726 
      (fname, ftype, fid) = iprot.readFieldBegin()
9727 
      if ftype == TType.STOP:
9728 
        break
9729 
      else:
9730 
        iprot.skip(ftype)
9731 
      iprot.readFieldEnd()
9732 
    iprot.readStructEnd()
9733 
 
9734 
  def write(self, oprot):
9735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9737 
      return
9738 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
9739 
    oprot.writeFieldStop()
9740 
    oprot.writeStructEnd()
9741 
 
3431 rajveer 9742 
  def validate(self):
9743 
    return
9744 
 
9745 
 
3064 chandransh 9746 
  def __repr__(self):
9747 
    L = ['%s=%r' % (key, value)
9748 
      for key, value in self.__dict__.iteritems()]
9749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9750 
 
9751 
  def __eq__(self, other):
9752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9753 
 
9754 
  def __ne__(self, other):
9755 
    return not (self == other)
9756 
 
9757 
class getValidOrdersAmountRange_result:
94 ashish 9758 
  """
9759 
  Attributes:
9760 
   - success
9761 
  """
9762 
 
9763 
  thrift_spec = (
3064 chandransh 9764 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 9765 
  )
9766 
 
3064 chandransh 9767 
  def __init__(self, success=None,):
94 ashish 9768 
    self.success = success
9769 
 
9770 
  def read(self, iprot):
9771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9773 
      return
9774 
    iprot.readStructBegin()
9775 
    while True:
9776 
      (fname, ftype, fid) = iprot.readFieldBegin()
9777 
      if ftype == TType.STOP:
9778 
        break
9779 
      if fid == 0:
483 rajveer 9780 
        if ftype == TType.LIST:
9781 
          self.success = []
4801 anupam.sin 9782 
          (_etype129, _size126) = iprot.readListBegin()
9783 
          for _i130 in xrange(_size126):
9784 
            _elem131 = iprot.readDouble();
9785 
            self.success.append(_elem131)
483 rajveer 9786 
          iprot.readListEnd()
94 ashish 9787 
        else:
9788 
          iprot.skip(ftype)
9789 
      else:
9790 
        iprot.skip(ftype)
9791 
      iprot.readFieldEnd()
9792 
    iprot.readStructEnd()
9793 
 
9794 
  def write(self, oprot):
9795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9797 
      return
3064 chandransh 9798 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 9799 
    if self.success is not None:
483 rajveer 9800 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 9801 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4801 anupam.sin 9802 
      for iter132 in self.success:
9803 
        oprot.writeDouble(iter132)
483 rajveer 9804 
      oprot.writeListEnd()
94 ashish 9805 
      oprot.writeFieldEnd()
9806 
    oprot.writeFieldStop()
9807 
    oprot.writeStructEnd()
9808 
 
3431 rajveer 9809 
  def validate(self):
9810 
    return
9811 
 
9812 
 
94 ashish 9813 
  def __repr__(self):
9814 
    L = ['%s=%r' % (key, value)
9815 
      for key, value in self.__dict__.iteritems()]
9816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9817 
 
9818 
  def __eq__(self, other):
9819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9820 
 
9821 
  def __ne__(self, other):
9822 
    return not (self == other)
9823 
 
3064 chandransh 9824 
class getValidOrders_args:
1528 ankur.sing 9825 
  """
9826 
  Attributes:
3064 chandransh 9827 
   - limit
1528 ankur.sing 9828 
  """
9829 
 
9830 
  thrift_spec = (
9831 
    None, # 0
3064 chandransh 9832 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 9833 
  )
9834 
 
3064 chandransh 9835 
  def __init__(self, limit=None,):
9836 
    self.limit = limit
1528 ankur.sing 9837 
 
9838 
  def read(self, iprot):
9839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9841 
      return
9842 
    iprot.readStructBegin()
9843 
    while True:
9844 
      (fname, ftype, fid) = iprot.readFieldBegin()
9845 
      if ftype == TType.STOP:
9846 
        break
9847 
      if fid == 1:
9848 
        if ftype == TType.I64:
3064 chandransh 9849 
          self.limit = iprot.readI64();
1528 ankur.sing 9850 
        else:
9851 
          iprot.skip(ftype)
9852 
      else:
9853 
        iprot.skip(ftype)
9854 
      iprot.readFieldEnd()
9855 
    iprot.readStructEnd()
9856 
 
9857 
  def write(self, oprot):
9858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9860 
      return
3064 chandransh 9861 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 9862 
    if self.limit is not None:
3064 chandransh 9863 
      oprot.writeFieldBegin('limit', TType.I64, 1)
9864 
      oprot.writeI64(self.limit)
1528 ankur.sing 9865 
      oprot.writeFieldEnd()
9866 
    oprot.writeFieldStop()
9867 
    oprot.writeStructEnd()
9868 
 
3431 rajveer 9869 
  def validate(self):
9870 
    return
9871 
 
9872 
 
1528 ankur.sing 9873 
  def __repr__(self):
9874 
    L = ['%s=%r' % (key, value)
9875 
      for key, value in self.__dict__.iteritems()]
9876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9877 
 
9878 
  def __eq__(self, other):
9879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9880 
 
9881 
  def __ne__(self, other):
9882 
    return not (self == other)
9883 
 
3064 chandransh 9884 
class getValidOrders_result:
1528 ankur.sing 9885 
  """
9886 
  Attributes:
9887 
   - success
9888 
  """
9889 
 
9890 
  thrift_spec = (
3064 chandransh 9891 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 9892 
  )
9893 
 
3064 chandransh 9894 
  def __init__(self, success=None,):
1528 ankur.sing 9895 
    self.success = success
9896 
 
9897 
  def read(self, iprot):
9898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9900 
      return
9901 
    iprot.readStructBegin()
9902 
    while True:
9903 
      (fname, ftype, fid) = iprot.readFieldBegin()
9904 
      if ftype == TType.STOP:
9905 
        break
9906 
      if fid == 0:
3064 chandransh 9907 
        if ftype == TType.LIST:
9908 
          self.success = []
4801 anupam.sin 9909 
          (_etype136, _size133) = iprot.readListBegin()
9910 
          for _i137 in xrange(_size133):
9911 
            _elem138 = Order()
9912 
            _elem138.read(iprot)
9913 
            self.success.append(_elem138)
3064 chandransh 9914 
          iprot.readListEnd()
1528 ankur.sing 9915 
        else:
9916 
          iprot.skip(ftype)
9917 
      else:
9918 
        iprot.skip(ftype)
9919 
      iprot.readFieldEnd()
9920 
    iprot.readStructEnd()
9921 
 
9922 
  def write(self, oprot):
9923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9925 
      return
3064 chandransh 9926 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9927 
    if self.success is not None:
3064 chandransh 9928 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9929 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 9930 
      for iter139 in self.success:
9931 
        iter139.write(oprot)
3064 chandransh 9932 
      oprot.writeListEnd()
1528 ankur.sing 9933 
      oprot.writeFieldEnd()
9934 
    oprot.writeFieldStop()
9935 
    oprot.writeStructEnd()
9936 
 
3431 rajveer 9937 
  def validate(self):
9938 
    return
9939 
 
9940 
 
1528 ankur.sing 9941 
  def __repr__(self):
9942 
    L = ['%s=%r' % (key, value)
9943 
      for key, value in self.__dict__.iteritems()]
9944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9945 
 
9946 
  def __eq__(self, other):
9947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9948 
 
9949 
  def __ne__(self, other):
9950 
    return not (self == other)
9951 
 
1220 chandransh 9952 
class batchOrders_args:
9953 
  """
9954 
  Attributes:
9955 
   - warehouseId
9956 
  """
9957 
 
9958 
  thrift_spec = (
9959 
    None, # 0
9960 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9961 
  )
9962 
 
9963 
  def __init__(self, warehouseId=None,):
9964 
    self.warehouseId = warehouseId
9965 
 
9966 
  def read(self, iprot):
9967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9969 
      return
9970 
    iprot.readStructBegin()
9971 
    while True:
9972 
      (fname, ftype, fid) = iprot.readFieldBegin()
9973 
      if ftype == TType.STOP:
9974 
        break
9975 
      if fid == 1:
9976 
        if ftype == TType.I64:
9977 
          self.warehouseId = iprot.readI64();
9978 
        else:
9979 
          iprot.skip(ftype)
9980 
      else:
9981 
        iprot.skip(ftype)
9982 
      iprot.readFieldEnd()
9983 
    iprot.readStructEnd()
9984 
 
9985 
  def write(self, oprot):
9986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9988 
      return
9989 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9990 
    if self.warehouseId is not None:
1220 chandransh 9991 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9992 
      oprot.writeI64(self.warehouseId)
9993 
      oprot.writeFieldEnd()
9994 
    oprot.writeFieldStop()
9995 
    oprot.writeStructEnd()
9996 
 
3431 rajveer 9997 
  def validate(self):
9998 
    return
9999 
 
10000 
 
1220 chandransh 10001 
  def __repr__(self):
10002 
    L = ['%s=%r' % (key, value)
10003 
      for key, value in self.__dict__.iteritems()]
10004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10005 
 
10006 
  def __eq__(self, other):
10007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10008 
 
10009 
  def __ne__(self, other):
10010 
    return not (self == other)
10011 
 
10012 
class batchOrders_result:
10013 
  """
10014 
  Attributes:
10015 
   - success
10016 
   - ex
10017 
  """
10018 
 
10019 
  thrift_spec = (
10020 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10021 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10022 
  )
10023 
 
10024 
  def __init__(self, success=None, ex=None,):
10025 
    self.success = success
10026 
    self.ex = ex
10027 
 
10028 
  def read(self, iprot):
10029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10031 
      return
10032 
    iprot.readStructBegin()
10033 
    while True:
10034 
      (fname, ftype, fid) = iprot.readFieldBegin()
10035 
      if ftype == TType.STOP:
10036 
        break
10037 
      if fid == 0:
10038 
        if ftype == TType.LIST:
10039 
          self.success = []
4801 anupam.sin 10040 
          (_etype143, _size140) = iprot.readListBegin()
10041 
          for _i144 in xrange(_size140):
10042 
            _elem145 = Order()
10043 
            _elem145.read(iprot)
10044 
            self.success.append(_elem145)
1220 chandransh 10045 
          iprot.readListEnd()
10046 
        else:
10047 
          iprot.skip(ftype)
10048 
      elif fid == 1:
10049 
        if ftype == TType.STRUCT:
10050 
          self.ex = TransactionServiceException()
10051 
          self.ex.read(iprot)
10052 
        else:
10053 
          iprot.skip(ftype)
10054 
      else:
10055 
        iprot.skip(ftype)
10056 
      iprot.readFieldEnd()
10057 
    iprot.readStructEnd()
10058 
 
10059 
  def write(self, oprot):
10060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10062 
      return
10063 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 10064 
    if self.success is not None:
1220 chandransh 10065 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10066 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 10067 
      for iter146 in self.success:
10068 
        iter146.write(oprot)
1220 chandransh 10069 
      oprot.writeListEnd()
10070 
      oprot.writeFieldEnd()
3431 rajveer 10071 
    if self.ex is not None:
1220 chandransh 10072 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10073 
      self.ex.write(oprot)
10074 
      oprot.writeFieldEnd()
10075 
    oprot.writeFieldStop()
10076 
    oprot.writeStructEnd()
10077 
 
3431 rajveer 10078 
  def validate(self):
10079 
    return
10080 
 
10081 
 
1220 chandransh 10082 
  def __repr__(self):
10083 
    L = ['%s=%r' % (key, value)
10084 
      for key, value in self.__dict__.iteritems()]
10085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10086 
 
10087 
  def __eq__(self, other):
10088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10089 
 
10090 
  def __ne__(self, other):
10091 
    return not (self == other)
10092 
 
1208 chandransh 10093 
class markOrderAsOutOfStock_args:
10094 
  """
10095 
  Attributes:
10096 
   - orderId
10097 
  """
10098 
 
10099 
  thrift_spec = (
10100 
    None, # 0
10101 
    (1, TType.I64, 'orderId', None, None, ), # 1
10102 
  )
10103 
 
10104 
  def __init__(self, orderId=None,):
10105 
    self.orderId = orderId
10106 
 
10107 
  def read(self, iprot):
10108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10110 
      return
10111 
    iprot.readStructBegin()
10112 
    while True:
10113 
      (fname, ftype, fid) = iprot.readFieldBegin()
10114 
      if ftype == TType.STOP:
10115 
        break
10116 
      if fid == 1:
10117 
        if ftype == TType.I64:
10118 
          self.orderId = iprot.readI64();
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('markOrderAsOutOfStock_args')
3431 rajveer 10131 
    if self.orderId is not None:
1208 chandransh 10132 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10133 
      oprot.writeI64(self.orderId)
10134 
      oprot.writeFieldEnd()
10135 
    oprot.writeFieldStop()
10136 
    oprot.writeStructEnd()
10137 
 
3431 rajveer 10138 
  def validate(self):
10139 
    return
10140 
 
10141 
 
1208 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 
 
10153 
class markOrderAsOutOfStock_result:
10154 
  """
10155 
  Attributes:
10156 
   - success
10157 
   - ex
10158 
  """
10159 
 
10160 
  thrift_spec = (
10161 
    (0, TType.BOOL, 'success', None, None, ), # 0
10162 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10163 
  )
10164 
 
10165 
  def __init__(self, success=None, ex=None,):
10166 
    self.success = success
10167 
    self.ex = ex
10168 
 
10169 
  def read(self, iprot):
10170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10172 
      return
10173 
    iprot.readStructBegin()
10174 
    while True:
10175 
      (fname, ftype, fid) = iprot.readFieldBegin()
10176 
      if ftype == TType.STOP:
10177 
        break
10178 
      if fid == 0:
10179 
        if ftype == TType.BOOL:
10180 
          self.success = iprot.readBool();
10181 
        else:
10182 
          iprot.skip(ftype)
10183 
      elif fid == 1:
10184 
        if ftype == TType.STRUCT:
10185 
          self.ex = TransactionServiceException()
10186 
          self.ex.read(iprot)
10187 
        else:
10188 
          iprot.skip(ftype)
10189 
      else:
10190 
        iprot.skip(ftype)
10191 
      iprot.readFieldEnd()
10192 
    iprot.readStructEnd()
10193 
 
10194 
  def write(self, oprot):
10195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10197 
      return
10198 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 10199 
    if self.success is not None:
1208 chandransh 10200 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10201 
      oprot.writeBool(self.success)
10202 
      oprot.writeFieldEnd()
3431 rajveer 10203 
    if self.ex is not None:
1208 chandransh 10204 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10205 
      self.ex.write(oprot)
10206 
      oprot.writeFieldEnd()
10207 
    oprot.writeFieldStop()
10208 
    oprot.writeStructEnd()
10209 
 
3431 rajveer 10210 
  def validate(self):
10211 
    return
10212 
 
10213 
 
1208 chandransh 10214 
  def __repr__(self):
10215 
    L = ['%s=%r' % (key, value)
10216 
      for key, value in self.__dict__.iteritems()]
10217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10218 
 
10219 
  def __eq__(self, other):
10220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10221 
 
10222 
  def __ne__(self, other):
10223 
    return not (self == other)
10224 
 
3064 chandransh 10225 
class verifyOrder_args:
759 chandransh 10226 
  """
10227 
  Attributes:
3064 chandransh 10228 
   - orderId
759 chandransh 10229 
  """
10230 
 
10231 
  thrift_spec = (
10232 
    None, # 0
3064 chandransh 10233 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 10234 
  )
10235 
 
3064 chandransh 10236 
  def __init__(self, orderId=None,):
10237 
    self.orderId = orderId
759 chandransh 10238 
 
10239 
  def read(self, iprot):
10240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10242 
      return
10243 
    iprot.readStructBegin()
10244 
    while True:
10245 
      (fname, ftype, fid) = iprot.readFieldBegin()
10246 
      if ftype == TType.STOP:
10247 
        break
10248 
      if fid == 1:
10249 
        if ftype == TType.I64:
3064 chandransh 10250 
          self.orderId = iprot.readI64();
759 chandransh 10251 
        else:
10252 
          iprot.skip(ftype)
10253 
      else:
10254 
        iprot.skip(ftype)
10255 
      iprot.readFieldEnd()
10256 
    iprot.readStructEnd()
10257 
 
10258 
  def write(self, oprot):
10259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10261 
      return
3064 chandransh 10262 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 10263 
    if self.orderId is not None:
3064 chandransh 10264 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10265 
      oprot.writeI64(self.orderId)
759 chandransh 10266 
      oprot.writeFieldEnd()
10267 
    oprot.writeFieldStop()
10268 
    oprot.writeStructEnd()
10269 
 
3431 rajveer 10270 
  def validate(self):
10271 
    return
10272 
 
10273 
 
759 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)
10284 
 
3064 chandransh 10285 
class verifyOrder_result:
759 chandransh 10286 
  """
10287 
  Attributes:
10288 
   - success
10289 
   - ex
10290 
  """
10291 
 
10292 
  thrift_spec = (
10293 
    (0, TType.BOOL, 'success', None, None, ), # 0
10294 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10295 
  )
10296 
 
10297 
  def __init__(self, success=None, ex=None,):
10298 
    self.success = success
10299 
    self.ex = ex
10300 
 
10301 
  def read(self, iprot):
10302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10304 
      return
10305 
    iprot.readStructBegin()
10306 
    while True:
10307 
      (fname, ftype, fid) = iprot.readFieldBegin()
10308 
      if ftype == TType.STOP:
10309 
        break
10310 
      if fid == 0:
10311 
        if ftype == TType.BOOL:
10312 
          self.success = iprot.readBool();
10313 
        else:
10314 
          iprot.skip(ftype)
10315 
      elif fid == 1:
10316 
        if ftype == TType.STRUCT:
10317 
          self.ex = TransactionServiceException()
10318 
          self.ex.read(iprot)
10319 
        else:
10320 
          iprot.skip(ftype)
10321 
      else:
10322 
        iprot.skip(ftype)
10323 
      iprot.readFieldEnd()
10324 
    iprot.readStructEnd()
10325 
 
10326 
  def write(self, oprot):
10327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10329 
      return
3064 chandransh 10330 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 10331 
    if self.success is not None:
759 chandransh 10332 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10333 
      oprot.writeBool(self.success)
10334 
      oprot.writeFieldEnd()
3431 rajveer 10335 
    if self.ex is not None:
759 chandransh 10336 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10337 
      self.ex.write(oprot)
10338 
      oprot.writeFieldEnd()
10339 
    oprot.writeFieldStop()
10340 
    oprot.writeStructEnd()
10341 
 
3431 rajveer 10342 
  def validate(self):
10343 
    return
10344 
 
10345 
 
759 chandransh 10346 
  def __repr__(self):
10347 
    L = ['%s=%r' % (key, value)
10348 
      for key, value in self.__dict__.iteritems()]
10349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10350 
 
10351 
  def __eq__(self, other):
10352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10353 
 
10354 
  def __ne__(self, other):
10355 
    return not (self == other)
10356 
 
3064 chandransh 10357 
class acceptOrder_args:
1113 chandransh 10358 
  """
10359 
  Attributes:
3064 chandransh 10360 
   - orderId
1113 chandransh 10361 
  """
10362 
 
10363 
  thrift_spec = (
10364 
    None, # 0
3064 chandransh 10365 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 10366 
  )
10367 
 
3064 chandransh 10368 
  def __init__(self, orderId=None,):
10369 
    self.orderId = orderId
1113 chandransh 10370 
 
10371 
  def read(self, iprot):
10372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10374 
      return
10375 
    iprot.readStructBegin()
10376 
    while True:
10377 
      (fname, ftype, fid) = iprot.readFieldBegin()
10378 
      if ftype == TType.STOP:
10379 
        break
10380 
      if fid == 1:
10381 
        if ftype == TType.I64:
3064 chandransh 10382 
          self.orderId = iprot.readI64();
1113 chandransh 10383 
        else:
10384 
          iprot.skip(ftype)
10385 
      else:
10386 
        iprot.skip(ftype)
10387 
      iprot.readFieldEnd()
10388 
    iprot.readStructEnd()
10389 
 
10390 
  def write(self, oprot):
10391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10393 
      return
3064 chandransh 10394 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 10395 
    if self.orderId is not None:
3064 chandransh 10396 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10397 
      oprot.writeI64(self.orderId)
1113 chandransh 10398 
      oprot.writeFieldEnd()
10399 
    oprot.writeFieldStop()
10400 
    oprot.writeStructEnd()
10401 
 
3431 rajveer 10402 
  def validate(self):
10403 
    return
10404 
 
10405 
 
1113 chandransh 10406 
  def __repr__(self):
10407 
    L = ['%s=%r' % (key, value)
10408 
      for key, value in self.__dict__.iteritems()]
10409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10410 
 
10411 
  def __eq__(self, other):
10412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10413 
 
10414 
  def __ne__(self, other):
10415 
    return not (self == other)
10416 
 
3064 chandransh 10417 
class acceptOrder_result:
1113 chandransh 10418 
  """
10419 
  Attributes:
10420 
   - success
10421 
   - ex
10422 
  """
10423 
 
10424 
  thrift_spec = (
3064 chandransh 10425 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 10426 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10427 
  )
10428 
 
10429 
  def __init__(self, success=None, ex=None,):
10430 
    self.success = success
10431 
    self.ex = ex
10432 
 
10433 
  def read(self, iprot):
10434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10436 
      return
10437 
    iprot.readStructBegin()
10438 
    while True:
10439 
      (fname, ftype, fid) = iprot.readFieldBegin()
10440 
      if ftype == TType.STOP:
10441 
        break
10442 
      if fid == 0:
3064 chandransh 10443 
        if ftype == TType.BOOL:
10444 
          self.success = iprot.readBool();
1113 chandransh 10445 
        else:
10446 
          iprot.skip(ftype)
10447 
      elif fid == 1:
10448 
        if ftype == TType.STRUCT:
10449 
          self.ex = TransactionServiceException()
10450 
          self.ex.read(iprot)
10451 
        else:
10452 
          iprot.skip(ftype)
10453 
      else:
10454 
        iprot.skip(ftype)
10455 
      iprot.readFieldEnd()
10456 
    iprot.readStructEnd()
10457 
 
10458 
  def write(self, oprot):
10459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10461 
      return
3064 chandransh 10462 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 10463 
    if self.success is not None:
3064 chandransh 10464 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10465 
      oprot.writeBool(self.success)
1113 chandransh 10466 
      oprot.writeFieldEnd()
3431 rajveer 10467 
    if self.ex is not None:
1113 chandransh 10468 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10469 
      self.ex.write(oprot)
10470 
      oprot.writeFieldEnd()
10471 
    oprot.writeFieldStop()
10472 
    oprot.writeStructEnd()
10473 
 
3431 rajveer 10474 
  def validate(self):
10475 
    return
10476 
 
10477 
 
1113 chandransh 10478 
  def __repr__(self):
10479 
    L = ['%s=%r' % (key, value)
10480 
      for key, value in self.__dict__.iteritems()]
10481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10482 
 
10483 
  def __eq__(self, other):
10484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10485 
 
10486 
  def __ne__(self, other):
10487 
    return not (self == other)
10488 
 
3064 chandransh 10489 
class addBillingDetails_args:
1135 chandransh 10490 
  """
10491 
  Attributes:
3064 chandransh 10492 
   - orderId
10493 
   - invoice_number
4658 mandeep.dh 10494 
   - serialNumber
4283 anupam.sin 10495 
   - itemNumber
3064 chandransh 10496 
   - billed_by
4264 rajveer 10497 
   - jacketNumber
4283 anupam.sin 10498 
   - billingType
10499 
   - vendorId
4763 rajveer 10500 
   - authorize
1135 chandransh 10501 
  """
10502 
 
10503 
  thrift_spec = (
10504 
    None, # 0
3064 chandransh 10505 
    (1, TType.I64, 'orderId', None, None, ), # 1
10506 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 10507 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 10508 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10509 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10510 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10511 
    (7, TType.I64, 'billingType', None, None, ), # 7
10512 
    (8, TType.I64, 'vendorId', None, None, ), # 8
4763 rajveer 10513 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 10514 
  )
10515 
 
4763 rajveer 10516 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None, authorize=None,):
3064 chandransh 10517 
    self.orderId = orderId
10518 
    self.invoice_number = invoice_number
4658 mandeep.dh 10519 
    self.serialNumber = serialNumber
4283 anupam.sin 10520 
    self.itemNumber = itemNumber
3064 chandransh 10521 
    self.billed_by = billed_by
4264 rajveer 10522 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10523 
    self.billingType = billingType
10524 
    self.vendorId = vendorId
4763 rajveer 10525 
    self.authorize = authorize
1135 chandransh 10526 
 
10527 
  def read(self, iprot):
10528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10530 
      return
10531 
    iprot.readStructBegin()
10532 
    while True:
10533 
      (fname, ftype, fid) = iprot.readFieldBegin()
10534 
      if ftype == TType.STOP:
10535 
        break
10536 
      if fid == 1:
10537 
        if ftype == TType.I64:
3064 chandransh 10538 
          self.orderId = iprot.readI64();
1135 chandransh 10539 
        else:
10540 
          iprot.skip(ftype)
10541 
      elif fid == 2:
3064 chandransh 10542 
        if ftype == TType.STRING:
10543 
          self.invoice_number = iprot.readString();
1135 chandransh 10544 
        else:
10545 
          iprot.skip(ftype)
3064 chandransh 10546 
      elif fid == 3:
4658 mandeep.dh 10547 
        if ftype == TType.STRING:
10548 
          self.serialNumber = iprot.readString();
3064 chandransh 10549 
        else:
10550 
          iprot.skip(ftype)
10551 
      elif fid == 4:
10552 
        if ftype == TType.STRING:
10553 
          self.itemNumber = iprot.readString();
10554 
        else:
10555 
          iprot.skip(ftype)
10556 
      elif fid == 5:
10557 
        if ftype == TType.STRING:
4283 anupam.sin 10558 
          self.billed_by = iprot.readString();
3064 chandransh 10559 
        else:
10560 
          iprot.skip(ftype)
10561 
      elif fid == 6:
10562 
        if ftype == TType.I64:
4283 anupam.sin 10563 
          self.jacketNumber = iprot.readI64();
10564 
        else:
10565 
          iprot.skip(ftype)
10566 
      elif fid == 7:
10567 
        if ftype == TType.I64:
3064 chandransh 10568 
          self.billingType = iprot.readI64();
10569 
        else:
10570 
          iprot.skip(ftype)
4283 anupam.sin 10571 
      elif fid == 8:
10572 
        if ftype == TType.I64:
10573 
          self.vendorId = iprot.readI64();
10574 
        else:
10575 
          iprot.skip(ftype)
4763 rajveer 10576 
      elif fid == 9:
10577 
        if ftype == TType.BOOL:
10578 
          self.authorize = iprot.readBool();
10579 
        else:
10580 
          iprot.skip(ftype)
1246 chandransh 10581 
      else:
10582 
        iprot.skip(ftype)
10583 
      iprot.readFieldEnd()
10584 
    iprot.readStructEnd()
10585 
 
10586 
  def write(self, oprot):
10587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10589 
      return
4283 anupam.sin 10590 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 10591 
    if self.orderId is not None:
3064 chandransh 10592 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10593 
      oprot.writeI64(self.orderId)
1246 chandransh 10594 
      oprot.writeFieldEnd()
4283 anupam.sin 10595 
    if self.invoice_number is not None:
10596 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
10597 
      oprot.writeString(self.invoice_number)
1246 chandransh 10598 
      oprot.writeFieldEnd()
4658 mandeep.dh 10599 
    if self.serialNumber is not None:
10600 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
10601 
      oprot.writeString(self.serialNumber)
3064 chandransh 10602 
      oprot.writeFieldEnd()
3431 rajveer 10603 
    if self.itemNumber is not None:
3064 chandransh 10604 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
10605 
      oprot.writeString(self.itemNumber)
10606 
      oprot.writeFieldEnd()
4283 anupam.sin 10607 
    if self.billed_by is not None:
10608 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
10609 
      oprot.writeString(self.billed_by)
3064 chandransh 10610 
      oprot.writeFieldEnd()
4283 anupam.sin 10611 
    if self.jacketNumber is not None:
10612 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
10613 
      oprot.writeI64(self.jacketNumber)
10614 
      oprot.writeFieldEnd()
3431 rajveer 10615 
    if self.billingType is not None:
4283 anupam.sin 10616 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 10617 
      oprot.writeI64(self.billingType)
10618 
      oprot.writeFieldEnd()
4283 anupam.sin 10619 
    if self.vendorId is not None:
10620 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
10621 
      oprot.writeI64(self.vendorId)
10622 
      oprot.writeFieldEnd()
4763 rajveer 10623 
    if self.authorize is not None:
10624 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
10625 
      oprot.writeBool(self.authorize)
10626 
      oprot.writeFieldEnd()
1246 chandransh 10627 
    oprot.writeFieldStop()
10628 
    oprot.writeStructEnd()
10629 
 
3431 rajveer 10630 
  def validate(self):
10631 
    return
10632 
 
10633 
 
1246 chandransh 10634 
  def __repr__(self):
10635 
    L = ['%s=%r' % (key, value)
10636 
      for key, value in self.__dict__.iteritems()]
10637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10638 
 
10639 
  def __eq__(self, other):
10640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10641 
 
10642 
  def __ne__(self, other):
10643 
    return not (self == other)
10644 
 
4283 anupam.sin 10645 
class addBillingDetails_result:
1246 chandransh 10646 
  """
10647 
  Attributes:
3064 chandransh 10648 
   - success
1246 chandransh 10649 
   - ex
10650 
  """
10651 
 
10652 
  thrift_spec = (
3064 chandransh 10653 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 10654 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10655 
  )
10656 
 
3064 chandransh 10657 
  def __init__(self, success=None, ex=None,):
10658 
    self.success = success
1246 chandransh 10659 
    self.ex = ex
10660 
 
10661 
  def read(self, iprot):
10662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10664 
      return
10665 
    iprot.readStructBegin()
10666 
    while True:
10667 
      (fname, ftype, fid) = iprot.readFieldBegin()
10668 
      if ftype == TType.STOP:
10669 
        break
3064 chandransh 10670 
      if fid == 0:
10671 
        if ftype == TType.BOOL:
10672 
          self.success = iprot.readBool();
10673 
        else:
10674 
          iprot.skip(ftype)
10675 
      elif fid == 1:
1246 chandransh 10676 
        if ftype == TType.STRUCT:
10677 
          self.ex = TransactionServiceException()
10678 
          self.ex.read(iprot)
10679 
        else:
10680 
          iprot.skip(ftype)
10681 
      else:
10682 
        iprot.skip(ftype)
10683 
      iprot.readFieldEnd()
10684 
    iprot.readStructEnd()
10685 
 
10686 
  def write(self, oprot):
10687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10689 
      return
4283 anupam.sin 10690 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 10691 
    if self.success is not None:
3064 chandransh 10692 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10693 
      oprot.writeBool(self.success)
10694 
      oprot.writeFieldEnd()
3431 rajveer 10695 
    if self.ex is not None:
1246 chandransh 10696 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10697 
      self.ex.write(oprot)
10698 
      oprot.writeFieldEnd()
10699 
    oprot.writeFieldStop()
10700 
    oprot.writeStructEnd()
10701 
 
3431 rajveer 10702 
  def validate(self):
10703 
    return
10704 
 
10705 
 
1246 chandransh 10706 
  def __repr__(self):
10707 
    L = ['%s=%r' % (key, value)
10708 
      for key, value in self.__dict__.iteritems()]
10709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10710 
 
10711 
  def __eq__(self, other):
10712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10713 
 
10714 
  def __ne__(self, other):
10715 
    return not (self == other)
10716 
 
4579 rajveer 10717 
class addInvoiceNumber_args:
10718 
  """
10719 
  Attributes:
10720 
   - orderId
10721 
   - invoiceNumber
4763 rajveer 10722 
   - color
4579 rajveer 10723 
  """
10724 
 
10725 
  thrift_spec = (
10726 
    None, # 0
10727 
    (1, TType.I64, 'orderId', None, None, ), # 1
10728 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 10729 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 10730 
  )
10731 
 
4763 rajveer 10732 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 10733 
    self.orderId = orderId
10734 
    self.invoiceNumber = invoiceNumber
4763 rajveer 10735 
    self.color = color
4579 rajveer 10736 
 
10737 
  def read(self, iprot):
10738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10740 
      return
10741 
    iprot.readStructBegin()
10742 
    while True:
10743 
      (fname, ftype, fid) = iprot.readFieldBegin()
10744 
      if ftype == TType.STOP:
10745 
        break
10746 
      if fid == 1:
10747 
        if ftype == TType.I64:
10748 
          self.orderId = iprot.readI64();
10749 
        else:
10750 
          iprot.skip(ftype)
10751 
      elif fid == 2:
10752 
        if ftype == TType.STRING:
10753 
          self.invoiceNumber = iprot.readString();
10754 
        else:
10755 
          iprot.skip(ftype)
4763 rajveer 10756 
      elif fid == 3:
10757 
        if ftype == TType.STRING:
10758 
          self.color = iprot.readString();
10759 
        else:
10760 
          iprot.skip(ftype)
4579 rajveer 10761 
      else:
10762 
        iprot.skip(ftype)
10763 
      iprot.readFieldEnd()
10764 
    iprot.readStructEnd()
10765 
 
10766 
  def write(self, oprot):
10767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10769 
      return
10770 
    oprot.writeStructBegin('addInvoiceNumber_args')
10771 
    if self.orderId is not None:
10772 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10773 
      oprot.writeI64(self.orderId)
10774 
      oprot.writeFieldEnd()
10775 
    if self.invoiceNumber is not None:
10776 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
10777 
      oprot.writeString(self.invoiceNumber)
10778 
      oprot.writeFieldEnd()
4763 rajveer 10779 
    if self.color is not None:
10780 
      oprot.writeFieldBegin('color', TType.STRING, 3)
10781 
      oprot.writeString(self.color)
10782 
      oprot.writeFieldEnd()
4579 rajveer 10783 
    oprot.writeFieldStop()
10784 
    oprot.writeStructEnd()
10785 
 
10786 
  def validate(self):
10787 
    return
10788 
 
10789 
 
10790 
  def __repr__(self):
10791 
    L = ['%s=%r' % (key, value)
10792 
      for key, value in self.__dict__.iteritems()]
10793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10794 
 
10795 
  def __eq__(self, other):
10796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10797 
 
10798 
  def __ne__(self, other):
10799 
    return not (self == other)
10800 
 
10801 
class addInvoiceNumber_result:
10802 
  """
10803 
  Attributes:
10804 
   - ex
10805 
  """
10806 
 
10807 
  thrift_spec = (
10808 
    None, # 0
10809 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10810 
  )
10811 
 
10812 
  def __init__(self, ex=None,):
10813 
    self.ex = ex
10814 
 
10815 
  def read(self, iprot):
10816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10818 
      return
10819 
    iprot.readStructBegin()
10820 
    while True:
10821 
      (fname, ftype, fid) = iprot.readFieldBegin()
10822 
      if ftype == TType.STOP:
10823 
        break
10824 
      if fid == 1:
10825 
        if ftype == TType.STRUCT:
10826 
          self.ex = TransactionServiceException()
10827 
          self.ex.read(iprot)
10828 
        else:
10829 
          iprot.skip(ftype)
10830 
      else:
10831 
        iprot.skip(ftype)
10832 
      iprot.readFieldEnd()
10833 
    iprot.readStructEnd()
10834 
 
10835 
  def write(self, oprot):
10836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10838 
      return
10839 
    oprot.writeStructBegin('addInvoiceNumber_result')
10840 
    if self.ex is not None:
10841 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10842 
      self.ex.write(oprot)
10843 
      oprot.writeFieldEnd()
10844 
    oprot.writeFieldStop()
10845 
    oprot.writeStructEnd()
10846 
 
10847 
  def validate(self):
10848 
    return
10849 
 
10850 
 
10851 
  def __repr__(self):
10852 
    L = ['%s=%r' % (key, value)
10853 
      for key, value in self.__dict__.iteritems()]
10854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10855 
 
10856 
  def __eq__(self, other):
10857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10858 
 
10859 
  def __ne__(self, other):
10860 
    return not (self == other)
10861 
 
3064 chandransh 10862 
class markOrdersAsManifested_args:
1408 ankur.sing 10863 
  """
10864 
  Attributes:
3064 chandransh 10865 
   - warehouseId
1408 ankur.sing 10866 
   - providerId
3064 chandransh 10867 
   - cod
1408 ankur.sing 10868 
  """
10869 
 
10870 
  thrift_spec = (
10871 
    None, # 0
3064 chandransh 10872 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10873 
    (2, TType.I64, 'providerId', None, None, ), # 2
10874 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 10875 
  )
10876 
 
3064 chandransh 10877 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10878 
    self.warehouseId = warehouseId
1408 ankur.sing 10879 
    self.providerId = providerId
3064 chandransh 10880 
    self.cod = cod
1408 ankur.sing 10881 
 
10882 
  def read(self, iprot):
10883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10885 
      return
10886 
    iprot.readStructBegin()
10887 
    while True:
10888 
      (fname, ftype, fid) = iprot.readFieldBegin()
10889 
      if ftype == TType.STOP:
10890 
        break
10891 
      if fid == 1:
10892 
        if ftype == TType.I64:
3064 chandransh 10893 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 10894 
        else:
10895 
          iprot.skip(ftype)
10896 
      elif fid == 2:
10897 
        if ftype == TType.I64:
3064 chandransh 10898 
          self.providerId = iprot.readI64();
1408 ankur.sing 10899 
        else:
10900 
          iprot.skip(ftype)
3064 chandransh 10901 
      elif fid == 3:
10902 
        if ftype == TType.BOOL:
10903 
          self.cod = iprot.readBool();
10904 
        else:
10905 
          iprot.skip(ftype)
1408 ankur.sing 10906 
      else:
10907 
        iprot.skip(ftype)
10908 
      iprot.readFieldEnd()
10909 
    iprot.readStructEnd()
10910 
 
10911 
  def write(self, oprot):
10912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10914 
      return
3064 chandransh 10915 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 10916 
    if self.warehouseId is not None:
3064 chandransh 10917 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10918 
      oprot.writeI64(self.warehouseId)
10919 
      oprot.writeFieldEnd()
3431 rajveer 10920 
    if self.providerId is not None:
3064 chandransh 10921 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 10922 
      oprot.writeI64(self.providerId)
10923 
      oprot.writeFieldEnd()
3431 rajveer 10924 
    if self.cod is not None:
3064 chandransh 10925 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10926 
      oprot.writeBool(self.cod)
1408 ankur.sing 10927 
      oprot.writeFieldEnd()
10928 
    oprot.writeFieldStop()
10929 
    oprot.writeStructEnd()
10930 
 
3431 rajveer 10931 
  def validate(self):
10932 
    return
10933 
 
10934 
 
1408 ankur.sing 10935 
  def __repr__(self):
10936 
    L = ['%s=%r' % (key, value)
10937 
      for key, value in self.__dict__.iteritems()]
10938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10939 
 
10940 
  def __eq__(self, other):
10941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10942 
 
10943 
  def __ne__(self, other):
10944 
    return not (self == other)
10945 
 
3064 chandransh 10946 
class markOrdersAsManifested_result:
1408 ankur.sing 10947 
  """
10948 
  Attributes:
10949 
   - success
3064 chandransh 10950 
   - ex
1408 ankur.sing 10951 
  """
10952 
 
10953 
  thrift_spec = (
3064 chandransh 10954 
    (0, TType.BOOL, 'success', None, None, ), # 0
10955 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10956 
  )
10957 
 
3064 chandransh 10958 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10959 
    self.success = success
3064 chandransh 10960 
    self.ex = ex
1408 ankur.sing 10961 
 
10962 
  def read(self, iprot):
10963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10965 
      return
10966 
    iprot.readStructBegin()
10967 
    while True:
10968 
      (fname, ftype, fid) = iprot.readFieldBegin()
10969 
      if ftype == TType.STOP:
10970 
        break
10971 
      if fid == 0:
3064 chandransh 10972 
        if ftype == TType.BOOL:
10973 
          self.success = iprot.readBool();
1408 ankur.sing 10974 
        else:
10975 
          iprot.skip(ftype)
3064 chandransh 10976 
      elif fid == 1:
10977 
        if ftype == TType.STRUCT:
10978 
          self.ex = TransactionServiceException()
10979 
          self.ex.read(iprot)
10980 
        else:
10981 
          iprot.skip(ftype)
1408 ankur.sing 10982 
      else:
10983 
        iprot.skip(ftype)
10984 
      iprot.readFieldEnd()
10985 
    iprot.readStructEnd()
10986 
 
10987 
  def write(self, oprot):
10988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10990 
      return
3064 chandransh 10991 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10992 
    if self.success is not None:
3064 chandransh 10993 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10994 
      oprot.writeBool(self.success)
1408 ankur.sing 10995 
      oprot.writeFieldEnd()
3431 rajveer 10996 
    if self.ex is not None:
3064 chandransh 10997 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10998 
      self.ex.write(oprot)
10999 
      oprot.writeFieldEnd()
1408 ankur.sing 11000 
    oprot.writeFieldStop()
11001 
    oprot.writeStructEnd()
11002 
 
3431 rajveer 11003 
  def validate(self):
11004 
    return
11005 
 
11006 
 
1408 ankur.sing 11007 
  def __repr__(self):
11008 
    L = ['%s=%r' % (key, value)
11009 
      for key, value in self.__dict__.iteritems()]
11010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11011 
 
11012 
  def __eq__(self, other):
11013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11014 
 
11015 
  def __ne__(self, other):
11016 
    return not (self == other)
11017 
 
4410 rajveer 11018 
class markOrdersAsShippedFromWarehouse_args:
11019 
  """
11020 
  Attributes:
11021 
   - warehouseId
11022 
   - providerId
11023 
   - cod
4789 rajveer 11024 
   - orderIds
4410 rajveer 11025 
  """
11026 
 
11027 
  thrift_spec = (
11028 
    None, # 0
11029 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11030 
    (2, TType.I64, 'providerId', None, None, ), # 2
11031 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4789 rajveer 11032 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
4410 rajveer 11033 
  )
11034 
 
4789 rajveer 11035 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
4410 rajveer 11036 
    self.warehouseId = warehouseId
11037 
    self.providerId = providerId
11038 
    self.cod = cod
4789 rajveer 11039 
    self.orderIds = orderIds
4410 rajveer 11040 
 
11041 
  def read(self, iprot):
11042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11044 
      return
11045 
    iprot.readStructBegin()
11046 
    while True:
11047 
      (fname, ftype, fid) = iprot.readFieldBegin()
11048 
      if ftype == TType.STOP:
11049 
        break
11050 
      if fid == 1:
11051 
        if ftype == TType.I64:
11052 
          self.warehouseId = iprot.readI64();
11053 
        else:
11054 
          iprot.skip(ftype)
11055 
      elif fid == 2:
11056 
        if ftype == TType.I64:
11057 
          self.providerId = iprot.readI64();
11058 
        else:
11059 
          iprot.skip(ftype)
11060 
      elif fid == 3:
11061 
        if ftype == TType.BOOL:
11062 
          self.cod = iprot.readBool();
11063 
        else:
11064 
          iprot.skip(ftype)
4789 rajveer 11065 
      elif fid == 4:
11066 
        if ftype == TType.LIST:
11067 
          self.orderIds = []
4801 anupam.sin 11068 
          (_etype150, _size147) = iprot.readListBegin()
11069 
          for _i151 in xrange(_size147):
11070 
            _elem152 = iprot.readI64();
11071 
            self.orderIds.append(_elem152)
4789 rajveer 11072 
          iprot.readListEnd()
11073 
        else:
11074 
          iprot.skip(ftype)
4410 rajveer 11075 
      else:
11076 
        iprot.skip(ftype)
11077 
      iprot.readFieldEnd()
11078 
    iprot.readStructEnd()
11079 
 
11080 
  def write(self, oprot):
11081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11083 
      return
11084 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
11085 
    if self.warehouseId is not None:
11086 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11087 
      oprot.writeI64(self.warehouseId)
11088 
      oprot.writeFieldEnd()
11089 
    if self.providerId is not None:
11090 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
11091 
      oprot.writeI64(self.providerId)
11092 
      oprot.writeFieldEnd()
11093 
    if self.cod is not None:
11094 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11095 
      oprot.writeBool(self.cod)
11096 
      oprot.writeFieldEnd()
4789 rajveer 11097 
    if self.orderIds is not None:
11098 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
11099 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
4801 anupam.sin 11100 
      for iter153 in self.orderIds:
11101 
        oprot.writeI64(iter153)
4789 rajveer 11102 
      oprot.writeListEnd()
11103 
      oprot.writeFieldEnd()
4410 rajveer 11104 
    oprot.writeFieldStop()
11105 
    oprot.writeStructEnd()
11106 
 
11107 
  def validate(self):
11108 
    return
11109 
 
11110 
 
11111 
  def __repr__(self):
11112 
    L = ['%s=%r' % (key, value)
11113 
      for key, value in self.__dict__.iteritems()]
11114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11115 
 
11116 
  def __eq__(self, other):
11117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11118 
 
11119 
  def __ne__(self, other):
11120 
    return not (self == other)
11121 
 
11122 
class markOrdersAsShippedFromWarehouse_result:
11123 
  """
11124 
  Attributes:
11125 
   - success
11126 
   - ex
11127 
  """
11128 
 
11129 
  thrift_spec = (
11130 
    (0, TType.BOOL, 'success', None, None, ), # 0
11131 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11132 
  )
11133 
 
11134 
  def __init__(self, success=None, ex=None,):
11135 
    self.success = success
11136 
    self.ex = ex
11137 
 
11138 
  def read(self, iprot):
11139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11141 
      return
11142 
    iprot.readStructBegin()
11143 
    while True:
11144 
      (fname, ftype, fid) = iprot.readFieldBegin()
11145 
      if ftype == TType.STOP:
11146 
        break
11147 
      if fid == 0:
11148 
        if ftype == TType.BOOL:
11149 
          self.success = iprot.readBool();
11150 
        else:
11151 
          iprot.skip(ftype)
11152 
      elif fid == 1:
11153 
        if ftype == TType.STRUCT:
11154 
          self.ex = TransactionServiceException()
11155 
          self.ex.read(iprot)
11156 
        else:
11157 
          iprot.skip(ftype)
11158 
      else:
11159 
        iprot.skip(ftype)
11160 
      iprot.readFieldEnd()
11161 
    iprot.readStructEnd()
11162 
 
11163 
  def write(self, oprot):
11164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11166 
      return
11167 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
11168 
    if self.success is not None:
11169 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11170 
      oprot.writeBool(self.success)
11171 
      oprot.writeFieldEnd()
11172 
    if self.ex is not None:
11173 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11174 
      self.ex.write(oprot)
11175 
      oprot.writeFieldEnd()
11176 
    oprot.writeFieldStop()
11177 
    oprot.writeStructEnd()
11178 
 
11179 
  def validate(self):
11180 
    return
11181 
 
11182 
 
11183 
  def __repr__(self):
11184 
    L = ['%s=%r' % (key, value)
11185 
      for key, value in self.__dict__.iteritems()]
11186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11187 
 
11188 
  def __eq__(self, other):
11189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11190 
 
11191 
  def __ne__(self, other):
11192 
    return not (self == other)
11193 
 
3064 chandransh 11194 
class markOrdersAsPickedUp_args:
304 ashish 11195 
  """
11196 
  Attributes:
3064 chandransh 11197 
   - providerId
11198 
   - pickupDetails
304 ashish 11199 
  """
94 ashish 11200 
 
304 ashish 11201 
  thrift_spec = (
11202 
    None, # 0
3064 chandransh 11203 
    (1, TType.I64, 'providerId', None, None, ), # 1
11204 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11205 
  )
11206 
 
3064 chandransh 11207 
  def __init__(self, providerId=None, pickupDetails=None,):
11208 
    self.providerId = providerId
11209 
    self.pickupDetails = pickupDetails
304 ashish 11210 
 
11211 
  def read(self, iprot):
11212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11214 
      return
11215 
    iprot.readStructBegin()
11216 
    while True:
11217 
      (fname, ftype, fid) = iprot.readFieldBegin()
11218 
      if ftype == TType.STOP:
11219 
        break
11220 
      if fid == 1:
11221 
        if ftype == TType.I64:
3064 chandransh 11222 
          self.providerId = iprot.readI64();
304 ashish 11223 
        else:
11224 
          iprot.skip(ftype)
11225 
      elif fid == 2:
3064 chandransh 11226 
        if ftype == TType.MAP:
11227 
          self.pickupDetails = {}
4801 anupam.sin 11228 
          (_ktype155, _vtype156, _size154 ) = iprot.readMapBegin()
11229 
          for _i158 in xrange(_size154):
11230 
            _key159 = iprot.readString();
11231 
            _val160 = iprot.readString();
11232 
            self.pickupDetails[_key159] = _val160
3064 chandransh 11233 
          iprot.readMapEnd()
304 ashish 11234 
        else:
11235 
          iprot.skip(ftype)
11236 
      else:
11237 
        iprot.skip(ftype)
11238 
      iprot.readFieldEnd()
11239 
    iprot.readStructEnd()
11240 
 
11241 
  def write(self, oprot):
11242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11244 
      return
3064 chandransh 11245 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 11246 
    if self.providerId is not None:
3064 chandransh 11247 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11248 
      oprot.writeI64(self.providerId)
304 ashish 11249 
      oprot.writeFieldEnd()
3431 rajveer 11250 
    if self.pickupDetails is not None:
3064 chandransh 11251 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11252 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4801 anupam.sin 11253 
      for kiter161,viter162 in self.pickupDetails.items():
11254 
        oprot.writeString(kiter161)
11255 
        oprot.writeString(viter162)
3064 chandransh 11256 
      oprot.writeMapEnd()
304 ashish 11257 
      oprot.writeFieldEnd()
11258 
    oprot.writeFieldStop()
11259 
    oprot.writeStructEnd()
11260 
 
3431 rajveer 11261 
  def validate(self):
11262 
    return
11263 
 
11264 
 
304 ashish 11265 
  def __repr__(self):
11266 
    L = ['%s=%r' % (key, value)
11267 
      for key, value in self.__dict__.iteritems()]
11268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11269 
 
11270 
  def __eq__(self, other):
11271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11272 
 
11273 
  def __ne__(self, other):
11274 
    return not (self == other)
11275 
 
3064 chandransh 11276 
class markOrdersAsPickedUp_result:
304 ashish 11277 
  """
11278 
  Attributes:
11279 
   - success
3064 chandransh 11280 
   - ex
304 ashish 11281 
  """
11282 
 
11283 
  thrift_spec = (
3064 chandransh 11284 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11285 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11286 
  )
11287 
 
3064 chandransh 11288 
  def __init__(self, success=None, ex=None,):
304 ashish 11289 
    self.success = success
3064 chandransh 11290 
    self.ex = ex
304 ashish 11291 
 
11292 
  def read(self, iprot):
11293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11295 
      return
11296 
    iprot.readStructBegin()
11297 
    while True:
11298 
      (fname, ftype, fid) = iprot.readFieldBegin()
11299 
      if ftype == TType.STOP:
11300 
        break
11301 
      if fid == 0:
11302 
        if ftype == TType.LIST:
11303 
          self.success = []
4801 anupam.sin 11304 
          (_etype166, _size163) = iprot.readListBegin()
11305 
          for _i167 in xrange(_size163):
11306 
            _elem168 = Order()
11307 
            _elem168.read(iprot)
11308 
            self.success.append(_elem168)
304 ashish 11309 
          iprot.readListEnd()
11310 
        else:
11311 
          iprot.skip(ftype)
3064 chandransh 11312 
      elif fid == 1:
11313 
        if ftype == TType.STRUCT:
11314 
          self.ex = TransactionServiceException()
11315 
          self.ex.read(iprot)
11316 
        else:
11317 
          iprot.skip(ftype)
304 ashish 11318 
      else:
11319 
        iprot.skip(ftype)
11320 
      iprot.readFieldEnd()
11321 
    iprot.readStructEnd()
11322 
 
11323 
  def write(self, oprot):
11324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11326 
      return
3064 chandransh 11327 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 11328 
    if self.success is not None:
304 ashish 11329 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11330 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 11331 
      for iter169 in self.success:
11332 
        iter169.write(oprot)
304 ashish 11333 
      oprot.writeListEnd()
11334 
      oprot.writeFieldEnd()
3431 rajveer 11335 
    if self.ex is not None:
3064 chandransh 11336 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11337 
      self.ex.write(oprot)
11338 
      oprot.writeFieldEnd()
304 ashish 11339 
    oprot.writeFieldStop()
11340 
    oprot.writeStructEnd()
11341 
 
3431 rajveer 11342 
  def validate(self):
11343 
    return
11344 
 
11345 
 
304 ashish 11346 
  def __repr__(self):
11347 
    L = ['%s=%r' % (key, value)
11348 
      for key, value in self.__dict__.iteritems()]
11349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11350 
 
11351 
  def __eq__(self, other):
11352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11353 
 
11354 
  def __ne__(self, other):
11355 
    return not (self == other)
11356 
 
3064 chandransh 11357 
class markOrdersAsDelivered_args:
304 ashish 11358 
  """
11359 
  Attributes:
3064 chandransh 11360 
   - providerId
11361 
   - deliveredOrders
304 ashish 11362 
  """
11363 
 
11364 
  thrift_spec = (
11365 
    None, # 0
3064 chandransh 11366 
    (1, TType.I64, 'providerId', None, None, ), # 1
11367 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11368 
  )
11369 
 
3064 chandransh 11370 
  def __init__(self, providerId=None, deliveredOrders=None,):
11371 
    self.providerId = providerId
11372 
    self.deliveredOrders = deliveredOrders
304 ashish 11373 
 
11374 
  def read(self, iprot):
11375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11377 
      return
11378 
    iprot.readStructBegin()
11379 
    while True:
11380 
      (fname, ftype, fid) = iprot.readFieldBegin()
11381 
      if ftype == TType.STOP:
11382 
        break
11383 
      if fid == 1:
11384 
        if ftype == TType.I64:
3064 chandransh 11385 
          self.providerId = iprot.readI64();
304 ashish 11386 
        else:
11387 
          iprot.skip(ftype)
11388 
      elif fid == 2:
3064 chandransh 11389 
        if ftype == TType.MAP:
11390 
          self.deliveredOrders = {}
4801 anupam.sin 11391 
          (_ktype171, _vtype172, _size170 ) = iprot.readMapBegin()
11392 
          for _i174 in xrange(_size170):
11393 
            _key175 = iprot.readString();
11394 
            _val176 = iprot.readString();
11395 
            self.deliveredOrders[_key175] = _val176
3064 chandransh 11396 
          iprot.readMapEnd()
304 ashish 11397 
        else:
11398 
          iprot.skip(ftype)
11399 
      else:
11400 
        iprot.skip(ftype)
11401 
      iprot.readFieldEnd()
11402 
    iprot.readStructEnd()
11403 
 
11404 
  def write(self, oprot):
11405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11407 
      return
3064 chandransh 11408 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 11409 
    if self.providerId is not None:
3064 chandransh 11410 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11411 
      oprot.writeI64(self.providerId)
304 ashish 11412 
      oprot.writeFieldEnd()
3431 rajveer 11413 
    if self.deliveredOrders is not None:
3064 chandransh 11414 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
11415 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4801 anupam.sin 11416 
      for kiter177,viter178 in self.deliveredOrders.items():
11417 
        oprot.writeString(kiter177)
11418 
        oprot.writeString(viter178)
3064 chandransh 11419 
      oprot.writeMapEnd()
304 ashish 11420 
      oprot.writeFieldEnd()
11421 
    oprot.writeFieldStop()
11422 
    oprot.writeStructEnd()
11423 
 
3431 rajveer 11424 
  def validate(self):
11425 
    return
11426 
 
11427 
 
304 ashish 11428 
  def __repr__(self):
11429 
    L = ['%s=%r' % (key, value)
11430 
      for key, value in self.__dict__.iteritems()]
11431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11432 
 
11433 
  def __eq__(self, other):
11434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11435 
 
11436 
  def __ne__(self, other):
11437 
    return not (self == other)
11438 
 
3064 chandransh 11439 
class markOrdersAsDelivered_result:
11440 
  """
11441 
  Attributes:
11442 
   - ex
11443 
  """
304 ashish 11444 
 
11445 
  thrift_spec = (
3064 chandransh 11446 
    None, # 0
11447 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11448 
  )
11449 
 
3064 chandransh 11450 
  def __init__(self, ex=None,):
11451 
    self.ex = ex
304 ashish 11452 
 
1596 ankur.sing 11453 
  def read(self, iprot):
11454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11456 
      return
11457 
    iprot.readStructBegin()
11458 
    while True:
11459 
      (fname, ftype, fid) = iprot.readFieldBegin()
11460 
      if ftype == TType.STOP:
11461 
        break
3064 chandransh 11462 
      if fid == 1:
11463 
        if ftype == TType.STRUCT:
11464 
          self.ex = TransactionServiceException()
11465 
          self.ex.read(iprot)
11466 
        else:
11467 
          iprot.skip(ftype)
1596 ankur.sing 11468 
      else:
11469 
        iprot.skip(ftype)
11470 
      iprot.readFieldEnd()
11471 
    iprot.readStructEnd()
11472 
 
11473 
  def write(self, oprot):
11474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11476 
      return
3064 chandransh 11477 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 11478 
    if self.ex is not None:
3064 chandransh 11479 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11480 
      self.ex.write(oprot)
11481 
      oprot.writeFieldEnd()
1596 ankur.sing 11482 
    oprot.writeFieldStop()
11483 
    oprot.writeStructEnd()
11484 
 
3431 rajveer 11485 
  def validate(self):
11486 
    return
11487 
 
11488 
 
1596 ankur.sing 11489 
  def __repr__(self):
11490 
    L = ['%s=%r' % (key, value)
11491 
      for key, value in self.__dict__.iteritems()]
11492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11493 
 
11494 
  def __eq__(self, other):
11495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11496 
 
11497 
  def __ne__(self, other):
11498 
    return not (self == other)
11499 
 
3064 chandransh 11500 
class markOrdersAsFailed_args:
1596 ankur.sing 11501 
  """
11502 
  Attributes:
3064 chandransh 11503 
   - providerId
11504 
   - returnedOrders
1596 ankur.sing 11505 
  """
11506 
 
11507 
  thrift_spec = (
3064 chandransh 11508 
    None, # 0
11509 
    (1, TType.I64, 'providerId', None, None, ), # 1
11510 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 11511 
  )
11512 
 
3064 chandransh 11513 
  def __init__(self, providerId=None, returnedOrders=None,):
11514 
    self.providerId = providerId
11515 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11516 
 
11517 
  def read(self, iprot):
11518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11520 
      return
11521 
    iprot.readStructBegin()
11522 
    while True:
11523 
      (fname, ftype, fid) = iprot.readFieldBegin()
11524 
      if ftype == TType.STOP:
11525 
        break
3064 chandransh 11526 
      if fid == 1:
1596 ankur.sing 11527 
        if ftype == TType.I64:
3064 chandransh 11528 
          self.providerId = iprot.readI64();
1596 ankur.sing 11529 
        else:
11530 
          iprot.skip(ftype)
3064 chandransh 11531 
      elif fid == 2:
11532 
        if ftype == TType.MAP:
11533 
          self.returnedOrders = {}
4801 anupam.sin 11534 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
11535 
          for _i183 in xrange(_size179):
11536 
            _key184 = iprot.readString();
11537 
            _val185 = iprot.readString();
11538 
            self.returnedOrders[_key184] = _val185
3064 chandransh 11539 
          iprot.readMapEnd()
11540 
        else:
11541 
          iprot.skip(ftype)
1596 ankur.sing 11542 
      else:
11543 
        iprot.skip(ftype)
11544 
      iprot.readFieldEnd()
11545 
    iprot.readStructEnd()
11546 
 
11547 
  def write(self, oprot):
11548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11550 
      return
3064 chandransh 11551 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 11552 
    if self.providerId is not None:
3064 chandransh 11553 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11554 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11555 
      oprot.writeFieldEnd()
3431 rajveer 11556 
    if self.returnedOrders is not None:
3064 chandransh 11557 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11558 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4801 anupam.sin 11559 
      for kiter186,viter187 in self.returnedOrders.items():
11560 
        oprot.writeString(kiter186)
11561 
        oprot.writeString(viter187)
3064 chandransh 11562 
      oprot.writeMapEnd()
11563 
      oprot.writeFieldEnd()
1596 ankur.sing 11564 
    oprot.writeFieldStop()
11565 
    oprot.writeStructEnd()
11566 
 
3431 rajveer 11567 
  def validate(self):
11568 
    return
11569 
 
11570 
 
1596 ankur.sing 11571 
  def __repr__(self):
11572 
    L = ['%s=%r' % (key, value)
11573 
      for key, value in self.__dict__.iteritems()]
11574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11575 
 
11576 
  def __eq__(self, other):
11577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11578 
 
11579 
  def __ne__(self, other):
11580 
    return not (self == other)
11581 
 
3064 chandransh 11582 
class markOrdersAsFailed_result:
11583 
  """
11584 
  Attributes:
11585 
   - ex
11586 
  """
1596 ankur.sing 11587 
 
1627 ankur.sing 11588 
  thrift_spec = (
3064 chandransh 11589 
    None, # 0
11590 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11591 
  )
11592 
 
3064 chandransh 11593 
  def __init__(self, ex=None,):
11594 
    self.ex = ex
11595 
 
1627 ankur.sing 11596 
  def read(self, iprot):
11597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11599 
      return
11600 
    iprot.readStructBegin()
11601 
    while True:
11602 
      (fname, ftype, fid) = iprot.readFieldBegin()
11603 
      if ftype == TType.STOP:
11604 
        break
3064 chandransh 11605 
      if fid == 1:
11606 
        if ftype == TType.STRUCT:
11607 
          self.ex = TransactionServiceException()
11608 
          self.ex.read(iprot)
11609 
        else:
11610 
          iprot.skip(ftype)
1627 ankur.sing 11611 
      else:
11612 
        iprot.skip(ftype)
11613 
      iprot.readFieldEnd()
11614 
    iprot.readStructEnd()
11615 
 
11616 
  def write(self, oprot):
11617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11619 
      return
3064 chandransh 11620 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 11621 
    if self.ex is not None:
3064 chandransh 11622 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11623 
      self.ex.write(oprot)
11624 
      oprot.writeFieldEnd()
1627 ankur.sing 11625 
    oprot.writeFieldStop()
11626 
    oprot.writeStructEnd()
11627 
 
3431 rajveer 11628 
  def validate(self):
11629 
    return
11630 
 
11631 
 
1627 ankur.sing 11632 
  def __repr__(self):
11633 
    L = ['%s=%r' % (key, value)
11634 
      for key, value in self.__dict__.iteritems()]
11635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11636 
 
11637 
  def __eq__(self, other):
11638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11639 
 
11640 
  def __ne__(self, other):
11641 
    return not (self == other)
11642 
 
3064 chandransh 11643 
class updateNonDeliveryReason_args:
1627 ankur.sing 11644 
  """
11645 
  Attributes:
3064 chandransh 11646 
   - providerId
11647 
   - undeliveredOrders
1627 ankur.sing 11648 
  """
11649 
 
11650 
  thrift_spec = (
3064 chandransh 11651 
    None, # 0
11652 
    (1, TType.I64, 'providerId', None, None, ), # 1
11653 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 11654 
  )
11655 
 
3064 chandransh 11656 
  def __init__(self, providerId=None, undeliveredOrders=None,):
11657 
    self.providerId = providerId
11658 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 11659 
 
11660 
  def read(self, iprot):
11661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11663 
      return
11664 
    iprot.readStructBegin()
11665 
    while True:
11666 
      (fname, ftype, fid) = iprot.readFieldBegin()
11667 
      if ftype == TType.STOP:
11668 
        break
3064 chandransh 11669 
      if fid == 1:
1627 ankur.sing 11670 
        if ftype == TType.I64:
3064 chandransh 11671 
          self.providerId = iprot.readI64();
1627 ankur.sing 11672 
        else:
11673 
          iprot.skip(ftype)
3064 chandransh 11674 
      elif fid == 2:
11675 
        if ftype == TType.MAP:
11676 
          self.undeliveredOrders = {}
4801 anupam.sin 11677 
          (_ktype189, _vtype190, _size188 ) = iprot.readMapBegin()
11678 
          for _i192 in xrange(_size188):
11679 
            _key193 = iprot.readString();
11680 
            _val194 = iprot.readString();
11681 
            self.undeliveredOrders[_key193] = _val194
3064 chandransh 11682 
          iprot.readMapEnd()
11683 
        else:
11684 
          iprot.skip(ftype)
1627 ankur.sing 11685 
      else:
11686 
        iprot.skip(ftype)
11687 
      iprot.readFieldEnd()
11688 
    iprot.readStructEnd()
11689 
 
11690 
  def write(self, oprot):
11691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11693 
      return
3064 chandransh 11694 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 11695 
    if self.providerId is not None:
3064 chandransh 11696 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11697 
      oprot.writeI64(self.providerId)
1627 ankur.sing 11698 
      oprot.writeFieldEnd()
3431 rajveer 11699 
    if self.undeliveredOrders is not None:
3064 chandransh 11700 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
11701 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4801 anupam.sin 11702 
      for kiter195,viter196 in self.undeliveredOrders.items():
11703 
        oprot.writeString(kiter195)
11704 
        oprot.writeString(viter196)
3064 chandransh 11705 
      oprot.writeMapEnd()
11706 
      oprot.writeFieldEnd()
1627 ankur.sing 11707 
    oprot.writeFieldStop()
11708 
    oprot.writeStructEnd()
11709 
 
3431 rajveer 11710 
  def validate(self):
11711 
    return
11712 
 
11713 
 
1627 ankur.sing 11714 
  def __repr__(self):
11715 
    L = ['%s=%r' % (key, value)
11716 
      for key, value in self.__dict__.iteritems()]
11717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11718 
 
11719 
  def __eq__(self, other):
11720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11721 
 
11722 
  def __ne__(self, other):
11723 
    return not (self == other)
11724 
 
3064 chandransh 11725 
class updateNonDeliveryReason_result:
1627 ankur.sing 11726 
  """
11727 
  Attributes:
4581 phani.kuma 11728 
   - success
3064 chandransh 11729 
   - ex
1627 ankur.sing 11730 
  """
11731 
 
11732 
  thrift_spec = (
4581 phani.kuma 11733 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 11734 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11735 
  )
11736 
 
4581 phani.kuma 11737 
  def __init__(self, success=None, ex=None,):
11738 
    self.success = success
3064 chandransh 11739 
    self.ex = ex
1627 ankur.sing 11740 
 
11741 
  def read(self, iprot):
11742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11744 
      return
11745 
    iprot.readStructBegin()
11746 
    while True:
11747 
      (fname, ftype, fid) = iprot.readFieldBegin()
11748 
      if ftype == TType.STOP:
11749 
        break
4581 phani.kuma 11750 
      if fid == 0:
11751 
        if ftype == TType.LIST:
11752 
          self.success = []
4801 anupam.sin 11753 
          (_etype200, _size197) = iprot.readListBegin()
11754 
          for _i201 in xrange(_size197):
11755 
            _elem202 = Order()
11756 
            _elem202.read(iprot)
11757 
            self.success.append(_elem202)
4581 phani.kuma 11758 
          iprot.readListEnd()
11759 
        else:
11760 
          iprot.skip(ftype)
11761 
      elif fid == 1:
3064 chandransh 11762 
        if ftype == TType.STRUCT:
11763 
          self.ex = TransactionServiceException()
11764 
          self.ex.read(iprot)
1627 ankur.sing 11765 
        else:
11766 
          iprot.skip(ftype)
11767 
      else:
11768 
        iprot.skip(ftype)
11769 
      iprot.readFieldEnd()
11770 
    iprot.readStructEnd()
11771 
 
11772 
  def write(self, oprot):
11773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11775 
      return
3064 chandransh 11776 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 11777 
    if self.success is not None:
11778 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11779 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 11780 
      for iter203 in self.success:
11781 
        iter203.write(oprot)
4581 phani.kuma 11782 
      oprot.writeListEnd()
11783 
      oprot.writeFieldEnd()
3431 rajveer 11784 
    if self.ex is not None:
3064 chandransh 11785 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11786 
      self.ex.write(oprot)
1627 ankur.sing 11787 
      oprot.writeFieldEnd()
11788 
    oprot.writeFieldStop()
11789 
    oprot.writeStructEnd()
11790 
 
3431 rajveer 11791 
  def validate(self):
11792 
    return
11793 
 
11794 
 
1627 ankur.sing 11795 
  def __repr__(self):
11796 
    L = ['%s=%r' % (key, value)
11797 
      for key, value in self.__dict__.iteritems()]
11798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11799 
 
11800 
  def __eq__(self, other):
11801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11802 
 
11803 
  def __ne__(self, other):
11804 
    return not (self == other)
11805 
 
3064 chandransh 11806 
class getUndeliveredOrders_args:
1886 ankur.sing 11807 
  """
11808 
  Attributes:
3064 chandransh 11809 
   - providerId
11810 
   - warehouseId
1886 ankur.sing 11811 
  """
1627 ankur.sing 11812 
 
1886 ankur.sing 11813 
  thrift_spec = (
11814 
    None, # 0
3064 chandransh 11815 
    (1, TType.I64, 'providerId', None, None, ), # 1
11816 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 11817 
  )
11818 
 
3064 chandransh 11819 
  def __init__(self, providerId=None, warehouseId=None,):
11820 
    self.providerId = providerId
11821 
    self.warehouseId = warehouseId
1886 ankur.sing 11822 
 
11823 
  def read(self, iprot):
11824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11826 
      return
11827 
    iprot.readStructBegin()
11828 
    while True:
11829 
      (fname, ftype, fid) = iprot.readFieldBegin()
11830 
      if ftype == TType.STOP:
11831 
        break
11832 
      if fid == 1:
11833 
        if ftype == TType.I64:
3064 chandransh 11834 
          self.providerId = iprot.readI64();
1886 ankur.sing 11835 
        else:
11836 
          iprot.skip(ftype)
3064 chandransh 11837 
      elif fid == 2:
11838 
        if ftype == TType.I64:
11839 
          self.warehouseId = iprot.readI64();
11840 
        else:
11841 
          iprot.skip(ftype)
1886 ankur.sing 11842 
      else:
11843 
        iprot.skip(ftype)
11844 
      iprot.readFieldEnd()
11845 
    iprot.readStructEnd()
11846 
 
11847 
  def write(self, oprot):
11848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11850 
      return
3064 chandransh 11851 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 11852 
    if self.providerId is not None:
3064 chandransh 11853 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11854 
      oprot.writeI64(self.providerId)
1886 ankur.sing 11855 
      oprot.writeFieldEnd()
3431 rajveer 11856 
    if self.warehouseId is not None:
3064 chandransh 11857 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11858 
      oprot.writeI64(self.warehouseId)
11859 
      oprot.writeFieldEnd()
1886 ankur.sing 11860 
    oprot.writeFieldStop()
11861 
    oprot.writeStructEnd()
11862 
 
3431 rajveer 11863 
  def validate(self):
11864 
    return
11865 
 
11866 
 
1886 ankur.sing 11867 
  def __repr__(self):
11868 
    L = ['%s=%r' % (key, value)
11869 
      for key, value in self.__dict__.iteritems()]
11870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11871 
 
11872 
  def __eq__(self, other):
11873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11874 
 
11875 
  def __ne__(self, other):
11876 
    return not (self == other)
11877 
 
3064 chandransh 11878 
class getUndeliveredOrders_result:
1886 ankur.sing 11879 
  """
11880 
  Attributes:
11881 
   - success
11882 
  """
11883 
 
11884 
  thrift_spec = (
11885 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11886 
  )
11887 
 
11888 
  def __init__(self, success=None,):
11889 
    self.success = success
11890 
 
11891 
  def read(self, iprot):
11892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11894 
      return
11895 
    iprot.readStructBegin()
11896 
    while True:
11897 
      (fname, ftype, fid) = iprot.readFieldBegin()
11898 
      if ftype == TType.STOP:
11899 
        break
11900 
      if fid == 0:
11901 
        if ftype == TType.LIST:
11902 
          self.success = []
4801 anupam.sin 11903 
          (_etype207, _size204) = iprot.readListBegin()
11904 
          for _i208 in xrange(_size204):
11905 
            _elem209 = Order()
11906 
            _elem209.read(iprot)
11907 
            self.success.append(_elem209)
1886 ankur.sing 11908 
          iprot.readListEnd()
11909 
        else:
11910 
          iprot.skip(ftype)
11911 
      else:
11912 
        iprot.skip(ftype)
11913 
      iprot.readFieldEnd()
11914 
    iprot.readStructEnd()
11915 
 
11916 
  def write(self, oprot):
11917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11919 
      return
3064 chandransh 11920 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 11921 
    if self.success is not None:
1886 ankur.sing 11922 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11923 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 11924 
      for iter210 in self.success:
11925 
        iter210.write(oprot)
1886 ankur.sing 11926 
      oprot.writeListEnd()
11927 
      oprot.writeFieldEnd()
11928 
    oprot.writeFieldStop()
11929 
    oprot.writeStructEnd()
11930 
 
3431 rajveer 11931 
  def validate(self):
11932 
    return
11933 
 
11934 
 
1886 ankur.sing 11935 
  def __repr__(self):
11936 
    L = ['%s=%r' % (key, value)
11937 
      for key, value in self.__dict__.iteritems()]
11938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11939 
 
11940 
  def __eq__(self, other):
11941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11942 
 
11943 
  def __ne__(self, other):
11944 
    return not (self == other)
11945 
 
4783 phani.kuma 11946 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
11947 
 
11948 
  thrift_spec = (
11949 
  )
11950 
 
11951 
  def read(self, iprot):
11952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11954 
      return
11955 
    iprot.readStructBegin()
11956 
    while True:
11957 
      (fname, ftype, fid) = iprot.readFieldBegin()
11958 
      if ftype == TType.STOP:
11959 
        break
11960 
      else:
11961 
        iprot.skip(ftype)
11962 
      iprot.readFieldEnd()
11963 
    iprot.readStructEnd()
11964 
 
11965 
  def write(self, oprot):
11966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11968 
      return
11969 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
11970 
    oprot.writeFieldStop()
11971 
    oprot.writeStructEnd()
11972 
 
11973 
  def validate(self):
11974 
    return
11975 
 
11976 
 
11977 
  def __repr__(self):
11978 
    L = ['%s=%r' % (key, value)
11979 
      for key, value in self.__dict__.iteritems()]
11980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11981 
 
11982 
  def __eq__(self, other):
11983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11984 
 
11985 
  def __ne__(self, other):
11986 
    return not (self == other)
11987 
 
11988 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
11989 
  """
11990 
  Attributes:
11991 
   - success
11992 
  """
11993 
 
11994 
  thrift_spec = (
11995 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11996 
  )
11997 
 
11998 
  def __init__(self, success=None,):
11999 
    self.success = success
12000 
 
12001 
  def read(self, iprot):
12002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12004 
      return
12005 
    iprot.readStructBegin()
12006 
    while True:
12007 
      (fname, ftype, fid) = iprot.readFieldBegin()
12008 
      if ftype == TType.STOP:
12009 
        break
12010 
      if fid == 0:
12011 
        if ftype == TType.LIST:
12012 
          self.success = []
4801 anupam.sin 12013 
          (_etype214, _size211) = iprot.readListBegin()
12014 
          for _i215 in xrange(_size211):
12015 
            _elem216 = Order()
12016 
            _elem216.read(iprot)
12017 
            self.success.append(_elem216)
4783 phani.kuma 12018 
          iprot.readListEnd()
12019 
        else:
12020 
          iprot.skip(ftype)
12021 
      else:
12022 
        iprot.skip(ftype)
12023 
      iprot.readFieldEnd()
12024 
    iprot.readStructEnd()
12025 
 
12026 
  def write(self, oprot):
12027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12029 
      return
12030 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
12031 
    if self.success is not None:
12032 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12033 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 12034 
      for iter217 in self.success:
12035 
        iter217.write(oprot)
4783 phani.kuma 12036 
      oprot.writeListEnd()
12037 
      oprot.writeFieldEnd()
12038 
    oprot.writeFieldStop()
12039 
    oprot.writeStructEnd()
12040 
 
12041 
  def validate(self):
12042 
    return
12043 
 
12044 
 
12045 
  def __repr__(self):
12046 
    L = ['%s=%r' % (key, value)
12047 
      for key, value in self.__dict__.iteritems()]
12048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12049 
 
12050 
  def __eq__(self, other):
12051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12052 
 
12053 
  def __ne__(self, other):
12054 
    return not (self == other)
12055 
 
2536 chandransh 12056 
class toggleDOAFlag_args:
12057 
  """
12058 
  Attributes:
12059 
   - orderId
12060 
  """
1886 ankur.sing 12061 
 
2536 chandransh 12062 
  thrift_spec = (
12063 
    None, # 0
12064 
    (1, TType.I64, 'orderId', None, None, ), # 1
12065 
  )
12066 
 
12067 
  def __init__(self, orderId=None,):
12068 
    self.orderId = orderId
12069 
 
12070 
  def read(self, iprot):
12071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12073 
      return
12074 
    iprot.readStructBegin()
12075 
    while True:
12076 
      (fname, ftype, fid) = iprot.readFieldBegin()
12077 
      if ftype == TType.STOP:
12078 
        break
12079 
      if fid == 1:
12080 
        if ftype == TType.I64:
12081 
          self.orderId = iprot.readI64();
12082 
        else:
12083 
          iprot.skip(ftype)
12084 
      else:
12085 
        iprot.skip(ftype)
12086 
      iprot.readFieldEnd()
12087 
    iprot.readStructEnd()
12088 
 
12089 
  def write(self, oprot):
12090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12092 
      return
12093 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 12094 
    if self.orderId is not None:
2536 chandransh 12095 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12096 
      oprot.writeI64(self.orderId)
12097 
      oprot.writeFieldEnd()
12098 
    oprot.writeFieldStop()
12099 
    oprot.writeStructEnd()
12100 
 
3431 rajveer 12101 
  def validate(self):
12102 
    return
12103 
 
12104 
 
2536 chandransh 12105 
  def __repr__(self):
12106 
    L = ['%s=%r' % (key, value)
12107 
      for key, value in self.__dict__.iteritems()]
12108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12109 
 
12110 
  def __eq__(self, other):
12111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12112 
 
12113 
  def __ne__(self, other):
12114 
    return not (self == other)
12115 
 
12116 
class toggleDOAFlag_result:
12117 
  """
12118 
  Attributes:
12119 
   - success
12120 
   - ex
12121 
  """
12122 
 
12123 
  thrift_spec = (
12124 
    (0, TType.BOOL, 'success', None, None, ), # 0
12125 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12126 
  )
12127 
 
12128 
  def __init__(self, success=None, ex=None,):
12129 
    self.success = success
12130 
    self.ex = ex
12131 
 
12132 
  def read(self, iprot):
12133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12135 
      return
12136 
    iprot.readStructBegin()
12137 
    while True:
12138 
      (fname, ftype, fid) = iprot.readFieldBegin()
12139 
      if ftype == TType.STOP:
12140 
        break
12141 
      if fid == 0:
12142 
        if ftype == TType.BOOL:
12143 
          self.success = iprot.readBool();
12144 
        else:
12145 
          iprot.skip(ftype)
12146 
      elif fid == 1:
12147 
        if ftype == TType.STRUCT:
12148 
          self.ex = TransactionServiceException()
12149 
          self.ex.read(iprot)
12150 
        else:
12151 
          iprot.skip(ftype)
12152 
      else:
12153 
        iprot.skip(ftype)
12154 
      iprot.readFieldEnd()
12155 
    iprot.readStructEnd()
12156 
 
12157 
  def write(self, oprot):
12158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12160 
      return
12161 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 12162 
    if self.success is not None:
2536 chandransh 12163 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12164 
      oprot.writeBool(self.success)
12165 
      oprot.writeFieldEnd()
3431 rajveer 12166 
    if self.ex is not None:
2536 chandransh 12167 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12168 
      self.ex.write(oprot)
12169 
      oprot.writeFieldEnd()
12170 
    oprot.writeFieldStop()
12171 
    oprot.writeStructEnd()
12172 
 
3431 rajveer 12173 
  def validate(self):
12174 
    return
12175 
 
12176 
 
2536 chandransh 12177 
  def __repr__(self):
12178 
    L = ['%s=%r' % (key, value)
12179 
      for key, value in self.__dict__.iteritems()]
12180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12181 
 
12182 
  def __eq__(self, other):
12183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12184 
 
12185 
  def __ne__(self, other):
12186 
    return not (self == other)
12187 
 
4712 rajveer 12188 
class markOrderAsDelivered_args:
12189 
  """
12190 
  Attributes:
12191 
   - orderId
12192 
   - deliveryTimestamp
12193 
   - receiver
12194 
  """
12195 
 
12196 
  thrift_spec = None
12197 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
12198 
    self.orderId = orderId
12199 
    self.deliveryTimestamp = deliveryTimestamp
12200 
    self.receiver = receiver
12201 
 
12202 
  def read(self, iprot):
12203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12205 
      return
12206 
    iprot.readStructBegin()
12207 
    while True:
12208 
      (fname, ftype, fid) = iprot.readFieldBegin()
12209 
      if ftype == TType.STOP:
12210 
        break
12211 
      if fid == 1:
12212 
        if ftype == TType.I64:
12213 
          self.orderId = iprot.readI64();
12214 
        else:
12215 
          iprot.skip(ftype)
12216 
      elif fid == 2:
12217 
        if ftype == TType.I64:
12218 
          self.deliveryTimestamp = iprot.readI64();
12219 
        else:
12220 
          iprot.skip(ftype)
12221 
      elif fid == -1:
12222 
        if ftype == TType.STRING:
12223 
          self.receiver = iprot.readString();
12224 
        else:
12225 
          iprot.skip(ftype)
12226 
      else:
12227 
        iprot.skip(ftype)
12228 
      iprot.readFieldEnd()
12229 
    iprot.readStructEnd()
12230 
 
12231 
  def write(self, oprot):
12232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12234 
      return
12235 
    oprot.writeStructBegin('markOrderAsDelivered_args')
12236 
    if self.receiver is not None:
12237 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
12238 
      oprot.writeString(self.receiver)
12239 
      oprot.writeFieldEnd()
12240 
    if self.orderId is not None:
12241 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12242 
      oprot.writeI64(self.orderId)
12243 
      oprot.writeFieldEnd()
12244 
    if self.deliveryTimestamp is not None:
12245 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
12246 
      oprot.writeI64(self.deliveryTimestamp)
12247 
      oprot.writeFieldEnd()
12248 
    oprot.writeFieldStop()
12249 
    oprot.writeStructEnd()
12250 
 
12251 
  def validate(self):
12252 
    return
12253 
 
12254 
 
12255 
  def __repr__(self):
12256 
    L = ['%s=%r' % (key, value)
12257 
      for key, value in self.__dict__.iteritems()]
12258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12259 
 
12260 
  def __eq__(self, other):
12261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12262 
 
12263 
  def __ne__(self, other):
12264 
    return not (self == other)
12265 
 
12266 
class markOrderAsDelivered_result:
12267 
  """
12268 
  Attributes:
12269 
   - ex
12270 
  """
12271 
 
12272 
  thrift_spec = (
12273 
    None, # 0
12274 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12275 
  )
12276 
 
12277 
  def __init__(self, ex=None,):
12278 
    self.ex = ex
12279 
 
12280 
  def read(self, iprot):
12281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12283 
      return
12284 
    iprot.readStructBegin()
12285 
    while True:
12286 
      (fname, ftype, fid) = iprot.readFieldBegin()
12287 
      if ftype == TType.STOP:
12288 
        break
12289 
      if fid == 1:
12290 
        if ftype == TType.STRUCT:
12291 
          self.ex = TransactionServiceException()
12292 
          self.ex.read(iprot)
12293 
        else:
12294 
          iprot.skip(ftype)
12295 
      else:
12296 
        iprot.skip(ftype)
12297 
      iprot.readFieldEnd()
12298 
    iprot.readStructEnd()
12299 
 
12300 
  def write(self, oprot):
12301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12303 
      return
12304 
    oprot.writeStructBegin('markOrderAsDelivered_result')
12305 
    if self.ex is not None:
12306 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12307 
      self.ex.write(oprot)
12308 
      oprot.writeFieldEnd()
12309 
    oprot.writeFieldStop()
12310 
    oprot.writeStructEnd()
12311 
 
12312 
  def validate(self):
12313 
    return
12314 
 
12315 
 
12316 
  def __repr__(self):
12317 
    L = ['%s=%r' % (key, value)
12318 
      for key, value in self.__dict__.iteritems()]
12319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12320 
 
12321 
  def __eq__(self, other):
12322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12323 
 
12324 
  def __ne__(self, other):
12325 
    return not (self == other)
12326 
 
4454 rajveer 12327 
class markOrderDoaRequestReceived_args:
12328 
  """
12329 
  Attributes:
12330 
   - orderId
12331 
  """
12332 
 
12333 
  thrift_spec = (
12334 
    None, # 0
12335 
    (1, TType.I64, 'orderId', None, None, ), # 1
12336 
  )
12337 
 
12338 
  def __init__(self, orderId=None,):
12339 
    self.orderId = orderId
12340 
 
12341 
  def read(self, iprot):
12342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12344 
      return
12345 
    iprot.readStructBegin()
12346 
    while True:
12347 
      (fname, ftype, fid) = iprot.readFieldBegin()
12348 
      if ftype == TType.STOP:
12349 
        break
12350 
      if fid == 1:
12351 
        if ftype == TType.I64:
12352 
          self.orderId = iprot.readI64();
12353 
        else:
12354 
          iprot.skip(ftype)
12355 
      else:
12356 
        iprot.skip(ftype)
12357 
      iprot.readFieldEnd()
12358 
    iprot.readStructEnd()
12359 
 
12360 
  def write(self, oprot):
12361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12363 
      return
12364 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
12365 
    if self.orderId is not None:
12366 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12367 
      oprot.writeI64(self.orderId)
12368 
      oprot.writeFieldEnd()
12369 
    oprot.writeFieldStop()
12370 
    oprot.writeStructEnd()
12371 
 
12372 
  def validate(self):
12373 
    return
12374 
 
12375 
 
12376 
  def __repr__(self):
12377 
    L = ['%s=%r' % (key, value)
12378 
      for key, value in self.__dict__.iteritems()]
12379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12380 
 
12381 
  def __eq__(self, other):
12382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12383 
 
12384 
  def __ne__(self, other):
12385 
    return not (self == other)
12386 
 
12387 
class markOrderDoaRequestReceived_result:
12388 
  """
12389 
  Attributes:
12390 
   - success
12391 
   - ex
12392 
  """
12393 
 
12394 
  thrift_spec = (
12395 
    (0, TType.BOOL, 'success', None, None, ), # 0
12396 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12397 
  )
12398 
 
12399 
  def __init__(self, success=None, ex=None,):
12400 
    self.success = success
12401 
    self.ex = ex
12402 
 
12403 
  def read(self, iprot):
12404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12406 
      return
12407 
    iprot.readStructBegin()
12408 
    while True:
12409 
      (fname, ftype, fid) = iprot.readFieldBegin()
12410 
      if ftype == TType.STOP:
12411 
        break
12412 
      if fid == 0:
12413 
        if ftype == TType.BOOL:
12414 
          self.success = iprot.readBool();
12415 
        else:
12416 
          iprot.skip(ftype)
12417 
      elif fid == 1:
12418 
        if ftype == TType.STRUCT:
12419 
          self.ex = TransactionServiceException()
12420 
          self.ex.read(iprot)
12421 
        else:
12422 
          iprot.skip(ftype)
12423 
      else:
12424 
        iprot.skip(ftype)
12425 
      iprot.readFieldEnd()
12426 
    iprot.readStructEnd()
12427 
 
12428 
  def write(self, oprot):
12429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12431 
      return
12432 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
12433 
    if self.success is not None:
12434 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12435 
      oprot.writeBool(self.success)
12436 
      oprot.writeFieldEnd()
12437 
    if self.ex is not None:
12438 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12439 
      self.ex.write(oprot)
12440 
      oprot.writeFieldEnd()
12441 
    oprot.writeFieldStop()
12442 
    oprot.writeStructEnd()
12443 
 
12444 
  def validate(self):
12445 
    return
12446 
 
12447 
 
12448 
  def __repr__(self):
12449 
    L = ['%s=%r' % (key, value)
12450 
      for key, value in self.__dict__.iteritems()]
12451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12452 
 
12453 
  def __eq__(self, other):
12454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12455 
 
12456 
  def __ne__(self, other):
12457 
    return not (self == other)
12458 
 
12459 
class markOrderDoaRequestAuthorized_args:
12460 
  """
12461 
  Attributes:
12462 
   - orderId
12463 
   - isAuthorized
12464 
  """
12465 
 
12466 
  thrift_spec = (
12467 
    None, # 0
12468 
    (1, TType.I64, 'orderId', None, None, ), # 1
12469 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12470 
  )
12471 
 
12472 
  def __init__(self, orderId=None, isAuthorized=None,):
12473 
    self.orderId = orderId
12474 
    self.isAuthorized = isAuthorized
12475 
 
12476 
  def read(self, iprot):
12477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12479 
      return
12480 
    iprot.readStructBegin()
12481 
    while True:
12482 
      (fname, ftype, fid) = iprot.readFieldBegin()
12483 
      if ftype == TType.STOP:
12484 
        break
12485 
      if fid == 1:
12486 
        if ftype == TType.I64:
12487 
          self.orderId = iprot.readI64();
12488 
        else:
12489 
          iprot.skip(ftype)
12490 
      elif fid == 2:
12491 
        if ftype == TType.BOOL:
12492 
          self.isAuthorized = iprot.readBool();
12493 
        else:
12494 
          iprot.skip(ftype)
12495 
      else:
12496 
        iprot.skip(ftype)
12497 
      iprot.readFieldEnd()
12498 
    iprot.readStructEnd()
12499 
 
12500 
  def write(self, oprot):
12501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12503 
      return
12504 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
12505 
    if self.orderId is not None:
12506 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12507 
      oprot.writeI64(self.orderId)
12508 
      oprot.writeFieldEnd()
12509 
    if self.isAuthorized is not None:
12510 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12511 
      oprot.writeBool(self.isAuthorized)
12512 
      oprot.writeFieldEnd()
12513 
    oprot.writeFieldStop()
12514 
    oprot.writeStructEnd()
12515 
 
12516 
  def validate(self):
12517 
    return
12518 
 
12519 
 
12520 
  def __repr__(self):
12521 
    L = ['%s=%r' % (key, value)
12522 
      for key, value in self.__dict__.iteritems()]
12523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12524 
 
12525 
  def __eq__(self, other):
12526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12527 
 
12528 
  def __ne__(self, other):
12529 
    return not (self == other)
12530 
 
12531 
class markOrderDoaRequestAuthorized_result:
12532 
  """
12533 
  Attributes:
12534 
   - success
12535 
   - ex
12536 
  """
12537 
 
12538 
  thrift_spec = (
12539 
    (0, TType.BOOL, 'success', None, None, ), # 0
12540 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12541 
  )
12542 
 
12543 
  def __init__(self, success=None, ex=None,):
12544 
    self.success = success
12545 
    self.ex = ex
12546 
 
12547 
  def read(self, iprot):
12548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12550 
      return
12551 
    iprot.readStructBegin()
12552 
    while True:
12553 
      (fname, ftype, fid) = iprot.readFieldBegin()
12554 
      if ftype == TType.STOP:
12555 
        break
12556 
      if fid == 0:
12557 
        if ftype == TType.BOOL:
12558 
          self.success = iprot.readBool();
12559 
        else:
12560 
          iprot.skip(ftype)
12561 
      elif fid == 1:
12562 
        if ftype == TType.STRUCT:
12563 
          self.ex = TransactionServiceException()
12564 
          self.ex.read(iprot)
12565 
        else:
12566 
          iprot.skip(ftype)
12567 
      else:
12568 
        iprot.skip(ftype)
12569 
      iprot.readFieldEnd()
12570 
    iprot.readStructEnd()
12571 
 
12572 
  def write(self, oprot):
12573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12575 
      return
12576 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
12577 
    if self.success is not None:
12578 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12579 
      oprot.writeBool(self.success)
12580 
      oprot.writeFieldEnd()
12581 
    if self.ex is not None:
12582 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12583 
      self.ex.write(oprot)
12584 
      oprot.writeFieldEnd()
12585 
    oprot.writeFieldStop()
12586 
    oprot.writeStructEnd()
12587 
 
12588 
  def validate(self):
12589 
    return
12590 
 
12591 
 
12592 
  def __repr__(self):
12593 
    L = ['%s=%r' % (key, value)
12594 
      for key, value in self.__dict__.iteritems()]
12595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12596 
 
12597 
  def __eq__(self, other):
12598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12599 
 
12600 
  def __ne__(self, other):
12601 
    return not (self == other)
12602 
 
4488 rajveer 12603 
class markOrderReturnRequestReceived_args:
12604 
  """
12605 
  Attributes:
12606 
   - orderId
12607 
  """
12608 
 
12609 
  thrift_spec = (
12610 
    None, # 0
12611 
    (1, TType.I64, 'orderId', None, None, ), # 1
12612 
  )
12613 
 
12614 
  def __init__(self, orderId=None,):
12615 
    self.orderId = orderId
12616 
 
12617 
  def read(self, iprot):
12618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12620 
      return
12621 
    iprot.readStructBegin()
12622 
    while True:
12623 
      (fname, ftype, fid) = iprot.readFieldBegin()
12624 
      if ftype == TType.STOP:
12625 
        break
12626 
      if fid == 1:
12627 
        if ftype == TType.I64:
12628 
          self.orderId = iprot.readI64();
12629 
        else:
12630 
          iprot.skip(ftype)
12631 
      else:
12632 
        iprot.skip(ftype)
12633 
      iprot.readFieldEnd()
12634 
    iprot.readStructEnd()
12635 
 
12636 
  def write(self, oprot):
12637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12639 
      return
12640 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
12641 
    if self.orderId is not None:
12642 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12643 
      oprot.writeI64(self.orderId)
12644 
      oprot.writeFieldEnd()
12645 
    oprot.writeFieldStop()
12646 
    oprot.writeStructEnd()
12647 
 
12648 
  def validate(self):
12649 
    return
12650 
 
12651 
 
12652 
  def __repr__(self):
12653 
    L = ['%s=%r' % (key, value)
12654 
      for key, value in self.__dict__.iteritems()]
12655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12656 
 
12657 
  def __eq__(self, other):
12658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12659 
 
12660 
  def __ne__(self, other):
12661 
    return not (self == other)
12662 
 
12663 
class markOrderReturnRequestReceived_result:
12664 
  """
12665 
  Attributes:
12666 
   - success
12667 
   - ex
12668 
  """
12669 
 
12670 
  thrift_spec = (
12671 
    (0, TType.BOOL, 'success', None, None, ), # 0
12672 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12673 
  )
12674 
 
12675 
  def __init__(self, success=None, ex=None,):
12676 
    self.success = success
12677 
    self.ex = ex
12678 
 
12679 
  def read(self, iprot):
12680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12682 
      return
12683 
    iprot.readStructBegin()
12684 
    while True:
12685 
      (fname, ftype, fid) = iprot.readFieldBegin()
12686 
      if ftype == TType.STOP:
12687 
        break
12688 
      if fid == 0:
12689 
        if ftype == TType.BOOL:
12690 
          self.success = iprot.readBool();
12691 
        else:
12692 
          iprot.skip(ftype)
12693 
      elif fid == 1:
12694 
        if ftype == TType.STRUCT:
12695 
          self.ex = TransactionServiceException()
12696 
          self.ex.read(iprot)
12697 
        else:
12698 
          iprot.skip(ftype)
12699 
      else:
12700 
        iprot.skip(ftype)
12701 
      iprot.readFieldEnd()
12702 
    iprot.readStructEnd()
12703 
 
12704 
  def write(self, oprot):
12705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12707 
      return
12708 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
12709 
    if self.success is not None:
12710 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12711 
      oprot.writeBool(self.success)
12712 
      oprot.writeFieldEnd()
12713 
    if self.ex is not None:
12714 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12715 
      self.ex.write(oprot)
12716 
      oprot.writeFieldEnd()
12717 
    oprot.writeFieldStop()
12718 
    oprot.writeStructEnd()
12719 
 
12720 
  def validate(self):
12721 
    return
12722 
 
12723 
 
12724 
  def __repr__(self):
12725 
    L = ['%s=%r' % (key, value)
12726 
      for key, value in self.__dict__.iteritems()]
12727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12728 
 
12729 
  def __eq__(self, other):
12730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12731 
 
12732 
  def __ne__(self, other):
12733 
    return not (self == other)
12734 
 
12735 
class markOrderReturnRequestAuthorized_args:
12736 
  """
12737 
  Attributes:
12738 
   - orderId
12739 
   - isAuthorized
12740 
  """
12741 
 
12742 
  thrift_spec = (
12743 
    None, # 0
12744 
    (1, TType.I64, 'orderId', None, None, ), # 1
12745 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12746 
  )
12747 
 
12748 
  def __init__(self, orderId=None, isAuthorized=None,):
12749 
    self.orderId = orderId
12750 
    self.isAuthorized = isAuthorized
12751 
 
12752 
  def read(self, iprot):
12753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12755 
      return
12756 
    iprot.readStructBegin()
12757 
    while True:
12758 
      (fname, ftype, fid) = iprot.readFieldBegin()
12759 
      if ftype == TType.STOP:
12760 
        break
12761 
      if fid == 1:
12762 
        if ftype == TType.I64:
12763 
          self.orderId = iprot.readI64();
12764 
        else:
12765 
          iprot.skip(ftype)
12766 
      elif fid == 2:
12767 
        if ftype == TType.BOOL:
12768 
          self.isAuthorized = iprot.readBool();
12769 
        else:
12770 
          iprot.skip(ftype)
12771 
      else:
12772 
        iprot.skip(ftype)
12773 
      iprot.readFieldEnd()
12774 
    iprot.readStructEnd()
12775 
 
12776 
  def write(self, oprot):
12777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12779 
      return
12780 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
12781 
    if self.orderId is not None:
12782 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12783 
      oprot.writeI64(self.orderId)
12784 
      oprot.writeFieldEnd()
12785 
    if self.isAuthorized is not None:
12786 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12787 
      oprot.writeBool(self.isAuthorized)
12788 
      oprot.writeFieldEnd()
12789 
    oprot.writeFieldStop()
12790 
    oprot.writeStructEnd()
12791 
 
12792 
  def validate(self):
12793 
    return
12794 
 
12795 
 
12796 
  def __repr__(self):
12797 
    L = ['%s=%r' % (key, value)
12798 
      for key, value in self.__dict__.iteritems()]
12799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12800 
 
12801 
  def __eq__(self, other):
12802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12803 
 
12804 
  def __ne__(self, other):
12805 
    return not (self == other)
12806 
 
12807 
class markOrderReturnRequestAuthorized_result:
12808 
  """
12809 
  Attributes:
12810 
   - success
12811 
   - ex
12812 
  """
12813 
 
12814 
  thrift_spec = (
12815 
    (0, TType.BOOL, 'success', None, None, ), # 0
12816 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12817 
  )
12818 
 
12819 
  def __init__(self, success=None, ex=None,):
12820 
    self.success = success
12821 
    self.ex = ex
12822 
 
12823 
  def read(self, iprot):
12824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12826 
      return
12827 
    iprot.readStructBegin()
12828 
    while True:
12829 
      (fname, ftype, fid) = iprot.readFieldBegin()
12830 
      if ftype == TType.STOP:
12831 
        break
12832 
      if fid == 0:
12833 
        if ftype == TType.BOOL:
12834 
          self.success = iprot.readBool();
12835 
        else:
12836 
          iprot.skip(ftype)
12837 
      elif fid == 1:
12838 
        if ftype == TType.STRUCT:
12839 
          self.ex = TransactionServiceException()
12840 
          self.ex.read(iprot)
12841 
        else:
12842 
          iprot.skip(ftype)
12843 
      else:
12844 
        iprot.skip(ftype)
12845 
      iprot.readFieldEnd()
12846 
    iprot.readStructEnd()
12847 
 
12848 
  def write(self, oprot):
12849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12851 
      return
12852 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
12853 
    if self.success is not None:
12854 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12855 
      oprot.writeBool(self.success)
12856 
      oprot.writeFieldEnd()
12857 
    if self.ex is not None:
12858 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12859 
      self.ex.write(oprot)
12860 
      oprot.writeFieldEnd()
12861 
    oprot.writeFieldStop()
12862 
    oprot.writeStructEnd()
12863 
 
12864 
  def validate(self):
12865 
    return
12866 
 
12867 
 
12868 
  def __repr__(self):
12869 
    L = ['%s=%r' % (key, value)
12870 
      for key, value in self.__dict__.iteritems()]
12871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12872 
 
12873 
  def __eq__(self, other):
12874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12875 
 
12876 
  def __ne__(self, other):
12877 
    return not (self == other)
12878 
 
2536 chandransh 12879 
class requestPickupNumber_args:
12880 
  """
12881 
  Attributes:
12882 
   - orderId
4579 rajveer 12883 
   - providerId
2536 chandransh 12884 
  """
12885 
 
12886 
  thrift_spec = (
12887 
    None, # 0
12888 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 12889 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 12890 
  )
12891 
 
4579 rajveer 12892 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 12893 
    self.orderId = orderId
4579 rajveer 12894 
    self.providerId = providerId
2536 chandransh 12895 
 
12896 
  def read(self, iprot):
12897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12899 
      return
12900 
    iprot.readStructBegin()
12901 
    while True:
12902 
      (fname, ftype, fid) = iprot.readFieldBegin()
12903 
      if ftype == TType.STOP:
12904 
        break
12905 
      if fid == 1:
12906 
        if ftype == TType.I64:
12907 
          self.orderId = iprot.readI64();
12908 
        else:
12909 
          iprot.skip(ftype)
4579 rajveer 12910 
      elif fid == 2:
12911 
        if ftype == TType.I64:
12912 
          self.providerId = iprot.readI64();
12913 
        else:
12914 
          iprot.skip(ftype)
2536 chandransh 12915 
      else:
12916 
        iprot.skip(ftype)
12917 
      iprot.readFieldEnd()
12918 
    iprot.readStructEnd()
12919 
 
12920 
  def write(self, oprot):
12921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12923 
      return
12924 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 12925 
    if self.orderId is not None:
2536 chandransh 12926 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12927 
      oprot.writeI64(self.orderId)
12928 
      oprot.writeFieldEnd()
4579 rajveer 12929 
    if self.providerId is not None:
12930 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
12931 
      oprot.writeI64(self.providerId)
12932 
      oprot.writeFieldEnd()
2536 chandransh 12933 
    oprot.writeFieldStop()
12934 
    oprot.writeStructEnd()
12935 
 
3431 rajveer 12936 
  def validate(self):
12937 
    return
12938 
 
12939 
 
2536 chandransh 12940 
  def __repr__(self):
12941 
    L = ['%s=%r' % (key, value)
12942 
      for key, value in self.__dict__.iteritems()]
12943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12944 
 
12945 
  def __eq__(self, other):
12946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12947 
 
12948 
  def __ne__(self, other):
12949 
    return not (self == other)
12950 
 
12951 
class requestPickupNumber_result:
12952 
  """
12953 
  Attributes:
12954 
   - success
12955 
   - ex
12956 
  """
12957 
 
12958 
  thrift_spec = (
12959 
    (0, TType.BOOL, 'success', None, None, ), # 0
12960 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12961 
  )
12962 
 
12963 
  def __init__(self, success=None, ex=None,):
12964 
    self.success = success
12965 
    self.ex = ex
12966 
 
12967 
  def read(self, iprot):
12968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12970 
      return
12971 
    iprot.readStructBegin()
12972 
    while True:
12973 
      (fname, ftype, fid) = iprot.readFieldBegin()
12974 
      if ftype == TType.STOP:
12975 
        break
12976 
      if fid == 0:
12977 
        if ftype == TType.BOOL:
12978 
          self.success = iprot.readBool();
12979 
        else:
12980 
          iprot.skip(ftype)
12981 
      elif fid == 1:
12982 
        if ftype == TType.STRUCT:
12983 
          self.ex = TransactionServiceException()
12984 
          self.ex.read(iprot)
12985 
        else:
12986 
          iprot.skip(ftype)
12987 
      else:
12988 
        iprot.skip(ftype)
12989 
      iprot.readFieldEnd()
12990 
    iprot.readStructEnd()
12991 
 
12992 
  def write(self, oprot):
12993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12995 
      return
12996 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 12997 
    if self.success is not None:
2536 chandransh 12998 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12999 
      oprot.writeBool(self.success)
13000 
      oprot.writeFieldEnd()
3431 rajveer 13001 
    if self.ex is not None:
2536 chandransh 13002 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13003 
      self.ex.write(oprot)
13004 
      oprot.writeFieldEnd()
13005 
    oprot.writeFieldStop()
13006 
    oprot.writeStructEnd()
13007 
 
3431 rajveer 13008 
  def validate(self):
13009 
    return
13010 
 
13011 
 
2536 chandransh 13012 
  def __repr__(self):
13013 
    L = ['%s=%r' % (key, value)
13014 
      for key, value in self.__dict__.iteritems()]
13015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13016 
 
13017 
  def __eq__(self, other):
13018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13019 
 
13020 
  def __ne__(self, other):
13021 
    return not (self == other)
13022 
 
13023 
class authorizePickup_args:
13024 
  """
13025 
  Attributes:
13026 
   - orderId
13027 
   - pickupNumber
4602 rajveer 13028 
   - providerId
2536 chandransh 13029 
  """
13030 
 
13031 
  thrift_spec = (
13032 
    None, # 0
13033 
    (1, TType.I64, 'orderId', None, None, ), # 1
13034 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 13035 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 13036 
  )
13037 
 
4602 rajveer 13038 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 13039 
    self.orderId = orderId
13040 
    self.pickupNumber = pickupNumber
4602 rajveer 13041 
    self.providerId = providerId
2536 chandransh 13042 
 
13043 
  def read(self, iprot):
13044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13046 
      return
13047 
    iprot.readStructBegin()
13048 
    while True:
13049 
      (fname, ftype, fid) = iprot.readFieldBegin()
13050 
      if ftype == TType.STOP:
13051 
        break
13052 
      if fid == 1:
13053 
        if ftype == TType.I64:
13054 
          self.orderId = iprot.readI64();
13055 
        else:
13056 
          iprot.skip(ftype)
13057 
      elif fid == 2:
13058 
        if ftype == TType.STRING:
13059 
          self.pickupNumber = iprot.readString();
13060 
        else:
13061 
          iprot.skip(ftype)
4602 rajveer 13062 
      elif fid == 3:
13063 
        if ftype == TType.I64:
13064 
          self.providerId = iprot.readI64();
13065 
        else:
13066 
          iprot.skip(ftype)
2536 chandransh 13067 
      else:
13068 
        iprot.skip(ftype)
13069 
      iprot.readFieldEnd()
13070 
    iprot.readStructEnd()
13071 
 
13072 
  def write(self, oprot):
13073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13075 
      return
13076 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 13077 
    if self.orderId is not None:
2536 chandransh 13078 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13079 
      oprot.writeI64(self.orderId)
13080 
      oprot.writeFieldEnd()
3431 rajveer 13081 
    if self.pickupNumber is not None:
2536 chandransh 13082 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
13083 
      oprot.writeString(self.pickupNumber)
13084 
      oprot.writeFieldEnd()
4602 rajveer 13085 
    if self.providerId is not None:
13086 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
13087 
      oprot.writeI64(self.providerId)
13088 
      oprot.writeFieldEnd()
2536 chandransh 13089 
    oprot.writeFieldStop()
13090 
    oprot.writeStructEnd()
13091 
 
3431 rajveer 13092 
  def validate(self):
13093 
    return
13094 
 
13095 
 
2536 chandransh 13096 
  def __repr__(self):
13097 
    L = ['%s=%r' % (key, value)
13098 
      for key, value in self.__dict__.iteritems()]
13099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13100 
 
13101 
  def __eq__(self, other):
13102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13103 
 
13104 
  def __ne__(self, other):
13105 
    return not (self == other)
13106 
 
13107 
class authorizePickup_result:
13108 
  """
13109 
  Attributes:
13110 
   - success
13111 
   - ex
13112 
  """
13113 
 
13114 
  thrift_spec = (
13115 
    (0, TType.BOOL, 'success', None, None, ), # 0
13116 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13117 
  )
13118 
 
13119 
  def __init__(self, success=None, ex=None,):
13120 
    self.success = success
13121 
    self.ex = ex
13122 
 
13123 
  def read(self, iprot):
13124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13126 
      return
13127 
    iprot.readStructBegin()
13128 
    while True:
13129 
      (fname, ftype, fid) = iprot.readFieldBegin()
13130 
      if ftype == TType.STOP:
13131 
        break
13132 
      if fid == 0:
13133 
        if ftype == TType.BOOL:
13134 
          self.success = iprot.readBool();
13135 
        else:
13136 
          iprot.skip(ftype)
13137 
      elif fid == 1:
13138 
        if ftype == TType.STRUCT:
13139 
          self.ex = TransactionServiceException()
13140 
          self.ex.read(iprot)
13141 
        else:
13142 
          iprot.skip(ftype)
13143 
      else:
13144 
        iprot.skip(ftype)
13145 
      iprot.readFieldEnd()
13146 
    iprot.readStructEnd()
13147 
 
13148 
  def write(self, oprot):
13149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13151 
      return
13152 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 13153 
    if self.success is not None:
2536 chandransh 13154 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13155 
      oprot.writeBool(self.success)
13156 
      oprot.writeFieldEnd()
3431 rajveer 13157 
    if self.ex is not None:
2536 chandransh 13158 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13159 
      self.ex.write(oprot)
13160 
      oprot.writeFieldEnd()
13161 
    oprot.writeFieldStop()
13162 
    oprot.writeStructEnd()
13163 
 
3431 rajveer 13164 
  def validate(self):
13165 
    return
13166 
 
13167 
 
2536 chandransh 13168 
  def __repr__(self):
13169 
    L = ['%s=%r' % (key, value)
13170 
      for key, value in self.__dict__.iteritems()]
13171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13172 
 
13173 
  def __eq__(self, other):
13174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13175 
 
13176 
  def __ne__(self, other):
13177 
    return not (self == other)
13178 
 
2764 chandransh 13179 
class markDoasAsPickedUp_args:
13180 
  """
13181 
  Attributes:
13182 
   - providerId
13183 
   - pickupDetails
13184 
  """
13185 
 
13186 
  thrift_spec = (
13187 
    None, # 0
13188 
    (1, TType.I64, 'providerId', None, None, ), # 1
13189 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
13190 
  )
13191 
 
13192 
  def __init__(self, providerId=None, pickupDetails=None,):
13193 
    self.providerId = providerId
13194 
    self.pickupDetails = pickupDetails
13195 
 
13196 
  def read(self, iprot):
13197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13199 
      return
13200 
    iprot.readStructBegin()
13201 
    while True:
13202 
      (fname, ftype, fid) = iprot.readFieldBegin()
13203 
      if ftype == TType.STOP:
13204 
        break
13205 
      if fid == 1:
13206 
        if ftype == TType.I64:
13207 
          self.providerId = iprot.readI64();
13208 
        else:
13209 
          iprot.skip(ftype)
13210 
      elif fid == 2:
13211 
        if ftype == TType.MAP:
13212 
          self.pickupDetails = {}
4801 anupam.sin 13213 
          (_ktype219, _vtype220, _size218 ) = iprot.readMapBegin()
13214 
          for _i222 in xrange(_size218):
13215 
            _key223 = iprot.readString();
13216 
            _val224 = iprot.readString();
13217 
            self.pickupDetails[_key223] = _val224
2764 chandransh 13218 
          iprot.readMapEnd()
13219 
        else:
13220 
          iprot.skip(ftype)
13221 
      else:
13222 
        iprot.skip(ftype)
13223 
      iprot.readFieldEnd()
13224 
    iprot.readStructEnd()
13225 
 
13226 
  def write(self, oprot):
13227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13229 
      return
13230 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 13231 
    if self.providerId is not None:
2764 chandransh 13232 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13233 
      oprot.writeI64(self.providerId)
13234 
      oprot.writeFieldEnd()
3431 rajveer 13235 
    if self.pickupDetails is not None:
2764 chandransh 13236 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13237 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4801 anupam.sin 13238 
      for kiter225,viter226 in self.pickupDetails.items():
13239 
        oprot.writeString(kiter225)
13240 
        oprot.writeString(viter226)
2764 chandransh 13241 
      oprot.writeMapEnd()
13242 
      oprot.writeFieldEnd()
13243 
    oprot.writeFieldStop()
13244 
    oprot.writeStructEnd()
13245 
 
3431 rajveer 13246 
  def validate(self):
13247 
    return
13248 
 
13249 
 
2764 chandransh 13250 
  def __repr__(self):
13251 
    L = ['%s=%r' % (key, value)
13252 
      for key, value in self.__dict__.iteritems()]
13253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13254 
 
13255 
  def __eq__(self, other):
13256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13257 
 
13258 
  def __ne__(self, other):
13259 
    return not (self == other)
13260 
 
13261 
class markDoasAsPickedUp_result:
13262 
  """
13263 
  Attributes:
13264 
   - success
13265 
  """
13266 
 
13267 
  thrift_spec = (
13268 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13269 
  )
13270 
 
13271 
  def __init__(self, success=None,):
13272 
    self.success = success
13273 
 
13274 
  def read(self, iprot):
13275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13277 
      return
13278 
    iprot.readStructBegin()
13279 
    while True:
13280 
      (fname, ftype, fid) = iprot.readFieldBegin()
13281 
      if ftype == TType.STOP:
13282 
        break
13283 
      if fid == 0:
13284 
        if ftype == TType.LIST:
13285 
          self.success = []
4801 anupam.sin 13286 
          (_etype230, _size227) = iprot.readListBegin()
13287 
          for _i231 in xrange(_size227):
13288 
            _elem232 = Order()
13289 
            _elem232.read(iprot)
13290 
            self.success.append(_elem232)
2764 chandransh 13291 
          iprot.readListEnd()
13292 
        else:
13293 
          iprot.skip(ftype)
13294 
      else:
13295 
        iprot.skip(ftype)
13296 
      iprot.readFieldEnd()
13297 
    iprot.readStructEnd()
13298 
 
13299 
  def write(self, oprot):
13300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13302 
      return
13303 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 13304 
    if self.success is not None:
2764 chandransh 13305 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13306 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 13307 
      for iter233 in self.success:
13308 
        iter233.write(oprot)
2764 chandransh 13309 
      oprot.writeListEnd()
13310 
      oprot.writeFieldEnd()
13311 
    oprot.writeFieldStop()
13312 
    oprot.writeStructEnd()
13313 
 
3431 rajveer 13314 
  def validate(self):
13315 
    return
13316 
 
13317 
 
2764 chandransh 13318 
  def __repr__(self):
13319 
    L = ['%s=%r' % (key, value)
13320 
      for key, value in self.__dict__.iteritems()]
13321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13322 
 
13323 
  def __eq__(self, other):
13324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13325 
 
13326 
  def __ne__(self, other):
13327 
    return not (self == other)
13328 
 
4741 phani.kuma 13329 
class markReturnOrdersAsPickedUp_args:
13330 
  """
13331 
  Attributes:
13332 
   - providerId
13333 
   - pickupDetails
13334 
  """
13335 
 
13336 
  thrift_spec = (
13337 
    None, # 0
13338 
    (1, TType.I64, 'providerId', None, None, ), # 1
13339 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
13340 
  )
13341 
 
13342 
  def __init__(self, providerId=None, pickupDetails=None,):
13343 
    self.providerId = providerId
13344 
    self.pickupDetails = pickupDetails
13345 
 
13346 
  def read(self, iprot):
13347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13349 
      return
13350 
    iprot.readStructBegin()
13351 
    while True:
13352 
      (fname, ftype, fid) = iprot.readFieldBegin()
13353 
      if ftype == TType.STOP:
13354 
        break
13355 
      if fid == 1:
13356 
        if ftype == TType.I64:
13357 
          self.providerId = iprot.readI64();
13358 
        else:
13359 
          iprot.skip(ftype)
13360 
      elif fid == 2:
13361 
        if ftype == TType.MAP:
13362 
          self.pickupDetails = {}
4801 anupam.sin 13363 
          (_ktype235, _vtype236, _size234 ) = iprot.readMapBegin()
13364 
          for _i238 in xrange(_size234):
13365 
            _key239 = iprot.readString();
13366 
            _val240 = iprot.readString();
13367 
            self.pickupDetails[_key239] = _val240
4741 phani.kuma 13368 
          iprot.readMapEnd()
13369 
        else:
13370 
          iprot.skip(ftype)
13371 
      else:
13372 
        iprot.skip(ftype)
13373 
      iprot.readFieldEnd()
13374 
    iprot.readStructEnd()
13375 
 
13376 
  def write(self, oprot):
13377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13379 
      return
13380 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
13381 
    if self.providerId is not None:
13382 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13383 
      oprot.writeI64(self.providerId)
13384 
      oprot.writeFieldEnd()
13385 
    if self.pickupDetails is not None:
13386 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13387 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4801 anupam.sin 13388 
      for kiter241,viter242 in self.pickupDetails.items():
13389 
        oprot.writeString(kiter241)
13390 
        oprot.writeString(viter242)
4741 phani.kuma 13391 
      oprot.writeMapEnd()
13392 
      oprot.writeFieldEnd()
13393 
    oprot.writeFieldStop()
13394 
    oprot.writeStructEnd()
13395 
 
13396 
  def validate(self):
13397 
    return
13398 
 
13399 
 
13400 
  def __repr__(self):
13401 
    L = ['%s=%r' % (key, value)
13402 
      for key, value in self.__dict__.iteritems()]
13403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13404 
 
13405 
  def __eq__(self, other):
13406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13407 
 
13408 
  def __ne__(self, other):
13409 
    return not (self == other)
13410 
 
13411 
class markReturnOrdersAsPickedUp_result:
13412 
  """
13413 
  Attributes:
13414 
   - success
13415 
  """
13416 
 
13417 
  thrift_spec = (
13418 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13419 
  )
13420 
 
13421 
  def __init__(self, success=None,):
13422 
    self.success = success
13423 
 
13424 
  def read(self, iprot):
13425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13427 
      return
13428 
    iprot.readStructBegin()
13429 
    while True:
13430 
      (fname, ftype, fid) = iprot.readFieldBegin()
13431 
      if ftype == TType.STOP:
13432 
        break
13433 
      if fid == 0:
13434 
        if ftype == TType.LIST:
13435 
          self.success = []
4801 anupam.sin 13436 
          (_etype246, _size243) = iprot.readListBegin()
13437 
          for _i247 in xrange(_size243):
13438 
            _elem248 = Order()
13439 
            _elem248.read(iprot)
13440 
            self.success.append(_elem248)
4741 phani.kuma 13441 
          iprot.readListEnd()
13442 
        else:
13443 
          iprot.skip(ftype)
13444 
      else:
13445 
        iprot.skip(ftype)
13446 
      iprot.readFieldEnd()
13447 
    iprot.readStructEnd()
13448 
 
13449 
  def write(self, oprot):
13450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13452 
      return
13453 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
13454 
    if self.success is not None:
13455 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13456 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 13457 
      for iter249 in self.success:
13458 
        iter249.write(oprot)
4741 phani.kuma 13459 
      oprot.writeListEnd()
13460 
      oprot.writeFieldEnd()
13461 
    oprot.writeFieldStop()
13462 
    oprot.writeStructEnd()
13463 
 
13464 
  def validate(self):
13465 
    return
13466 
 
13467 
 
13468 
  def __repr__(self):
13469 
    L = ['%s=%r' % (key, value)
13470 
      for key, value in self.__dict__.iteritems()]
13471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13472 
 
13473 
  def __eq__(self, other):
13474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13475 
 
13476 
  def __ne__(self, other):
13477 
    return not (self == other)
13478 
 
2616 chandransh 13479 
class receiveReturn_args:
2591 chandransh 13480 
  """
13481 
  Attributes:
13482 
   - orderId
4479 rajveer 13483 
   - receiveCondition
2591 chandransh 13484 
  """
2536 chandransh 13485 
 
2591 chandransh 13486 
  thrift_spec = (
13487 
    None, # 0
13488 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 13489 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 13490 
  )
13491 
 
4479 rajveer 13492 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 13493 
    self.orderId = orderId
4479 rajveer 13494 
    self.receiveCondition = receiveCondition
2591 chandransh 13495 
 
13496 
  def read(self, iprot):
13497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13499 
      return
13500 
    iprot.readStructBegin()
13501 
    while True:
13502 
      (fname, ftype, fid) = iprot.readFieldBegin()
13503 
      if ftype == TType.STOP:
13504 
        break
13505 
      if fid == 1:
13506 
        if ftype == TType.I64:
13507 
          self.orderId = iprot.readI64();
13508 
        else:
13509 
          iprot.skip(ftype)
4479 rajveer 13510 
      elif fid == 2:
13511 
        if ftype == TType.I64:
13512 
          self.receiveCondition = iprot.readI64();
13513 
        else:
13514 
          iprot.skip(ftype)
2591 chandransh 13515 
      else:
13516 
        iprot.skip(ftype)
13517 
      iprot.readFieldEnd()
13518 
    iprot.readStructEnd()
13519 
 
13520 
  def write(self, oprot):
13521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13523 
      return
2616 chandransh 13524 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 13525 
    if self.orderId is not None:
2591 chandransh 13526 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13527 
      oprot.writeI64(self.orderId)
13528 
      oprot.writeFieldEnd()
4479 rajveer 13529 
    if self.receiveCondition is not None:
13530 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
13531 
      oprot.writeI64(self.receiveCondition)
13532 
      oprot.writeFieldEnd()
2591 chandransh 13533 
    oprot.writeFieldStop()
13534 
    oprot.writeStructEnd()
13535 
 
3431 rajveer 13536 
  def validate(self):
13537 
    return
13538 
 
13539 
 
2591 chandransh 13540 
  def __repr__(self):
13541 
    L = ['%s=%r' % (key, value)
13542 
      for key, value in self.__dict__.iteritems()]
13543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13544 
 
13545 
  def __eq__(self, other):
13546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13547 
 
13548 
  def __ne__(self, other):
13549 
    return not (self == other)
13550 
 
2616 chandransh 13551 
class receiveReturn_result:
2591 chandransh 13552 
  """
13553 
  Attributes:
13554 
   - success
13555 
   - ex
13556 
  """
13557 
 
13558 
  thrift_spec = (
13559 
    (0, TType.BOOL, 'success', None, None, ), # 0
13560 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13561 
  )
13562 
 
13563 
  def __init__(self, success=None, ex=None,):
13564 
    self.success = success
13565 
    self.ex = ex
13566 
 
13567 
  def read(self, iprot):
13568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13570 
      return
13571 
    iprot.readStructBegin()
13572 
    while True:
13573 
      (fname, ftype, fid) = iprot.readFieldBegin()
13574 
      if ftype == TType.STOP:
13575 
        break
13576 
      if fid == 0:
13577 
        if ftype == TType.BOOL:
13578 
          self.success = iprot.readBool();
13579 
        else:
13580 
          iprot.skip(ftype)
13581 
      elif fid == 1:
13582 
        if ftype == TType.STRUCT:
13583 
          self.ex = TransactionServiceException()
13584 
          self.ex.read(iprot)
13585 
        else:
13586 
          iprot.skip(ftype)
13587 
      else:
13588 
        iprot.skip(ftype)
13589 
      iprot.readFieldEnd()
13590 
    iprot.readStructEnd()
13591 
 
13592 
  def write(self, oprot):
13593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13595 
      return
2616 chandransh 13596 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 13597 
    if self.success is not None:
2591 chandransh 13598 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13599 
      oprot.writeBool(self.success)
13600 
      oprot.writeFieldEnd()
3431 rajveer 13601 
    if self.ex is not None:
2591 chandransh 13602 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13603 
      self.ex.write(oprot)
13604 
      oprot.writeFieldEnd()
13605 
    oprot.writeFieldStop()
13606 
    oprot.writeStructEnd()
13607 
 
3431 rajveer 13608 
  def validate(self):
13609 
    return
13610 
 
13611 
 
2591 chandransh 13612 
  def __repr__(self):
13613 
    L = ['%s=%r' % (key, value)
13614 
      for key, value in self.__dict__.iteritems()]
13615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13616 
 
13617 
  def __eq__(self, other):
13618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13619 
 
13620 
  def __ne__(self, other):
13621 
    return not (self == other)
13622 
 
13623 
class validateDoa_args:
13624 
  """
13625 
  Attributes:
13626 
   - orderId
13627 
   - isValid
13628 
  """
13629 
 
13630 
  thrift_spec = (
13631 
    None, # 0
13632 
    (1, TType.I64, 'orderId', None, None, ), # 1
13633 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
13634 
  )
13635 
 
13636 
  def __init__(self, orderId=None, isValid=None,):
13637 
    self.orderId = orderId
13638 
    self.isValid = isValid
13639 
 
13640 
  def read(self, iprot):
13641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13643 
      return
13644 
    iprot.readStructBegin()
13645 
    while True:
13646 
      (fname, ftype, fid) = iprot.readFieldBegin()
13647 
      if ftype == TType.STOP:
13648 
        break
13649 
      if fid == 1:
13650 
        if ftype == TType.I64:
13651 
          self.orderId = iprot.readI64();
13652 
        else:
13653 
          iprot.skip(ftype)
13654 
      elif fid == 2:
13655 
        if ftype == TType.BOOL:
13656 
          self.isValid = iprot.readBool();
13657 
        else:
13658 
          iprot.skip(ftype)
13659 
      else:
13660 
        iprot.skip(ftype)
13661 
      iprot.readFieldEnd()
13662 
    iprot.readStructEnd()
13663 
 
13664 
  def write(self, oprot):
13665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13667 
      return
13668 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 13669 
    if self.orderId is not None:
2591 chandransh 13670 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13671 
      oprot.writeI64(self.orderId)
13672 
      oprot.writeFieldEnd()
3431 rajveer 13673 
    if self.isValid is not None:
2591 chandransh 13674 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
13675 
      oprot.writeBool(self.isValid)
13676 
      oprot.writeFieldEnd()
13677 
    oprot.writeFieldStop()
13678 
    oprot.writeStructEnd()
13679 
 
3431 rajveer 13680 
  def validate(self):
13681 
    return
13682 
 
13683 
 
2591 chandransh 13684 
  def __repr__(self):
13685 
    L = ['%s=%r' % (key, value)
13686 
      for key, value in self.__dict__.iteritems()]
13687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13688 
 
13689 
  def __eq__(self, other):
13690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13691 
 
13692 
  def __ne__(self, other):
13693 
    return not (self == other)
13694 
 
13695 
class validateDoa_result:
13696 
  """
13697 
  Attributes:
13698 
   - success
13699 
   - ex
13700 
  """
13701 
 
13702 
  thrift_spec = (
13703 
    (0, TType.BOOL, 'success', None, None, ), # 0
13704 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13705 
  )
13706 
 
13707 
  def __init__(self, success=None, ex=None,):
13708 
    self.success = success
13709 
    self.ex = ex
13710 
 
13711 
  def read(self, iprot):
13712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13714 
      return
13715 
    iprot.readStructBegin()
13716 
    while True:
13717 
      (fname, ftype, fid) = iprot.readFieldBegin()
13718 
      if ftype == TType.STOP:
13719 
        break
13720 
      if fid == 0:
13721 
        if ftype == TType.BOOL:
13722 
          self.success = iprot.readBool();
13723 
        else:
13724 
          iprot.skip(ftype)
13725 
      elif fid == 1:
13726 
        if ftype == TType.STRUCT:
13727 
          self.ex = TransactionServiceException()
13728 
          self.ex.read(iprot)
13729 
        else:
13730 
          iprot.skip(ftype)
13731 
      else:
13732 
        iprot.skip(ftype)
13733 
      iprot.readFieldEnd()
13734 
    iprot.readStructEnd()
13735 
 
13736 
  def write(self, oprot):
13737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13739 
      return
13740 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 13741 
    if self.success is not None:
2591 chandransh 13742 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13743 
      oprot.writeBool(self.success)
13744 
      oprot.writeFieldEnd()
3431 rajveer 13745 
    if self.ex is not None:
2591 chandransh 13746 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13747 
      self.ex.write(oprot)
13748 
      oprot.writeFieldEnd()
13749 
    oprot.writeFieldStop()
13750 
    oprot.writeStructEnd()
13751 
 
3431 rajveer 13752 
  def validate(self):
13753 
    return
13754 
 
13755 
 
2591 chandransh 13756 
  def __repr__(self):
13757 
    L = ['%s=%r' % (key, value)
13758 
      for key, value in self.__dict__.iteritems()]
13759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13760 
 
13761 
  def __eq__(self, other):
13762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13763 
 
13764 
  def __ne__(self, other):
13765 
    return not (self == other)
13766 
 
4495 rajveer 13767 
class validateReturnProduct_args:
13768 
  """
13769 
  Attributes:
13770 
   - orderId
13771 
   - isUsable
13772 
  """
13773 
 
13774 
  thrift_spec = (
13775 
    None, # 0
13776 
    (1, TType.I64, 'orderId', None, None, ), # 1
13777 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
13778 
  )
13779 
 
13780 
  def __init__(self, orderId=None, isUsable=None,):
13781 
    self.orderId = orderId
13782 
    self.isUsable = isUsable
13783 
 
13784 
  def read(self, iprot):
13785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13787 
      return
13788 
    iprot.readStructBegin()
13789 
    while True:
13790 
      (fname, ftype, fid) = iprot.readFieldBegin()
13791 
      if ftype == TType.STOP:
13792 
        break
13793 
      if fid == 1:
13794 
        if ftype == TType.I64:
13795 
          self.orderId = iprot.readI64();
13796 
        else:
13797 
          iprot.skip(ftype)
13798 
      elif fid == 2:
13799 
        if ftype == TType.BOOL:
13800 
          self.isUsable = iprot.readBool();
13801 
        else:
13802 
          iprot.skip(ftype)
13803 
      else:
13804 
        iprot.skip(ftype)
13805 
      iprot.readFieldEnd()
13806 
    iprot.readStructEnd()
13807 
 
13808 
  def write(self, oprot):
13809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13811 
      return
13812 
    oprot.writeStructBegin('validateReturnProduct_args')
13813 
    if self.orderId is not None:
13814 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13815 
      oprot.writeI64(self.orderId)
13816 
      oprot.writeFieldEnd()
13817 
    if self.isUsable is not None:
13818 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
13819 
      oprot.writeBool(self.isUsable)
13820 
      oprot.writeFieldEnd()
13821 
    oprot.writeFieldStop()
13822 
    oprot.writeStructEnd()
13823 
 
13824 
  def validate(self):
13825 
    return
13826 
 
13827 
 
13828 
  def __repr__(self):
13829 
    L = ['%s=%r' % (key, value)
13830 
      for key, value in self.__dict__.iteritems()]
13831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13832 
 
13833 
  def __eq__(self, other):
13834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13835 
 
13836 
  def __ne__(self, other):
13837 
    return not (self == other)
13838 
 
13839 
class validateReturnProduct_result:
13840 
  """
13841 
  Attributes:
13842 
   - success
13843 
   - ex
13844 
  """
13845 
 
13846 
  thrift_spec = (
13847 
    (0, TType.BOOL, 'success', None, None, ), # 0
13848 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13849 
  )
13850 
 
13851 
  def __init__(self, success=None, ex=None,):
13852 
    self.success = success
13853 
    self.ex = ex
13854 
 
13855 
  def read(self, iprot):
13856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13858 
      return
13859 
    iprot.readStructBegin()
13860 
    while True:
13861 
      (fname, ftype, fid) = iprot.readFieldBegin()
13862 
      if ftype == TType.STOP:
13863 
        break
13864 
      if fid == 0:
13865 
        if ftype == TType.BOOL:
13866 
          self.success = iprot.readBool();
13867 
        else:
13868 
          iprot.skip(ftype)
13869 
      elif fid == 1:
13870 
        if ftype == TType.STRUCT:
13871 
          self.ex = TransactionServiceException()
13872 
          self.ex.read(iprot)
13873 
        else:
13874 
          iprot.skip(ftype)
13875 
      else:
13876 
        iprot.skip(ftype)
13877 
      iprot.readFieldEnd()
13878 
    iprot.readStructEnd()
13879 
 
13880 
  def write(self, oprot):
13881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13883 
      return
13884 
    oprot.writeStructBegin('validateReturnProduct_result')
13885 
    if self.success is not None:
13886 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13887 
      oprot.writeBool(self.success)
13888 
      oprot.writeFieldEnd()
13889 
    if self.ex is not None:
13890 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13891 
      self.ex.write(oprot)
13892 
      oprot.writeFieldEnd()
13893 
    oprot.writeFieldStop()
13894 
    oprot.writeStructEnd()
13895 
 
13896 
  def validate(self):
13897 
    return
13898 
 
13899 
 
13900 
  def __repr__(self):
13901 
    L = ['%s=%r' % (key, value)
13902 
      for key, value in self.__dict__.iteritems()]
13903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13904 
 
13905 
  def __eq__(self, other):
13906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13907 
 
13908 
  def __ne__(self, other):
13909 
    return not (self == other)
13910 
 
2616 chandransh 13911 
class reshipOrder_args:
13912 
  """
13913 
  Attributes:
13914 
   - orderId
13915 
  """
2591 chandransh 13916 
 
2616 chandransh 13917 
  thrift_spec = (
13918 
    None, # 0
13919 
    (1, TType.I64, 'orderId', None, None, ), # 1
13920 
  )
13921 
 
13922 
  def __init__(self, orderId=None,):
13923 
    self.orderId = orderId
13924 
 
13925 
  def read(self, iprot):
13926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13928 
      return
13929 
    iprot.readStructBegin()
13930 
    while True:
13931 
      (fname, ftype, fid) = iprot.readFieldBegin()
13932 
      if ftype == TType.STOP:
13933 
        break
13934 
      if fid == 1:
13935 
        if ftype == TType.I64:
13936 
          self.orderId = iprot.readI64();
13937 
        else:
13938 
          iprot.skip(ftype)
13939 
      else:
13940 
        iprot.skip(ftype)
13941 
      iprot.readFieldEnd()
13942 
    iprot.readStructEnd()
13943 
 
13944 
  def write(self, oprot):
13945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13947 
      return
13948 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 13949 
    if self.orderId is not None:
2616 chandransh 13950 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13951 
      oprot.writeI64(self.orderId)
13952 
      oprot.writeFieldEnd()
13953 
    oprot.writeFieldStop()
13954 
    oprot.writeStructEnd()
13955 
 
3431 rajveer 13956 
  def validate(self):
13957 
    return
13958 
 
13959 
 
2616 chandransh 13960 
  def __repr__(self):
13961 
    L = ['%s=%r' % (key, value)
13962 
      for key, value in self.__dict__.iteritems()]
13963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13964 
 
13965 
  def __eq__(self, other):
13966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13967 
 
13968 
  def __ne__(self, other):
13969 
    return not (self == other)
13970 
 
13971 
class reshipOrder_result:
13972 
  """
13973 
  Attributes:
13974 
   - success
13975 
   - ex
13976 
  """
13977 
 
13978 
  thrift_spec = (
13979 
    (0, TType.I64, 'success', None, None, ), # 0
13980 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13981 
  )
13982 
 
13983 
  def __init__(self, success=None, ex=None,):
13984 
    self.success = success
13985 
    self.ex = ex
13986 
 
13987 
  def read(self, iprot):
13988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13990 
      return
13991 
    iprot.readStructBegin()
13992 
    while True:
13993 
      (fname, ftype, fid) = iprot.readFieldBegin()
13994 
      if ftype == TType.STOP:
13995 
        break
13996 
      if fid == 0:
13997 
        if ftype == TType.I64:
13998 
          self.success = iprot.readI64();
13999 
        else:
14000 
          iprot.skip(ftype)
14001 
      elif fid == 1:
14002 
        if ftype == TType.STRUCT:
14003 
          self.ex = TransactionServiceException()
14004 
          self.ex.read(iprot)
14005 
        else:
14006 
          iprot.skip(ftype)
14007 
      else:
14008 
        iprot.skip(ftype)
14009 
      iprot.readFieldEnd()
14010 
    iprot.readStructEnd()
14011 
 
14012 
  def write(self, oprot):
14013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14015 
      return
14016 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 14017 
    if self.success is not None:
2616 chandransh 14018 
      oprot.writeFieldBegin('success', TType.I64, 0)
14019 
      oprot.writeI64(self.success)
14020 
      oprot.writeFieldEnd()
3431 rajveer 14021 
    if self.ex is not None:
2616 chandransh 14022 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14023 
      self.ex.write(oprot)
14024 
      oprot.writeFieldEnd()
14025 
    oprot.writeFieldStop()
14026 
    oprot.writeStructEnd()
14027 
 
3431 rajveer 14028 
  def validate(self):
14029 
    return
14030 
 
14031 
 
2616 chandransh 14032 
  def __repr__(self):
14033 
    L = ['%s=%r' % (key, value)
14034 
      for key, value in self.__dict__.iteritems()]
14035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14036 
 
14037 
  def __eq__(self, other):
14038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14039 
 
14040 
  def __ne__(self, other):
14041 
    return not (self == other)
14042 
 
14043 
class refundOrder_args:
14044 
  """
14045 
  Attributes:
14046 
   - orderId
3226 chandransh 14047 
   - refundedBy
14048 
   - reason
2616 chandransh 14049 
  """
14050 
 
14051 
  thrift_spec = (
14052 
    None, # 0
14053 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 14054 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
14055 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 14056 
  )
14057 
 
3226 chandransh 14058 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 14059 
    self.orderId = orderId
3226 chandransh 14060 
    self.refundedBy = refundedBy
14061 
    self.reason = reason
2616 chandransh 14062 
 
14063 
  def read(self, iprot):
14064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14066 
      return
14067 
    iprot.readStructBegin()
14068 
    while True:
14069 
      (fname, ftype, fid) = iprot.readFieldBegin()
14070 
      if ftype == TType.STOP:
14071 
        break
14072 
      if fid == 1:
14073 
        if ftype == TType.I64:
14074 
          self.orderId = iprot.readI64();
14075 
        else:
14076 
          iprot.skip(ftype)
3226 chandransh 14077 
      elif fid == 2:
14078 
        if ftype == TType.STRING:
14079 
          self.refundedBy = iprot.readString();
14080 
        else:
14081 
          iprot.skip(ftype)
14082 
      elif fid == 3:
14083 
        if ftype == TType.STRING:
14084 
          self.reason = iprot.readString();
14085 
        else:
14086 
          iprot.skip(ftype)
2616 chandransh 14087 
      else:
14088 
        iprot.skip(ftype)
14089 
      iprot.readFieldEnd()
14090 
    iprot.readStructEnd()
14091 
 
14092 
  def write(self, oprot):
14093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14095 
      return
14096 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 14097 
    if self.orderId is not None:
2616 chandransh 14098 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14099 
      oprot.writeI64(self.orderId)
14100 
      oprot.writeFieldEnd()
3431 rajveer 14101 
    if self.refundedBy is not None:
3226 chandransh 14102 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
14103 
      oprot.writeString(self.refundedBy)
14104 
      oprot.writeFieldEnd()
3431 rajveer 14105 
    if self.reason is not None:
3226 chandransh 14106 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14107 
      oprot.writeString(self.reason)
14108 
      oprot.writeFieldEnd()
2616 chandransh 14109 
    oprot.writeFieldStop()
14110 
    oprot.writeStructEnd()
14111 
 
3431 rajveer 14112 
  def validate(self):
14113 
    return
14114 
 
14115 
 
2616 chandransh 14116 
  def __repr__(self):
14117 
    L = ['%s=%r' % (key, value)
14118 
      for key, value in self.__dict__.iteritems()]
14119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14120 
 
14121 
  def __eq__(self, other):
14122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14123 
 
14124 
  def __ne__(self, other):
14125 
    return not (self == other)
14126 
 
14127 
class refundOrder_result:
14128 
  """
14129 
  Attributes:
14130 
   - success
14131 
   - ex
14132 
  """
14133 
 
14134 
  thrift_spec = (
14135 
    (0, TType.BOOL, 'success', None, None, ), # 0
14136 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14137 
  )
14138 
 
14139 
  def __init__(self, success=None, ex=None,):
14140 
    self.success = success
14141 
    self.ex = ex
14142 
 
14143 
  def read(self, iprot):
14144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14146 
      return
14147 
    iprot.readStructBegin()
14148 
    while True:
14149 
      (fname, ftype, fid) = iprot.readFieldBegin()
14150 
      if ftype == TType.STOP:
14151 
        break
14152 
      if fid == 0:
14153 
        if ftype == TType.BOOL:
14154 
          self.success = iprot.readBool();
14155 
        else:
14156 
          iprot.skip(ftype)
14157 
      elif fid == 1:
14158 
        if ftype == TType.STRUCT:
14159 
          self.ex = TransactionServiceException()
14160 
          self.ex.read(iprot)
14161 
        else:
14162 
          iprot.skip(ftype)
14163 
      else:
14164 
        iprot.skip(ftype)
14165 
      iprot.readFieldEnd()
14166 
    iprot.readStructEnd()
14167 
 
14168 
  def write(self, oprot):
14169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14171 
      return
14172 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 14173 
    if self.success is not None:
2616 chandransh 14174 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14175 
      oprot.writeBool(self.success)
14176 
      oprot.writeFieldEnd()
3431 rajveer 14177 
    if self.ex is not None:
2616 chandransh 14178 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14179 
      self.ex.write(oprot)
14180 
      oprot.writeFieldEnd()
14181 
    oprot.writeFieldStop()
14182 
    oprot.writeStructEnd()
14183 
 
3431 rajveer 14184 
  def validate(self):
14185 
    return
14186 
 
14187 
 
2616 chandransh 14188 
  def __repr__(self):
14189 
    L = ['%s=%r' % (key, value)
14190 
      for key, value in self.__dict__.iteritems()]
14191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14192 
 
14193 
  def __eq__(self, other):
14194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14195 
 
14196 
  def __ne__(self, other):
14197 
    return not (self == other)
14198 
 
2690 chandransh 14199 
class getReturnOrders_args:
14200 
  """
14201 
  Attributes:
14202 
   - warehouseId
14203 
   - fromDate
14204 
   - toDate
14205 
  """
2616 chandransh 14206 
 
2690 chandransh 14207 
  thrift_spec = (
14208 
    None, # 0
14209 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14210 
    (2, TType.I64, 'fromDate', None, None, ), # 2
14211 
    (3, TType.I64, 'toDate', None, None, ), # 3
14212 
  )
14213 
 
14214 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
14215 
    self.warehouseId = warehouseId
14216 
    self.fromDate = fromDate
14217 
    self.toDate = toDate
14218 
 
14219 
  def read(self, iprot):
14220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14222 
      return
14223 
    iprot.readStructBegin()
14224 
    while True:
14225 
      (fname, ftype, fid) = iprot.readFieldBegin()
14226 
      if ftype == TType.STOP:
14227 
        break
14228 
      if fid == 1:
14229 
        if ftype == TType.I64:
14230 
          self.warehouseId = iprot.readI64();
14231 
        else:
14232 
          iprot.skip(ftype)
14233 
      elif fid == 2:
14234 
        if ftype == TType.I64:
14235 
          self.fromDate = iprot.readI64();
14236 
        else:
14237 
          iprot.skip(ftype)
14238 
      elif fid == 3:
14239 
        if ftype == TType.I64:
14240 
          self.toDate = iprot.readI64();
14241 
        else:
14242 
          iprot.skip(ftype)
14243 
      else:
14244 
        iprot.skip(ftype)
14245 
      iprot.readFieldEnd()
14246 
    iprot.readStructEnd()
14247 
 
14248 
  def write(self, oprot):
14249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14251 
      return
14252 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 14253 
    if self.warehouseId is not None:
2690 chandransh 14254 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14255 
      oprot.writeI64(self.warehouseId)
14256 
      oprot.writeFieldEnd()
3431 rajveer 14257 
    if self.fromDate is not None:
2690 chandransh 14258 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
14259 
      oprot.writeI64(self.fromDate)
14260 
      oprot.writeFieldEnd()
3431 rajveer 14261 
    if self.toDate is not None:
2690 chandransh 14262 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
14263 
      oprot.writeI64(self.toDate)
14264 
      oprot.writeFieldEnd()
14265 
    oprot.writeFieldStop()
14266 
    oprot.writeStructEnd()
14267 
 
3431 rajveer 14268 
  def validate(self):
14269 
    return
14270 
 
14271 
 
2690 chandransh 14272 
  def __repr__(self):
14273 
    L = ['%s=%r' % (key, value)
14274 
      for key, value in self.__dict__.iteritems()]
14275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14276 
 
14277 
  def __eq__(self, other):
14278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14279 
 
14280 
  def __ne__(self, other):
14281 
    return not (self == other)
14282 
 
14283 
class getReturnOrders_result:
14284 
  """
14285 
  Attributes:
14286 
   - success
14287 
  """
14288 
 
14289 
  thrift_spec = (
14290 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
14291 
  )
14292 
 
14293 
  def __init__(self, success=None,):
14294 
    self.success = success
14295 
 
14296 
  def read(self, iprot):
14297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14299 
      return
14300 
    iprot.readStructBegin()
14301 
    while True:
14302 
      (fname, ftype, fid) = iprot.readFieldBegin()
14303 
      if ftype == TType.STOP:
14304 
        break
14305 
      if fid == 0:
14306 
        if ftype == TType.LIST:
14307 
          self.success = []
4801 anupam.sin 14308 
          (_etype253, _size250) = iprot.readListBegin()
14309 
          for _i254 in xrange(_size250):
14310 
            _elem255 = ReturnOrder()
14311 
            _elem255.read(iprot)
14312 
            self.success.append(_elem255)
2690 chandransh 14313 
          iprot.readListEnd()
14314 
        else:
14315 
          iprot.skip(ftype)
14316 
      else:
14317 
        iprot.skip(ftype)
14318 
      iprot.readFieldEnd()
14319 
    iprot.readStructEnd()
14320 
 
14321 
  def write(self, oprot):
14322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14324 
      return
14325 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 14326 
    if self.success is not None:
2690 chandransh 14327 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14328 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 14329 
      for iter256 in self.success:
14330 
        iter256.write(oprot)
2690 chandransh 14331 
      oprot.writeListEnd()
14332 
      oprot.writeFieldEnd()
14333 
    oprot.writeFieldStop()
14334 
    oprot.writeStructEnd()
14335 
 
3431 rajveer 14336 
  def validate(self):
14337 
    return
14338 
 
14339 
 
2690 chandransh 14340 
  def __repr__(self):
14341 
    L = ['%s=%r' % (key, value)
14342 
      for key, value in self.__dict__.iteritems()]
14343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14344 
 
14345 
  def __eq__(self, other):
14346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14347 
 
14348 
  def __ne__(self, other):
14349 
    return not (self == other)
14350 
 
2700 chandransh 14351 
class getReturnOrder_args:
14352 
  """
14353 
  Attributes:
14354 
   - id
14355 
  """
14356 
 
14357 
  thrift_spec = (
14358 
    None, # 0
14359 
    (1, TType.I64, 'id', None, None, ), # 1
14360 
  )
14361 
 
14362 
  def __init__(self, id=None,):
14363 
    self.id = id
14364 
 
14365 
  def read(self, iprot):
14366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14368 
      return
14369 
    iprot.readStructBegin()
14370 
    while True:
14371 
      (fname, ftype, fid) = iprot.readFieldBegin()
14372 
      if ftype == TType.STOP:
14373 
        break
14374 
      if fid == 1:
14375 
        if ftype == TType.I64:
14376 
          self.id = iprot.readI64();
14377 
        else:
14378 
          iprot.skip(ftype)
14379 
      else:
14380 
        iprot.skip(ftype)
14381 
      iprot.readFieldEnd()
14382 
    iprot.readStructEnd()
14383 
 
14384 
  def write(self, oprot):
14385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14387 
      return
14388 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 14389 
    if self.id is not None:
2700 chandransh 14390 
      oprot.writeFieldBegin('id', TType.I64, 1)
14391 
      oprot.writeI64(self.id)
14392 
      oprot.writeFieldEnd()
14393 
    oprot.writeFieldStop()
14394 
    oprot.writeStructEnd()
14395 
 
3431 rajveer 14396 
  def validate(self):
14397 
    return
14398 
 
14399 
 
2700 chandransh 14400 
  def __repr__(self):
14401 
    L = ['%s=%r' % (key, value)
14402 
      for key, value in self.__dict__.iteritems()]
14403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14404 
 
14405 
  def __eq__(self, other):
14406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14407 
 
14408 
  def __ne__(self, other):
14409 
    return not (self == other)
14410 
 
14411 
class getReturnOrder_result:
14412 
  """
14413 
  Attributes:
14414 
   - success
14415 
   - ex
14416 
  """
14417 
 
14418 
  thrift_spec = (
14419 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
14420 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14421 
  )
14422 
 
14423 
  def __init__(self, success=None, ex=None,):
14424 
    self.success = success
14425 
    self.ex = ex
14426 
 
14427 
  def read(self, iprot):
14428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14430 
      return
14431 
    iprot.readStructBegin()
14432 
    while True:
14433 
      (fname, ftype, fid) = iprot.readFieldBegin()
14434 
      if ftype == TType.STOP:
14435 
        break
14436 
      if fid == 0:
14437 
        if ftype == TType.STRUCT:
14438 
          self.success = ReturnOrder()
14439 
          self.success.read(iprot)
14440 
        else:
14441 
          iprot.skip(ftype)
14442 
      elif fid == 1:
14443 
        if ftype == TType.STRUCT:
14444 
          self.ex = TransactionServiceException()
14445 
          self.ex.read(iprot)
14446 
        else:
14447 
          iprot.skip(ftype)
14448 
      else:
14449 
        iprot.skip(ftype)
14450 
      iprot.readFieldEnd()
14451 
    iprot.readStructEnd()
14452 
 
14453 
  def write(self, oprot):
14454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14456 
      return
14457 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 14458 
    if self.success is not None:
2700 chandransh 14459 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14460 
      self.success.write(oprot)
14461 
      oprot.writeFieldEnd()
3431 rajveer 14462 
    if self.ex is not None:
2700 chandransh 14463 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14464 
      self.ex.write(oprot)
14465 
      oprot.writeFieldEnd()
14466 
    oprot.writeFieldStop()
14467 
    oprot.writeStructEnd()
14468 
 
3431 rajveer 14469 
  def validate(self):
14470 
    return
14471 
 
14472 
 
2700 chandransh 14473 
  def __repr__(self):
14474 
    L = ['%s=%r' % (key, value)
14475 
      for key, value in self.__dict__.iteritems()]
14476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14477 
 
14478 
  def __eq__(self, other):
14479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14480 
 
14481 
  def __ne__(self, other):
14482 
    return not (self == other)
14483 
 
2690 chandransh 14484 
class processReturn_args:
14485 
  """
14486 
  Attributes:
14487 
   - returnOrderId
14488 
  """
14489 
 
14490 
  thrift_spec = (
14491 
    None, # 0
14492 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
14493 
  )
14494 
 
14495 
  def __init__(self, returnOrderId=None,):
14496 
    self.returnOrderId = returnOrderId
14497 
 
14498 
  def read(self, iprot):
14499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14501 
      return
14502 
    iprot.readStructBegin()
14503 
    while True:
14504 
      (fname, ftype, fid) = iprot.readFieldBegin()
14505 
      if ftype == TType.STOP:
14506 
        break
14507 
      if fid == 1:
14508 
        if ftype == TType.I64:
14509 
          self.returnOrderId = iprot.readI64();
14510 
        else:
14511 
          iprot.skip(ftype)
14512 
      else:
14513 
        iprot.skip(ftype)
14514 
      iprot.readFieldEnd()
14515 
    iprot.readStructEnd()
14516 
 
14517 
  def write(self, oprot):
14518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14520 
      return
14521 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 14522 
    if self.returnOrderId is not None:
2690 chandransh 14523 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
14524 
      oprot.writeI64(self.returnOrderId)
14525 
      oprot.writeFieldEnd()
14526 
    oprot.writeFieldStop()
14527 
    oprot.writeStructEnd()
14528 
 
3431 rajveer 14529 
  def validate(self):
14530 
    return
14531 
 
14532 
 
2690 chandransh 14533 
  def __repr__(self):
14534 
    L = ['%s=%r' % (key, value)
14535 
      for key, value in self.__dict__.iteritems()]
14536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14537 
 
14538 
  def __eq__(self, other):
14539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14540 
 
14541 
  def __ne__(self, other):
14542 
    return not (self == other)
14543 
 
14544 
class processReturn_result:
14545 
  """
14546 
  Attributes:
14547 
   - ex
14548 
  """
14549 
 
14550 
  thrift_spec = (
14551 
    None, # 0
14552 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14553 
  )
14554 
 
14555 
  def __init__(self, ex=None,):
14556 
    self.ex = ex
14557 
 
14558 
  def read(self, iprot):
14559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14561 
      return
14562 
    iprot.readStructBegin()
14563 
    while True:
14564 
      (fname, ftype, fid) = iprot.readFieldBegin()
14565 
      if ftype == TType.STOP:
14566 
        break
14567 
      if fid == 1:
14568 
        if ftype == TType.STRUCT:
14569 
          self.ex = TransactionServiceException()
14570 
          self.ex.read(iprot)
14571 
        else:
14572 
          iprot.skip(ftype)
14573 
      else:
14574 
        iprot.skip(ftype)
14575 
      iprot.readFieldEnd()
14576 
    iprot.readStructEnd()
14577 
 
14578 
  def write(self, oprot):
14579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14581 
      return
14582 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 14583 
    if self.ex is not None:
2690 chandransh 14584 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14585 
      self.ex.write(oprot)
14586 
      oprot.writeFieldEnd()
14587 
    oprot.writeFieldStop()
14588 
    oprot.writeStructEnd()
14589 
 
3431 rajveer 14590 
  def validate(self):
14591 
    return
14592 
 
14593 
 
2690 chandransh 14594 
  def __repr__(self):
14595 
    L = ['%s=%r' % (key, value)
14596 
      for key, value in self.__dict__.iteritems()]
14597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14598 
 
14599 
  def __eq__(self, other):
14600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14601 
 
14602 
  def __ne__(self, other):
14603 
    return not (self == other)
14604 
 
3451 chandransh 14605 
class updateWeight_args:
14606 
  """
14607 
  Attributes:
14608 
   - orderId
14609 
   - weight
14610 
  """
14611 
 
14612 
  thrift_spec = (
14613 
    None, # 0
14614 
    (1, TType.I64, 'orderId', None, None, ), # 1
14615 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
14616 
  )
14617 
 
14618 
  def __init__(self, orderId=None, weight=None,):
14619 
    self.orderId = orderId
14620 
    self.weight = weight
14621 
 
14622 
  def read(self, iprot):
14623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14625 
      return
14626 
    iprot.readStructBegin()
14627 
    while True:
14628 
      (fname, ftype, fid) = iprot.readFieldBegin()
14629 
      if ftype == TType.STOP:
14630 
        break
14631 
      if fid == 1:
14632 
        if ftype == TType.I64:
14633 
          self.orderId = iprot.readI64();
14634 
        else:
14635 
          iprot.skip(ftype)
14636 
      elif fid == 2:
14637 
        if ftype == TType.DOUBLE:
14638 
          self.weight = iprot.readDouble();
14639 
        else:
14640 
          iprot.skip(ftype)
14641 
      else:
14642 
        iprot.skip(ftype)
14643 
      iprot.readFieldEnd()
14644 
    iprot.readStructEnd()
14645 
 
14646 
  def write(self, oprot):
14647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14649 
      return
14650 
    oprot.writeStructBegin('updateWeight_args')
14651 
    if self.orderId is not None:
14652 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14653 
      oprot.writeI64(self.orderId)
14654 
      oprot.writeFieldEnd()
14655 
    if self.weight is not None:
14656 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
14657 
      oprot.writeDouble(self.weight)
14658 
      oprot.writeFieldEnd()
14659 
    oprot.writeFieldStop()
14660 
    oprot.writeStructEnd()
14661 
 
14662 
  def validate(self):
14663 
    return
14664 
 
14665 
 
14666 
  def __repr__(self):
14667 
    L = ['%s=%r' % (key, value)
14668 
      for key, value in self.__dict__.iteritems()]
14669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14670 
 
14671 
  def __eq__(self, other):
14672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14673 
 
14674 
  def __ne__(self, other):
14675 
    return not (self == other)
14676 
 
14677 
class updateWeight_result:
14678 
  """
14679 
  Attributes:
14680 
   - success
14681 
   - ex
14682 
  """
14683 
 
14684 
  thrift_spec = (
14685 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14686 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14687 
  )
14688 
 
14689 
  def __init__(self, success=None, ex=None,):
14690 
    self.success = success
14691 
    self.ex = ex
14692 
 
14693 
  def read(self, iprot):
14694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14696 
      return
14697 
    iprot.readStructBegin()
14698 
    while True:
14699 
      (fname, ftype, fid) = iprot.readFieldBegin()
14700 
      if ftype == TType.STOP:
14701 
        break
14702 
      if fid == 0:
14703 
        if ftype == TType.STRUCT:
14704 
          self.success = Order()
14705 
          self.success.read(iprot)
14706 
        else:
14707 
          iprot.skip(ftype)
14708 
      elif fid == 1:
14709 
        if ftype == TType.STRUCT:
14710 
          self.ex = TransactionServiceException()
14711 
          self.ex.read(iprot)
14712 
        else:
14713 
          iprot.skip(ftype)
14714 
      else:
14715 
        iprot.skip(ftype)
14716 
      iprot.readFieldEnd()
14717 
    iprot.readStructEnd()
14718 
 
14719 
  def write(self, oprot):
14720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14722 
      return
14723 
    oprot.writeStructBegin('updateWeight_result')
14724 
    if self.success is not None:
14725 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14726 
      self.success.write(oprot)
14727 
      oprot.writeFieldEnd()
14728 
    if self.ex is not None:
14729 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14730 
      self.ex.write(oprot)
14731 
      oprot.writeFieldEnd()
14732 
    oprot.writeFieldStop()
14733 
    oprot.writeStructEnd()
14734 
 
14735 
  def validate(self):
14736 
    return
14737 
 
14738 
 
14739 
  def __repr__(self):
14740 
    L = ['%s=%r' % (key, value)
14741 
      for key, value in self.__dict__.iteritems()]
14742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14743 
 
14744 
  def __eq__(self, other):
14745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14746 
 
14747 
  def __ne__(self, other):
14748 
    return not (self == other)
3469 chandransh 14749 
 
14750 
class changeItem_args:
14751 
  """
14752 
  Attributes:
14753 
   - orderId
14754 
   - itemId
14755 
  """
14756 
 
14757 
  thrift_spec = (
14758 
    None, # 0
14759 
    (1, TType.I64, 'orderId', None, None, ), # 1
14760 
    (2, TType.I64, 'itemId', None, None, ), # 2
14761 
  )
14762 
 
14763 
  def __init__(self, orderId=None, itemId=None,):
14764 
    self.orderId = orderId
14765 
    self.itemId = itemId
14766 
 
14767 
  def read(self, iprot):
14768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14770 
      return
14771 
    iprot.readStructBegin()
14772 
    while True:
14773 
      (fname, ftype, fid) = iprot.readFieldBegin()
14774 
      if ftype == TType.STOP:
14775 
        break
14776 
      if fid == 1:
14777 
        if ftype == TType.I64:
14778 
          self.orderId = iprot.readI64();
14779 
        else:
14780 
          iprot.skip(ftype)
14781 
      elif fid == 2:
14782 
        if ftype == TType.I64:
14783 
          self.itemId = iprot.readI64();
14784 
        else:
14785 
          iprot.skip(ftype)
14786 
      else:
14787 
        iprot.skip(ftype)
14788 
      iprot.readFieldEnd()
14789 
    iprot.readStructEnd()
14790 
 
14791 
  def write(self, oprot):
14792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14794 
      return
14795 
    oprot.writeStructBegin('changeItem_args')
14796 
    if self.orderId is not None:
14797 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14798 
      oprot.writeI64(self.orderId)
14799 
      oprot.writeFieldEnd()
14800 
    if self.itemId is not None:
14801 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14802 
      oprot.writeI64(self.itemId)
14803 
      oprot.writeFieldEnd()
14804 
    oprot.writeFieldStop()
14805 
    oprot.writeStructEnd()
14806 
 
14807 
  def validate(self):
14808 
    return
14809 
 
14810 
 
14811 
  def __repr__(self):
14812 
    L = ['%s=%r' % (key, value)
14813 
      for key, value in self.__dict__.iteritems()]
14814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14815 
 
14816 
  def __eq__(self, other):
14817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14818 
 
14819 
  def __ne__(self, other):
14820 
    return not (self == other)
14821 
 
14822 
class changeItem_result:
14823 
  """
14824 
  Attributes:
14825 
   - success
14826 
   - ex
14827 
  """
14828 
 
14829 
  thrift_spec = (
14830 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14831 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14832 
  )
14833 
 
14834 
  def __init__(self, success=None, ex=None,):
14835 
    self.success = success
14836 
    self.ex = ex
14837 
 
14838 
  def read(self, iprot):
14839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14841 
      return
14842 
    iprot.readStructBegin()
14843 
    while True:
14844 
      (fname, ftype, fid) = iprot.readFieldBegin()
14845 
      if ftype == TType.STOP:
14846 
        break
14847 
      if fid == 0:
14848 
        if ftype == TType.STRUCT:
14849 
          self.success = Order()
14850 
          self.success.read(iprot)
14851 
        else:
14852 
          iprot.skip(ftype)
14853 
      elif fid == 1:
14854 
        if ftype == TType.STRUCT:
14855 
          self.ex = TransactionServiceException()
14856 
          self.ex.read(iprot)
14857 
        else:
14858 
          iprot.skip(ftype)
14859 
      else:
14860 
        iprot.skip(ftype)
14861 
      iprot.readFieldEnd()
14862 
    iprot.readStructEnd()
14863 
 
14864 
  def write(self, oprot):
14865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14867 
      return
14868 
    oprot.writeStructBegin('changeItem_result')
14869 
    if self.success is not None:
14870 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14871 
      self.success.write(oprot)
14872 
      oprot.writeFieldEnd()
14873 
    if self.ex is not None:
14874 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14875 
      self.ex.write(oprot)
14876 
      oprot.writeFieldEnd()
14877 
    oprot.writeFieldStop()
14878 
    oprot.writeStructEnd()
14879 
 
14880 
  def validate(self):
14881 
    return
14882 
 
14883 
 
14884 
  def __repr__(self):
14885 
    L = ['%s=%r' % (key, value)
14886 
      for key, value in self.__dict__.iteritems()]
14887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14888 
 
14889 
  def __eq__(self, other):
14890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14891 
 
14892 
  def __ne__(self, other):
14893 
    return not (self == other)
14894 
 
14895 
class shiftToWarehouse_args:
14896 
  """
14897 
  Attributes:
14898 
   - orderId
14899 
   - warehouseId
14900 
  """
14901 
 
14902 
  thrift_spec = (
14903 
    None, # 0
14904 
    (1, TType.I64, 'orderId', None, None, ), # 1
14905 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
14906 
  )
14907 
 
14908 
  def __init__(self, orderId=None, warehouseId=None,):
14909 
    self.orderId = orderId
14910 
    self.warehouseId = warehouseId
14911 
 
14912 
  def read(self, iprot):
14913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14915 
      return
14916 
    iprot.readStructBegin()
14917 
    while True:
14918 
      (fname, ftype, fid) = iprot.readFieldBegin()
14919 
      if ftype == TType.STOP:
14920 
        break
14921 
      if fid == 1:
14922 
        if ftype == TType.I64:
14923 
          self.orderId = iprot.readI64();
14924 
        else:
14925 
          iprot.skip(ftype)
14926 
      elif fid == 2:
14927 
        if ftype == TType.I64:
14928 
          self.warehouseId = iprot.readI64();
14929 
        else:
14930 
          iprot.skip(ftype)
14931 
      else:
14932 
        iprot.skip(ftype)
14933 
      iprot.readFieldEnd()
14934 
    iprot.readStructEnd()
14935 
 
14936 
  def write(self, oprot):
14937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14939 
      return
14940 
    oprot.writeStructBegin('shiftToWarehouse_args')
14941 
    if self.orderId is not None:
14942 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14943 
      oprot.writeI64(self.orderId)
14944 
      oprot.writeFieldEnd()
14945 
    if self.warehouseId is not None:
14946 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14947 
      oprot.writeI64(self.warehouseId)
14948 
      oprot.writeFieldEnd()
14949 
    oprot.writeFieldStop()
14950 
    oprot.writeStructEnd()
14951 
 
14952 
  def validate(self):
14953 
    return
14954 
 
14955 
 
14956 
  def __repr__(self):
14957 
    L = ['%s=%r' % (key, value)
14958 
      for key, value in self.__dict__.iteritems()]
14959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14960 
 
14961 
  def __eq__(self, other):
14962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14963 
 
14964 
  def __ne__(self, other):
14965 
    return not (self == other)
14966 
 
14967 
class shiftToWarehouse_result:
14968 
  """
14969 
  Attributes:
14970 
   - success
14971 
   - ex
14972 
  """
14973 
 
14974 
  thrift_spec = (
14975 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14976 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14977 
  )
14978 
 
14979 
  def __init__(self, success=None, ex=None,):
14980 
    self.success = success
14981 
    self.ex = ex
14982 
 
14983 
  def read(self, iprot):
14984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14986 
      return
14987 
    iprot.readStructBegin()
14988 
    while True:
14989 
      (fname, ftype, fid) = iprot.readFieldBegin()
14990 
      if ftype == TType.STOP:
14991 
        break
14992 
      if fid == 0:
14993 
        if ftype == TType.STRUCT:
14994 
          self.success = Order()
14995 
          self.success.read(iprot)
14996 
        else:
14997 
          iprot.skip(ftype)
14998 
      elif fid == 1:
14999 
        if ftype == TType.STRUCT:
15000 
          self.ex = TransactionServiceException()
15001 
          self.ex.read(iprot)
15002 
        else:
15003 
          iprot.skip(ftype)
15004 
      else:
15005 
        iprot.skip(ftype)
15006 
      iprot.readFieldEnd()
15007 
    iprot.readStructEnd()
15008 
 
15009 
  def write(self, oprot):
15010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15012 
      return
15013 
    oprot.writeStructBegin('shiftToWarehouse_result')
15014 
    if self.success is not None:
15015 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15016 
      self.success.write(oprot)
15017 
      oprot.writeFieldEnd()
15018 
    if self.ex is not None:
15019 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15020 
      self.ex.write(oprot)
15021 
      oprot.writeFieldEnd()
15022 
    oprot.writeFieldStop()
15023 
    oprot.writeStructEnd()
15024 
 
15025 
  def validate(self):
15026 
    return
15027 
 
15028 
 
15029 
  def __repr__(self):
15030 
    L = ['%s=%r' % (key, value)
15031 
      for key, value in self.__dict__.iteritems()]
15032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15033 
 
15034 
  def __eq__(self, other):
15035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15036 
 
15037 
  def __ne__(self, other):
15038 
    return not (self == other)
3553 chandransh 15039 
 
15040 
class addDelayReason_args:
15041 
  """
15042 
  Attributes:
15043 
   - orderId
15044 
   - delayReason
3986 chandransh 15045 
   - furtherDelay
4647 rajveer 15046 
   - delayReasonText
3553 chandransh 15047 
  """
15048 
 
15049 
  thrift_spec = (
15050 
    None, # 0
15051 
    (1, TType.I64, 'orderId', None, None, ), # 1
15052 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 15053 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 15054 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 15055 
  )
15056 
 
4647 rajveer 15057 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 15058 
    self.orderId = orderId
15059 
    self.delayReason = delayReason
3986 chandransh 15060 
    self.furtherDelay = furtherDelay
4647 rajveer 15061 
    self.delayReasonText = delayReasonText
3553 chandransh 15062 
 
15063 
  def read(self, iprot):
15064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15066 
      return
15067 
    iprot.readStructBegin()
15068 
    while True:
15069 
      (fname, ftype, fid) = iprot.readFieldBegin()
15070 
      if ftype == TType.STOP:
15071 
        break
15072 
      if fid == 1:
15073 
        if ftype == TType.I64:
15074 
          self.orderId = iprot.readI64();
15075 
        else:
15076 
          iprot.skip(ftype)
15077 
      elif fid == 2:
15078 
        if ftype == TType.I32:
15079 
          self.delayReason = iprot.readI32();
15080 
        else:
15081 
          iprot.skip(ftype)
3986 chandransh 15082 
      elif fid == 3:
15083 
        if ftype == TType.I64:
15084 
          self.furtherDelay = iprot.readI64();
15085 
        else:
15086 
          iprot.skip(ftype)
4647 rajveer 15087 
      elif fid == 4:
15088 
        if ftype == TType.STRING:
15089 
          self.delayReasonText = iprot.readString();
15090 
        else:
15091 
          iprot.skip(ftype)
3553 chandransh 15092 
      else:
15093 
        iprot.skip(ftype)
15094 
      iprot.readFieldEnd()
15095 
    iprot.readStructEnd()
15096 
 
15097 
  def write(self, oprot):
15098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15100 
      return
15101 
    oprot.writeStructBegin('addDelayReason_args')
15102 
    if self.orderId is not None:
15103 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15104 
      oprot.writeI64(self.orderId)
15105 
      oprot.writeFieldEnd()
15106 
    if self.delayReason is not None:
15107 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
15108 
      oprot.writeI32(self.delayReason)
15109 
      oprot.writeFieldEnd()
3986 chandransh 15110 
    if self.furtherDelay is not None:
15111 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
15112 
      oprot.writeI64(self.furtherDelay)
15113 
      oprot.writeFieldEnd()
4647 rajveer 15114 
    if self.delayReasonText is not None:
15115 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
15116 
      oprot.writeString(self.delayReasonText)
15117 
      oprot.writeFieldEnd()
3553 chandransh 15118 
    oprot.writeFieldStop()
15119 
    oprot.writeStructEnd()
15120 
 
15121 
  def validate(self):
15122 
    return
15123 
 
15124 
 
15125 
  def __repr__(self):
15126 
    L = ['%s=%r' % (key, value)
15127 
      for key, value in self.__dict__.iteritems()]
15128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15129 
 
15130 
  def __eq__(self, other):
15131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15132 
 
15133 
  def __ne__(self, other):
15134 
    return not (self == other)
15135 
 
15136 
class addDelayReason_result:
15137 
  """
15138 
  Attributes:
15139 
   - success
15140 
   - ex
15141 
  """
15142 
 
15143 
  thrift_spec = (
15144 
    (0, TType.BOOL, 'success', None, None, ), # 0
15145 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15146 
  )
15147 
 
15148 
  def __init__(self, success=None, ex=None,):
15149 
    self.success = success
15150 
    self.ex = ex
15151 
 
15152 
  def read(self, iprot):
15153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15155 
      return
15156 
    iprot.readStructBegin()
15157 
    while True:
15158 
      (fname, ftype, fid) = iprot.readFieldBegin()
15159 
      if ftype == TType.STOP:
15160 
        break
15161 
      if fid == 0:
15162 
        if ftype == TType.BOOL:
15163 
          self.success = iprot.readBool();
15164 
        else:
15165 
          iprot.skip(ftype)
15166 
      elif fid == 1:
15167 
        if ftype == TType.STRUCT:
15168 
          self.ex = TransactionServiceException()
15169 
          self.ex.read(iprot)
15170 
        else:
15171 
          iprot.skip(ftype)
15172 
      else:
15173 
        iprot.skip(ftype)
15174 
      iprot.readFieldEnd()
15175 
    iprot.readStructEnd()
15176 
 
15177 
  def write(self, oprot):
15178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15180 
      return
15181 
    oprot.writeStructBegin('addDelayReason_result')
15182 
    if self.success is not None:
15183 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15184 
      oprot.writeBool(self.success)
15185 
      oprot.writeFieldEnd()
15186 
    if self.ex is not None:
15187 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15188 
      self.ex.write(oprot)
15189 
      oprot.writeFieldEnd()
15190 
    oprot.writeFieldStop()
15191 
    oprot.writeStructEnd()
15192 
 
15193 
  def validate(self):
15194 
    return
15195 
 
15196 
 
15197 
  def __repr__(self):
15198 
    L = ['%s=%r' % (key, value)
15199 
      for key, value in self.__dict__.iteritems()]
15200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15201 
 
15202 
  def __eq__(self, other):
15203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15204 
 
15205 
  def __ne__(self, other):
15206 
    return not (self == other)
3956 chandransh 15207 
 
15208 
class reconcileCodCollection_args:
15209 
  """
15210 
  Attributes:
15211 
   - collectedAmountMap
15212 
   - xferBy
15213 
   - xferTxnId
15214 
   - xferDate
15215 
  """
15216 
 
15217 
  thrift_spec = (
15218 
    None, # 0
15219 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
15220 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
15221 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
15222 
    (4, TType.I64, 'xferDate', None, None, ), # 4
15223 
  )
15224 
 
15225 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
15226 
    self.collectedAmountMap = collectedAmountMap
15227 
    self.xferBy = xferBy
15228 
    self.xferTxnId = xferTxnId
15229 
    self.xferDate = xferDate
15230 
 
15231 
  def read(self, iprot):
15232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15234 
      return
15235 
    iprot.readStructBegin()
15236 
    while True:
15237 
      (fname, ftype, fid) = iprot.readFieldBegin()
15238 
      if ftype == TType.STOP:
15239 
        break
15240 
      if fid == 1:
15241 
        if ftype == TType.MAP:
15242 
          self.collectedAmountMap = {}
4801 anupam.sin 15243 
          (_ktype258, _vtype259, _size257 ) = iprot.readMapBegin()
15244 
          for _i261 in xrange(_size257):
15245 
            _key262 = iprot.readString();
15246 
            _val263 = iprot.readDouble();
15247 
            self.collectedAmountMap[_key262] = _val263
3956 chandransh 15248 
          iprot.readMapEnd()
15249 
        else:
15250 
          iprot.skip(ftype)
15251 
      elif fid == 2:
15252 
        if ftype == TType.STRING:
15253 
          self.xferBy = iprot.readString();
15254 
        else:
15255 
          iprot.skip(ftype)
15256 
      elif fid == 3:
15257 
        if ftype == TType.STRING:
15258 
          self.xferTxnId = iprot.readString();
15259 
        else:
15260 
          iprot.skip(ftype)
15261 
      elif fid == 4:
15262 
        if ftype == TType.I64:
15263 
          self.xferDate = iprot.readI64();
15264 
        else:
15265 
          iprot.skip(ftype)
15266 
      else:
15267 
        iprot.skip(ftype)
15268 
      iprot.readFieldEnd()
15269 
    iprot.readStructEnd()
15270 
 
15271 
  def write(self, oprot):
15272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15274 
      return
15275 
    oprot.writeStructBegin('reconcileCodCollection_args')
15276 
    if self.collectedAmountMap is not None:
15277 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
15278 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4801 anupam.sin 15279 
      for kiter264,viter265 in self.collectedAmountMap.items():
15280 
        oprot.writeString(kiter264)
15281 
        oprot.writeDouble(viter265)
3956 chandransh 15282 
      oprot.writeMapEnd()
15283 
      oprot.writeFieldEnd()
15284 
    if self.xferBy is not None:
15285 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
15286 
      oprot.writeString(self.xferBy)
15287 
      oprot.writeFieldEnd()
15288 
    if self.xferTxnId is not None:
15289 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
15290 
      oprot.writeString(self.xferTxnId)
15291 
      oprot.writeFieldEnd()
15292 
    if self.xferDate is not None:
15293 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
15294 
      oprot.writeI64(self.xferDate)
15295 
      oprot.writeFieldEnd()
15296 
    oprot.writeFieldStop()
15297 
    oprot.writeStructEnd()
15298 
 
15299 
  def validate(self):
15300 
    return
15301 
 
15302 
 
15303 
  def __repr__(self):
15304 
    L = ['%s=%r' % (key, value)
15305 
      for key, value in self.__dict__.iteritems()]
15306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15307 
 
15308 
  def __eq__(self, other):
15309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15310 
 
15311 
  def __ne__(self, other):
15312 
    return not (self == other)
15313 
 
15314 
class reconcileCodCollection_result:
15315 
  """
15316 
  Attributes:
15317 
   - success
15318 
   - ex
15319 
  """
15320 
 
15321 
  thrift_spec = (
15322 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15323 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15324 
  )
15325 
 
15326 
  def __init__(self, success=None, ex=None,):
15327 
    self.success = success
15328 
    self.ex = ex
15329 
 
15330 
  def read(self, iprot):
15331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15333 
      return
15334 
    iprot.readStructBegin()
15335 
    while True:
15336 
      (fname, ftype, fid) = iprot.readFieldBegin()
15337 
      if ftype == TType.STOP:
15338 
        break
15339 
      if fid == 0:
15340 
        if ftype == TType.MAP:
15341 
          self.success = {}
4801 anupam.sin 15342 
          (_ktype267, _vtype268, _size266 ) = iprot.readMapBegin()
15343 
          for _i270 in xrange(_size266):
15344 
            _key271 = iprot.readString();
15345 
            _val272 = iprot.readString();
15346 
            self.success[_key271] = _val272
3956 chandransh 15347 
          iprot.readMapEnd()
15348 
        else:
15349 
          iprot.skip(ftype)
15350 
      elif fid == 1:
15351 
        if ftype == TType.STRUCT:
15352 
          self.ex = TransactionServiceException()
15353 
          self.ex.read(iprot)
15354 
        else:
15355 
          iprot.skip(ftype)
15356 
      else:
15357 
        iprot.skip(ftype)
15358 
      iprot.readFieldEnd()
15359 
    iprot.readStructEnd()
15360 
 
15361 
  def write(self, oprot):
15362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15364 
      return
15365 
    oprot.writeStructBegin('reconcileCodCollection_result')
15366 
    if self.success is not None:
15367 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15368 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4801 anupam.sin 15369 
      for kiter273,viter274 in self.success.items():
15370 
        oprot.writeString(kiter273)
15371 
        oprot.writeString(viter274)
3956 chandransh 15372 
      oprot.writeMapEnd()
15373 
      oprot.writeFieldEnd()
15374 
    if self.ex is not None:
15375 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15376 
      self.ex.write(oprot)
15377 
      oprot.writeFieldEnd()
15378 
    oprot.writeFieldStop()
15379 
    oprot.writeStructEnd()
15380 
 
15381 
  def validate(self):
15382 
    return
15383 
 
15384 
 
15385 
  def __repr__(self):
15386 
    L = ['%s=%r' % (key, value)
15387 
      for key, value in self.__dict__.iteritems()]
15388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15389 
 
15390 
  def __eq__(self, other):
15391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15392 
 
15393 
  def __ne__(self, other):
15394 
    return not (self == other)
4008 mandeep.dh 15395 
 
15396 
class getTransactionsRequiringExtraProcessing_args:
15397 
  """
15398 
  Attributes:
15399 
   - category
15400 
  """
15401 
 
15402 
  thrift_spec = (
15403 
    None, # 0
15404 
    (1, TType.I32, 'category', None, None, ), # 1
15405 
  )
15406 
 
15407 
  def __init__(self, category=None,):
15408 
    self.category = category
15409 
 
15410 
  def read(self, iprot):
15411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15413 
      return
15414 
    iprot.readStructBegin()
15415 
    while True:
15416 
      (fname, ftype, fid) = iprot.readFieldBegin()
15417 
      if ftype == TType.STOP:
15418 
        break
15419 
      if fid == 1:
15420 
        if ftype == TType.I32:
15421 
          self.category = iprot.readI32();
15422 
        else:
15423 
          iprot.skip(ftype)
15424 
      else:
15425 
        iprot.skip(ftype)
15426 
      iprot.readFieldEnd()
15427 
    iprot.readStructEnd()
15428 
 
15429 
  def write(self, oprot):
15430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15432 
      return
15433 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
15434 
    if self.category is not None:
15435 
      oprot.writeFieldBegin('category', TType.I32, 1)
15436 
      oprot.writeI32(self.category)
15437 
      oprot.writeFieldEnd()
15438 
    oprot.writeFieldStop()
15439 
    oprot.writeStructEnd()
15440 
 
15441 
  def validate(self):
15442 
    return
15443 
 
15444 
 
15445 
  def __repr__(self):
15446 
    L = ['%s=%r' % (key, value)
15447 
      for key, value in self.__dict__.iteritems()]
15448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15449 
 
15450 
  def __eq__(self, other):
15451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15452 
 
15453 
  def __ne__(self, other):
15454 
    return not (self == other)
15455 
 
15456 
class getTransactionsRequiringExtraProcessing_result:
15457 
  """
15458 
  Attributes:
15459 
   - success
15460 
  """
15461 
 
15462 
  thrift_spec = (
15463 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15464 
  )
15465 
 
15466 
  def __init__(self, success=None,):
15467 
    self.success = success
15468 
 
15469 
  def read(self, iprot):
15470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15472 
      return
15473 
    iprot.readStructBegin()
15474 
    while True:
15475 
      (fname, ftype, fid) = iprot.readFieldBegin()
15476 
      if ftype == TType.STOP:
15477 
        break
15478 
      if fid == 0:
15479 
        if ftype == TType.LIST:
15480 
          self.success = []
4801 anupam.sin 15481 
          (_etype278, _size275) = iprot.readListBegin()
15482 
          for _i279 in xrange(_size275):
15483 
            _elem280 = iprot.readI64();
15484 
            self.success.append(_elem280)
4008 mandeep.dh 15485 
          iprot.readListEnd()
15486 
        else:
15487 
          iprot.skip(ftype)
15488 
      else:
15489 
        iprot.skip(ftype)
15490 
      iprot.readFieldEnd()
15491 
    iprot.readStructEnd()
15492 
 
15493 
  def write(self, oprot):
15494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15496 
      return
15497 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
15498 
    if self.success is not None:
15499 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15500 
      oprot.writeListBegin(TType.I64, len(self.success))
4801 anupam.sin 15501 
      for iter281 in self.success:
15502 
        oprot.writeI64(iter281)
4008 mandeep.dh 15503 
      oprot.writeListEnd()
15504 
      oprot.writeFieldEnd()
15505 
    oprot.writeFieldStop()
15506 
    oprot.writeStructEnd()
15507 
 
15508 
  def validate(self):
15509 
    return
15510 
 
15511 
 
15512 
  def __repr__(self):
15513 
    L = ['%s=%r' % (key, value)
15514 
      for key, value in self.__dict__.iteritems()]
15515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15516 
 
15517 
  def __eq__(self, other):
15518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15519 
 
15520 
  def __ne__(self, other):
15521 
    return not (self == other)
15522 
 
15523 
class markTransactionAsProcessed_args:
15524 
  """
15525 
  Attributes:
15526 
   - transactionId
15527 
   - category
15528 
  """
15529 
 
15530 
  thrift_spec = (
15531 
    None, # 0
15532 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15533 
    (2, TType.I32, 'category', None, None, ), # 2
15534 
  )
15535 
 
15536 
  def __init__(self, transactionId=None, category=None,):
15537 
    self.transactionId = transactionId
15538 
    self.category = category
15539 
 
15540 
  def read(self, iprot):
15541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15543 
      return
15544 
    iprot.readStructBegin()
15545 
    while True:
15546 
      (fname, ftype, fid) = iprot.readFieldBegin()
15547 
      if ftype == TType.STOP:
15548 
        break
15549 
      if fid == 1:
15550 
        if ftype == TType.I64:
15551 
          self.transactionId = iprot.readI64();
15552 
        else:
15553 
          iprot.skip(ftype)
15554 
      elif fid == 2:
15555 
        if ftype == TType.I32:
15556 
          self.category = iprot.readI32();
15557 
        else:
15558 
          iprot.skip(ftype)
15559 
      else:
15560 
        iprot.skip(ftype)
15561 
      iprot.readFieldEnd()
15562 
    iprot.readStructEnd()
15563 
 
15564 
  def write(self, oprot):
15565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15567 
      return
15568 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
15569 
    if self.transactionId is not None:
15570 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15571 
      oprot.writeI64(self.transactionId)
15572 
      oprot.writeFieldEnd()
15573 
    if self.category is not None:
15574 
      oprot.writeFieldBegin('category', TType.I32, 2)
15575 
      oprot.writeI32(self.category)
15576 
      oprot.writeFieldEnd()
15577 
    oprot.writeFieldStop()
15578 
    oprot.writeStructEnd()
15579 
 
15580 
  def validate(self):
15581 
    return
15582 
 
15583 
 
15584 
  def __repr__(self):
15585 
    L = ['%s=%r' % (key, value)
15586 
      for key, value in self.__dict__.iteritems()]
15587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15588 
 
15589 
  def __eq__(self, other):
15590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15591 
 
15592 
  def __ne__(self, other):
15593 
    return not (self == other)
15594 
 
15595 
class markTransactionAsProcessed_result:
15596 
 
15597 
  thrift_spec = (
15598 
  )
15599 
 
15600 
  def read(self, iprot):
15601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15603 
      return
15604 
    iprot.readStructBegin()
15605 
    while True:
15606 
      (fname, ftype, fid) = iprot.readFieldBegin()
15607 
      if ftype == TType.STOP:
15608 
        break
15609 
      else:
15610 
        iprot.skip(ftype)
15611 
      iprot.readFieldEnd()
15612 
    iprot.readStructEnd()
15613 
 
15614 
  def write(self, oprot):
15615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15617 
      return
15618 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
15619 
    oprot.writeFieldStop()
15620 
    oprot.writeStructEnd()
15621 
 
15622 
  def validate(self):
15623 
    return
15624 
 
15625 
 
15626 
  def __repr__(self):
15627 
    L = ['%s=%r' % (key, value)
15628 
      for key, value in self.__dict__.iteritems()]
15629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15630 
 
15631 
  def __eq__(self, other):
15632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15633 
 
15634 
  def __ne__(self, other):
15635 
    return not (self == other)
4018 chandransh 15636 
 
15637 
class getItemWiseRiskyOrdersCount_args:
15638 
 
15639 
  thrift_spec = (
15640 
  )
15641 
 
15642 
  def read(self, iprot):
15643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15645 
      return
15646 
    iprot.readStructBegin()
15647 
    while True:
15648 
      (fname, ftype, fid) = iprot.readFieldBegin()
15649 
      if ftype == TType.STOP:
15650 
        break
15651 
      else:
15652 
        iprot.skip(ftype)
15653 
      iprot.readFieldEnd()
15654 
    iprot.readStructEnd()
15655 
 
15656 
  def write(self, oprot):
15657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15659 
      return
15660 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
15661 
    oprot.writeFieldStop()
15662 
    oprot.writeStructEnd()
15663 
 
15664 
  def validate(self):
15665 
    return
15666 
 
15667 
 
15668 
  def __repr__(self):
15669 
    L = ['%s=%r' % (key, value)
15670 
      for key, value in self.__dict__.iteritems()]
15671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15672 
 
15673 
  def __eq__(self, other):
15674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15675 
 
15676 
  def __ne__(self, other):
15677 
    return not (self == other)
15678 
 
15679 
class getItemWiseRiskyOrdersCount_result:
15680 
  """
15681 
  Attributes:
15682 
   - success
15683 
  """
15684 
 
15685 
  thrift_spec = (
15686 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
15687 
  )
15688 
 
15689 
  def __init__(self, success=None,):
15690 
    self.success = success
15691 
 
15692 
  def read(self, iprot):
15693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15695 
      return
15696 
    iprot.readStructBegin()
15697 
    while True:
15698 
      (fname, ftype, fid) = iprot.readFieldBegin()
15699 
      if ftype == TType.STOP:
15700 
        break
15701 
      if fid == 0:
15702 
        if ftype == TType.MAP:
15703 
          self.success = {}
4801 anupam.sin 15704 
          (_ktype283, _vtype284, _size282 ) = iprot.readMapBegin()
15705 
          for _i286 in xrange(_size282):
15706 
            _key287 = iprot.readI64();
15707 
            _val288 = iprot.readI64();
15708 
            self.success[_key287] = _val288
4018 chandransh 15709 
          iprot.readMapEnd()
15710 
        else:
15711 
          iprot.skip(ftype)
15712 
      else:
15713 
        iprot.skip(ftype)
15714 
      iprot.readFieldEnd()
15715 
    iprot.readStructEnd()
15716 
 
15717 
  def write(self, oprot):
15718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15720 
      return
15721 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
15722 
    if self.success is not None:
15723 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15724 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4801 anupam.sin 15725 
      for kiter289,viter290 in self.success.items():
15726 
        oprot.writeI64(kiter289)
15727 
        oprot.writeI64(viter290)
4018 chandransh 15728 
      oprot.writeMapEnd()
15729 
      oprot.writeFieldEnd()
15730 
    oprot.writeFieldStop()
15731 
    oprot.writeStructEnd()
15732 
 
15733 
  def validate(self):
15734 
    return
15735 
 
15736 
 
15737 
  def __repr__(self):
15738 
    L = ['%s=%r' % (key, value)
15739 
      for key, value in self.__dict__.iteritems()]
15740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15741 
 
15742 
  def __eq__(self, other):
15743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15744 
 
15745 
  def __ne__(self, other):
15746 
    return not (self == other)
4247 rajveer 15747 
 
4295 varun.gupt 15748 
class getOrdersForItemIds_args:
15749 
  """
15750 
  Attributes:
15751 
   - itemIds
15752 
  """
15753 
 
15754 
  thrift_spec = (
15755 
    None, # 0
15756 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15757 
  )
15758 
 
15759 
  def __init__(self, itemIds=None,):
15760 
    self.itemIds = itemIds
15761 
 
15762 
  def read(self, iprot):
15763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15765 
      return
15766 
    iprot.readStructBegin()
15767 
    while True:
15768 
      (fname, ftype, fid) = iprot.readFieldBegin()
15769 
      if ftype == TType.STOP:
15770 
        break
15771 
      if fid == 1:
15772 
        if ftype == TType.LIST:
15773 
          self.itemIds = []
4801 anupam.sin 15774 
          (_etype294, _size291) = iprot.readListBegin()
15775 
          for _i295 in xrange(_size291):
15776 
            _elem296 = iprot.readI64();
15777 
            self.itemIds.append(_elem296)
4295 varun.gupt 15778 
          iprot.readListEnd()
15779 
        else:
15780 
          iprot.skip(ftype)
15781 
      else:
15782 
        iprot.skip(ftype)
15783 
      iprot.readFieldEnd()
15784 
    iprot.readStructEnd()
15785 
 
15786 
  def write(self, oprot):
15787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15789 
      return
15790 
    oprot.writeStructBegin('getOrdersForItemIds_args')
15791 
    if self.itemIds is not None:
15792 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15793 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4801 anupam.sin 15794 
      for iter297 in self.itemIds:
15795 
        oprot.writeI64(iter297)
4295 varun.gupt 15796 
      oprot.writeListEnd()
15797 
      oprot.writeFieldEnd()
15798 
    oprot.writeFieldStop()
15799 
    oprot.writeStructEnd()
15800 
 
15801 
  def validate(self):
15802 
    return
15803 
 
15804 
 
15805 
  def __repr__(self):
15806 
    L = ['%s=%r' % (key, value)
15807 
      for key, value in self.__dict__.iteritems()]
15808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15809 
 
15810 
  def __eq__(self, other):
15811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15812 
 
15813 
  def __ne__(self, other):
15814 
    return not (self == other)
15815 
 
15816 
class getOrdersForItemIds_result:
15817 
  """
15818 
  Attributes:
15819 
   - success
15820 
  """
15821 
 
15822 
  thrift_spec = (
15823 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15824 
  )
15825 
 
15826 
  def __init__(self, success=None,):
15827 
    self.success = success
15828 
 
15829 
  def read(self, iprot):
15830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15832 
      return
15833 
    iprot.readStructBegin()
15834 
    while True:
15835 
      (fname, ftype, fid) = iprot.readFieldBegin()
15836 
      if ftype == TType.STOP:
15837 
        break
15838 
      if fid == 0:
15839 
        if ftype == TType.LIST:
15840 
          self.success = []
4801 anupam.sin 15841 
          (_etype301, _size298) = iprot.readListBegin()
15842 
          for _i302 in xrange(_size298):
15843 
            _elem303 = Order()
15844 
            _elem303.read(iprot)
15845 
            self.success.append(_elem303)
4295 varun.gupt 15846 
          iprot.readListEnd()
15847 
        else:
15848 
          iprot.skip(ftype)
15849 
      else:
15850 
        iprot.skip(ftype)
15851 
      iprot.readFieldEnd()
15852 
    iprot.readStructEnd()
15853 
 
15854 
  def write(self, oprot):
15855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15857 
      return
15858 
    oprot.writeStructBegin('getOrdersForItemIds_result')
15859 
    if self.success is not None:
15860 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15861 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 15862 
      for iter304 in self.success:
15863 
        iter304.write(oprot)
4295 varun.gupt 15864 
      oprot.writeListEnd()
15865 
      oprot.writeFieldEnd()
15866 
    oprot.writeFieldStop()
15867 
    oprot.writeStructEnd()
15868 
 
15869 
  def validate(self):
15870 
    return
15871 
 
15872 
 
15873 
  def __repr__(self):
15874 
    L = ['%s=%r' % (key, value)
15875 
      for key, value in self.__dict__.iteritems()]
15876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15877 
 
15878 
  def __eq__(self, other):
15879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15880 
 
15881 
  def __ne__(self, other):
15882 
    return not (self == other)
15883 
 
4247 rajveer 15884 
class markOrderCancellationRequestReceived_args:
15885 
  """
15886 
  Attributes:
15887 
   - orderId
15888 
  """
15889 
 
15890 
  thrift_spec = (
15891 
    None, # 0
15892 
    (1, TType.I64, 'orderId', None, None, ), # 1
15893 
  )
15894 
 
15895 
  def __init__(self, orderId=None,):
15896 
    self.orderId = orderId
15897 
 
15898 
  def read(self, iprot):
15899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15901 
      return
15902 
    iprot.readStructBegin()
15903 
    while True:
15904 
      (fname, ftype, fid) = iprot.readFieldBegin()
15905 
      if ftype == TType.STOP:
15906 
        break
15907 
      if fid == 1:
15908 
        if ftype == TType.I64:
15909 
          self.orderId = iprot.readI64();
15910 
        else:
15911 
          iprot.skip(ftype)
15912 
      else:
15913 
        iprot.skip(ftype)
15914 
      iprot.readFieldEnd()
15915 
    iprot.readStructEnd()
15916 
 
15917 
  def write(self, oprot):
15918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15920 
      return
15921 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
15922 
    if self.orderId is not None:
15923 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15924 
      oprot.writeI64(self.orderId)
15925 
      oprot.writeFieldEnd()
15926 
    oprot.writeFieldStop()
15927 
    oprot.writeStructEnd()
15928 
 
15929 
  def validate(self):
15930 
    return
15931 
 
15932 
 
15933 
  def __repr__(self):
15934 
    L = ['%s=%r' % (key, value)
15935 
      for key, value in self.__dict__.iteritems()]
15936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15937 
 
15938 
  def __eq__(self, other):
15939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15940 
 
15941 
  def __ne__(self, other):
15942 
    return not (self == other)
15943 
 
15944 
class markOrderCancellationRequestReceived_result:
15945 
  """
15946 
  Attributes:
15947 
   - ex
15948 
  """
15949 
 
15950 
  thrift_spec = (
15951 
    None, # 0
15952 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15953 
  )
15954 
 
15955 
  def __init__(self, ex=None,):
15956 
    self.ex = ex
15957 
 
15958 
  def read(self, iprot):
15959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15961 
      return
15962 
    iprot.readStructBegin()
15963 
    while True:
15964 
      (fname, ftype, fid) = iprot.readFieldBegin()
15965 
      if ftype == TType.STOP:
15966 
        break
15967 
      if fid == 1:
15968 
        if ftype == TType.STRUCT:
15969 
          self.ex = TransactionServiceException()
15970 
          self.ex.read(iprot)
15971 
        else:
15972 
          iprot.skip(ftype)
15973 
      else:
15974 
        iprot.skip(ftype)
15975 
      iprot.readFieldEnd()
15976 
    iprot.readStructEnd()
15977 
 
15978 
  def write(self, oprot):
15979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15981 
      return
15982 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
15983 
    if self.ex is not None:
15984 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15985 
      self.ex.write(oprot)
15986 
      oprot.writeFieldEnd()
15987 
    oprot.writeFieldStop()
15988 
    oprot.writeStructEnd()
15989 
 
15990 
  def validate(self):
15991 
    return
15992 
 
15993 
 
15994 
  def __repr__(self):
15995 
    L = ['%s=%r' % (key, value)
15996 
      for key, value in self.__dict__.iteritems()]
15997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15998 
 
15999 
  def __eq__(self, other):
16000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16001 
 
16002 
  def __ne__(self, other):
16003 
    return not (self == other)
16004 
 
16005 
class markOrderCancellationRequestConfirmed_args:
16006 
  """
16007 
  Attributes:
16008 
   - orderId
16009 
  """
16010 
 
16011 
  thrift_spec = (
16012 
    None, # 0
16013 
    (1, TType.I64, 'orderId', None, None, ), # 1
16014 
  )
16015 
 
16016 
  def __init__(self, orderId=None,):
16017 
    self.orderId = orderId
16018 
 
16019 
  def read(self, iprot):
16020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16022 
      return
16023 
    iprot.readStructBegin()
16024 
    while True:
16025 
      (fname, ftype, fid) = iprot.readFieldBegin()
16026 
      if ftype == TType.STOP:
16027 
        break
16028 
      if fid == 1:
16029 
        if ftype == TType.I64:
16030 
          self.orderId = iprot.readI64();
16031 
        else:
16032 
          iprot.skip(ftype)
16033 
      else:
16034 
        iprot.skip(ftype)
16035 
      iprot.readFieldEnd()
16036 
    iprot.readStructEnd()
16037 
 
16038 
  def write(self, oprot):
16039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16041 
      return
16042 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
16043 
    if self.orderId is not None:
16044 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16045 
      oprot.writeI64(self.orderId)
16046 
      oprot.writeFieldEnd()
16047 
    oprot.writeFieldStop()
16048 
    oprot.writeStructEnd()
16049 
 
16050 
  def validate(self):
16051 
    return
16052 
 
16053 
 
16054 
  def __repr__(self):
16055 
    L = ['%s=%r' % (key, value)
16056 
      for key, value in self.__dict__.iteritems()]
16057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16058 
 
16059 
  def __eq__(self, other):
16060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16061 
 
16062 
  def __ne__(self, other):
16063 
    return not (self == other)
16064 
 
16065 
class markOrderCancellationRequestConfirmed_result:
16066 
  """
16067 
  Attributes:
16068 
   - ex
16069 
  """
16070 
 
16071 
  thrift_spec = (
16072 
    None, # 0
16073 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16074 
  )
16075 
 
16076 
  def __init__(self, ex=None,):
16077 
    self.ex = ex
16078 
 
16079 
  def read(self, iprot):
16080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16082 
      return
16083 
    iprot.readStructBegin()
16084 
    while True:
16085 
      (fname, ftype, fid) = iprot.readFieldBegin()
16086 
      if ftype == TType.STOP:
16087 
        break
16088 
      if fid == 1:
16089 
        if ftype == TType.STRUCT:
16090 
          self.ex = TransactionServiceException()
16091 
          self.ex.read(iprot)
16092 
        else:
16093 
          iprot.skip(ftype)
16094 
      else:
16095 
        iprot.skip(ftype)
16096 
      iprot.readFieldEnd()
16097 
    iprot.readStructEnd()
16098 
 
16099 
  def write(self, oprot):
16100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16102 
      return
16103 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
16104 
    if self.ex is not None:
16105 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16106 
      self.ex.write(oprot)
16107 
      oprot.writeFieldEnd()
16108 
    oprot.writeFieldStop()
16109 
    oprot.writeStructEnd()
16110 
 
16111 
  def validate(self):
16112 
    return
16113 
 
16114 
 
16115 
  def __repr__(self):
16116 
    L = ['%s=%r' % (key, value)
16117 
      for key, value in self.__dict__.iteritems()]
16118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16119 
 
16120 
  def __eq__(self, other):
16121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16122 
 
16123 
  def __ne__(self, other):
16124 
    return not (self == other)
16125 
 
16126 
class markOrderCancellationRequestDenied_args:
16127 
  """
16128 
  Attributes:
16129 
   - orderId
16130 
  """
16131 
 
16132 
  thrift_spec = (
16133 
    None, # 0
16134 
    (1, TType.I64, 'orderId', None, None, ), # 1
16135 
  )
16136 
 
16137 
  def __init__(self, orderId=None,):
16138 
    self.orderId = orderId
16139 
 
16140 
  def read(self, iprot):
16141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16143 
      return
16144 
    iprot.readStructBegin()
16145 
    while True:
16146 
      (fname, ftype, fid) = iprot.readFieldBegin()
16147 
      if ftype == TType.STOP:
16148 
        break
16149 
      if fid == 1:
16150 
        if ftype == TType.I64:
16151 
          self.orderId = iprot.readI64();
16152 
        else:
16153 
          iprot.skip(ftype)
16154 
      else:
16155 
        iprot.skip(ftype)
16156 
      iprot.readFieldEnd()
16157 
    iprot.readStructEnd()
16158 
 
16159 
  def write(self, oprot):
16160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16162 
      return
16163 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
16164 
    if self.orderId is not None:
16165 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16166 
      oprot.writeI64(self.orderId)
16167 
      oprot.writeFieldEnd()
16168 
    oprot.writeFieldStop()
16169 
    oprot.writeStructEnd()
16170 
 
16171 
  def validate(self):
16172 
    return
16173 
 
16174 
 
16175 
  def __repr__(self):
16176 
    L = ['%s=%r' % (key, value)
16177 
      for key, value in self.__dict__.iteritems()]
16178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16179 
 
16180 
  def __eq__(self, other):
16181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16182 
 
16183 
  def __ne__(self, other):
16184 
    return not (self == other)
16185 
 
16186 
class markOrderCancellationRequestDenied_result:
16187 
  """
16188 
  Attributes:
16189 
   - ex
16190 
  """
16191 
 
16192 
  thrift_spec = (
16193 
    None, # 0
16194 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16195 
  )
16196 
 
16197 
  def __init__(self, ex=None,):
16198 
    self.ex = ex
16199 
 
16200 
  def read(self, iprot):
16201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16203 
      return
16204 
    iprot.readStructBegin()
16205 
    while True:
16206 
      (fname, ftype, fid) = iprot.readFieldBegin()
16207 
      if ftype == TType.STOP:
16208 
        break
16209 
      if fid == 1:
16210 
        if ftype == TType.STRUCT:
16211 
          self.ex = TransactionServiceException()
16212 
          self.ex.read(iprot)
16213 
        else:
16214 
          iprot.skip(ftype)
16215 
      else:
16216 
        iprot.skip(ftype)
16217 
      iprot.readFieldEnd()
16218 
    iprot.readStructEnd()
16219 
 
16220 
  def write(self, oprot):
16221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16223 
      return
16224 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
16225 
    if self.ex is not None:
16226 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16227 
      self.ex.write(oprot)
16228 
      oprot.writeFieldEnd()
16229 
    oprot.writeFieldStop()
16230 
    oprot.writeStructEnd()
16231 
 
16232 
  def validate(self):
16233 
    return
16234 
 
16235 
 
16236 
  def __repr__(self):
16237 
    L = ['%s=%r' % (key, value)
16238 
      for key, value in self.__dict__.iteritems()]
16239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16240 
 
16241 
  def __eq__(self, other):
16242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16243 
 
16244 
  def __ne__(self, other):
16245 
    return not (self == other)
16246 
 
4258 rajveer 16247 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 16248 
  """
16249 
  Attributes:
4258 rajveer 16250 
   - transactionId
4247 rajveer 16251 
  """
16252 
 
16253 
  thrift_spec = (
16254 
    None, # 0
4258 rajveer 16255 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 16256 
  )
16257 
 
4258 rajveer 16258 
  def __init__(self, transactionId=None,):
16259 
    self.transactionId = transactionId
4247 rajveer 16260 
 
16261 
  def read(self, iprot):
16262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16264 
      return
16265 
    iprot.readStructBegin()
16266 
    while True:
16267 
      (fname, ftype, fid) = iprot.readFieldBegin()
16268 
      if ftype == TType.STOP:
16269 
        break
16270 
      if fid == 1:
16271 
        if ftype == TType.I64:
4258 rajveer 16272 
          self.transactionId = iprot.readI64();
4247 rajveer 16273 
        else:
16274 
          iprot.skip(ftype)
16275 
      else:
16276 
        iprot.skip(ftype)
16277 
      iprot.readFieldEnd()
16278 
    iprot.readStructEnd()
16279 
 
16280 
  def write(self, oprot):
16281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16283 
      return
4258 rajveer 16284 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
16285 
    if self.transactionId is not None:
16286 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16287 
      oprot.writeI64(self.transactionId)
4247 rajveer 16288 
      oprot.writeFieldEnd()
16289 
    oprot.writeFieldStop()
16290 
    oprot.writeStructEnd()
16291 
 
16292 
  def validate(self):
16293 
    return
16294 
 
16295 
 
16296 
  def __repr__(self):
16297 
    L = ['%s=%r' % (key, value)
16298 
      for key, value in self.__dict__.iteritems()]
16299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16300 
 
16301 
  def __eq__(self, other):
16302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16303 
 
16304 
  def __ne__(self, other):
16305 
    return not (self == other)
16306 
 
4258 rajveer 16307 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 16308 
  """
16309 
  Attributes:
16310 
   - ex
16311 
  """
16312 
 
16313 
  thrift_spec = (
16314 
    None, # 0
16315 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16316 
  )
16317 
 
16318 
  def __init__(self, ex=None,):
16319 
    self.ex = ex
16320 
 
16321 
  def read(self, iprot):
16322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16324 
      return
16325 
    iprot.readStructBegin()
16326 
    while True:
16327 
      (fname, ftype, fid) = iprot.readFieldBegin()
16328 
      if ftype == TType.STOP:
16329 
        break
16330 
      if fid == 1:
16331 
        if ftype == TType.STRUCT:
16332 
          self.ex = TransactionServiceException()
16333 
          self.ex.read(iprot)
16334 
        else:
16335 
          iprot.skip(ftype)
16336 
      else:
16337 
        iprot.skip(ftype)
16338 
      iprot.readFieldEnd()
16339 
    iprot.readStructEnd()
16340 
 
16341 
  def write(self, oprot):
16342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16344 
      return
4258 rajveer 16345 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 16346 
    if self.ex is not None:
16347 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16348 
      self.ex.write(oprot)
16349 
      oprot.writeFieldEnd()
16350 
    oprot.writeFieldStop()
16351 
    oprot.writeStructEnd()
16352 
 
16353 
  def validate(self):
16354 
    return
16355 
 
16356 
 
16357 
  def __repr__(self):
16358 
    L = ['%s=%r' % (key, value)
16359 
      for key, value in self.__dict__.iteritems()]
16360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16361 
 
16362 
  def __eq__(self, other):
16363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16364 
 
16365 
  def __ne__(self, other):
16366 
    return not (self == other)
4259 anupam.sin 16367 
 
16368 
class refundTransaction_args:
16369 
  """
16370 
  Attributes:
16371 
   - transactionId
16372 
   - refundedBy
16373 
   - reason
16374 
  """
16375 
 
16376 
  thrift_spec = (
16377 
    None, # 0
16378 
    (1, TType.I64, 'transactionId', None, None, ), # 1
16379 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
16380 
    (3, TType.STRING, 'reason', None, None, ), # 3
16381 
  )
16382 
 
16383 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
16384 
    self.transactionId = transactionId
16385 
    self.refundedBy = refundedBy
16386 
    self.reason = reason
16387 
 
16388 
  def read(self, iprot):
16389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16391 
      return
16392 
    iprot.readStructBegin()
16393 
    while True:
16394 
      (fname, ftype, fid) = iprot.readFieldBegin()
16395 
      if ftype == TType.STOP:
16396 
        break
16397 
      if fid == 1:
16398 
        if ftype == TType.I64:
16399 
          self.transactionId = iprot.readI64();
16400 
        else:
16401 
          iprot.skip(ftype)
16402 
      elif fid == 2:
16403 
        if ftype == TType.STRING:
16404 
          self.refundedBy = iprot.readString();
16405 
        else:
16406 
          iprot.skip(ftype)
16407 
      elif fid == 3:
16408 
        if ftype == TType.STRING:
16409 
          self.reason = iprot.readString();
16410 
        else:
16411 
          iprot.skip(ftype)
16412 
      else:
16413 
        iprot.skip(ftype)
16414 
      iprot.readFieldEnd()
16415 
    iprot.readStructEnd()
16416 
 
16417 
  def write(self, oprot):
16418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16420 
      return
16421 
    oprot.writeStructBegin('refundTransaction_args')
16422 
    if self.transactionId is not None:
16423 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16424 
      oprot.writeI64(self.transactionId)
16425 
      oprot.writeFieldEnd()
16426 
    if self.refundedBy is not None:
16427 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16428 
      oprot.writeString(self.refundedBy)
16429 
      oprot.writeFieldEnd()
16430 
    if self.reason is not None:
16431 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16432 
      oprot.writeString(self.reason)
16433 
      oprot.writeFieldEnd()
16434 
    oprot.writeFieldStop()
16435 
    oprot.writeStructEnd()
16436 
 
16437 
  def validate(self):
16438 
    return
16439 
 
16440 
 
16441 
  def __repr__(self):
16442 
    L = ['%s=%r' % (key, value)
16443 
      for key, value in self.__dict__.iteritems()]
16444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16445 
 
16446 
  def __eq__(self, other):
16447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16448 
 
16449 
  def __ne__(self, other):
16450 
    return not (self == other)
16451 
 
16452 
class refundTransaction_result:
16453 
  """
16454 
  Attributes:
16455 
   - ex
16456 
  """
16457 
 
16458 
  thrift_spec = (
16459 
    None, # 0
16460 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16461 
  )
16462 
 
16463 
  def __init__(self, ex=None,):
16464 
    self.ex = ex
16465 
 
16466 
  def read(self, iprot):
16467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16469 
      return
16470 
    iprot.readStructBegin()
16471 
    while True:
16472 
      (fname, ftype, fid) = iprot.readFieldBegin()
16473 
      if ftype == TType.STOP:
16474 
        break
16475 
      if fid == 1:
16476 
        if ftype == TType.STRUCT:
16477 
          self.ex = TransactionServiceException()
16478 
          self.ex.read(iprot)
16479 
        else:
16480 
          iprot.skip(ftype)
16481 
      else:
16482 
        iprot.skip(ftype)
16483 
      iprot.readFieldEnd()
16484 
    iprot.readStructEnd()
16485 
 
16486 
  def write(self, oprot):
16487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16489 
      return
16490 
    oprot.writeStructBegin('refundTransaction_result')
16491 
    if self.ex is not None:
16492 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16493 
      self.ex.write(oprot)
16494 
      oprot.writeFieldEnd()
16495 
    oprot.writeFieldStop()
16496 
    oprot.writeStructEnd()
16497 
 
16498 
  def validate(self):
16499 
    return
16500 
 
16501 
 
16502 
  def __repr__(self):
16503 
    L = ['%s=%r' % (key, value)
16504 
      for key, value in self.__dict__.iteritems()]
16505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16506 
 
16507 
  def __eq__(self, other):
16508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16509 
 
16510 
  def __ne__(self, other):
16511 
    return not (self == other)
4285 rajveer 16512 
 
4324 mandeep.dh 16513 
class updateShipmentAddress_args:
16514 
  """
16515 
  Attributes:
16516 
   - orderId
16517 
   - addressId
16518 
  """
16519 
 
16520 
  thrift_spec = (
16521 
    None, # 0
16522 
    (1, TType.I64, 'orderId', None, None, ), # 1
16523 
    (2, TType.I64, 'addressId', None, None, ), # 2
16524 
  )
16525 
 
16526 
  def __init__(self, orderId=None, addressId=None,):
16527 
    self.orderId = orderId
16528 
    self.addressId = addressId
16529 
 
16530 
  def read(self, iprot):
16531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16533 
      return
16534 
    iprot.readStructBegin()
16535 
    while True:
16536 
      (fname, ftype, fid) = iprot.readFieldBegin()
16537 
      if ftype == TType.STOP:
16538 
        break
16539 
      if fid == 1:
16540 
        if ftype == TType.I64:
16541 
          self.orderId = iprot.readI64();
16542 
        else:
16543 
          iprot.skip(ftype)
16544 
      elif fid == 2:
16545 
        if ftype == TType.I64:
16546 
          self.addressId = iprot.readI64();
16547 
        else:
16548 
          iprot.skip(ftype)
16549 
      else:
16550 
        iprot.skip(ftype)
16551 
      iprot.readFieldEnd()
16552 
    iprot.readStructEnd()
16553 
 
16554 
  def write(self, oprot):
16555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16557 
      return
16558 
    oprot.writeStructBegin('updateShipmentAddress_args')
16559 
    if self.orderId is not None:
16560 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16561 
      oprot.writeI64(self.orderId)
16562 
      oprot.writeFieldEnd()
16563 
    if self.addressId is not None:
16564 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
16565 
      oprot.writeI64(self.addressId)
16566 
      oprot.writeFieldEnd()
16567 
    oprot.writeFieldStop()
16568 
    oprot.writeStructEnd()
16569 
 
16570 
  def validate(self):
16571 
    return
16572 
 
16573 
 
16574 
  def __repr__(self):
16575 
    L = ['%s=%r' % (key, value)
16576 
      for key, value in self.__dict__.iteritems()]
16577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16578 
 
16579 
  def __eq__(self, other):
16580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16581 
 
16582 
  def __ne__(self, other):
16583 
    return not (self == other)
16584 
 
16585 
class updateShipmentAddress_result:
16586 
  """
16587 
  Attributes:
16588 
   - ex
16589 
  """
16590 
 
16591 
  thrift_spec = (
16592 
    None, # 0
16593 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16594 
  )
16595 
 
16596 
  def __init__(self, ex=None,):
16597 
    self.ex = ex
16598 
 
16599 
  def read(self, iprot):
16600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16602 
      return
16603 
    iprot.readStructBegin()
16604 
    while True:
16605 
      (fname, ftype, fid) = iprot.readFieldBegin()
16606 
      if ftype == TType.STOP:
16607 
        break
16608 
      if fid == 1:
16609 
        if ftype == TType.STRUCT:
16610 
          self.ex = TransactionServiceException()
16611 
          self.ex.read(iprot)
16612 
        else:
16613 
          iprot.skip(ftype)
16614 
      else:
16615 
        iprot.skip(ftype)
16616 
      iprot.readFieldEnd()
16617 
    iprot.readStructEnd()
16618 
 
16619 
  def write(self, oprot):
16620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16622 
      return
16623 
    oprot.writeStructBegin('updateShipmentAddress_result')
16624 
    if self.ex is not None:
16625 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16626 
      self.ex.write(oprot)
16627 
      oprot.writeFieldEnd()
16628 
    oprot.writeFieldStop()
16629 
    oprot.writeStructEnd()
16630 
 
16631 
  def validate(self):
16632 
    return
16633 
 
16634 
 
16635 
  def __repr__(self):
16636 
    L = ['%s=%r' % (key, value)
16637 
      for key, value in self.__dict__.iteritems()]
16638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16639 
 
16640 
  def __eq__(self, other):
16641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16642 
 
16643 
  def __ne__(self, other):
16644 
    return not (self == other)
16645 
 
4285 rajveer 16646 
class acceptOrdersForItemId_args:
16647 
  """
16648 
  Attributes:
16649 
   - itemId
16650 
   - inventory
16651 
  """
16652 
 
16653 
  thrift_spec = (
16654 
    None, # 0
16655 
    (1, TType.I64, 'itemId', None, None, ), # 1
16656 
    (2, TType.I64, 'inventory', None, None, ), # 2
16657 
  )
16658 
 
16659 
  def __init__(self, itemId=None, inventory=None,):
16660 
    self.itemId = itemId
16661 
    self.inventory = inventory
16662 
 
16663 
  def read(self, iprot):
16664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16666 
      return
16667 
    iprot.readStructBegin()
16668 
    while True:
16669 
      (fname, ftype, fid) = iprot.readFieldBegin()
16670 
      if ftype == TType.STOP:
16671 
        break
16672 
      if fid == 1:
16673 
        if ftype == TType.I64:
16674 
          self.itemId = iprot.readI64();
16675 
        else:
16676 
          iprot.skip(ftype)
16677 
      elif fid == 2:
16678 
        if ftype == TType.I64:
16679 
          self.inventory = iprot.readI64();
16680 
        else:
16681 
          iprot.skip(ftype)
16682 
      else:
16683 
        iprot.skip(ftype)
16684 
      iprot.readFieldEnd()
16685 
    iprot.readStructEnd()
16686 
 
16687 
  def write(self, oprot):
16688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16690 
      return
16691 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
16692 
    if self.itemId is not None:
16693 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16694 
      oprot.writeI64(self.itemId)
16695 
      oprot.writeFieldEnd()
16696 
    if self.inventory is not None:
16697 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
16698 
      oprot.writeI64(self.inventory)
16699 
      oprot.writeFieldEnd()
16700 
    oprot.writeFieldStop()
16701 
    oprot.writeStructEnd()
16702 
 
16703 
  def validate(self):
16704 
    return
16705 
 
16706 
 
16707 
  def __repr__(self):
16708 
    L = ['%s=%r' % (key, value)
16709 
      for key, value in self.__dict__.iteritems()]
16710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16711 
 
16712 
  def __eq__(self, other):
16713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16714 
 
16715 
  def __ne__(self, other):
16716 
    return not (self == other)
16717 
 
16718 
class acceptOrdersForItemId_result:
16719 
  """
16720 
  Attributes:
16721 
   - success
16722 
   - ex
16723 
  """
16724 
 
16725 
  thrift_spec = (
16726 
    (0, TType.BOOL, 'success', None, None, ), # 0
16727 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16728 
  )
16729 
 
16730 
  def __init__(self, success=None, ex=None,):
16731 
    self.success = success
16732 
    self.ex = ex
16733 
 
16734 
  def read(self, iprot):
16735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16737 
      return
16738 
    iprot.readStructBegin()
16739 
    while True:
16740 
      (fname, ftype, fid) = iprot.readFieldBegin()
16741 
      if ftype == TType.STOP:
16742 
        break
16743 
      if fid == 0:
16744 
        if ftype == TType.BOOL:
16745 
          self.success = iprot.readBool();
16746 
        else:
16747 
          iprot.skip(ftype)
16748 
      elif fid == 1:
16749 
        if ftype == TType.STRUCT:
16750 
          self.ex = TransactionServiceException()
16751 
          self.ex.read(iprot)
16752 
        else:
16753 
          iprot.skip(ftype)
16754 
      else:
16755 
        iprot.skip(ftype)
16756 
      iprot.readFieldEnd()
16757 
    iprot.readStructEnd()
16758 
 
16759 
  def write(self, oprot):
16760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16762 
      return
16763 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
16764 
    if self.success is not None:
16765 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16766 
      oprot.writeBool(self.success)
16767 
      oprot.writeFieldEnd()
16768 
    if self.ex is not None:
16769 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16770 
      self.ex.write(oprot)
16771 
      oprot.writeFieldEnd()
16772 
    oprot.writeFieldStop()
16773 
    oprot.writeStructEnd()
16774 
 
16775 
  def validate(self):
16776 
    return
16777 
 
16778 
 
16779 
  def __repr__(self):
16780 
    L = ['%s=%r' % (key, value)
16781 
      for key, value in self.__dict__.iteritems()]
16782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16783 
 
16784 
  def __eq__(self, other):
16785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16786 
 
16787 
  def __ne__(self, other):
16788 
    return not (self == other)
4303 rajveer 16789 
 
16790 
class markOrdersAsPORaised_args:
16791 
  """
16792 
  Attributes:
16793 
   - vendorId
16794 
   - itemId
16795 
   - quantity
16796 
   - estimate
4369 rajveer 16797 
   - isReminder
4303 rajveer 16798 
  """
16799 
 
16800 
  thrift_spec = (
16801 
    None, # 0
16802 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16803 
    (2, TType.I64, 'itemId', None, None, ), # 2
16804 
    (3, TType.I64, 'quantity', None, None, ), # 3
16805 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16806 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16807 
  )
16808 
 
4369 rajveer 16809 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16810 
    self.vendorId = vendorId
16811 
    self.itemId = itemId
16812 
    self.quantity = quantity
16813 
    self.estimate = estimate
4369 rajveer 16814 
    self.isReminder = isReminder
4303 rajveer 16815 
 
16816 
  def read(self, iprot):
16817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16819 
      return
16820 
    iprot.readStructBegin()
16821 
    while True:
16822 
      (fname, ftype, fid) = iprot.readFieldBegin()
16823 
      if ftype == TType.STOP:
16824 
        break
16825 
      if fid == 1:
16826 
        if ftype == TType.I64:
16827 
          self.vendorId = iprot.readI64();
16828 
        else:
16829 
          iprot.skip(ftype)
16830 
      elif fid == 2:
16831 
        if ftype == TType.I64:
16832 
          self.itemId = iprot.readI64();
16833 
        else:
16834 
          iprot.skip(ftype)
16835 
      elif fid == 3:
16836 
        if ftype == TType.I64:
16837 
          self.quantity = iprot.readI64();
16838 
        else:
16839 
          iprot.skip(ftype)
16840 
      elif fid == 4:
16841 
        if ftype == TType.I64:
16842 
          self.estimate = iprot.readI64();
16843 
        else:
16844 
          iprot.skip(ftype)
4369 rajveer 16845 
      elif fid == 5:
16846 
        if ftype == TType.BOOL:
16847 
          self.isReminder = iprot.readBool();
16848 
        else:
16849 
          iprot.skip(ftype)
4303 rajveer 16850 
      else:
16851 
        iprot.skip(ftype)
16852 
      iprot.readFieldEnd()
16853 
    iprot.readStructEnd()
16854 
 
16855 
  def write(self, oprot):
16856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16858 
      return
16859 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
16860 
    if self.vendorId is not None:
16861 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16862 
      oprot.writeI64(self.vendorId)
16863 
      oprot.writeFieldEnd()
16864 
    if self.itemId is not None:
16865 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16866 
      oprot.writeI64(self.itemId)
16867 
      oprot.writeFieldEnd()
16868 
    if self.quantity is not None:
16869 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16870 
      oprot.writeI64(self.quantity)
16871 
      oprot.writeFieldEnd()
16872 
    if self.estimate is not None:
16873 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16874 
      oprot.writeI64(self.estimate)
16875 
      oprot.writeFieldEnd()
4369 rajveer 16876 
    if self.isReminder is not None:
16877 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16878 
      oprot.writeBool(self.isReminder)
16879 
      oprot.writeFieldEnd()
4303 rajveer 16880 
    oprot.writeFieldStop()
16881 
    oprot.writeStructEnd()
16882 
 
16883 
  def validate(self):
16884 
    return
16885 
 
16886 
 
16887 
  def __repr__(self):
16888 
    L = ['%s=%r' % (key, value)
16889 
      for key, value in self.__dict__.iteritems()]
16890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16891 
 
16892 
  def __eq__(self, other):
16893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16894 
 
16895 
  def __ne__(self, other):
16896 
    return not (self == other)
16897 
 
16898 
class markOrdersAsPORaised_result:
16899 
  """
16900 
  Attributes:
16901 
   - ex
16902 
  """
16903 
 
16904 
  thrift_spec = (
16905 
    None, # 0
16906 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16907 
  )
16908 
 
16909 
  def __init__(self, ex=None,):
16910 
    self.ex = ex
16911 
 
16912 
  def read(self, iprot):
16913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16915 
      return
16916 
    iprot.readStructBegin()
16917 
    while True:
16918 
      (fname, ftype, fid) = iprot.readFieldBegin()
16919 
      if ftype == TType.STOP:
16920 
        break
16921 
      if fid == 1:
16922 
        if ftype == TType.STRUCT:
16923 
          self.ex = TransactionServiceException()
16924 
          self.ex.read(iprot)
16925 
        else:
16926 
          iprot.skip(ftype)
16927 
      else:
16928 
        iprot.skip(ftype)
16929 
      iprot.readFieldEnd()
16930 
    iprot.readStructEnd()
16931 
 
16932 
  def write(self, oprot):
16933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16935 
      return
16936 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
16937 
    if self.ex is not None:
16938 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16939 
      self.ex.write(oprot)
16940 
      oprot.writeFieldEnd()
16941 
    oprot.writeFieldStop()
16942 
    oprot.writeStructEnd()
16943 
 
16944 
  def validate(self):
16945 
    return
16946 
 
16947 
 
16948 
  def __repr__(self):
16949 
    L = ['%s=%r' % (key, value)
16950 
      for key, value in self.__dict__.iteritems()]
16951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16952 
 
16953 
  def __eq__(self, other):
16954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16955 
 
16956 
  def __ne__(self, other):
16957 
    return not (self == other)
16958 
 
16959 
class markOrdersAsReversalInitiated_args:
16960 
  """
16961 
  Attributes:
16962 
   - vendorId
16963 
   - itemId
16964 
   - quantity
16965 
   - estimate
4369 rajveer 16966 
   - isReminder
4303 rajveer 16967 
  """
16968 
 
16969 
  thrift_spec = (
16970 
    None, # 0
16971 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16972 
    (2, TType.I64, 'itemId', None, None, ), # 2
16973 
    (3, TType.I64, 'quantity', None, None, ), # 3
16974 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16975 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16976 
  )
16977 
 
4369 rajveer 16978 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16979 
    self.vendorId = vendorId
16980 
    self.itemId = itemId
16981 
    self.quantity = quantity
16982 
    self.estimate = estimate
4369 rajveer 16983 
    self.isReminder = isReminder
4303 rajveer 16984 
 
16985 
  def read(self, iprot):
16986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16988 
      return
16989 
    iprot.readStructBegin()
16990 
    while True:
16991 
      (fname, ftype, fid) = iprot.readFieldBegin()
16992 
      if ftype == TType.STOP:
16993 
        break
16994 
      if fid == 1:
16995 
        if ftype == TType.I64:
16996 
          self.vendorId = iprot.readI64();
16997 
        else:
16998 
          iprot.skip(ftype)
16999 
      elif fid == 2:
17000 
        if ftype == TType.I64:
17001 
          self.itemId = iprot.readI64();
17002 
        else:
17003 
          iprot.skip(ftype)
17004 
      elif fid == 3:
17005 
        if ftype == TType.I64:
17006 
          self.quantity = iprot.readI64();
17007 
        else:
17008 
          iprot.skip(ftype)
17009 
      elif fid == 4:
17010 
        if ftype == TType.I64:
17011 
          self.estimate = iprot.readI64();
17012 
        else:
17013 
          iprot.skip(ftype)
4369 rajveer 17014 
      elif fid == 5:
17015 
        if ftype == TType.BOOL:
17016 
          self.isReminder = iprot.readBool();
17017 
        else:
17018 
          iprot.skip(ftype)
4303 rajveer 17019 
      else:
17020 
        iprot.skip(ftype)
17021 
      iprot.readFieldEnd()
17022 
    iprot.readStructEnd()
17023 
 
17024 
  def write(self, oprot):
17025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17027 
      return
17028 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
17029 
    if self.vendorId is not None:
17030 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17031 
      oprot.writeI64(self.vendorId)
17032 
      oprot.writeFieldEnd()
17033 
    if self.itemId is not None:
17034 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17035 
      oprot.writeI64(self.itemId)
17036 
      oprot.writeFieldEnd()
17037 
    if self.quantity is not None:
17038 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
17039 
      oprot.writeI64(self.quantity)
17040 
      oprot.writeFieldEnd()
17041 
    if self.estimate is not None:
17042 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
17043 
      oprot.writeI64(self.estimate)
17044 
      oprot.writeFieldEnd()
4369 rajveer 17045 
    if self.isReminder is not None:
17046 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
17047 
      oprot.writeBool(self.isReminder)
17048 
      oprot.writeFieldEnd()
4303 rajveer 17049 
    oprot.writeFieldStop()
17050 
    oprot.writeStructEnd()
17051 
 
17052 
  def validate(self):
17053 
    return
17054 
 
17055 
 
17056 
  def __repr__(self):
17057 
    L = ['%s=%r' % (key, value)
17058 
      for key, value in self.__dict__.iteritems()]
17059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17060 
 
17061 
  def __eq__(self, other):
17062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17063 
 
17064 
  def __ne__(self, other):
17065 
    return not (self == other)
17066 
 
17067 
class markOrdersAsReversalInitiated_result:
17068 
  """
17069 
  Attributes:
17070 
   - ex
17071 
  """
17072 
 
17073 
  thrift_spec = (
17074 
    None, # 0
17075 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17076 
  )
17077 
 
17078 
  def __init__(self, ex=None,):
17079 
    self.ex = ex
17080 
 
17081 
  def read(self, iprot):
17082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17084 
      return
17085 
    iprot.readStructBegin()
17086 
    while True:
17087 
      (fname, ftype, fid) = iprot.readFieldBegin()
17088 
      if ftype == TType.STOP:
17089 
        break
17090 
      if fid == 1:
17091 
        if ftype == TType.STRUCT:
17092 
          self.ex = TransactionServiceException()
17093 
          self.ex.read(iprot)
17094 
        else:
17095 
          iprot.skip(ftype)
17096 
      else:
17097 
        iprot.skip(ftype)
17098 
      iprot.readFieldEnd()
17099 
    iprot.readStructEnd()
17100 
 
17101 
  def write(self, oprot):
17102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17104 
      return
17105 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
17106 
    if self.ex is not None:
17107 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17108 
      self.ex.write(oprot)
17109 
      oprot.writeFieldEnd()
17110 
    oprot.writeFieldStop()
17111 
    oprot.writeStructEnd()
17112 
 
17113 
  def validate(self):
17114 
    return
17115 
 
17116 
 
17117 
  def __repr__(self):
17118 
    L = ['%s=%r' % (key, value)
17119 
      for key, value in self.__dict__.iteritems()]
17120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17121 
 
17122 
  def __eq__(self, other):
17123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17124 
 
17125 
  def __ne__(self, other):
17126 
    return not (self == other)
17127 
 
17128 
class markOrdersAsNotAvailabke_args:
17129 
  """
17130 
  Attributes:
17131 
   - vendorId
17132 
   - itemId
17133 
   - quantity
17134 
   - estimate
4369 rajveer 17135 
   - isReminder
4303 rajveer 17136 
  """
17137 
 
17138 
  thrift_spec = (
17139 
    None, # 0
17140 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17141 
    (2, TType.I64, 'itemId', None, None, ), # 2
17142 
    (3, TType.I64, 'quantity', None, None, ), # 3
17143 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 17144 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 17145 
  )
17146 
 
4369 rajveer 17147 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 17148 
    self.vendorId = vendorId
17149 
    self.itemId = itemId
17150 
    self.quantity = quantity
17151 
    self.estimate = estimate
4369 rajveer 17152 
    self.isReminder = isReminder
4303 rajveer 17153 
 
17154 
  def read(self, iprot):
17155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17157 
      return
17158 
    iprot.readStructBegin()
17159 
    while True:
17160 
      (fname, ftype, fid) = iprot.readFieldBegin()
17161 
      if ftype == TType.STOP:
17162 
        break
17163 
      if fid == 1:
17164 
        if ftype == TType.I64:
17165 
          self.vendorId = iprot.readI64();
17166 
        else:
17167 
          iprot.skip(ftype)
17168 
      elif fid == 2:
17169 
        if ftype == TType.I64:
17170 
          self.itemId = iprot.readI64();
17171 
        else:
17172 
          iprot.skip(ftype)
17173 
      elif fid == 3:
17174 
        if ftype == TType.I64:
17175 
          self.quantity = iprot.readI64();
17176 
        else:
17177 
          iprot.skip(ftype)
17178 
      elif fid == 4:
17179 
        if ftype == TType.I64:
17180 
          self.estimate = iprot.readI64();
17181 
        else:
17182 
          iprot.skip(ftype)
4369 rajveer 17183 
      elif fid == 5:
17184 
        if ftype == TType.BOOL:
17185 
          self.isReminder = iprot.readBool();
17186 
        else:
17187 
          iprot.skip(ftype)
4303 rajveer 17188 
      else:
17189 
        iprot.skip(ftype)
17190 
      iprot.readFieldEnd()
17191 
    iprot.readStructEnd()
17192 
 
17193 
  def write(self, oprot):
17194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17196 
      return
17197 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
17198 
    if self.vendorId is not None:
17199 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17200 
      oprot.writeI64(self.vendorId)
17201 
      oprot.writeFieldEnd()
17202 
    if self.itemId is not None:
17203 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17204 
      oprot.writeI64(self.itemId)
17205 
      oprot.writeFieldEnd()
17206 
    if self.quantity is not None:
17207 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
17208 
      oprot.writeI64(self.quantity)
17209 
      oprot.writeFieldEnd()
17210 
    if self.estimate is not None:
17211 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
17212 
      oprot.writeI64(self.estimate)
17213 
      oprot.writeFieldEnd()
4369 rajveer 17214 
    if self.isReminder is not None:
17215 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
17216 
      oprot.writeBool(self.isReminder)
17217 
      oprot.writeFieldEnd()
4303 rajveer 17218 
    oprot.writeFieldStop()
17219 
    oprot.writeStructEnd()
17220 
 
17221 
  def validate(self):
17222 
    return
17223 
 
17224 
 
17225 
  def __repr__(self):
17226 
    L = ['%s=%r' % (key, value)
17227 
      for key, value in self.__dict__.iteritems()]
17228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17229 
 
17230 
  def __eq__(self, other):
17231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17232 
 
17233 
  def __ne__(self, other):
17234 
    return not (self == other)
17235 
 
17236 
class markOrdersAsNotAvailabke_result:
17237 
  """
17238 
  Attributes:
17239 
   - ex
17240 
  """
17241 
 
17242 
  thrift_spec = (
17243 
    None, # 0
17244 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17245 
  )
17246 
 
17247 
  def __init__(self, ex=None,):
17248 
    self.ex = ex
17249 
 
17250 
  def read(self, iprot):
17251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17253 
      return
17254 
    iprot.readStructBegin()
17255 
    while True:
17256 
      (fname, ftype, fid) = iprot.readFieldBegin()
17257 
      if ftype == TType.STOP:
17258 
        break
17259 
      if fid == 1:
17260 
        if ftype == TType.STRUCT:
17261 
          self.ex = TransactionServiceException()
17262 
          self.ex.read(iprot)
17263 
        else:
17264 
          iprot.skip(ftype)
17265 
      else:
17266 
        iprot.skip(ftype)
17267 
      iprot.readFieldEnd()
17268 
    iprot.readStructEnd()
17269 
 
17270 
  def write(self, oprot):
17271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17273 
      return
17274 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
17275 
    if self.ex is not None:
17276 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17277 
      self.ex.write(oprot)
17278 
      oprot.writeFieldEnd()
17279 
    oprot.writeFieldStop()
17280 
    oprot.writeStructEnd()
17281 
 
17282 
  def validate(self):
17283 
    return
17284 
 
17285 
 
17286 
  def __repr__(self):
17287 
    L = ['%s=%r' % (key, value)
17288 
      for key, value in self.__dict__.iteritems()]
17289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17290 
 
17291 
  def __eq__(self, other):
17292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17293 
 
17294 
  def __ne__(self, other):
17295 
    return not (self == other)
4369 rajveer 17296 
 
17297 
class markOrdersAsTimeout_args:
17298 
  """
17299 
  Attributes:
17300 
   - vendorId
17301 
  """
17302 
 
17303 
  thrift_spec = (
17304 
    None, # 0
17305 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17306 
  )
17307 
 
17308 
  def __init__(self, vendorId=None,):
17309 
    self.vendorId = vendorId
17310 
 
17311 
  def read(self, iprot):
17312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17314 
      return
17315 
    iprot.readStructBegin()
17316 
    while True:
17317 
      (fname, ftype, fid) = iprot.readFieldBegin()
17318 
      if ftype == TType.STOP:
17319 
        break
17320 
      if fid == 1:
17321 
        if ftype == TType.I64:
17322 
          self.vendorId = iprot.readI64();
17323 
        else:
17324 
          iprot.skip(ftype)
17325 
      else:
17326 
        iprot.skip(ftype)
17327 
      iprot.readFieldEnd()
17328 
    iprot.readStructEnd()
17329 
 
17330 
  def write(self, oprot):
17331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17333 
      return
17334 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
17335 
    if self.vendorId is not None:
17336 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17337 
      oprot.writeI64(self.vendorId)
17338 
      oprot.writeFieldEnd()
17339 
    oprot.writeFieldStop()
17340 
    oprot.writeStructEnd()
17341 
 
17342 
  def validate(self):
17343 
    return
17344 
 
17345 
 
17346 
  def __repr__(self):
17347 
    L = ['%s=%r' % (key, value)
17348 
      for key, value in self.__dict__.iteritems()]
17349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17350 
 
17351 
  def __eq__(self, other):
17352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17353 
 
17354 
  def __ne__(self, other):
17355 
    return not (self == other)
17356 
 
17357 
class markOrdersAsTimeout_result:
17358 
  """
17359 
  Attributes:
17360 
   - success
17361 
   - ex
17362 
  """
17363 
 
17364 
  thrift_spec = (
17365 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
17366 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17367 
  )
17368 
 
17369 
  def __init__(self, success=None, ex=None,):
17370 
    self.success = success
17371 
    self.ex = ex
17372 
 
17373 
  def read(self, iprot):
17374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17376 
      return
17377 
    iprot.readStructBegin()
17378 
    while True:
17379 
      (fname, ftype, fid) = iprot.readFieldBegin()
17380 
      if ftype == TType.STOP:
17381 
        break
17382 
      if fid == 0:
17383 
        if ftype == TType.MAP:
17384 
          self.success = {}
4801 anupam.sin 17385 
          (_ktype306, _vtype307, _size305 ) = iprot.readMapBegin()
17386 
          for _i309 in xrange(_size305):
17387 
            _key310 = iprot.readI32();
17388 
            _val311 = TimeoutSummary()
17389 
            _val311.read(iprot)
17390 
            self.success[_key310] = _val311
4369 rajveer 17391 
          iprot.readMapEnd()
17392 
        else:
17393 
          iprot.skip(ftype)
17394 
      elif fid == 1:
17395 
        if ftype == TType.STRUCT:
17396 
          self.ex = TransactionServiceException()
17397 
          self.ex.read(iprot)
17398 
        else:
17399 
          iprot.skip(ftype)
17400 
      else:
17401 
        iprot.skip(ftype)
17402 
      iprot.readFieldEnd()
17403 
    iprot.readStructEnd()
17404 
 
17405 
  def write(self, oprot):
17406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17408 
      return
17409 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
17410 
    if self.success is not None:
17411 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17412 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4801 anupam.sin 17413 
      for kiter312,viter313 in self.success.items():
17414 
        oprot.writeI32(kiter312)
17415 
        viter313.write(oprot)
4369 rajveer 17416 
      oprot.writeMapEnd()
17417 
      oprot.writeFieldEnd()
17418 
    if self.ex is not None:
17419 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17420 
      self.ex.write(oprot)
17421 
      oprot.writeFieldEnd()
17422 
    oprot.writeFieldStop()
17423 
    oprot.writeStructEnd()
17424 
 
17425 
  def validate(self):
17426 
    return
17427 
 
17428 
 
17429 
  def __repr__(self):
17430 
    L = ['%s=%r' % (key, value)
17431 
      for key, value in self.__dict__.iteritems()]
17432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17433 
 
17434 
  def __eq__(self, other):
17435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17436 
 
17437 
  def __ne__(self, other):
17438 
    return not (self == other)
4386 anupam.sin 17439 
 
4662 rajveer 17440 
class markOrderAsLostInTransit_args:
17441 
  """
17442 
  Attributes:
17443 
   - orderId
17444 
  """
17445 
 
17446 
  thrift_spec = (
17447 
    None, # 0
17448 
    (1, TType.I64, 'orderId', None, None, ), # 1
17449 
  )
17450 
 
17451 
  def __init__(self, orderId=None,):
17452 
    self.orderId = orderId
17453 
 
17454 
  def read(self, iprot):
17455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17457 
      return
17458 
    iprot.readStructBegin()
17459 
    while True:
17460 
      (fname, ftype, fid) = iprot.readFieldBegin()
17461 
      if ftype == TType.STOP:
17462 
        break
17463 
      if fid == 1:
17464 
        if ftype == TType.I64:
17465 
          self.orderId = iprot.readI64();
17466 
        else:
17467 
          iprot.skip(ftype)
17468 
      else:
17469 
        iprot.skip(ftype)
17470 
      iprot.readFieldEnd()
17471 
    iprot.readStructEnd()
17472 
 
17473 
  def write(self, oprot):
17474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17476 
      return
17477 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
17478 
    if self.orderId is not None:
17479 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17480 
      oprot.writeI64(self.orderId)
17481 
      oprot.writeFieldEnd()
17482 
    oprot.writeFieldStop()
17483 
    oprot.writeStructEnd()
17484 
 
17485 
  def validate(self):
17486 
    return
17487 
 
17488 
 
17489 
  def __repr__(self):
17490 
    L = ['%s=%r' % (key, value)
17491 
      for key, value in self.__dict__.iteritems()]
17492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17493 
 
17494 
  def __eq__(self, other):
17495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17496 
 
17497 
  def __ne__(self, other):
17498 
    return not (self == other)
17499 
 
17500 
class markOrderAsLostInTransit_result:
17501 
  """
17502 
  Attributes:
17503 
   - success
17504 
   - ex
17505 
  """
17506 
 
17507 
  thrift_spec = (
17508 
    (0, TType.BOOL, 'success', None, None, ), # 0
17509 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17510 
  )
17511 
 
17512 
  def __init__(self, success=None, ex=None,):
17513 
    self.success = success
17514 
    self.ex = ex
17515 
 
17516 
  def read(self, iprot):
17517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17519 
      return
17520 
    iprot.readStructBegin()
17521 
    while True:
17522 
      (fname, ftype, fid) = iprot.readFieldBegin()
17523 
      if ftype == TType.STOP:
17524 
        break
17525 
      if fid == 0:
17526 
        if ftype == TType.BOOL:
17527 
          self.success = iprot.readBool();
17528 
        else:
17529 
          iprot.skip(ftype)
17530 
      elif fid == 1:
17531 
        if ftype == TType.STRUCT:
17532 
          self.ex = TransactionServiceException()
17533 
          self.ex.read(iprot)
17534 
        else:
17535 
          iprot.skip(ftype)
17536 
      else:
17537 
        iprot.skip(ftype)
17538 
      iprot.readFieldEnd()
17539 
    iprot.readStructEnd()
17540 
 
17541 
  def write(self, oprot):
17542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17544 
      return
17545 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
17546 
    if self.success is not None:
17547 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17548 
      oprot.writeBool(self.success)
17549 
      oprot.writeFieldEnd()
17550 
    if self.ex is not None:
17551 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17552 
      self.ex.write(oprot)
17553 
      oprot.writeFieldEnd()
17554 
    oprot.writeFieldStop()
17555 
    oprot.writeStructEnd()
17556 
 
17557 
  def validate(self):
17558 
    return
17559 
 
17560 
 
17561 
  def __repr__(self):
17562 
    L = ['%s=%r' % (key, value)
17563 
      for key, value in self.__dict__.iteritems()]
17564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17565 
 
17566 
  def __eq__(self, other):
17567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17568 
 
17569 
  def __ne__(self, other):
17570 
    return not (self == other)
17571 
 
4386 anupam.sin 17572 
class getOrderForAwb_args:
17573 
  """
17574 
  Attributes:
17575 
   - awb
17576 
  """
17577 
 
17578 
  thrift_spec = (
17579 
    None, # 0
17580 
    (1, TType.STRING, 'awb', None, None, ), # 1
17581 
  )
17582 
 
17583 
  def __init__(self, awb=None,):
17584 
    self.awb = awb
17585 
 
17586 
  def read(self, iprot):
17587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17589 
      return
17590 
    iprot.readStructBegin()
17591 
    while True:
17592 
      (fname, ftype, fid) = iprot.readFieldBegin()
17593 
      if ftype == TType.STOP:
17594 
        break
17595 
      if fid == 1:
17596 
        if ftype == TType.STRING:
17597 
          self.awb = iprot.readString();
17598 
        else:
17599 
          iprot.skip(ftype)
17600 
      else:
17601 
        iprot.skip(ftype)
17602 
      iprot.readFieldEnd()
17603 
    iprot.readStructEnd()
17604 
 
17605 
  def write(self, oprot):
17606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17608 
      return
17609 
    oprot.writeStructBegin('getOrderForAwb_args')
17610 
    if self.awb is not None:
17611 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
17612 
      oprot.writeString(self.awb)
17613 
      oprot.writeFieldEnd()
17614 
    oprot.writeFieldStop()
17615 
    oprot.writeStructEnd()
17616 
 
17617 
  def validate(self):
17618 
    return
17619 
 
17620 
 
17621 
  def __repr__(self):
17622 
    L = ['%s=%r' % (key, value)
17623 
      for key, value in self.__dict__.iteritems()]
17624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17625 
 
17626 
  def __eq__(self, other):
17627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17628 
 
17629 
  def __ne__(self, other):
17630 
    return not (self == other)
17631 
 
17632 
class getOrderForAwb_result:
17633 
  """
17634 
  Attributes:
17635 
   - success
17636 
   - ex
17637 
  """
17638 
 
17639 
  thrift_spec = (
17640 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17641 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17642 
  )
17643 
 
17644 
  def __init__(self, success=None, ex=None,):
17645 
    self.success = success
17646 
    self.ex = ex
17647 
 
17648 
  def read(self, iprot):
17649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17651 
      return
17652 
    iprot.readStructBegin()
17653 
    while True:
17654 
      (fname, ftype, fid) = iprot.readFieldBegin()
17655 
      if ftype == TType.STOP:
17656 
        break
17657 
      if fid == 0:
17658 
        if ftype == TType.STRUCT:
17659 
          self.success = Order()
17660 
          self.success.read(iprot)
17661 
        else:
17662 
          iprot.skip(ftype)
17663 
      elif fid == 1:
17664 
        if ftype == TType.STRUCT:
17665 
          self.ex = TransactionServiceException()
17666 
          self.ex.read(iprot)
17667 
        else:
17668 
          iprot.skip(ftype)
17669 
      else:
17670 
        iprot.skip(ftype)
17671 
      iprot.readFieldEnd()
17672 
    iprot.readStructEnd()
17673 
 
17674 
  def write(self, oprot):
17675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17677 
      return
17678 
    oprot.writeStructBegin('getOrderForAwb_result')
17679 
    if self.success is not None:
17680 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17681 
      self.success.write(oprot)
17682 
      oprot.writeFieldEnd()
17683 
    if self.ex is not None:
17684 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17685 
      self.ex.write(oprot)
17686 
      oprot.writeFieldEnd()
17687 
    oprot.writeFieldStop()
17688 
    oprot.writeStructEnd()
17689 
 
17690 
  def validate(self):
17691 
    return
17692 
 
17693 
 
17694 
  def __repr__(self):
17695 
    L = ['%s=%r' % (key, value)
17696 
      for key, value in self.__dict__.iteritems()]
17697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17698 
 
17699 
  def __eq__(self, other):
17700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17701 
 
17702 
  def __ne__(self, other):
17703 
    return not (self == other)
4506 phani.kuma 17704 
 
17705 
class getOrdersForProviderForStatus_args:
17706 
  """
17707 
  Attributes:
17708 
   - logistics_provider_id
17709 
   - order_status
17710 
  """
17711 
 
17712 
  thrift_spec = (
17713 
    None, # 0
17714 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
17715 
    (2, TType.I32, 'order_status', None, None, ), # 2
17716 
  )
17717 
 
17718 
  def __init__(self, logistics_provider_id=None, order_status=None,):
17719 
    self.logistics_provider_id = logistics_provider_id
17720 
    self.order_status = order_status
17721 
 
17722 
  def read(self, iprot):
17723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17725 
      return
17726 
    iprot.readStructBegin()
17727 
    while True:
17728 
      (fname, ftype, fid) = iprot.readFieldBegin()
17729 
      if ftype == TType.STOP:
17730 
        break
17731 
      if fid == 1:
17732 
        if ftype == TType.I64:
17733 
          self.logistics_provider_id = iprot.readI64();
17734 
        else:
17735 
          iprot.skip(ftype)
17736 
      elif fid == 2:
17737 
        if ftype == TType.I32:
17738 
          self.order_status = iprot.readI32();
17739 
        else:
17740 
          iprot.skip(ftype)
17741 
      else:
17742 
        iprot.skip(ftype)
17743 
      iprot.readFieldEnd()
17744 
    iprot.readStructEnd()
17745 
 
17746 
  def write(self, oprot):
17747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17749 
      return
17750 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
17751 
    if self.logistics_provider_id is not None:
17752 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
17753 
      oprot.writeI64(self.logistics_provider_id)
17754 
      oprot.writeFieldEnd()
17755 
    if self.order_status is not None:
17756 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
17757 
      oprot.writeI32(self.order_status)
17758 
      oprot.writeFieldEnd()
17759 
    oprot.writeFieldStop()
17760 
    oprot.writeStructEnd()
17761 
 
17762 
  def validate(self):
17763 
    return
17764 
 
17765 
 
17766 
  def __repr__(self):
17767 
    L = ['%s=%r' % (key, value)
17768 
      for key, value in self.__dict__.iteritems()]
17769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17770 
 
17771 
  def __eq__(self, other):
17772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17773 
 
17774 
  def __ne__(self, other):
17775 
    return not (self == other)
17776 
 
17777 
class getOrdersForProviderForStatus_result:
17778 
  """
17779 
  Attributes:
17780 
   - success
17781 
   - ex
17782 
  """
17783 
 
17784 
  thrift_spec = (
17785 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17786 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17787 
  )
17788 
 
17789 
  def __init__(self, success=None, ex=None,):
17790 
    self.success = success
17791 
    self.ex = ex
17792 
 
17793 
  def read(self, iprot):
17794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17796 
      return
17797 
    iprot.readStructBegin()
17798 
    while True:
17799 
      (fname, ftype, fid) = iprot.readFieldBegin()
17800 
      if ftype == TType.STOP:
17801 
        break
17802 
      if fid == 0:
17803 
        if ftype == TType.LIST:
17804 
          self.success = []
4801 anupam.sin 17805 
          (_etype317, _size314) = iprot.readListBegin()
17806 
          for _i318 in xrange(_size314):
17807 
            _elem319 = Order()
17808 
            _elem319.read(iprot)
17809 
            self.success.append(_elem319)
4506 phani.kuma 17810 
          iprot.readListEnd()
17811 
        else:
17812 
          iprot.skip(ftype)
17813 
      elif fid == 1:
17814 
        if ftype == TType.STRUCT:
17815 
          self.ex = TransactionServiceException()
17816 
          self.ex.read(iprot)
17817 
        else:
17818 
          iprot.skip(ftype)
17819 
      else:
17820 
        iprot.skip(ftype)
17821 
      iprot.readFieldEnd()
17822 
    iprot.readStructEnd()
17823 
 
17824 
  def write(self, oprot):
17825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17827 
      return
17828 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
17829 
    if self.success is not None:
17830 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17831 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 17832 
      for iter320 in self.success:
17833 
        iter320.write(oprot)
4506 phani.kuma 17834 
      oprot.writeListEnd()
17835 
      oprot.writeFieldEnd()
17836 
    if self.ex is not None:
17837 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17838 
      self.ex.write(oprot)
17839 
      oprot.writeFieldEnd()
17840 
    oprot.writeFieldStop()
17841 
    oprot.writeStructEnd()
17842 
 
17843 
  def validate(self):
17844 
    return
17845 
 
17846 
 
17847 
  def __repr__(self):
17848 
    L = ['%s=%r' % (key, value)
17849 
      for key, value in self.__dict__.iteritems()]
17850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17851 
 
17852 
  def __eq__(self, other):
17853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17854 
 
17855 
  def __ne__(self, other):
17856 
    return not (self == other)
4600 varun.gupt 17857 
 
17858 
class getBilledOrdersForVendor_args:
17859 
  """
17860 
  Attributes:
17861 
   - vendorId
17862 
   - billingDateFrom
17863 
   - billingDateTo
17864 
  """
17865 
 
17866 
  thrift_spec = (
17867 
    None, # 0
17868 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17869 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
17870 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
17871 
  )
17872 
 
17873 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
17874 
    self.vendorId = vendorId
17875 
    self.billingDateFrom = billingDateFrom
17876 
    self.billingDateTo = billingDateTo
17877 
 
17878 
  def read(self, iprot):
17879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17881 
      return
17882 
    iprot.readStructBegin()
17883 
    while True:
17884 
      (fname, ftype, fid) = iprot.readFieldBegin()
17885 
      if ftype == TType.STOP:
17886 
        break
17887 
      if fid == 1:
17888 
        if ftype == TType.I64:
17889 
          self.vendorId = iprot.readI64();
17890 
        else:
17891 
          iprot.skip(ftype)
17892 
      elif fid == 2:
17893 
        if ftype == TType.I64:
17894 
          self.billingDateFrom = iprot.readI64();
17895 
        else:
17896 
          iprot.skip(ftype)
17897 
      elif fid == 3:
17898 
        if ftype == TType.I64:
17899 
          self.billingDateTo = iprot.readI64();
17900 
        else:
17901 
          iprot.skip(ftype)
17902 
      else:
17903 
        iprot.skip(ftype)
17904 
      iprot.readFieldEnd()
17905 
    iprot.readStructEnd()
17906 
 
17907 
  def write(self, oprot):
17908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17910 
      return
17911 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
17912 
    if self.vendorId is not None:
17913 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17914 
      oprot.writeI64(self.vendorId)
17915 
      oprot.writeFieldEnd()
17916 
    if self.billingDateFrom is not None:
17917 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
17918 
      oprot.writeI64(self.billingDateFrom)
17919 
      oprot.writeFieldEnd()
17920 
    if self.billingDateTo is not None:
17921 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
17922 
      oprot.writeI64(self.billingDateTo)
17923 
      oprot.writeFieldEnd()
17924 
    oprot.writeFieldStop()
17925 
    oprot.writeStructEnd()
17926 
 
17927 
  def validate(self):
17928 
    return
17929 
 
17930 
 
17931 
  def __repr__(self):
17932 
    L = ['%s=%r' % (key, value)
17933 
      for key, value in self.__dict__.iteritems()]
17934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17935 
 
17936 
  def __eq__(self, other):
17937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17938 
 
17939 
  def __ne__(self, other):
17940 
    return not (self == other)
17941 
 
17942 
class getBilledOrdersForVendor_result:
17943 
  """
17944 
  Attributes:
17945 
   - success
17946 
   - ex
17947 
  """
17948 
 
17949 
  thrift_spec = (
17950 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17951 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17952 
  )
17953 
 
17954 
  def __init__(self, success=None, ex=None,):
17955 
    self.success = success
17956 
    self.ex = ex
17957 
 
17958 
  def read(self, iprot):
17959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17961 
      return
17962 
    iprot.readStructBegin()
17963 
    while True:
17964 
      (fname, ftype, fid) = iprot.readFieldBegin()
17965 
      if ftype == TType.STOP:
17966 
        break
17967 
      if fid == 0:
17968 
        if ftype == TType.LIST:
17969 
          self.success = []
4801 anupam.sin 17970 
          (_etype324, _size321) = iprot.readListBegin()
17971 
          for _i325 in xrange(_size321):
17972 
            _elem326 = Order()
17973 
            _elem326.read(iprot)
17974 
            self.success.append(_elem326)
4600 varun.gupt 17975 
          iprot.readListEnd()
17976 
        else:
17977 
          iprot.skip(ftype)
17978 
      elif fid == 1:
17979 
        if ftype == TType.STRUCT:
17980 
          self.ex = TransactionServiceException()
17981 
          self.ex.read(iprot)
17982 
        else:
17983 
          iprot.skip(ftype)
17984 
      else:
17985 
        iprot.skip(ftype)
17986 
      iprot.readFieldEnd()
17987 
    iprot.readStructEnd()
17988 
 
17989 
  def write(self, oprot):
17990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17992 
      return
17993 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
17994 
    if self.success is not None:
17995 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17996 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 17997 
      for iter327 in self.success:
17998 
        iter327.write(oprot)
4600 varun.gupt 17999 
      oprot.writeListEnd()
18000 
      oprot.writeFieldEnd()
18001 
    if self.ex is not None:
18002 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18003 
      self.ex.write(oprot)
18004 
      oprot.writeFieldEnd()
18005 
    oprot.writeFieldStop()
18006 
    oprot.writeStructEnd()
18007 
 
18008 
  def validate(self):
18009 
    return
18010 
 
18011 
 
18012 
  def __repr__(self):
18013 
    L = ['%s=%r' % (key, value)
18014 
      for key, value in self.__dict__.iteritems()]
18015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18016 
 
18017 
  def __eq__(self, other):
18018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18019 
 
18020 
  def __ne__(self, other):
18021 
    return not (self == other)
18022 
 
4607 rajveer 18023 
class getSlippedSippingDateOrders_args:
18024 
 
18025 
  thrift_spec = (
18026 
  )
18027 
 
18028 
  def read(self, iprot):
18029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18031 
      return
18032 
    iprot.readStructBegin()
18033 
    while True:
18034 
      (fname, ftype, fid) = iprot.readFieldBegin()
18035 
      if ftype == TType.STOP:
18036 
        break
18037 
      else:
18038 
        iprot.skip(ftype)
18039 
      iprot.readFieldEnd()
18040 
    iprot.readStructEnd()
18041 
 
18042 
  def write(self, oprot):
18043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18045 
      return
18046 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
18047 
    oprot.writeFieldStop()
18048 
    oprot.writeStructEnd()
18049 
 
18050 
  def validate(self):
18051 
    return
18052 
 
18053 
 
18054 
  def __repr__(self):
18055 
    L = ['%s=%r' % (key, value)
18056 
      for key, value in self.__dict__.iteritems()]
18057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18058 
 
18059 
  def __eq__(self, other):
18060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18061 
 
18062 
  def __ne__(self, other):
18063 
    return not (self == other)
18064 
 
18065 
class getSlippedSippingDateOrders_result:
18066 
  """
18067 
  Attributes:
18068 
   - success
18069 
   - ex
18070 
  """
18071 
 
18072 
  thrift_spec = (
18073 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18074 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18075 
  )
18076 
 
18077 
  def __init__(self, success=None, ex=None,):
18078 
    self.success = success
18079 
    self.ex = ex
18080 
 
18081 
  def read(self, iprot):
18082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18084 
      return
18085 
    iprot.readStructBegin()
18086 
    while True:
18087 
      (fname, ftype, fid) = iprot.readFieldBegin()
18088 
      if ftype == TType.STOP:
18089 
        break
18090 
      if fid == 0:
18091 
        if ftype == TType.LIST:
18092 
          self.success = []
4801 anupam.sin 18093 
          (_etype331, _size328) = iprot.readListBegin()
18094 
          for _i332 in xrange(_size328):
18095 
            _elem333 = Order()
18096 
            _elem333.read(iprot)
18097 
            self.success.append(_elem333)
4607 rajveer 18098 
          iprot.readListEnd()
18099 
        else:
18100 
          iprot.skip(ftype)
18101 
      elif fid == 1:
18102 
        if ftype == TType.STRUCT:
18103 
          self.ex = TransactionServiceException()
18104 
          self.ex.read(iprot)
18105 
        else:
18106 
          iprot.skip(ftype)
18107 
      else:
18108 
        iprot.skip(ftype)
18109 
      iprot.readFieldEnd()
18110 
    iprot.readStructEnd()
18111 
 
18112 
  def write(self, oprot):
18113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18115 
      return
18116 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
18117 
    if self.success is not None:
18118 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18119 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 18120 
      for iter334 in self.success:
18121 
        iter334.write(oprot)
4607 rajveer 18122 
      oprot.writeListEnd()
18123 
      oprot.writeFieldEnd()
18124 
    if self.ex is not None:
18125 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18126 
      self.ex.write(oprot)
18127 
      oprot.writeFieldEnd()
18128 
    oprot.writeFieldStop()
18129 
    oprot.writeStructEnd()
18130 
 
18131 
  def validate(self):
18132 
    return
18133 
 
18134 
 
18135 
  def __repr__(self):
18136 
    L = ['%s=%r' % (key, value)
18137 
      for key, value in self.__dict__.iteritems()]
18138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18139 
 
18140 
  def __eq__(self, other):
18141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18142 
 
18143 
  def __ne__(self, other):
18144 
    return not (self == other)
18145 
 
4709 rajveer 18146 
class getCancelledOrders_args:
18147 
  """
18148 
  Attributes:
18149 
   - cancelDateFrom
18150 
   - cancelDateTo
18151 
  """
18152 
 
18153 
  thrift_spec = (
18154 
    None, # 0
18155 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
18156 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
18157 
  )
18158 
 
18159 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
18160 
    self.cancelDateFrom = cancelDateFrom
18161 
    self.cancelDateTo = cancelDateTo
18162 
 
18163 
  def read(self, iprot):
18164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18166 
      return
18167 
    iprot.readStructBegin()
18168 
    while True:
18169 
      (fname, ftype, fid) = iprot.readFieldBegin()
18170 
      if ftype == TType.STOP:
18171 
        break
18172 
      if fid == 1:
18173 
        if ftype == TType.I64:
18174 
          self.cancelDateFrom = iprot.readI64();
18175 
        else:
18176 
          iprot.skip(ftype)
18177 
      elif fid == 2:
18178 
        if ftype == TType.I64:
18179 
          self.cancelDateTo = iprot.readI64();
18180 
        else:
18181 
          iprot.skip(ftype)
18182 
      else:
18183 
        iprot.skip(ftype)
18184 
      iprot.readFieldEnd()
18185 
    iprot.readStructEnd()
18186 
 
18187 
  def write(self, oprot):
18188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18190 
      return
18191 
    oprot.writeStructBegin('getCancelledOrders_args')
18192 
    if self.cancelDateFrom is not None:
18193 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
18194 
      oprot.writeI64(self.cancelDateFrom)
18195 
      oprot.writeFieldEnd()
18196 
    if self.cancelDateTo is not None:
18197 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
18198 
      oprot.writeI64(self.cancelDateTo)
18199 
      oprot.writeFieldEnd()
18200 
    oprot.writeFieldStop()
18201 
    oprot.writeStructEnd()
18202 
 
18203 
  def validate(self):
18204 
    return
18205 
 
18206 
 
18207 
  def __repr__(self):
18208 
    L = ['%s=%r' % (key, value)
18209 
      for key, value in self.__dict__.iteritems()]
18210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18211 
 
18212 
  def __eq__(self, other):
18213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18214 
 
18215 
  def __ne__(self, other):
18216 
    return not (self == other)
18217 
 
18218 
class getCancelledOrders_result:
18219 
  """
18220 
  Attributes:
18221 
   - success
18222 
   - ex
18223 
  """
18224 
 
18225 
  thrift_spec = (
18226 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18227 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18228 
  )
18229 
 
18230 
  def __init__(self, success=None, ex=None,):
18231 
    self.success = success
18232 
    self.ex = ex
18233 
 
18234 
  def read(self, iprot):
18235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18237 
      return
18238 
    iprot.readStructBegin()
18239 
    while True:
18240 
      (fname, ftype, fid) = iprot.readFieldBegin()
18241 
      if ftype == TType.STOP:
18242 
        break
18243 
      if fid == 0:
18244 
        if ftype == TType.LIST:
18245 
          self.success = []
4801 anupam.sin 18246 
          (_etype338, _size335) = iprot.readListBegin()
18247 
          for _i339 in xrange(_size335):
18248 
            _elem340 = Order()
18249 
            _elem340.read(iprot)
18250 
            self.success.append(_elem340)
4709 rajveer 18251 
          iprot.readListEnd()
18252 
        else:
18253 
          iprot.skip(ftype)
18254 
      elif fid == 1:
18255 
        if ftype == TType.STRUCT:
18256 
          self.ex = TransactionServiceException()
18257 
          self.ex.read(iprot)
18258 
        else:
18259 
          iprot.skip(ftype)
18260 
      else:
18261 
        iprot.skip(ftype)
18262 
      iprot.readFieldEnd()
18263 
    iprot.readStructEnd()
18264 
 
18265 
  def write(self, oprot):
18266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18268 
      return
18269 
    oprot.writeStructBegin('getCancelledOrders_result')
18270 
    if self.success is not None:
18271 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18272 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 18273 
      for iter341 in self.success:
18274 
        iter341.write(oprot)
4709 rajveer 18275 
      oprot.writeListEnd()
18276 
      oprot.writeFieldEnd()
18277 
    if self.ex is not None:
18278 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18279 
      self.ex.write(oprot)
18280 
      oprot.writeFieldEnd()
18281 
    oprot.writeFieldStop()
18282 
    oprot.writeStructEnd()
18283 
 
18284 
  def validate(self):
18285 
    return
18286 
 
18287 
 
18288 
  def __repr__(self):
18289 
    L = ['%s=%r' % (key, value)
18290 
      for key, value in self.__dict__.iteritems()]
18291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18292 
 
18293 
  def __eq__(self, other):
18294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18295 
 
18296 
  def __ne__(self, other):
18297 
    return not (self == other)
18298 
 
4600 varun.gupt 18299 
class saveBluedartSettlements_args:
18300 
  """
18301 
  Attributes:
18302 
   - mapAWBAndAmount
18303 
  """
18304 
 
18305 
  thrift_spec = (
18306 
    None, # 0
18307 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
18308 
  )
18309 
 
18310 
  def __init__(self, mapAWBAndAmount=None,):
18311 
    self.mapAWBAndAmount = mapAWBAndAmount
18312 
 
18313 
  def read(self, iprot):
18314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18316 
      return
18317 
    iprot.readStructBegin()
18318 
    while True:
18319 
      (fname, ftype, fid) = iprot.readFieldBegin()
18320 
      if ftype == TType.STOP:
18321 
        break
18322 
      if fid == 1:
18323 
        if ftype == TType.MAP:
18324 
          self.mapAWBAndAmount = {}
4801 anupam.sin 18325 
          (_ktype343, _vtype344, _size342 ) = iprot.readMapBegin()
18326 
          for _i346 in xrange(_size342):
18327 
            _key347 = iprot.readI64();
18328 
            _val348 = iprot.readDouble();
18329 
            self.mapAWBAndAmount[_key347] = _val348
4600 varun.gupt 18330 
          iprot.readMapEnd()
18331 
        else:
18332 
          iprot.skip(ftype)
18333 
      else:
18334 
        iprot.skip(ftype)
18335 
      iprot.readFieldEnd()
18336 
    iprot.readStructEnd()
18337 
 
18338 
  def write(self, oprot):
18339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18341 
      return
18342 
    oprot.writeStructBegin('saveBluedartSettlements_args')
18343 
    if self.mapAWBAndAmount is not None:
18344 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
18345 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
4801 anupam.sin 18346 
      for kiter349,viter350 in self.mapAWBAndAmount.items():
18347 
        oprot.writeI64(kiter349)
18348 
        oprot.writeDouble(viter350)
4600 varun.gupt 18349 
      oprot.writeMapEnd()
18350 
      oprot.writeFieldEnd()
18351 
    oprot.writeFieldStop()
18352 
    oprot.writeStructEnd()
18353 
 
18354 
  def validate(self):
18355 
    return
18356 
 
18357 
 
18358 
  def __repr__(self):
18359 
    L = ['%s=%r' % (key, value)
18360 
      for key, value in self.__dict__.iteritems()]
18361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18362 
 
18363 
  def __eq__(self, other):
18364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18365 
 
18366 
  def __ne__(self, other):
18367 
    return not (self == other)
18368 
 
18369 
class saveBluedartSettlements_result:
18370 
  """
18371 
  Attributes:
18372 
   - ex
18373 
  """
18374 
 
18375 
  thrift_spec = (
18376 
    None, # 0
18377 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18378 
  )
18379 
 
18380 
  def __init__(self, ex=None,):
18381 
    self.ex = ex
18382 
 
18383 
  def read(self, iprot):
18384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18386 
      return
18387 
    iprot.readStructBegin()
18388 
    while True:
18389 
      (fname, ftype, fid) = iprot.readFieldBegin()
18390 
      if ftype == TType.STOP:
18391 
        break
18392 
      if fid == 1:
18393 
        if ftype == TType.STRUCT:
18394 
          self.ex = TransactionServiceException()
18395 
          self.ex.read(iprot)
18396 
        else:
18397 
          iprot.skip(ftype)
18398 
      else:
18399 
        iprot.skip(ftype)
18400 
      iprot.readFieldEnd()
18401 
    iprot.readStructEnd()
18402 
 
18403 
  def write(self, oprot):
18404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18406 
      return
18407 
    oprot.writeStructBegin('saveBluedartSettlements_result')
18408 
    if self.ex is not None:
18409 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18410 
      self.ex.write(oprot)
18411 
      oprot.writeFieldEnd()
18412 
    oprot.writeFieldStop()
18413 
    oprot.writeStructEnd()
18414 
 
18415 
  def validate(self):
18416 
    return
18417 
 
18418 
 
18419 
  def __repr__(self):
18420 
    L = ['%s=%r' % (key, value)
18421 
      for key, value in self.__dict__.iteritems()]
18422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18423 
 
18424 
  def __eq__(self, other):
18425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18426 
 
18427 
  def __ne__(self, other):
18428 
    return not (self == other)
18429 
 
18430 
class savePaymentSettlements_args:
18431 
  """
18432 
  Attributes:
18433 
   - settlementDate
18434 
   - paymentGatewayId
18435 
   - paymentId
18436 
   - serviceTax
18437 
   - otherCharges
18438 
   - netCollection
18439 
  """
18440 
 
18441 
  thrift_spec = (
18442 
    None, # 0
18443 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
18444 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
18445 
    (3, TType.I64, 'paymentId', None, None, ), # 3
18446 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
18447 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
18448 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
18449 
  )
18450 
 
18451 
  def __init__(self, settlementDate=None, paymentGatewayId=None, paymentId=None, serviceTax=None, otherCharges=None, netCollection=None,):
18452 
    self.settlementDate = settlementDate
18453 
    self.paymentGatewayId = paymentGatewayId
18454 
    self.paymentId = paymentId
18455 
    self.serviceTax = serviceTax
18456 
    self.otherCharges = otherCharges
18457 
    self.netCollection = netCollection
18458 
 
18459 
  def read(self, iprot):
18460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18462 
      return
18463 
    iprot.readStructBegin()
18464 
    while True:
18465 
      (fname, ftype, fid) = iprot.readFieldBegin()
18466 
      if ftype == TType.STOP:
18467 
        break
18468 
      if fid == 1:
18469 
        if ftype == TType.I64:
18470 
          self.settlementDate = iprot.readI64();
18471 
        else:
18472 
          iprot.skip(ftype)
18473 
      elif fid == 2:
18474 
        if ftype == TType.I64:
18475 
          self.paymentGatewayId = iprot.readI64();
18476 
        else:
18477 
          iprot.skip(ftype)
18478 
      elif fid == 3:
18479 
        if ftype == TType.I64:
18480 
          self.paymentId = iprot.readI64();
18481 
        else:
18482 
          iprot.skip(ftype)
18483 
      elif fid == 4:
18484 
        if ftype == TType.DOUBLE:
18485 
          self.serviceTax = iprot.readDouble();
18486 
        else:
18487 
          iprot.skip(ftype)
18488 
      elif fid == 5:
18489 
        if ftype == TType.DOUBLE:
18490 
          self.otherCharges = iprot.readDouble();
18491 
        else:
18492 
          iprot.skip(ftype)
18493 
      elif fid == 6:
18494 
        if ftype == TType.DOUBLE:
18495 
          self.netCollection = iprot.readDouble();
18496 
        else:
18497 
          iprot.skip(ftype)
18498 
      else:
18499 
        iprot.skip(ftype)
18500 
      iprot.readFieldEnd()
18501 
    iprot.readStructEnd()
18502 
 
18503 
  def write(self, oprot):
18504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18506 
      return
18507 
    oprot.writeStructBegin('savePaymentSettlements_args')
18508 
    if self.settlementDate is not None:
18509 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
18510 
      oprot.writeI64(self.settlementDate)
18511 
      oprot.writeFieldEnd()
18512 
    if self.paymentGatewayId is not None:
18513 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
18514 
      oprot.writeI64(self.paymentGatewayId)
18515 
      oprot.writeFieldEnd()
18516 
    if self.paymentId is not None:
18517 
      oprot.writeFieldBegin('paymentId', TType.I64, 3)
18518 
      oprot.writeI64(self.paymentId)
18519 
      oprot.writeFieldEnd()
18520 
    if self.serviceTax is not None:
18521 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
18522 
      oprot.writeDouble(self.serviceTax)
18523 
      oprot.writeFieldEnd()
18524 
    if self.otherCharges is not None:
18525 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
18526 
      oprot.writeDouble(self.otherCharges)
18527 
      oprot.writeFieldEnd()
18528 
    if self.netCollection is not None:
18529 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
18530 
      oprot.writeDouble(self.netCollection)
18531 
      oprot.writeFieldEnd()
18532 
    oprot.writeFieldStop()
18533 
    oprot.writeStructEnd()
18534 
 
18535 
  def validate(self):
18536 
    return
18537 
 
18538 
 
18539 
  def __repr__(self):
18540 
    L = ['%s=%r' % (key, value)
18541 
      for key, value in self.__dict__.iteritems()]
18542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18543 
 
18544 
  def __eq__(self, other):
18545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18546 
 
18547 
  def __ne__(self, other):
18548 
    return not (self == other)
18549 
 
18550 
class savePaymentSettlements_result:
18551 
  """
18552 
  Attributes:
18553 
   - ex
18554 
  """
18555 
 
18556 
  thrift_spec = (
18557 
    None, # 0
18558 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18559 
  )
18560 
 
18561 
  def __init__(self, ex=None,):
18562 
    self.ex = ex
18563 
 
18564 
  def read(self, iprot):
18565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18567 
      return
18568 
    iprot.readStructBegin()
18569 
    while True:
18570 
      (fname, ftype, fid) = iprot.readFieldBegin()
18571 
      if ftype == TType.STOP:
18572 
        break
18573 
      if fid == 1:
18574 
        if ftype == TType.STRUCT:
18575 
          self.ex = TransactionServiceException()
18576 
          self.ex.read(iprot)
18577 
        else:
18578 
          iprot.skip(ftype)
18579 
      else:
18580 
        iprot.skip(ftype)
18581 
      iprot.readFieldEnd()
18582 
    iprot.readStructEnd()
18583 
 
18584 
  def write(self, oprot):
18585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18587 
      return
18588 
    oprot.writeStructBegin('savePaymentSettlements_result')
18589 
    if self.ex is not None:
18590 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18591 
      self.ex.write(oprot)
18592 
      oprot.writeFieldEnd()
18593 
    oprot.writeFieldStop()
18594 
    oprot.writeStructEnd()
18595 
 
18596 
  def validate(self):
18597 
    return
18598 
 
18599 
 
18600 
  def __repr__(self):
18601 
    L = ['%s=%r' % (key, value)
18602 
      for key, value in self.__dict__.iteritems()]
18603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18604 
 
18605 
  def __eq__(self, other):
18606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18607 
 
18608 
  def __ne__(self, other):
18609 
    return not (self == other)
18610 
 
18611 
class saveEBSSettlementSummary_args:
18612 
  """
18613 
  Attributes:
18614 
   - settlementId
18615 
   - settlementDate
18616 
   - transactionDateFrom
18617 
   - transactionDateTo
18618 
   - amount
18619 
  """
18620 
 
18621 
  thrift_spec = (
18622 
    None, # 0
18623 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18624 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
18625 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
18626 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
18627 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
18628 
  )
18629 
 
18630 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
18631 
    self.settlementId = settlementId
18632 
    self.settlementDate = settlementDate
18633 
    self.transactionDateFrom = transactionDateFrom
18634 
    self.transactionDateTo = transactionDateTo
18635 
    self.amount = amount
18636 
 
18637 
  def read(self, iprot):
18638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18640 
      return
18641 
    iprot.readStructBegin()
18642 
    while True:
18643 
      (fname, ftype, fid) = iprot.readFieldBegin()
18644 
      if ftype == TType.STOP:
18645 
        break
18646 
      if fid == 1:
18647 
        if ftype == TType.I64:
18648 
          self.settlementId = iprot.readI64();
18649 
        else:
18650 
          iprot.skip(ftype)
18651 
      elif fid == 2:
18652 
        if ftype == TType.I64:
18653 
          self.settlementDate = iprot.readI64();
18654 
        else:
18655 
          iprot.skip(ftype)
18656 
      elif fid == 3:
18657 
        if ftype == TType.I64:
18658 
          self.transactionDateFrom = iprot.readI64();
18659 
        else:
18660 
          iprot.skip(ftype)
18661 
      elif fid == 4:
18662 
        if ftype == TType.I64:
18663 
          self.transactionDateTo = iprot.readI64();
18664 
        else:
18665 
          iprot.skip(ftype)
18666 
      elif fid == 5:
18667 
        if ftype == TType.DOUBLE:
18668 
          self.amount = iprot.readDouble();
18669 
        else:
18670 
          iprot.skip(ftype)
18671 
      else:
18672 
        iprot.skip(ftype)
18673 
      iprot.readFieldEnd()
18674 
    iprot.readStructEnd()
18675 
 
18676 
  def write(self, oprot):
18677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18679 
      return
18680 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
18681 
    if self.settlementId is not None:
18682 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18683 
      oprot.writeI64(self.settlementId)
18684 
      oprot.writeFieldEnd()
18685 
    if self.settlementDate is not None:
18686 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
18687 
      oprot.writeI64(self.settlementDate)
18688 
      oprot.writeFieldEnd()
18689 
    if self.transactionDateFrom is not None:
18690 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
18691 
      oprot.writeI64(self.transactionDateFrom)
18692 
      oprot.writeFieldEnd()
18693 
    if self.transactionDateTo is not None:
18694 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
18695 
      oprot.writeI64(self.transactionDateTo)
18696 
      oprot.writeFieldEnd()
18697 
    if self.amount is not None:
18698 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
18699 
      oprot.writeDouble(self.amount)
18700 
      oprot.writeFieldEnd()
18701 
    oprot.writeFieldStop()
18702 
    oprot.writeStructEnd()
18703 
 
18704 
  def validate(self):
18705 
    return
18706 
 
18707 
 
18708 
  def __repr__(self):
18709 
    L = ['%s=%r' % (key, value)
18710 
      for key, value in self.__dict__.iteritems()]
18711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18712 
 
18713 
  def __eq__(self, other):
18714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18715 
 
18716 
  def __ne__(self, other):
18717 
    return not (self == other)
18718 
 
18719 
class saveEBSSettlementSummary_result:
18720 
  """
18721 
  Attributes:
18722 
   - ex
18723 
  """
18724 
 
18725 
  thrift_spec = (
18726 
    None, # 0
18727 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18728 
  )
18729 
 
18730 
  def __init__(self, ex=None,):
18731 
    self.ex = ex
18732 
 
18733 
  def read(self, iprot):
18734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18736 
      return
18737 
    iprot.readStructBegin()
18738 
    while True:
18739 
      (fname, ftype, fid) = iprot.readFieldBegin()
18740 
      if ftype == TType.STOP:
18741 
        break
18742 
      if fid == 1:
18743 
        if ftype == TType.STRUCT:
18744 
          self.ex = TransactionServiceException()
18745 
          self.ex.read(iprot)
18746 
        else:
18747 
          iprot.skip(ftype)
18748 
      else:
18749 
        iprot.skip(ftype)
18750 
      iprot.readFieldEnd()
18751 
    iprot.readStructEnd()
18752 
 
18753 
  def write(self, oprot):
18754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18756 
      return
18757 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
18758 
    if self.ex is not None:
18759 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18760 
      self.ex.write(oprot)
18761 
      oprot.writeFieldEnd()
18762 
    oprot.writeFieldStop()
18763 
    oprot.writeStructEnd()
18764 
 
18765 
  def validate(self):
18766 
    return
18767 
 
18768 
 
18769 
  def __repr__(self):
18770 
    L = ['%s=%r' % (key, value)
18771 
      for key, value in self.__dict__.iteritems()]
18772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18773 
 
18774 
  def __eq__(self, other):
18775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18776 
 
18777 
  def __ne__(self, other):
18778 
    return not (self == other)
18779 
 
18780 
class getSettlementForPaymentId_args:
18781 
  """
18782 
  Attributes:
18783 
   - paymentId
18784 
  """
18785 
 
18786 
  thrift_spec = (
18787 
    None, # 0
18788 
    (1, TType.I64, 'paymentId', None, None, ), # 1
18789 
  )
18790 
 
18791 
  def __init__(self, paymentId=None,):
18792 
    self.paymentId = paymentId
18793 
 
18794 
  def read(self, iprot):
18795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18797 
      return
18798 
    iprot.readStructBegin()
18799 
    while True:
18800 
      (fname, ftype, fid) = iprot.readFieldBegin()
18801 
      if ftype == TType.STOP:
18802 
        break
18803 
      if fid == 1:
18804 
        if ftype == TType.I64:
18805 
          self.paymentId = iprot.readI64();
18806 
        else:
18807 
          iprot.skip(ftype)
18808 
      else:
18809 
        iprot.skip(ftype)
18810 
      iprot.readFieldEnd()
18811 
    iprot.readStructEnd()
18812 
 
18813 
  def write(self, oprot):
18814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18816 
      return
18817 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
18818 
    if self.paymentId is not None:
18819 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
18820 
      oprot.writeI64(self.paymentId)
18821 
      oprot.writeFieldEnd()
18822 
    oprot.writeFieldStop()
18823 
    oprot.writeStructEnd()
18824 
 
18825 
  def validate(self):
18826 
    return
18827 
 
18828 
 
18829 
  def __repr__(self):
18830 
    L = ['%s=%r' % (key, value)
18831 
      for key, value in self.__dict__.iteritems()]
18832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18833 
 
18834 
  def __eq__(self, other):
18835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18836 
 
18837 
  def __ne__(self, other):
18838 
    return not (self == other)
18839 
 
18840 
class getSettlementForPaymentId_result:
18841 
  """
18842 
  Attributes:
18843 
   - success
18844 
   - ex
18845 
  """
18846 
 
18847 
  thrift_spec = (
18848 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
18849 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18850 
  )
18851 
 
18852 
  def __init__(self, success=None, ex=None,):
18853 
    self.success = success
18854 
    self.ex = ex
18855 
 
18856 
  def read(self, iprot):
18857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18859 
      return
18860 
    iprot.readStructBegin()
18861 
    while True:
18862 
      (fname, ftype, fid) = iprot.readFieldBegin()
18863 
      if ftype == TType.STOP:
18864 
        break
18865 
      if fid == 0:
18866 
        if ftype == TType.STRUCT:
18867 
          self.success = PaymentSettlement()
18868 
          self.success.read(iprot)
18869 
        else:
18870 
          iprot.skip(ftype)
18871 
      elif fid == 1:
18872 
        if ftype == TType.STRUCT:
18873 
          self.ex = TransactionServiceException()
18874 
          self.ex.read(iprot)
18875 
        else:
18876 
          iprot.skip(ftype)
18877 
      else:
18878 
        iprot.skip(ftype)
18879 
      iprot.readFieldEnd()
18880 
    iprot.readStructEnd()
18881 
 
18882 
  def write(self, oprot):
18883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18885 
      return
18886 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
18887 
    if self.success is not None:
18888 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18889 
      self.success.write(oprot)
18890 
      oprot.writeFieldEnd()
18891 
    if self.ex is not None:
18892 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18893 
      self.ex.write(oprot)
18894 
      oprot.writeFieldEnd()
18895 
    oprot.writeFieldStop()
18896 
    oprot.writeStructEnd()
18897 
 
18898 
  def validate(self):
18899 
    return
18900 
 
18901 
 
18902 
  def __repr__(self):
18903 
    L = ['%s=%r' % (key, value)
18904 
      for key, value in self.__dict__.iteritems()]
18905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18906 
 
18907 
  def __eq__(self, other):
18908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18909 
 
18910 
  def __ne__(self, other):
18911 
    return not (self == other)
18912 
 
18913 
class getEBSSettlementSummaries_args:
18914 
 
18915 
  thrift_spec = (
18916 
  )
18917 
 
18918 
  def read(self, iprot):
18919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18921 
      return
18922 
    iprot.readStructBegin()
18923 
    while True:
18924 
      (fname, ftype, fid) = iprot.readFieldBegin()
18925 
      if ftype == TType.STOP:
18926 
        break
18927 
      else:
18928 
        iprot.skip(ftype)
18929 
      iprot.readFieldEnd()
18930 
    iprot.readStructEnd()
18931 
 
18932 
  def write(self, oprot):
18933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18935 
      return
18936 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
18937 
    oprot.writeFieldStop()
18938 
    oprot.writeStructEnd()
18939 
 
18940 
  def validate(self):
18941 
    return
18942 
 
18943 
 
18944 
  def __repr__(self):
18945 
    L = ['%s=%r' % (key, value)
18946 
      for key, value in self.__dict__.iteritems()]
18947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18948 
 
18949 
  def __eq__(self, other):
18950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18951 
 
18952 
  def __ne__(self, other):
18953 
    return not (self == other)
18954 
 
18955 
class getEBSSettlementSummaries_result:
18956 
  """
18957 
  Attributes:
18958 
   - success
18959 
   - ex
18960 
  """
18961 
 
18962 
  thrift_spec = (
18963 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
18964 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18965 
  )
18966 
 
18967 
  def __init__(self, success=None, ex=None,):
18968 
    self.success = success
18969 
    self.ex = ex
18970 
 
18971 
  def read(self, iprot):
18972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18974 
      return
18975 
    iprot.readStructBegin()
18976 
    while True:
18977 
      (fname, ftype, fid) = iprot.readFieldBegin()
18978 
      if ftype == TType.STOP:
18979 
        break
18980 
      if fid == 0:
18981 
        if ftype == TType.MAP:
18982 
          self.success = {}
4801 anupam.sin 18983 
          (_ktype352, _vtype353, _size351 ) = iprot.readMapBegin()
18984 
          for _i355 in xrange(_size351):
18985 
            _key356 = iprot.readI64();
18986 
            _val357 = iprot.readString();
18987 
            self.success[_key356] = _val357
4600 varun.gupt 18988 
          iprot.readMapEnd()
18989 
        else:
18990 
          iprot.skip(ftype)
18991 
      elif fid == 1:
18992 
        if ftype == TType.STRUCT:
18993 
          self.ex = TransactionServiceException()
18994 
          self.ex.read(iprot)
18995 
        else:
18996 
          iprot.skip(ftype)
18997 
      else:
18998 
        iprot.skip(ftype)
18999 
      iprot.readFieldEnd()
19000 
    iprot.readStructEnd()
19001 
 
19002 
  def write(self, oprot):
19003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19005 
      return
19006 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
19007 
    if self.success is not None:
19008 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19009 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
4801 anupam.sin 19010 
      for kiter358,viter359 in self.success.items():
19011 
        oprot.writeI64(kiter358)
19012 
        oprot.writeString(viter359)
4600 varun.gupt 19013 
      oprot.writeMapEnd()
19014 
      oprot.writeFieldEnd()
19015 
    if self.ex is not None:
19016 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19017 
      self.ex.write(oprot)
19018 
      oprot.writeFieldEnd()
19019 
    oprot.writeFieldStop()
19020 
    oprot.writeStructEnd()
19021 
 
19022 
  def validate(self):
19023 
    return
19024 
 
19025 
 
19026 
  def __repr__(self):
19027 
    L = ['%s=%r' % (key, value)
19028 
      for key, value in self.__dict__.iteritems()]
19029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19030 
 
19031 
  def __eq__(self, other):
19032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19033 
 
19034 
  def __ne__(self, other):
19035 
    return not (self == other)
19036 
 
19037 
class markEBSSettlementUploaded_args:
19038 
  """
19039 
  Attributes:
19040 
   - settlementId
19041 
  """
19042 
 
19043 
  thrift_spec = (
19044 
    None, # 0
19045 
    (1, TType.I64, 'settlementId', None, None, ), # 1
19046 
  )
19047 
 
19048 
  def __init__(self, settlementId=None,):
19049 
    self.settlementId = settlementId
19050 
 
19051 
  def read(self, iprot):
19052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19054 
      return
19055 
    iprot.readStructBegin()
19056 
    while True:
19057 
      (fname, ftype, fid) = iprot.readFieldBegin()
19058 
      if ftype == TType.STOP:
19059 
        break
19060 
      if fid == 1:
19061 
        if ftype == TType.I64:
19062 
          self.settlementId = iprot.readI64();
19063 
        else:
19064 
          iprot.skip(ftype)
19065 
      else:
19066 
        iprot.skip(ftype)
19067 
      iprot.readFieldEnd()
19068 
    iprot.readStructEnd()
19069 
 
19070 
  def write(self, oprot):
19071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19073 
      return
19074 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
19075 
    if self.settlementId is not None:
19076 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
19077 
      oprot.writeI64(self.settlementId)
19078 
      oprot.writeFieldEnd()
19079 
    oprot.writeFieldStop()
19080 
    oprot.writeStructEnd()
19081 
 
19082 
  def validate(self):
19083 
    return
19084 
 
19085 
 
19086 
  def __repr__(self):
19087 
    L = ['%s=%r' % (key, value)
19088 
      for key, value in self.__dict__.iteritems()]
19089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19090 
 
19091 
  def __eq__(self, other):
19092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19093 
 
19094 
  def __ne__(self, other):
19095 
    return not (self == other)
19096 
 
19097 
class markEBSSettlementUploaded_result:
19098 
  """
19099 
  Attributes:
19100 
   - ex
19101 
  """
19102 
 
19103 
  thrift_spec = (
19104 
    None, # 0
19105 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19106 
  )
19107 
 
19108 
  def __init__(self, ex=None,):
19109 
    self.ex = ex
19110 
 
19111 
  def read(self, iprot):
19112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19114 
      return
19115 
    iprot.readStructBegin()
19116 
    while True:
19117 
      (fname, ftype, fid) = iprot.readFieldBegin()
19118 
      if ftype == TType.STOP:
19119 
        break
19120 
      if fid == 1:
19121 
        if ftype == TType.STRUCT:
19122 
          self.ex = TransactionServiceException()
19123 
          self.ex.read(iprot)
19124 
        else:
19125 
          iprot.skip(ftype)
19126 
      else:
19127 
        iprot.skip(ftype)
19128 
      iprot.readFieldEnd()
19129 
    iprot.readStructEnd()
19130 
 
19131 
  def write(self, oprot):
19132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19134 
      return
19135 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
19136 
    if self.ex is not None:
19137 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19138 
      self.ex.write(oprot)
19139 
      oprot.writeFieldEnd()
19140 
    oprot.writeFieldStop()
19141 
    oprot.writeStructEnd()
19142 
 
19143 
  def validate(self):
19144 
    return
19145 
 
19146 
 
19147 
  def __repr__(self):
19148 
    L = ['%s=%r' % (key, value)
19149 
      for key, value in self.__dict__.iteritems()]
19150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19151 
 
19152 
  def __eq__(self, other):
19153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19154 
 
19155 
  def __ne__(self, other):
19156 
    return not (self == other)
19157 
 
19158 
class getEBSSettlementDate_args:
19159 
  """
19160 
  Attributes:
19161 
   - settlementId
19162 
  """
19163 
 
19164 
  thrift_spec = (
19165 
    None, # 0
19166 
    (1, TType.I64, 'settlementId', None, None, ), # 1
19167 
  )
19168 
 
19169 
  def __init__(self, settlementId=None,):
19170 
    self.settlementId = settlementId
19171 
 
19172 
  def read(self, iprot):
19173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19175 
      return
19176 
    iprot.readStructBegin()
19177 
    while True:
19178 
      (fname, ftype, fid) = iprot.readFieldBegin()
19179 
      if ftype == TType.STOP:
19180 
        break
19181 
      if fid == 1:
19182 
        if ftype == TType.I64:
19183 
          self.settlementId = iprot.readI64();
19184 
        else:
19185 
          iprot.skip(ftype)
19186 
      else:
19187 
        iprot.skip(ftype)
19188 
      iprot.readFieldEnd()
19189 
    iprot.readStructEnd()
19190 
 
19191 
  def write(self, oprot):
19192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19194 
      return
19195 
    oprot.writeStructBegin('getEBSSettlementDate_args')
19196 
    if self.settlementId is not None:
19197 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
19198 
      oprot.writeI64(self.settlementId)
19199 
      oprot.writeFieldEnd()
19200 
    oprot.writeFieldStop()
19201 
    oprot.writeStructEnd()
19202 
 
19203 
  def validate(self):
19204 
    return
19205 
 
19206 
 
19207 
  def __repr__(self):
19208 
    L = ['%s=%r' % (key, value)
19209 
      for key, value in self.__dict__.iteritems()]
19210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19211 
 
19212 
  def __eq__(self, other):
19213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19214 
 
19215 
  def __ne__(self, other):
19216 
    return not (self == other)
19217 
 
19218 
class getEBSSettlementDate_result:
19219 
  """
19220 
  Attributes:
19221 
   - success
19222 
   - ex
19223 
  """
19224 
 
19225 
  thrift_spec = (
19226 
    (0, TType.I64, 'success', None, None, ), # 0
19227 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19228 
  )
19229 
 
19230 
  def __init__(self, success=None, ex=None,):
19231 
    self.success = success
19232 
    self.ex = ex
19233 
 
19234 
  def read(self, iprot):
19235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19237 
      return
19238 
    iprot.readStructBegin()
19239 
    while True:
19240 
      (fname, ftype, fid) = iprot.readFieldBegin()
19241 
      if ftype == TType.STOP:
19242 
        break
19243 
      if fid == 0:
19244 
        if ftype == TType.I64:
19245 
          self.success = iprot.readI64();
19246 
        else:
19247 
          iprot.skip(ftype)
19248 
      elif fid == 1:
19249 
        if ftype == TType.STRUCT:
19250 
          self.ex = TransactionServiceException()
19251 
          self.ex.read(iprot)
19252 
        else:
19253 
          iprot.skip(ftype)
19254 
      else:
19255 
        iprot.skip(ftype)
19256 
      iprot.readFieldEnd()
19257 
    iprot.readStructEnd()
19258 
 
19259 
  def write(self, oprot):
19260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19262 
      return
19263 
    oprot.writeStructBegin('getEBSSettlementDate_result')
19264 
    if self.success is not None:
19265 
      oprot.writeFieldBegin('success', TType.I64, 0)
19266 
      oprot.writeI64(self.success)
19267 
      oprot.writeFieldEnd()
19268 
    if self.ex is not None:
19269 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19270 
      self.ex.write(oprot)
19271 
      oprot.writeFieldEnd()
19272 
    oprot.writeFieldStop()
19273 
    oprot.writeStructEnd()
19274 
 
19275 
  def validate(self):
19276 
    return
19277 
 
19278 
 
19279 
  def __repr__(self):
19280 
    L = ['%s=%r' % (key, value)
19281 
      for key, value in self.__dict__.iteritems()]
19282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19283 
 
19284 
  def __eq__(self, other):
19285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19286 
 
19287 
  def __ne__(self, other):
19288 
    return not (self == other)
4715 varun.gupt 19289 
 
19290 
class getSettlementsByDate_args:
19291 
  """
19292 
  Attributes:
19293 
   - settlementDateFrom
19294 
   - settlementDateTo
19295 
   - isRefund
19296 
  """
19297 
 
19298 
  thrift_spec = (
19299 
    None, # 0
19300 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
19301 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
19302 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
19303 
  )
19304 
 
19305 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
19306 
    self.settlementDateFrom = settlementDateFrom
19307 
    self.settlementDateTo = settlementDateTo
19308 
    self.isRefund = isRefund
19309 
 
19310 
  def read(self, iprot):
19311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19313 
      return
19314 
    iprot.readStructBegin()
19315 
    while True:
19316 
      (fname, ftype, fid) = iprot.readFieldBegin()
19317 
      if ftype == TType.STOP:
19318 
        break
19319 
      if fid == 1:
19320 
        if ftype == TType.I64:
19321 
          self.settlementDateFrom = iprot.readI64();
19322 
        else:
19323 
          iprot.skip(ftype)
19324 
      elif fid == 2:
19325 
        if ftype == TType.I64:
19326 
          self.settlementDateTo = iprot.readI64();
19327 
        else:
19328 
          iprot.skip(ftype)
19329 
      elif fid == 3:
19330 
        if ftype == TType.BOOL:
19331 
          self.isRefund = iprot.readBool();
19332 
        else:
19333 
          iprot.skip(ftype)
19334 
      else:
19335 
        iprot.skip(ftype)
19336 
      iprot.readFieldEnd()
19337 
    iprot.readStructEnd()
19338 
 
19339 
  def write(self, oprot):
19340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19342 
      return
19343 
    oprot.writeStructBegin('getSettlementsByDate_args')
19344 
    if self.settlementDateFrom is not None:
19345 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
19346 
      oprot.writeI64(self.settlementDateFrom)
19347 
      oprot.writeFieldEnd()
19348 
    if self.settlementDateTo is not None:
19349 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
19350 
      oprot.writeI64(self.settlementDateTo)
19351 
      oprot.writeFieldEnd()
19352 
    if self.isRefund is not None:
19353 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
19354 
      oprot.writeBool(self.isRefund)
19355 
      oprot.writeFieldEnd()
19356 
    oprot.writeFieldStop()
19357 
    oprot.writeStructEnd()
19358 
 
19359 
  def validate(self):
19360 
    return
19361 
 
19362 
 
19363 
  def __repr__(self):
19364 
    L = ['%s=%r' % (key, value)
19365 
      for key, value in self.__dict__.iteritems()]
19366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19367 
 
19368 
  def __eq__(self, other):
19369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19370 
 
19371 
  def __ne__(self, other):
19372 
    return not (self == other)
19373 
 
19374 
class getSettlementsByDate_result:
19375 
  """
19376 
  Attributes:
19377 
   - success
19378 
   - ex
19379 
  """
19380 
 
19381 
  thrift_spec = (
19382 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
19383 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19384 
  )
19385 
 
19386 
  def __init__(self, success=None, ex=None,):
19387 
    self.success = success
19388 
    self.ex = ex
19389 
 
19390 
  def read(self, iprot):
19391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19393 
      return
19394 
    iprot.readStructBegin()
19395 
    while True:
19396 
      (fname, ftype, fid) = iprot.readFieldBegin()
19397 
      if ftype == TType.STOP:
19398 
        break
19399 
      if fid == 0:
19400 
        if ftype == TType.LIST:
19401 
          self.success = []
4801 anupam.sin 19402 
          (_etype363, _size360) = iprot.readListBegin()
19403 
          for _i364 in xrange(_size360):
19404 
            _elem365 = PaymentSettlement()
19405 
            _elem365.read(iprot)
19406 
            self.success.append(_elem365)
4715 varun.gupt 19407 
          iprot.readListEnd()
19408 
        else:
19409 
          iprot.skip(ftype)
19410 
      elif fid == 1:
19411 
        if ftype == TType.STRUCT:
19412 
          self.ex = TransactionServiceException()
19413 
          self.ex.read(iprot)
19414 
        else:
19415 
          iprot.skip(ftype)
19416 
      else:
19417 
        iprot.skip(ftype)
19418 
      iprot.readFieldEnd()
19419 
    iprot.readStructEnd()
19420 
 
19421 
  def write(self, oprot):
19422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19424 
      return
19425 
    oprot.writeStructBegin('getSettlementsByDate_result')
19426 
    if self.success is not None:
19427 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19428 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4801 anupam.sin 19429 
      for iter366 in self.success:
19430 
        iter366.write(oprot)
4715 varun.gupt 19431 
      oprot.writeListEnd()
19432 
      oprot.writeFieldEnd()
19433 
    if self.ex is not None:
19434 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19435 
      self.ex.write(oprot)
19436 
      oprot.writeFieldEnd()
19437 
    oprot.writeFieldStop()
19438 
    oprot.writeStructEnd()
19439 
 
19440 
  def validate(self):
19441 
    return
19442 
 
19443 
 
19444 
  def __repr__(self):
19445 
    L = ['%s=%r' % (key, value)
19446 
      for key, value in self.__dict__.iteritems()]
19447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19448 
 
19449 
  def __eq__(self, other):
19450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19451 
 
19452 
  def __ne__(self, other):
19453 
    return not (self == other)
19454 
 
19455 
class getReshippedOrderIds_args:
19456 
  """
19457 
  Attributes:
19458 
   - orderIds
19459 
  """
19460 
 
19461 
  thrift_spec = (
19462 
    None, # 0
19463 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
19464 
  )
19465 
 
19466 
  def __init__(self, orderIds=None,):
19467 
    self.orderIds = orderIds
19468 
 
19469 
  def read(self, iprot):
19470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19472 
      return
19473 
    iprot.readStructBegin()
19474 
    while True:
19475 
      (fname, ftype, fid) = iprot.readFieldBegin()
19476 
      if ftype == TType.STOP:
19477 
        break
19478 
      if fid == 1:
19479 
        if ftype == TType.LIST:
19480 
          self.orderIds = []
4801 anupam.sin 19481 
          (_etype370, _size367) = iprot.readListBegin()
19482 
          for _i371 in xrange(_size367):
19483 
            _elem372 = iprot.readI64();
19484 
            self.orderIds.append(_elem372)
4715 varun.gupt 19485 
          iprot.readListEnd()
19486 
        else:
19487 
          iprot.skip(ftype)
19488 
      else:
19489 
        iprot.skip(ftype)
19490 
      iprot.readFieldEnd()
19491 
    iprot.readStructEnd()
19492 
 
19493 
  def write(self, oprot):
19494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19496 
      return
19497 
    oprot.writeStructBegin('getReshippedOrderIds_args')
19498 
    if self.orderIds is not None:
19499 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
19500 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
4801 anupam.sin 19501 
      for iter373 in self.orderIds:
19502 
        oprot.writeI64(iter373)
4715 varun.gupt 19503 
      oprot.writeListEnd()
19504 
      oprot.writeFieldEnd()
19505 
    oprot.writeFieldStop()
19506 
    oprot.writeStructEnd()
19507 
 
19508 
  def validate(self):
19509 
    return
19510 
 
19511 
 
19512 
  def __repr__(self):
19513 
    L = ['%s=%r' % (key, value)
19514 
      for key, value in self.__dict__.iteritems()]
19515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19516 
 
19517 
  def __eq__(self, other):
19518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19519 
 
19520 
  def __ne__(self, other):
19521 
    return not (self == other)
19522 
 
19523 
class getReshippedOrderIds_result:
19524 
  """
19525 
  Attributes:
19526 
   - success
19527 
   - ex
19528 
  """
19529 
 
19530 
  thrift_spec = (
19531 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19532 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19533 
  )
19534 
 
19535 
  def __init__(self, success=None, ex=None,):
19536 
    self.success = success
19537 
    self.ex = ex
19538 
 
19539 
  def read(self, iprot):
19540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19542 
      return
19543 
    iprot.readStructBegin()
19544 
    while True:
19545 
      (fname, ftype, fid) = iprot.readFieldBegin()
19546 
      if ftype == TType.STOP:
19547 
        break
19548 
      if fid == 0:
19549 
        if ftype == TType.LIST:
19550 
          self.success = []
4801 anupam.sin 19551 
          (_etype377, _size374) = iprot.readListBegin()
19552 
          for _i378 in xrange(_size374):
19553 
            _elem379 = iprot.readI64();
19554 
            self.success.append(_elem379)
4715 varun.gupt 19555 
          iprot.readListEnd()
19556 
        else:
19557 
          iprot.skip(ftype)
19558 
      elif fid == 1:
19559 
        if ftype == TType.STRUCT:
19560 
          self.ex = TransactionServiceException()
19561 
          self.ex.read(iprot)
19562 
        else:
19563 
          iprot.skip(ftype)
19564 
      else:
19565 
        iprot.skip(ftype)
19566 
      iprot.readFieldEnd()
19567 
    iprot.readStructEnd()
19568 
 
19569 
  def write(self, oprot):
19570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19572 
      return
19573 
    oprot.writeStructBegin('getReshippedOrderIds_result')
19574 
    if self.success is not None:
19575 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19576 
      oprot.writeListBegin(TType.I64, len(self.success))
4801 anupam.sin 19577 
      for iter380 in self.success:
19578 
        oprot.writeI64(iter380)
4715 varun.gupt 19579 
      oprot.writeListEnd()
19580 
      oprot.writeFieldEnd()
19581 
    if self.ex is not None:
19582 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19583 
      self.ex.write(oprot)
19584 
      oprot.writeFieldEnd()
19585 
    oprot.writeFieldStop()
19586 
    oprot.writeStructEnd()
19587 
 
19588 
  def validate(self):
19589 
    return
19590 
 
19591 
 
19592 
  def __repr__(self):
19593 
    L = ['%s=%r' % (key, value)
19594 
      for key, value in self.__dict__.iteritems()]
19595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19596 
 
19597 
  def __eq__(self, other):
19598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19599 
 
19600 
  def __ne__(self, other):
19601 
    return not (self == other)
4757 mandeep.dh 19602 
 
19603 
class updateOrdersAsPORaised_args:
19604 
  """
19605 
  Attributes:
19606 
   - itemIdQuantityMap
19607 
   - purchaseOrderId
19608 
   - warehouseId
19609 
  """
19610 
 
19611 
  thrift_spec = (
19612 
    None, # 0
19613 
    (1, TType.MAP, 'itemIdQuantityMap', (TType.I64,None,TType.I64,None), None, ), # 1
19614 
    (2, TType.I64, 'purchaseOrderId', None, None, ), # 2
19615 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
19616 
  )
19617 
 
19618 
  def __init__(self, itemIdQuantityMap=None, purchaseOrderId=None, warehouseId=None,):
19619 
    self.itemIdQuantityMap = itemIdQuantityMap
19620 
    self.purchaseOrderId = purchaseOrderId
19621 
    self.warehouseId = warehouseId
19622 
 
19623 
  def read(self, iprot):
19624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19626 
      return
19627 
    iprot.readStructBegin()
19628 
    while True:
19629 
      (fname, ftype, fid) = iprot.readFieldBegin()
19630 
      if ftype == TType.STOP:
19631 
        break
19632 
      if fid == 1:
19633 
        if ftype == TType.MAP:
19634 
          self.itemIdQuantityMap = {}
4801 anupam.sin 19635 
          (_ktype382, _vtype383, _size381 ) = iprot.readMapBegin()
19636 
          for _i385 in xrange(_size381):
19637 
            _key386 = iprot.readI64();
19638 
            _val387 = iprot.readI64();
19639 
            self.itemIdQuantityMap[_key386] = _val387
4757 mandeep.dh 19640 
          iprot.readMapEnd()
19641 
        else:
19642 
          iprot.skip(ftype)
19643 
      elif fid == 2:
19644 
        if ftype == TType.I64:
19645 
          self.purchaseOrderId = iprot.readI64();
19646 
        else:
19647 
          iprot.skip(ftype)
19648 
      elif fid == 3:
19649 
        if ftype == TType.I64:
19650 
          self.warehouseId = iprot.readI64();
19651 
        else:
19652 
          iprot.skip(ftype)
19653 
      else:
19654 
        iprot.skip(ftype)
19655 
      iprot.readFieldEnd()
19656 
    iprot.readStructEnd()
19657 
 
19658 
  def write(self, oprot):
19659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19661 
      return
19662 
    oprot.writeStructBegin('updateOrdersAsPORaised_args')
19663 
    if self.itemIdQuantityMap is not None:
19664 
      oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
19665 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
4801 anupam.sin 19666 
      for kiter388,viter389 in self.itemIdQuantityMap.items():
19667 
        oprot.writeI64(kiter388)
19668 
        oprot.writeI64(viter389)
4757 mandeep.dh 19669 
      oprot.writeMapEnd()
19670 
      oprot.writeFieldEnd()
19671 
    if self.purchaseOrderId is not None:
19672 
      oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
19673 
      oprot.writeI64(self.purchaseOrderId)
19674 
      oprot.writeFieldEnd()
19675 
    if self.warehouseId is not None:
19676 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
19677 
      oprot.writeI64(self.warehouseId)
19678 
      oprot.writeFieldEnd()
19679 
    oprot.writeFieldStop()
19680 
    oprot.writeStructEnd()
19681 
 
19682 
  def validate(self):
19683 
    return
19684 
 
19685 
 
19686 
  def __repr__(self):
19687 
    L = ['%s=%r' % (key, value)
19688 
      for key, value in self.__dict__.iteritems()]
19689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19690 
 
19691 
  def __eq__(self, other):
19692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19693 
 
19694 
  def __ne__(self, other):
19695 
    return not (self == other)
19696 
 
19697 
class updateOrdersAsPORaised_result:
19698 
  """
19699 
  Attributes:
19700 
   - ex
19701 
  """
19702 
 
19703 
  thrift_spec = (
19704 
    None, # 0
19705 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19706 
  )
19707 
 
19708 
  def __init__(self, ex=None,):
19709 
    self.ex = ex
19710 
 
19711 
  def read(self, iprot):
19712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19714 
      return
19715 
    iprot.readStructBegin()
19716 
    while True:
19717 
      (fname, ftype, fid) = iprot.readFieldBegin()
19718 
      if ftype == TType.STOP:
19719 
        break
19720 
      if fid == 1:
19721 
        if ftype == TType.STRUCT:
19722 
          self.ex = TransactionServiceException()
19723 
          self.ex.read(iprot)
19724 
        else:
19725 
          iprot.skip(ftype)
19726 
      else:
19727 
        iprot.skip(ftype)
19728 
      iprot.readFieldEnd()
19729 
    iprot.readStructEnd()
19730 
 
19731 
  def write(self, oprot):
19732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19734 
      return
19735 
    oprot.writeStructBegin('updateOrdersAsPORaised_result')
19736 
    if self.ex is not None:
19737 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19738 
      self.ex.write(oprot)
19739 
      oprot.writeFieldEnd()
19740 
    oprot.writeFieldStop()
19741 
    oprot.writeStructEnd()
19742 
 
19743 
  def validate(self):
19744 
    return
19745 
 
19746 
 
19747 
  def __repr__(self):
19748 
    L = ['%s=%r' % (key, value)
19749 
      for key, value in self.__dict__.iteritems()]
19750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19751 
 
19752 
  def __eq__(self, other):
19753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19754 
 
19755 
  def __ne__(self, other):
19756 
    return not (self == other)