Subversion Repositories SmartDukaan

Rev

Rev 4875 | Rev 4910 | 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 
 
4905 varun.gupt 948 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 949 
    """
950 
    Parameters:
951 
     - settlementDate
952 
     - paymentGatewayId
4905 varun.gupt 953 
     - referenceId
4600 varun.gupt 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 
 
4875 varun.gupt 1025 
  def getOrdersWhereVendorNotPaid(self, vendorId):
1026 
    """
1027 
    Parameters:
1028 
     - vendorId
1029 
    """
1030 
    pass
4757 mandeep.dh 1031 
 
4875 varun.gupt 1032 
 
3376 rajveer 1033 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1034 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1035 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1036 
 
1037 
  def createTransaction(self, transaction):
1038 
    """
1039 
    Parameters:
1040 
     - transaction
1041 
    """
1042 
    self.send_createTransaction(transaction)
132 ashish 1043 
    return self.recv_createTransaction()
94 ashish 1044 
 
1045 
  def send_createTransaction(self, transaction):
1046 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1047 
    args = createTransaction_args()
1048 
    args.transaction = transaction
1049 
    args.write(self._oprot)
1050 
    self._oprot.writeMessageEnd()
1051 
    self._oprot.trans.flush()
1052 
 
1053 
  def recv_createTransaction(self, ):
1054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1055 
    if mtype == TMessageType.EXCEPTION:
1056 
      x = TApplicationException()
1057 
      x.read(self._iprot)
1058 
      self._iprot.readMessageEnd()
1059 
      raise x
1060 
    result = createTransaction_result()
1061 
    result.read(self._iprot)
1062 
    self._iprot.readMessageEnd()
3431 rajveer 1063 
    if result.success is not None:
132 ashish 1064 
      return result.success
3431 rajveer 1065 
    if result.ex is not None:
94 ashish 1066 
      raise result.ex
132 ashish 1067 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1068 
 
1069 
  def getTransaction(self, id):
1070 
    """
1071 
    Parameters:
1072 
     - id
1073 
    """
1074 
    self.send_getTransaction(id)
1075 
    return self.recv_getTransaction()
1076 
 
1077 
  def send_getTransaction(self, id):
1078 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1079 
    args = getTransaction_args()
1080 
    args.id = id
1081 
    args.write(self._oprot)
1082 
    self._oprot.writeMessageEnd()
1083 
    self._oprot.trans.flush()
1084 
 
1085 
  def recv_getTransaction(self, ):
1086 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1087 
    if mtype == TMessageType.EXCEPTION:
1088 
      x = TApplicationException()
1089 
      x.read(self._iprot)
1090 
      self._iprot.readMessageEnd()
1091 
      raise x
1092 
    result = getTransaction_result()
1093 
    result.read(self._iprot)
1094 
    self._iprot.readMessageEnd()
3431 rajveer 1095 
    if result.success is not None:
94 ashish 1096 
      return result.success
3431 rajveer 1097 
    if result.ex is not None:
94 ashish 1098 
      raise result.ex
1099 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1100 
 
1101 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1102 
    """
1103 
    Parameters:
1104 
     - customerId
1105 
     - from_date
1106 
     - to_date
1107 
     - status
1108 
    """
1109 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1110 
    return self.recv_getTransactionsForCustomer()
1111 
 
1112 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1113 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1114 
    args = getTransactionsForCustomer_args()
1115 
    args.customerId = customerId
1116 
    args.from_date = from_date
1117 
    args.to_date = to_date
1118 
    args.status = status
1119 
    args.write(self._oprot)
1120 
    self._oprot.writeMessageEnd()
1121 
    self._oprot.trans.flush()
1122 
 
1123 
  def recv_getTransactionsForCustomer(self, ):
1124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1125 
    if mtype == TMessageType.EXCEPTION:
1126 
      x = TApplicationException()
1127 
      x.read(self._iprot)
1128 
      self._iprot.readMessageEnd()
1129 
      raise x
1130 
    result = getTransactionsForCustomer_result()
1131 
    result.read(self._iprot)
1132 
    self._iprot.readMessageEnd()
3431 rajveer 1133 
    if result.success is not None:
94 ashish 1134 
      return result.success
3431 rajveer 1135 
    if result.ex is not None:
94 ashish 1136 
      raise result.ex
1137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1138 
 
132 ashish 1139 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1140 
    """
1141 
    Parameters:
1142 
     - shoppingCartId
1143 
    """
1144 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1145 
    return self.recv_getTransactionsForShoppingCartId()
1146 
 
1147 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1148 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1149 
    args = getTransactionsForShoppingCartId_args()
1150 
    args.shoppingCartId = shoppingCartId
1151 
    args.write(self._oprot)
1152 
    self._oprot.writeMessageEnd()
1153 
    self._oprot.trans.flush()
1154 
 
1155 
  def recv_getTransactionsForShoppingCartId(self, ):
1156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1157 
    if mtype == TMessageType.EXCEPTION:
1158 
      x = TApplicationException()
1159 
      x.read(self._iprot)
1160 
      self._iprot.readMessageEnd()
1161 
      raise x
1162 
    result = getTransactionsForShoppingCartId_result()
1163 
    result.read(self._iprot)
1164 
    self._iprot.readMessageEnd()
3431 rajveer 1165 
    if result.success is not None:
132 ashish 1166 
      return result.success
3431 rajveer 1167 
    if result.ex is not None:
132 ashish 1168 
      raise result.ex
1169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1170 
 
94 ashish 1171 
  def getTransactionStatus(self, transactionId):
1172 
    """
1173 
    Parameters:
1174 
     - transactionId
1175 
    """
1176 
    self.send_getTransactionStatus(transactionId)
1177 
    return self.recv_getTransactionStatus()
1178 
 
1179 
  def send_getTransactionStatus(self, transactionId):
1180 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1181 
    args = getTransactionStatus_args()
1182 
    args.transactionId = transactionId
1183 
    args.write(self._oprot)
1184 
    self._oprot.writeMessageEnd()
1185 
    self._oprot.trans.flush()
1186 
 
1187 
  def recv_getTransactionStatus(self, ):
1188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1189 
    if mtype == TMessageType.EXCEPTION:
1190 
      x = TApplicationException()
1191 
      x.read(self._iprot)
1192 
      self._iprot.readMessageEnd()
1193 
      raise x
1194 
    result = getTransactionStatus_result()
1195 
    result.read(self._iprot)
1196 
    self._iprot.readMessageEnd()
3431 rajveer 1197 
    if result.success is not None:
94 ashish 1198 
      return result.success
3431 rajveer 1199 
    if result.ex is not None:
94 ashish 1200 
      raise result.ex
1201 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1202 
 
1203 
  def changeTransactionStatus(self, transactionId, status, description):
1204 
    """
1205 
    Parameters:
1206 
     - transactionId
1207 
     - status
1208 
     - description
1209 
    """
1210 
    self.send_changeTransactionStatus(transactionId, status, description)
1211 
    return self.recv_changeTransactionStatus()
1212 
 
1213 
  def send_changeTransactionStatus(self, transactionId, status, description):
1214 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1215 
    args = changeTransactionStatus_args()
1216 
    args.transactionId = transactionId
1217 
    args.status = status
1218 
    args.description = description
1219 
    args.write(self._oprot)
1220 
    self._oprot.writeMessageEnd()
1221 
    self._oprot.trans.flush()
1222 
 
1223 
  def recv_changeTransactionStatus(self, ):
1224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1225 
    if mtype == TMessageType.EXCEPTION:
1226 
      x = TApplicationException()
1227 
      x.read(self._iprot)
1228 
      self._iprot.readMessageEnd()
1229 
      raise x
1230 
    result = changeTransactionStatus_result()
1231 
    result.read(self._iprot)
1232 
    self._iprot.readMessageEnd()
3431 rajveer 1233 
    if result.success is not None:
94 ashish 1234 
      return result.success
3431 rajveer 1235 
    if result.ex is not None:
94 ashish 1236 
      raise result.ex
1237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1238 
 
1398 varun.gupt 1239 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1240 
    """
1241 
    Parameters:
1242 
     - transactionId
1243 
    """
1398 varun.gupt 1244 
    self.send_enqueueTransactionInfoEmail(transactionId)
1245 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1246 
 
1398 varun.gupt 1247 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1248 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1249 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1250 
    args.transactionId = transactionId
1251 
    args.write(self._oprot)
1252 
    self._oprot.writeMessageEnd()
1253 
    self._oprot.trans.flush()
1254 
 
1398 varun.gupt 1255 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1257 
    if mtype == TMessageType.EXCEPTION:
1258 
      x = TApplicationException()
1259 
      x.read(self._iprot)
1260 
      self._iprot.readMessageEnd()
1261 
      raise x
1398 varun.gupt 1262 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1263 
    result.read(self._iprot)
1264 
    self._iprot.readMessageEnd()
3431 rajveer 1265 
    if result.success is not None:
1382 varun.gupt 1266 
      return result.success
3431 rajveer 1267 
    if result.ex is not None:
1382 varun.gupt 1268 
      raise result.ex
1398 varun.gupt 1269 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1270 
 
4801 anupam.sin 1271 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1272 
    """
1273 
    Parameters:
4801 anupam.sin 1274 
     - statuses
483 rajveer 1275 
     - from_date
1276 
     - to_date
1277 
     - warehouse_id
94 ashish 1278 
    """
4801 anupam.sin 1279 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1280 
    return self.recv_getAllOrders()
94 ashish 1281 
 
4801 anupam.sin 1282 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1283 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1284 
    args = getAllOrders_args()
4801 anupam.sin 1285 
    args.statuses = statuses
483 rajveer 1286 
    args.from_date = from_date
1287 
    args.to_date = to_date
1288 
    args.warehouse_id = warehouse_id
94 ashish 1289 
    args.write(self._oprot)
1290 
    self._oprot.writeMessageEnd()
1291 
    self._oprot.trans.flush()
1292 
 
483 rajveer 1293 
  def recv_getAllOrders(self, ):
94 ashish 1294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1295 
    if mtype == TMessageType.EXCEPTION:
1296 
      x = TApplicationException()
1297 
      x.read(self._iprot)
1298 
      self._iprot.readMessageEnd()
1299 
      raise x
483 rajveer 1300 
    result = getAllOrders_result()
94 ashish 1301 
    result.read(self._iprot)
1302 
    self._iprot.readMessageEnd()
3431 rajveer 1303 
    if result.success is not None:
94 ashish 1304 
      return result.success
3431 rajveer 1305 
    if result.ex is not None:
94 ashish 1306 
      raise result.ex
483 rajveer 1307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1308 
 
4133 chandransh 1309 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1310 
    """
1311 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1312 
    Pass the status as null and the limit as 0 to ignore them.
1313 
 
1314 
    Parameters:
1315 
     - statuses
1316 
     - offset
1317 
     - limit
1318 
     - warehouse_id
1319 
    """
1320 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1321 
    return self.recv_getOrdersInBatch()
1322 
 
1323 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1324 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1325 
    args = getOrdersInBatch_args()
1326 
    args.statuses = statuses
1327 
    args.offset = offset
1328 
    args.limit = limit
1329 
    args.warehouse_id = warehouse_id
1330 
    args.write(self._oprot)
1331 
    self._oprot.writeMessageEnd()
1332 
    self._oprot.trans.flush()
1333 
 
1334 
  def recv_getOrdersInBatch(self, ):
1335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1336 
    if mtype == TMessageType.EXCEPTION:
1337 
      x = TApplicationException()
1338 
      x.read(self._iprot)
1339 
      self._iprot.readMessageEnd()
1340 
      raise x
1341 
    result = getOrdersInBatch_result()
1342 
    result.read(self._iprot)
1343 
    self._iprot.readMessageEnd()
1344 
    if result.success is not None:
1345 
      return result.success
1346 
    if result.ex is not None:
1347 
      raise result.ex
1348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1349 
 
1350 
  def getOrderCount(self, statuses, warehouseId):
1351 
    """
1352 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1353 
 
1354 
    Parameters:
1355 
     - statuses
1356 
     - warehouseId
1357 
    """
1358 
    self.send_getOrderCount(statuses, warehouseId)
1359 
    return self.recv_getOrderCount()
1360 
 
1361 
  def send_getOrderCount(self, statuses, warehouseId):
1362 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1363 
    args = getOrderCount_args()
1364 
    args.statuses = statuses
1365 
    args.warehouseId = warehouseId
1366 
    args.write(self._oprot)
1367 
    self._oprot.writeMessageEnd()
1368 
    self._oprot.trans.flush()
1369 
 
1370 
  def recv_getOrderCount(self, ):
1371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1372 
    if mtype == TMessageType.EXCEPTION:
1373 
      x = TApplicationException()
1374 
      x.read(self._iprot)
1375 
      self._iprot.readMessageEnd()
1376 
      raise x
1377 
    result = getOrderCount_result()
1378 
    result.read(self._iprot)
1379 
    self._iprot.readMessageEnd()
1380 
    if result.success is not None:
1381 
      return result.success
1382 
    if result.ex is not None:
1383 
      raise result.ex
1384 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1385 
 
999 varun.gupt 1386 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1387 
    """
1132 chandransh 1388 
    Returns orders within a range of their billing dates
3431 rajveer 1389 
 
999 varun.gupt 1390 
    Parameters:
1391 
     - status
1392 
     - start_billing_date
1393 
     - end_billing_date
1394 
     - warehouse_id
1395 
    """
1396 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1397 
    return self.recv_getOrdersByBillingDate()
1398 
 
1399 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1400 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1401 
    args = getOrdersByBillingDate_args()
1402 
    args.status = status
1403 
    args.start_billing_date = start_billing_date
1404 
    args.end_billing_date = end_billing_date
1405 
    args.warehouse_id = warehouse_id
1406 
    args.write(self._oprot)
1407 
    self._oprot.writeMessageEnd()
1408 
    self._oprot.trans.flush()
1409 
 
1410 
  def recv_getOrdersByBillingDate(self, ):
1411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1412 
    if mtype == TMessageType.EXCEPTION:
1413 
      x = TApplicationException()
1414 
      x.read(self._iprot)
1415 
      self._iprot.readMessageEnd()
1416 
      raise x
1417 
    result = getOrdersByBillingDate_result()
1418 
    result.read(self._iprot)
1419 
    self._iprot.readMessageEnd()
3431 rajveer 1420 
    if result.success is not None:
999 varun.gupt 1421 
      return result.success
3431 rajveer 1422 
    if result.ex is not None:
999 varun.gupt 1423 
      raise result.ex
1424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1425 
 
3451 chandransh 1426 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1427 
    """
1428 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1429 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1430 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1431 
 
3427 chandransh 1432 
    Parameters:
1433 
     - fromShippingDate
1434 
     - toShippingDate
1435 
     - providerId
1436 
     - warehouseId
3451 chandransh 1437 
     - cod
3427 chandransh 1438 
    """
3451 chandransh 1439 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1440 
    return self.recv_getOrdersByShippingDate()
1441 
 
3451 chandransh 1442 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1443 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1444 
    args = getOrdersByShippingDate_args()
1445 
    args.fromShippingDate = fromShippingDate
1446 
    args.toShippingDate = toShippingDate
1447 
    args.providerId = providerId
1448 
    args.warehouseId = warehouseId
3451 chandransh 1449 
    args.cod = cod
3427 chandransh 1450 
    args.write(self._oprot)
1451 
    self._oprot.writeMessageEnd()
1452 
    self._oprot.trans.flush()
1453 
 
1454 
  def recv_getOrdersByShippingDate(self, ):
1455 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1456 
    if mtype == TMessageType.EXCEPTION:
1457 
      x = TApplicationException()
1458 
      x.read(self._iprot)
1459 
      self._iprot.readMessageEnd()
1460 
      raise x
1461 
    result = getOrdersByShippingDate_result()
1462 
    result.read(self._iprot)
1463 
    self._iprot.readMessageEnd()
3431 rajveer 1464 
    if result.success is not None:
3427 chandransh 1465 
      return result.success
3431 rajveer 1466 
    if result.ex is not None:
3427 chandransh 1467 
      raise result.ex
1468 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1469 
 
1382 varun.gupt 1470 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1471 
    """
1472 
    Returns order ids for orders which can be returned
3431 rajveer 1473 
 
1382 varun.gupt 1474 
    Parameters:
1475 
     - customer_id
1476 
     - limit
1477 
    """
1478 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1479 
    return self.recv_getReturnableOrdersForCustomer()
1480 
 
1481 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1482 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1483 
    args = getReturnableOrdersForCustomer_args()
1484 
    args.customer_id = customer_id
1485 
    args.limit = limit
1486 
    args.write(self._oprot)
1487 
    self._oprot.writeMessageEnd()
1488 
    self._oprot.trans.flush()
1489 
 
1490 
  def recv_getReturnableOrdersForCustomer(self, ):
1491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1492 
    if mtype == TMessageType.EXCEPTION:
1493 
      x = TApplicationException()
1494 
      x.read(self._iprot)
1495 
      self._iprot.readMessageEnd()
1496 
      raise x
1497 
    result = getReturnableOrdersForCustomer_result()
1498 
    result.read(self._iprot)
1499 
    self._iprot.readMessageEnd()
3431 rajveer 1500 
    if result.success is not None:
1382 varun.gupt 1501 
      return result.success
3431 rajveer 1502 
    if result.ex is not None:
1382 varun.gupt 1503 
      raise result.ex
1504 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1505 
 
1506 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1507 
    """
1508 
    Returns order ids for orders which can be cancelled
3431 rajveer 1509 
 
1382 varun.gupt 1510 
    Parameters:
1511 
     - customer_id
1512 
     - limit
1513 
    """
1514 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1515 
    return self.recv_getCancellableOrdersForCustomer()
1516 
 
1517 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1518 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1519 
    args = getCancellableOrdersForCustomer_args()
1520 
    args.customer_id = customer_id
1521 
    args.limit = limit
1522 
    args.write(self._oprot)
1523 
    self._oprot.writeMessageEnd()
1524 
    self._oprot.trans.flush()
1525 
 
1526 
  def recv_getCancellableOrdersForCustomer(self, ):
1527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1528 
    if mtype == TMessageType.EXCEPTION:
1529 
      x = TApplicationException()
1530 
      x.read(self._iprot)
1531 
      self._iprot.readMessageEnd()
1532 
      raise x
1533 
    result = getCancellableOrdersForCustomer_result()
1534 
    result.read(self._iprot)
1535 
    self._iprot.readMessageEnd()
3431 rajveer 1536 
    if result.success is not None:
1382 varun.gupt 1537 
      return result.success
3431 rajveer 1538 
    if result.ex is not None:
1382 varun.gupt 1539 
      raise result.ex
1540 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1541 
 
483 rajveer 1542 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1543 
    """
1544 
    Parameters:
483 rajveer 1545 
     - orderId
1546 
     - status
1547 
     - description
94 ashish 1548 
    """
483 rajveer 1549 
    self.send_changeOrderStatus(orderId, status, description)
1550 
    return self.recv_changeOrderStatus()
94 ashish 1551 
 
483 rajveer 1552 
  def send_changeOrderStatus(self, orderId, status, description):
1553 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1554 
    args = changeOrderStatus_args()
1555 
    args.orderId = orderId
1556 
    args.status = status
1557 
    args.description = description
94 ashish 1558 
    args.write(self._oprot)
1559 
    self._oprot.writeMessageEnd()
1560 
    self._oprot.trans.flush()
1561 
 
483 rajveer 1562 
  def recv_changeOrderStatus(self, ):
94 ashish 1563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1564 
    if mtype == TMessageType.EXCEPTION:
1565 
      x = TApplicationException()
1566 
      x.read(self._iprot)
1567 
      self._iprot.readMessageEnd()
1568 
      raise x
483 rajveer 1569 
    result = changeOrderStatus_result()
94 ashish 1570 
    result.read(self._iprot)
1571 
    self._iprot.readMessageEnd()
3431 rajveer 1572 
    if result.success is not None:
94 ashish 1573 
      return result.success
3431 rajveer 1574 
    if result.ex is not None:
94 ashish 1575 
      raise result.ex
483 rajveer 1576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1577 
 
1528 ankur.sing 1578 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1579 
    """
1528 ankur.sing 1580 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1581 
    only user who owns the transaction can view its order details.
3431 rajveer 1582 
 
94 ashish 1583 
    Parameters:
1584 
     - transactionId
1528 ankur.sing 1585 
     - customerId
94 ashish 1586 
    """
1528 ankur.sing 1587 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1588 
    return self.recv_getOrdersForTransaction()
94 ashish 1589 
 
1528 ankur.sing 1590 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1591 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1592 
    args = getOrdersForTransaction_args()
94 ashish 1593 
    args.transactionId = transactionId
1528 ankur.sing 1594 
    args.customerId = customerId
94 ashish 1595 
    args.write(self._oprot)
1596 
    self._oprot.writeMessageEnd()
1597 
    self._oprot.trans.flush()
1598 
 
483 rajveer 1599 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1601 
    if mtype == TMessageType.EXCEPTION:
1602 
      x = TApplicationException()
1603 
      x.read(self._iprot)
1604 
      self._iprot.readMessageEnd()
1605 
      raise x
483 rajveer 1606 
    result = getOrdersForTransaction_result()
94 ashish 1607 
    result.read(self._iprot)
1608 
    self._iprot.readMessageEnd()
3431 rajveer 1609 
    if result.success is not None:
94 ashish 1610 
      return result.success
3431 rajveer 1611 
    if result.ex is not None:
94 ashish 1612 
      raise result.ex
483 rajveer 1613 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1614 
 
3014 chandransh 1615 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1616 
    """
3014 chandransh 1617 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1618 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1619 
 
94 ashish 1620 
    Parameters:
483 rajveer 1621 
     - customerId
1622 
     - from_date
1623 
     - to_date
3014 chandransh 1624 
     - statuses
94 ashish 1625 
    """
3014 chandransh 1626 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1627 
    return self.recv_getOrdersForCustomer()
94 ashish 1628 
 
3014 chandransh 1629 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1630 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1631 
    args = getOrdersForCustomer_args()
1632 
    args.customerId = customerId
1633 
    args.from_date = from_date
1634 
    args.to_date = to_date
3014 chandransh 1635 
    args.statuses = statuses
94 ashish 1636 
    args.write(self._oprot)
1637 
    self._oprot.writeMessageEnd()
1638 
    self._oprot.trans.flush()
1639 
 
483 rajveer 1640 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1641 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1642 
    if mtype == TMessageType.EXCEPTION:
1643 
      x = TApplicationException()
1644 
      x.read(self._iprot)
1645 
      self._iprot.readMessageEnd()
1646 
      raise x
483 rajveer 1647 
    result = getOrdersForCustomer_result()
94 ashish 1648 
    result.read(self._iprot)
1649 
    self._iprot.readMessageEnd()
3431 rajveer 1650 
    if result.success is not None:
94 ashish 1651 
      return result.success
3431 rajveer 1652 
    if result.ex is not None:
94 ashish 1653 
      raise result.ex
483 rajveer 1654 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1655 
 
483 rajveer 1656 
  def createOrder(self, order):
94 ashish 1657 
    """
1658 
    Parameters:
483 rajveer 1659 
     - order
94 ashish 1660 
    """
483 rajveer 1661 
    self.send_createOrder(order)
1662 
    return self.recv_createOrder()
94 ashish 1663 
 
483 rajveer 1664 
  def send_createOrder(self, order):
1665 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1666 
    args = createOrder_args()
1667 
    args.order = order
94 ashish 1668 
    args.write(self._oprot)
1669 
    self._oprot.writeMessageEnd()
1670 
    self._oprot.trans.flush()
1671 
 
483 rajveer 1672 
  def recv_createOrder(self, ):
94 ashish 1673 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1674 
    if mtype == TMessageType.EXCEPTION:
1675 
      x = TApplicationException()
1676 
      x.read(self._iprot)
1677 
      self._iprot.readMessageEnd()
1678 
      raise x
483 rajveer 1679 
    result = createOrder_result()
94 ashish 1680 
    result.read(self._iprot)
1681 
    self._iprot.readMessageEnd()
3431 rajveer 1682 
    if result.success is not None:
94 ashish 1683 
      return result.success
3431 rajveer 1684 
    if result.ex is not None:
94 ashish 1685 
      raise result.ex
483 rajveer 1686 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1687 
 
483 rajveer 1688 
  def getOrder(self, id):
94 ashish 1689 
    """
1690 
    Parameters:
483 rajveer 1691 
     - id
94 ashish 1692 
    """
483 rajveer 1693 
    self.send_getOrder(id)
1694 
    return self.recv_getOrder()
94 ashish 1695 
 
483 rajveer 1696 
  def send_getOrder(self, id):
1697 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1698 
    args = getOrder_args()
1699 
    args.id = id
94 ashish 1700 
    args.write(self._oprot)
1701 
    self._oprot.writeMessageEnd()
1702 
    self._oprot.trans.flush()
1703 
 
483 rajveer 1704 
  def recv_getOrder(self, ):
94 ashish 1705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1706 
    if mtype == TMessageType.EXCEPTION:
1707 
      x = TApplicationException()
1708 
      x.read(self._iprot)
1709 
      self._iprot.readMessageEnd()
1710 
      raise x
483 rajveer 1711 
    result = getOrder_result()
94 ashish 1712 
    result.read(self._iprot)
1713 
    self._iprot.readMessageEnd()
3431 rajveer 1714 
    if result.success is not None:
94 ashish 1715 
      return result.success
3431 rajveer 1716 
    if result.ex is not None:
94 ashish 1717 
      raise result.ex
483 rajveer 1718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1719 
 
483 rajveer 1720 
  def getLineItemsForOrder(self, orderId):
94 ashish 1721 
    """
1722 
    Parameters:
483 rajveer 1723 
     - orderId
94 ashish 1724 
    """
483 rajveer 1725 
    self.send_getLineItemsForOrder(orderId)
1726 
    return self.recv_getLineItemsForOrder()
94 ashish 1727 
 
483 rajveer 1728 
  def send_getLineItemsForOrder(self, orderId):
1729 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1730 
    args = getLineItemsForOrder_args()
1731 
    args.orderId = orderId
94 ashish 1732 
    args.write(self._oprot)
1733 
    self._oprot.writeMessageEnd()
1734 
    self._oprot.trans.flush()
1735 
 
483 rajveer 1736 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1738 
    if mtype == TMessageType.EXCEPTION:
1739 
      x = TApplicationException()
1740 
      x.read(self._iprot)
1741 
      self._iprot.readMessageEnd()
1742 
      raise x
483 rajveer 1743 
    result = getLineItemsForOrder_result()
94 ashish 1744 
    result.read(self._iprot)
1745 
    self._iprot.readMessageEnd()
3431 rajveer 1746 
    if result.success is not None:
94 ashish 1747 
      return result.success
3431 rajveer 1748 
    if result.ex is not None:
94 ashish 1749 
      raise result.ex
483 rajveer 1750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1751 
 
1528 ankur.sing 1752 
  def getOrderForCustomer(self, orderId, customerId):
1753 
    """
1754 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1755 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1756 
 
1528 ankur.sing 1757 
    Parameters:
1758 
     - orderId
1759 
     - customerId
1760 
    """
1761 
    self.send_getOrderForCustomer(orderId, customerId)
1762 
    return self.recv_getOrderForCustomer()
1763 
 
1764 
  def send_getOrderForCustomer(self, orderId, customerId):
1765 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1766 
    args = getOrderForCustomer_args()
1767 
    args.orderId = orderId
1768 
    args.customerId = customerId
1769 
    args.write(self._oprot)
1770 
    self._oprot.writeMessageEnd()
1771 
    self._oprot.trans.flush()
1772 
 
1773 
  def recv_getOrderForCustomer(self, ):
1774 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1775 
    if mtype == TMessageType.EXCEPTION:
1776 
      x = TApplicationException()
1777 
      x.read(self._iprot)
1778 
      self._iprot.readMessageEnd()
1779 
      raise x
1780 
    result = getOrderForCustomer_result()
1781 
    result.read(self._iprot)
1782 
    self._iprot.readMessageEnd()
3431 rajveer 1783 
    if result.success is not None:
1528 ankur.sing 1784 
      return result.success
3431 rajveer 1785 
    if result.ex is not None:
1528 ankur.sing 1786 
      raise result.ex
1787 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1788 
 
4444 rajveer 1789 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1790 
    """
1791 
    Parameters:
4394 rajveer 1792 
     - type
4444 rajveer 1793 
     - warehouseId
4394 rajveer 1794 
     - status
1795 
     - timestamp
3064 chandransh 1796 
    """
4444 rajveer 1797 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1798 
    return self.recv_getAlerts()
1799 
 
4444 rajveer 1800 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1801 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1802 
    args = getAlerts_args()
4394 rajveer 1803 
    args.type = type
4444 rajveer 1804 
    args.warehouseId = warehouseId
4394 rajveer 1805 
    args.status = status
1806 
    args.timestamp = timestamp
3064 chandransh 1807 
    args.write(self._oprot)
1808 
    self._oprot.writeMessageEnd()
1809 
    self._oprot.trans.flush()
1810 
 
1811 
  def recv_getAlerts(self, ):
1812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1813 
    if mtype == TMessageType.EXCEPTION:
1814 
      x = TApplicationException()
1815 
      x.read(self._iprot)
1816 
      self._iprot.readMessageEnd()
1817 
      raise x
1818 
    result = getAlerts_result()
1819 
    result.read(self._iprot)
1820 
    self._iprot.readMessageEnd()
3431 rajveer 1821 
    if result.success is not None:
3064 chandransh 1822 
      return result.success
1823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1824 
 
4444 rajveer 1825 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1826 
    """
1827 
    Parameters:
1828 
     - type
4444 rajveer 1829 
     - warehouseId
4394 rajveer 1830 
     - description
3064 chandransh 1831 
    """
4444 rajveer 1832 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1833 
    self.recv_addAlert()
3064 chandransh 1834 
 
4444 rajveer 1835 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1836 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1837 
    args = addAlert_args()
3064 chandransh 1838 
    args.type = type
4444 rajveer 1839 
    args.warehouseId = warehouseId
4394 rajveer 1840 
    args.description = description
3064 chandransh 1841 
    args.write(self._oprot)
1842 
    self._oprot.writeMessageEnd()
1843 
    self._oprot.trans.flush()
1844 
 
4394 rajveer 1845 
  def recv_addAlert(self, ):
3064 chandransh 1846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1847 
    if mtype == TMessageType.EXCEPTION:
1848 
      x = TApplicationException()
1849 
      x.read(self._iprot)
1850 
      self._iprot.readMessageEnd()
1851 
      raise x
4394 rajveer 1852 
    result = addAlert_result()
3064 chandransh 1853 
    result.read(self._iprot)
1854 
    self._iprot.readMessageEnd()
1855 
    return
1856 
 
4444 rajveer 1857 
  def markAlertsAsSeen(self, warehouseId):
1858 
    """
1859 
    Parameters:
1860 
     - warehouseId
1861 
    """
1862 
    self.send_markAlertsAsSeen(warehouseId)
1863 
    self.recv_markAlertsAsSeen()
1864 
 
1865 
  def send_markAlertsAsSeen(self, warehouseId):
1866 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1867 
    args = markAlertsAsSeen_args()
1868 
    args.warehouseId = warehouseId
1869 
    args.write(self._oprot)
1870 
    self._oprot.writeMessageEnd()
1871 
    self._oprot.trans.flush()
1872 
 
1873 
  def recv_markAlertsAsSeen(self, ):
1874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1875 
    if mtype == TMessageType.EXCEPTION:
1876 
      x = TApplicationException()
1877 
      x.read(self._iprot)
1878 
      self._iprot.readMessageEnd()
1879 
      raise x
1880 
    result = markAlertsAsSeen_result()
1881 
    result.read(self._iprot)
1882 
    self._iprot.readMessageEnd()
1883 
    return
1884 
 
3064 chandransh 1885 
  def getValidOrderCount(self, ):
1886 
    """
1887 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1888 
    """
1889 
    self.send_getValidOrderCount()
1890 
    return self.recv_getValidOrderCount()
1891 
 
1892 
  def send_getValidOrderCount(self, ):
1893 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1894 
    args = getValidOrderCount_args()
1895 
    args.write(self._oprot)
1896 
    self._oprot.writeMessageEnd()
1897 
    self._oprot.trans.flush()
1898 
 
1899 
  def recv_getValidOrderCount(self, ):
1900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1901 
    if mtype == TMessageType.EXCEPTION:
1902 
      x = TApplicationException()
1903 
      x.read(self._iprot)
1904 
      self._iprot.readMessageEnd()
1905 
      raise x
1906 
    result = getValidOrderCount_result()
1907 
    result.read(self._iprot)
1908 
    self._iprot.readMessageEnd()
3431 rajveer 1909 
    if result.success is not None:
3064 chandransh 1910 
      return result.success
1911 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1912 
 
1913 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1914 
    """
1915 
    Returns the number of distinct customers who have done successful transactions
1916 
    """
1917 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1918 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1919 
 
1920 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1921 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1922 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1923 
    args.write(self._oprot)
1924 
    self._oprot.writeMessageEnd()
1925 
    self._oprot.trans.flush()
1926 
 
1927 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1929 
    if mtype == TMessageType.EXCEPTION:
1930 
      x = TApplicationException()
1931 
      x.read(self._iprot)
1932 
      self._iprot.readMessageEnd()
1933 
      raise x
1934 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1935 
    result.read(self._iprot)
1936 
    self._iprot.readMessageEnd()
3431 rajveer 1937 
    if result.success is not None:
3064 chandransh 1938 
      return result.success
1939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1940 
 
1941 
  def getValidOrdersAmountRange(self, ):
1942 
    """
1943 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1944 
    List contains two values, first minimum amount and second maximum amount.
1945 
    """
1946 
    self.send_getValidOrdersAmountRange()
1947 
    return self.recv_getValidOrdersAmountRange()
1948 
 
1949 
  def send_getValidOrdersAmountRange(self, ):
1950 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1951 
    args = getValidOrdersAmountRange_args()
1952 
    args.write(self._oprot)
1953 
    self._oprot.writeMessageEnd()
1954 
    self._oprot.trans.flush()
1955 
 
1956 
  def recv_getValidOrdersAmountRange(self, ):
1957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1958 
    if mtype == TMessageType.EXCEPTION:
1959 
      x = TApplicationException()
1960 
      x.read(self._iprot)
1961 
      self._iprot.readMessageEnd()
1962 
      raise x
1963 
    result = getValidOrdersAmountRange_result()
1964 
    result.read(self._iprot)
1965 
    self._iprot.readMessageEnd()
3431 rajveer 1966 
    if result.success is not None:
3064 chandransh 1967 
      return result.success
1968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1969 
 
1970 
  def getValidOrders(self, limit):
1971 
    """
1972 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1973 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1974 
 
3064 chandransh 1975 
    Parameters:
1976 
     - limit
1977 
    """
1978 
    self.send_getValidOrders(limit)
1979 
    return self.recv_getValidOrders()
1980 
 
1981 
  def send_getValidOrders(self, limit):
1982 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1983 
    args = getValidOrders_args()
1984 
    args.limit = limit
1985 
    args.write(self._oprot)
1986 
    self._oprot.writeMessageEnd()
1987 
    self._oprot.trans.flush()
1988 
 
1989 
  def recv_getValidOrders(self, ):
1990 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1991 
    if mtype == TMessageType.EXCEPTION:
1992 
      x = TApplicationException()
1993 
      x.read(self._iprot)
1994 
      self._iprot.readMessageEnd()
1995 
      raise x
1996 
    result = getValidOrders_result()
1997 
    result.read(self._iprot)
1998 
    self._iprot.readMessageEnd()
3431 rajveer 1999 
    if result.success is not None:
3064 chandransh 2000 
      return result.success
2001 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2002 
 
1220 chandransh 2003 
  def batchOrders(self, warehouseId):
2004 
    """
2005 
    Create a batch of all the pending orders for the given warehouse.
2006 
    The returned list is orderd by created_timestamp.
2007 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2008 
 
1220 chandransh 2009 
    Parameters:
2010 
     - warehouseId
2011 
    """
2012 
    self.send_batchOrders(warehouseId)
2013 
    return self.recv_batchOrders()
2014 
 
2015 
  def send_batchOrders(self, warehouseId):
2016 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2017 
    args = batchOrders_args()
2018 
    args.warehouseId = warehouseId
2019 
    args.write(self._oprot)
2020 
    self._oprot.writeMessageEnd()
2021 
    self._oprot.trans.flush()
2022 
 
2023 
  def recv_batchOrders(self, ):
2024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2025 
    if mtype == TMessageType.EXCEPTION:
2026 
      x = TApplicationException()
2027 
      x.read(self._iprot)
2028 
      self._iprot.readMessageEnd()
2029 
      raise x
2030 
    result = batchOrders_result()
2031 
    result.read(self._iprot)
2032 
    self._iprot.readMessageEnd()
3431 rajveer 2033 
    if result.success is not None:
1220 chandransh 2034 
      return result.success
3431 rajveer 2035 
    if result.ex is not None:
1220 chandransh 2036 
      raise result.ex
2037 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2038 
 
1208 chandransh 2039 
  def markOrderAsOutOfStock(self, orderId):
2040 
    """
2041 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2042 
 
1208 chandransh 2043 
    Parameters:
2044 
     - orderId
2045 
    """
2046 
    self.send_markOrderAsOutOfStock(orderId)
2047 
    return self.recv_markOrderAsOutOfStock()
2048 
 
2049 
  def send_markOrderAsOutOfStock(self, orderId):
2050 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2051 
    args = markOrderAsOutOfStock_args()
2052 
    args.orderId = orderId
2053 
    args.write(self._oprot)
2054 
    self._oprot.writeMessageEnd()
2055 
    self._oprot.trans.flush()
2056 
 
2057 
  def recv_markOrderAsOutOfStock(self, ):
2058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2059 
    if mtype == TMessageType.EXCEPTION:
2060 
      x = TApplicationException()
2061 
      x.read(self._iprot)
2062 
      self._iprot.readMessageEnd()
2063 
      raise x
2064 
    result = markOrderAsOutOfStock_result()
2065 
    result.read(self._iprot)
2066 
    self._iprot.readMessageEnd()
3431 rajveer 2067 
    if result.success is not None:
1208 chandransh 2068 
      return result.success
3431 rajveer 2069 
    if result.ex is not None:
1208 chandransh 2070 
      raise result.ex
2071 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2072 
 
3064 chandransh 2073 
  def verifyOrder(self, orderId):
759 chandransh 2074 
    """
3064 chandransh 2075 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2076 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2077 
    used for all other orders as well.
2078 
    Throws an exception if no such order exists.
3431 rajveer 2079 
 
759 chandransh 2080 
    Parameters:
3064 chandransh 2081 
     - orderId
759 chandransh 2082 
    """
3064 chandransh 2083 
    self.send_verifyOrder(orderId)
2084 
    return self.recv_verifyOrder()
759 chandransh 2085 
 
3064 chandransh 2086 
  def send_verifyOrder(self, orderId):
2087 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2088 
    args = verifyOrder_args()
2089 
    args.orderId = orderId
759 chandransh 2090 
    args.write(self._oprot)
2091 
    self._oprot.writeMessageEnd()
2092 
    self._oprot.trans.flush()
2093 
 
3064 chandransh 2094 
  def recv_verifyOrder(self, ):
759 chandransh 2095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2096 
    if mtype == TMessageType.EXCEPTION:
2097 
      x = TApplicationException()
2098 
      x.read(self._iprot)
2099 
      self._iprot.readMessageEnd()
2100 
      raise x
3064 chandransh 2101 
    result = verifyOrder_result()
759 chandransh 2102 
    result.read(self._iprot)
2103 
    self._iprot.readMessageEnd()
3431 rajveer 2104 
    if result.success is not None:
759 chandransh 2105 
      return result.success
3431 rajveer 2106 
    if result.ex is not None:
759 chandransh 2107 
      raise result.ex
3064 chandransh 2108 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2109 
 
3064 chandransh 2110 
  def acceptOrder(self, orderId):
1113 chandransh 2111 
    """
3064 chandransh 2112 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2113 
    given order is not a COD order, it also captures the payment if the same has
2114 
    not been captured.
2115 
    Throws an exception if no such order exists.
3431 rajveer 2116 
 
1113 chandransh 2117 
    Parameters:
3064 chandransh 2118 
     - orderId
1113 chandransh 2119 
    """
3064 chandransh 2120 
    self.send_acceptOrder(orderId)
2121 
    return self.recv_acceptOrder()
1113 chandransh 2122 
 
3064 chandransh 2123 
  def send_acceptOrder(self, orderId):
2124 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2125 
    args = acceptOrder_args()
2126 
    args.orderId = orderId
1113 chandransh 2127 
    args.write(self._oprot)
2128 
    self._oprot.writeMessageEnd()
2129 
    self._oprot.trans.flush()
2130 
 
3064 chandransh 2131 
  def recv_acceptOrder(self, ):
1113 chandransh 2132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2133 
    if mtype == TMessageType.EXCEPTION:
2134 
      x = TApplicationException()
2135 
      x.read(self._iprot)
2136 
      self._iprot.readMessageEnd()
2137 
      raise x
3064 chandransh 2138 
    result = acceptOrder_result()
1113 chandransh 2139 
    result.read(self._iprot)
2140 
    self._iprot.readMessageEnd()
3431 rajveer 2141 
    if result.success is not None:
1113 chandransh 2142 
      return result.success
3431 rajveer 2143 
    if result.ex is not None:
1113 chandransh 2144 
      raise result.ex
3064 chandransh 2145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2146 
 
4763 rajveer 2147 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
1132 chandransh 2148 
    """
3064 chandransh 2149 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2150 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2151 
    the IMEI no. if a -1 is supplied.
2152 
    Also, it generates an invoice number for the order, marks the order as
2153 
    BILLED and sets the billing timestamp.
2154 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2155 
 
1135 chandransh 2156 
    Parameters:
3064 chandransh 2157 
     - orderId
2158 
     - invoice_number
4658 mandeep.dh 2159 
     - serialNumber
4283 anupam.sin 2160 
     - itemNumber
3064 chandransh 2161 
     - billed_by
4264 rajveer 2162 
     - jacketNumber
4283 anupam.sin 2163 
     - billingType
2164 
     - vendorId
4763 rajveer 2165 
     - authorize
1135 chandransh 2166 
    """
4763 rajveer 2167 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize)
3064 chandransh 2168 
    return self.recv_addBillingDetails()
1135 chandransh 2169 
 
4763 rajveer 2170 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 2171 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2172 
    args = addBillingDetails_args()
2173 
    args.orderId = orderId
2174 
    args.invoice_number = invoice_number
4658 mandeep.dh 2175 
    args.serialNumber = serialNumber
4283 anupam.sin 2176 
    args.itemNumber = itemNumber
3064 chandransh 2177 
    args.billed_by = billed_by
4264 rajveer 2178 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2179 
    args.billingType = billingType
2180 
    args.vendorId = vendorId
4763 rajveer 2181 
    args.authorize = authorize
1135 chandransh 2182 
    args.write(self._oprot)
2183 
    self._oprot.writeMessageEnd()
2184 
    self._oprot.trans.flush()
2185 
 
3064 chandransh 2186 
  def recv_addBillingDetails(self, ):
1135 chandransh 2187 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2188 
    if mtype == TMessageType.EXCEPTION:
2189 
      x = TApplicationException()
2190 
      x.read(self._iprot)
2191 
      self._iprot.readMessageEnd()
2192 
      raise x
3064 chandransh 2193 
    result = addBillingDetails_result()
1135 chandransh 2194 
    result.read(self._iprot)
2195 
    self._iprot.readMessageEnd()
3431 rajveer 2196 
    if result.success is not None:
3064 chandransh 2197 
      return result.success
3431 rajveer 2198 
    if result.ex is not None:
1135 chandransh 2199 
      raise result.ex
3064 chandransh 2200 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2201 
 
4763 rajveer 2202 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2203 
    """
2204 
    Add the invoice number to the order.
2205 
 
2206 
    Parameters:
2207 
     - orderId
2208 
     - invoiceNumber
4763 rajveer 2209 
     - color
4579 rajveer 2210 
    """
4763 rajveer 2211 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2212 
    self.recv_addInvoiceNumber()
2213 
 
4763 rajveer 2214 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2215 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2216 
    args = addInvoiceNumber_args()
2217 
    args.orderId = orderId
2218 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2219 
    args.color = color
4579 rajveer 2220 
    args.write(self._oprot)
2221 
    self._oprot.writeMessageEnd()
2222 
    self._oprot.trans.flush()
2223 
 
2224 
  def recv_addInvoiceNumber(self, ):
2225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2226 
    if mtype == TMessageType.EXCEPTION:
2227 
      x = TApplicationException()
2228 
      x.read(self._iprot)
2229 
      self._iprot.readMessageEnd()
2230 
      raise x
2231 
    result = addInvoiceNumber_result()
2232 
    result.read(self._iprot)
2233 
    self._iprot.readMessageEnd()
2234 
    if result.ex is not None:
2235 
      raise result.ex
2236 
    return
2237 
 
3064 chandransh 2238 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2239 
    """
3064 chandransh 2240 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2241 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2242 
 
1408 ankur.sing 2243 
    Parameters:
3064 chandransh 2244 
     - warehouseId
1408 ankur.sing 2245 
     - providerId
3064 chandransh 2246 
     - cod
1408 ankur.sing 2247 
    """
3064 chandransh 2248 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2249 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2250 
 
3064 chandransh 2251 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2252 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2253 
    args = markOrdersAsManifested_args()
2254 
    args.warehouseId = warehouseId
1408 ankur.sing 2255 
    args.providerId = providerId
3064 chandransh 2256 
    args.cod = cod
1408 ankur.sing 2257 
    args.write(self._oprot)
2258 
    self._oprot.writeMessageEnd()
2259 
    self._oprot.trans.flush()
2260 
 
3064 chandransh 2261 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2263 
    if mtype == TMessageType.EXCEPTION:
2264 
      x = TApplicationException()
2265 
      x.read(self._iprot)
2266 
      self._iprot.readMessageEnd()
2267 
      raise x
3064 chandransh 2268 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2269 
    result.read(self._iprot)
2270 
    self._iprot.readMessageEnd()
3431 rajveer 2271 
    if result.success is not None:
1408 ankur.sing 2272 
      return result.success
3431 rajveer 2273 
    if result.ex is not None:
3064 chandransh 2274 
      raise result.ex
2275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2276 
 
4789 rajveer 2277 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
4410 rajveer 2278 
    """
2279 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2280 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2281 
 
2282 
    Parameters:
2283 
     - warehouseId
2284 
     - providerId
2285 
     - cod
4789 rajveer 2286 
     - orderIds
4410 rajveer 2287 
    """
4789 rajveer 2288 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
4410 rajveer 2289 
    return self.recv_markOrdersAsShippedFromWarehouse()
2290 
 
4789 rajveer 2291 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
4410 rajveer 2292 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2293 
    args = markOrdersAsShippedFromWarehouse_args()
2294 
    args.warehouseId = warehouseId
2295 
    args.providerId = providerId
2296 
    args.cod = cod
4789 rajveer 2297 
    args.orderIds = orderIds
4410 rajveer 2298 
    args.write(self._oprot)
2299 
    self._oprot.writeMessageEnd()
2300 
    self._oprot.trans.flush()
2301 
 
2302 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2304 
    if mtype == TMessageType.EXCEPTION:
2305 
      x = TApplicationException()
2306 
      x.read(self._iprot)
2307 
      self._iprot.readMessageEnd()
2308 
      raise x
2309 
    result = markOrdersAsShippedFromWarehouse_result()
2310 
    result.read(self._iprot)
2311 
    self._iprot.readMessageEnd()
2312 
    if result.success is not None:
2313 
      return result.success
2314 
    if result.ex is not None:
2315 
      raise result.ex
2316 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2317 
 
3064 chandransh 2318 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2319 
    """
3064 chandransh 2320 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2321 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2322 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2323 
 
94 ashish 2324 
    Parameters:
3064 chandransh 2325 
     - providerId
2326 
     - pickupDetails
304 ashish 2327 
    """
3064 chandransh 2328 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2329 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2330 
 
3064 chandransh 2331 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2332 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2333 
    args = markOrdersAsPickedUp_args()
2334 
    args.providerId = providerId
2335 
    args.pickupDetails = pickupDetails
304 ashish 2336 
    args.write(self._oprot)
2337 
    self._oprot.writeMessageEnd()
2338 
    self._oprot.trans.flush()
2339 
 
3064 chandransh 2340 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2342 
    if mtype == TMessageType.EXCEPTION:
2343 
      x = TApplicationException()
2344 
      x.read(self._iprot)
2345 
      self._iprot.readMessageEnd()
2346 
      raise x
3064 chandransh 2347 
    result = markOrdersAsPickedUp_result()
304 ashish 2348 
    result.read(self._iprot)
2349 
    self._iprot.readMessageEnd()
3431 rajveer 2350 
    if result.success is not None:
304 ashish 2351 
      return result.success
3431 rajveer 2352 
    if result.ex is not None:
3064 chandransh 2353 
      raise result.ex
2354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2355 
 
3064 chandransh 2356 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2357 
    """
3064 chandransh 2358 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2359 
    the name of the receiver.
2360 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2361 
 
304 ashish 2362 
    Parameters:
3064 chandransh 2363 
     - providerId
2364 
     - deliveredOrders
304 ashish 2365 
    """
3064 chandransh 2366 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2367 
    self.recv_markOrdersAsDelivered()
304 ashish 2368 
 
3064 chandransh 2369 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2370 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2371 
    args = markOrdersAsDelivered_args()
2372 
    args.providerId = providerId
2373 
    args.deliveredOrders = deliveredOrders
304 ashish 2374 
    args.write(self._oprot)
2375 
    self._oprot.writeMessageEnd()
2376 
    self._oprot.trans.flush()
2377 
 
3064 chandransh 2378 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2380 
    if mtype == TMessageType.EXCEPTION:
2381 
      x = TApplicationException()
2382 
      x.read(self._iprot)
2383 
      self._iprot.readMessageEnd()
2384 
      raise x
3064 chandransh 2385 
    result = markOrdersAsDelivered_result()
304 ashish 2386 
    result.read(self._iprot)
2387 
    self._iprot.readMessageEnd()
3431 rajveer 2388 
    if result.ex is not None:
3064 chandransh 2389 
      raise result.ex
304 ashish 2390 
    return
2391 
 
3064 chandransh 2392 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2393 
    """
3064 chandransh 2394 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2395 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2396 
 
3064 chandransh 2397 
    Parameters:
2398 
     - providerId
2399 
     - returnedOrders
1596 ankur.sing 2400 
    """
3064 chandransh 2401 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2402 
    self.recv_markOrdersAsFailed()
304 ashish 2403 
 
3064 chandransh 2404 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2405 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2406 
    args = markOrdersAsFailed_args()
2407 
    args.providerId = providerId
2408 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2409 
    args.write(self._oprot)
2410 
    self._oprot.writeMessageEnd()
2411 
    self._oprot.trans.flush()
2412 
 
3064 chandransh 2413 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2415 
    if mtype == TMessageType.EXCEPTION:
2416 
      x = TApplicationException()
2417 
      x.read(self._iprot)
2418 
      self._iprot.readMessageEnd()
2419 
      raise x
3064 chandransh 2420 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2421 
    result.read(self._iprot)
2422 
    self._iprot.readMessageEnd()
3431 rajveer 2423 
    if result.ex is not None:
3064 chandransh 2424 
      raise result.ex
2425 
    return
1596 ankur.sing 2426 
 
3064 chandransh 2427 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2428 
    """
3064 chandransh 2429 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2430 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2431 
 
3064 chandransh 2432 
    Parameters:
2433 
     - providerId
2434 
     - undeliveredOrders
1627 ankur.sing 2435 
    """
3064 chandransh 2436 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2437 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2438 
 
3064 chandransh 2439 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2440 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2441 
    args = updateNonDeliveryReason_args()
2442 
    args.providerId = providerId
2443 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2444 
    args.write(self._oprot)
2445 
    self._oprot.writeMessageEnd()
2446 
    self._oprot.trans.flush()
2447 
 
3064 chandransh 2448 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2450 
    if mtype == TMessageType.EXCEPTION:
2451 
      x = TApplicationException()
2452 
      x.read(self._iprot)
2453 
      self._iprot.readMessageEnd()
2454 
      raise x
3064 chandransh 2455 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2456 
    result.read(self._iprot)
2457 
    self._iprot.readMessageEnd()
4581 phani.kuma 2458 
    if result.success is not None:
2459 
      return result.success
3431 rajveer 2460 
    if result.ex is not None:
3064 chandransh 2461 
      raise result.ex
4581 phani.kuma 2462 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2463 
 
3064 chandransh 2464 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2465 
    """
3064 chandransh 2466 
    Returns the list of orders whose delivery time has passed but have not been
2467 
    delivered yet for the given provider and warehouse. To get a complete list of
2468 
    undelivered orders, pass them as -1.
2469 
    Returns an empty list if no such orders exist.
3431 rajveer 2470 
 
1886 ankur.sing 2471 
    Parameters:
3064 chandransh 2472 
     - providerId
2473 
     - warehouseId
1886 ankur.sing 2474 
    """
3064 chandransh 2475 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2476 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2477 
 
3064 chandransh 2478 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2479 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2480 
    args = getUndeliveredOrders_args()
2481 
    args.providerId = providerId
2482 
    args.warehouseId = warehouseId
1886 ankur.sing 2483 
    args.write(self._oprot)
2484 
    self._oprot.writeMessageEnd()
2485 
    self._oprot.trans.flush()
2486 
 
3064 chandransh 2487 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2488 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2489 
    if mtype == TMessageType.EXCEPTION:
2490 
      x = TApplicationException()
2491 
      x.read(self._iprot)
2492 
      self._iprot.readMessageEnd()
2493 
      raise x
3064 chandransh 2494 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2495 
    result.read(self._iprot)
2496 
    self._iprot.readMessageEnd()
3431 rajveer 2497 
    if result.success is not None:
1886 ankur.sing 2498 
      return result.success
3064 chandransh 2499 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2500 
 
4783 phani.kuma 2501 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2502 
    """
2503 
    Returns the list of orders whose expected delivery date has passed but have not been
2504 
    delivered yet.
2505 
    Returns an empty list if no such orders exist.
2506 
    """
2507 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2508 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2509 
 
2510 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2511 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2512 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2513 
    args.write(self._oprot)
2514 
    self._oprot.writeMessageEnd()
2515 
    self._oprot.trans.flush()
2516 
 
2517 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2519 
    if mtype == TMessageType.EXCEPTION:
2520 
      x = TApplicationException()
2521 
      x.read(self._iprot)
2522 
      self._iprot.readMessageEnd()
2523 
      raise x
2524 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2525 
    result.read(self._iprot)
2526 
    self._iprot.readMessageEnd()
2527 
    if result.success is not None:
2528 
      return result.success
2529 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2530 
 
2536 chandransh 2531 
  def toggleDOAFlag(self, orderId):
2532 
    """
2533 
    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.
2534 
    Returns the final flag status.
2535 
    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 2536 
 
2536 chandransh 2537 
    Parameters:
2538 
     - orderId
2539 
    """
2540 
    self.send_toggleDOAFlag(orderId)
2541 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2542 
 
2536 chandransh 2543 
  def send_toggleDOAFlag(self, orderId):
2544 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2545 
    args = toggleDOAFlag_args()
2546 
    args.orderId = orderId
2547 
    args.write(self._oprot)
2548 
    self._oprot.writeMessageEnd()
2549 
    self._oprot.trans.flush()
2550 
 
2551 
  def recv_toggleDOAFlag(self, ):
2552 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2553 
    if mtype == TMessageType.EXCEPTION:
2554 
      x = TApplicationException()
2555 
      x.read(self._iprot)
2556 
      self._iprot.readMessageEnd()
2557 
      raise x
2558 
    result = toggleDOAFlag_result()
2559 
    result.read(self._iprot)
2560 
    self._iprot.readMessageEnd()
3431 rajveer 2561 
    if result.success is not None:
2536 chandransh 2562 
      return result.success
3431 rajveer 2563 
    if result.ex is not None:
2536 chandransh 2564 
      raise result.ex
2565 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2566 
 
4712 rajveer 2567 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2568 
    """
2569 
    Parameters:
2570 
     - orderId
2571 
     - deliveryTimestamp
2572 
     - receiver
2573 
    """
2574 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2575 
    self.recv_markOrderAsDelivered()
2576 
 
2577 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2578 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2579 
    args = markOrderAsDelivered_args()
2580 
    args.orderId = orderId
2581 
    args.deliveryTimestamp = deliveryTimestamp
2582 
    args.receiver = receiver
2583 
    args.write(self._oprot)
2584 
    self._oprot.writeMessageEnd()
2585 
    self._oprot.trans.flush()
2586 
 
2587 
  def recv_markOrderAsDelivered(self, ):
2588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2589 
    if mtype == TMessageType.EXCEPTION:
2590 
      x = TApplicationException()
2591 
      x.read(self._iprot)
2592 
      self._iprot.readMessageEnd()
2593 
      raise x
2594 
    result = markOrderAsDelivered_result()
2595 
    result.read(self._iprot)
2596 
    self._iprot.readMessageEnd()
2597 
    if result.ex is not None:
2598 
      raise result.ex
2599 
    return
2600 
 
4454 rajveer 2601 
  def markOrderDoaRequestReceived(self, orderId):
2602 
    """
2603 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2604 
 
2605 
    Parameters:
2606 
     - orderId
2607 
    """
2608 
    self.send_markOrderDoaRequestReceived(orderId)
2609 
    return self.recv_markOrderDoaRequestReceived()
2610 
 
2611 
  def send_markOrderDoaRequestReceived(self, orderId):
2612 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2613 
    args = markOrderDoaRequestReceived_args()
2614 
    args.orderId = orderId
2615 
    args.write(self._oprot)
2616 
    self._oprot.writeMessageEnd()
2617 
    self._oprot.trans.flush()
2618 
 
2619 
  def recv_markOrderDoaRequestReceived(self, ):
2620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2621 
    if mtype == TMessageType.EXCEPTION:
2622 
      x = TApplicationException()
2623 
      x.read(self._iprot)
2624 
      self._iprot.readMessageEnd()
2625 
      raise x
2626 
    result = markOrderDoaRequestReceived_result()
2627 
    result.read(self._iprot)
2628 
    self._iprot.readMessageEnd()
2629 
    if result.success is not None:
2630 
      return result.success
2631 
    if result.ex is not None:
2632 
      raise result.ex
2633 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2634 
 
2635 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2636 
    """
2637 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2638 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2639 
 
2640 
    Parameters:
2641 
     - orderId
2642 
     - isAuthorized
2643 
    """
2644 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2645 
    return self.recv_markOrderDoaRequestAuthorized()
2646 
 
2647 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2648 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2649 
    args = markOrderDoaRequestAuthorized_args()
2650 
    args.orderId = orderId
2651 
    args.isAuthorized = isAuthorized
2652 
    args.write(self._oprot)
2653 
    self._oprot.writeMessageEnd()
2654 
    self._oprot.trans.flush()
2655 
 
2656 
  def recv_markOrderDoaRequestAuthorized(self, ):
2657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2658 
    if mtype == TMessageType.EXCEPTION:
2659 
      x = TApplicationException()
2660 
      x.read(self._iprot)
2661 
      self._iprot.readMessageEnd()
2662 
      raise x
2663 
    result = markOrderDoaRequestAuthorized_result()
2664 
    result.read(self._iprot)
2665 
    self._iprot.readMessageEnd()
2666 
    if result.success is not None:
2667 
      return result.success
2668 
    if result.ex is not None:
2669 
      raise result.ex
2670 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2671 
 
4488 rajveer 2672 
  def markOrderReturnRequestReceived(self, orderId):
2673 
    """
2674 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2675 
 
2676 
    Parameters:
2677 
     - orderId
2678 
    """
2679 
    self.send_markOrderReturnRequestReceived(orderId)
2680 
    return self.recv_markOrderReturnRequestReceived()
2681 
 
2682 
  def send_markOrderReturnRequestReceived(self, orderId):
2683 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2684 
    args = markOrderReturnRequestReceived_args()
2685 
    args.orderId = orderId
2686 
    args.write(self._oprot)
2687 
    self._oprot.writeMessageEnd()
2688 
    self._oprot.trans.flush()
2689 
 
2690 
  def recv_markOrderReturnRequestReceived(self, ):
2691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2692 
    if mtype == TMessageType.EXCEPTION:
2693 
      x = TApplicationException()
2694 
      x.read(self._iprot)
2695 
      self._iprot.readMessageEnd()
2696 
      raise x
2697 
    result = markOrderReturnRequestReceived_result()
2698 
    result.read(self._iprot)
2699 
    self._iprot.readMessageEnd()
2700 
    if result.success is not None:
2701 
      return result.success
2702 
    if result.ex is not None:
2703 
      raise result.ex
2704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2705 
 
2706 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2707 
    """
2708 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2709 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2710 
 
2711 
    Parameters:
2712 
     - orderId
2713 
     - isAuthorized
2714 
    """
2715 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2716 
    return self.recv_markOrderReturnRequestAuthorized()
2717 
 
2718 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2719 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2720 
    args = markOrderReturnRequestAuthorized_args()
2721 
    args.orderId = orderId
2722 
    args.isAuthorized = isAuthorized
2723 
    args.write(self._oprot)
2724 
    self._oprot.writeMessageEnd()
2725 
    self._oprot.trans.flush()
2726 
 
2727 
  def recv_markOrderReturnRequestAuthorized(self, ):
2728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2729 
    if mtype == TMessageType.EXCEPTION:
2730 
      x = TApplicationException()
2731 
      x.read(self._iprot)
2732 
      self._iprot.readMessageEnd()
2733 
      raise x
2734 
    result = markOrderReturnRequestAuthorized_result()
2735 
    result.read(self._iprot)
2736 
    self._iprot.readMessageEnd()
2737 
    if result.success is not None:
2738 
      return result.success
2739 
    if result.ex is not None:
2740 
      raise result.ex
2741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2742 
 
4579 rajveer 2743 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2744 
    """
2745 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2746 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2747 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2748 
    For any other status, it returns false.
2749 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2750 
 
2536 chandransh 2751 
    Parameters:
2752 
     - orderId
4579 rajveer 2753 
     - providerId
2536 chandransh 2754 
    """
4579 rajveer 2755 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2756 
    return self.recv_requestPickupNumber()
2757 
 
4579 rajveer 2758 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2759 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2760 
    args = requestPickupNumber_args()
2761 
    args.orderId = orderId
4579 rajveer 2762 
    args.providerId = providerId
2536 chandransh 2763 
    args.write(self._oprot)
2764 
    self._oprot.writeMessageEnd()
2765 
    self._oprot.trans.flush()
2766 
 
2767 
  def recv_requestPickupNumber(self, ):
2768 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2769 
    if mtype == TMessageType.EXCEPTION:
2770 
      x = TApplicationException()
2771 
      x.read(self._iprot)
2772 
      self._iprot.readMessageEnd()
2773 
      raise x
2774 
    result = requestPickupNumber_result()
2775 
    result.read(self._iprot)
2776 
    self._iprot.readMessageEnd()
3431 rajveer 2777 
    if result.success is not None:
2536 chandransh 2778 
      return result.success
3431 rajveer 2779 
    if result.ex is not None:
2536 chandransh 2780 
      raise result.ex
2781 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2782 
 
4602 rajveer 2783 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2784 
    """
4452 rajveer 2785 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2786 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2787 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2788 
    	3. Returns true
2591 chandransh 2789 
    If the order is in any other status, it returns false.
2536 chandransh 2790 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2791 
 
2536 chandransh 2792 
    Parameters:
2793 
     - orderId
2794 
     - pickupNumber
4602 rajveer 2795 
     - providerId
2536 chandransh 2796 
    """
4602 rajveer 2797 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 2798 
    return self.recv_authorizePickup()
2799 
 
4602 rajveer 2800 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2801 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2802 
    args = authorizePickup_args()
2803 
    args.orderId = orderId
2804 
    args.pickupNumber = pickupNumber
4602 rajveer 2805 
    args.providerId = providerId
2536 chandransh 2806 
    args.write(self._oprot)
2807 
    self._oprot.writeMessageEnd()
2808 
    self._oprot.trans.flush()
2809 
 
2810 
  def recv_authorizePickup(self, ):
2811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2812 
    if mtype == TMessageType.EXCEPTION:
2813 
      x = TApplicationException()
2814 
      x.read(self._iprot)
2815 
      self._iprot.readMessageEnd()
2816 
      raise x
2817 
    result = authorizePickup_result()
2818 
    result.read(self._iprot)
2819 
    self._iprot.readMessageEnd()
3431 rajveer 2820 
    if result.success is not None:
2536 chandransh 2821 
      return result.success
3431 rajveer 2822 
    if result.ex is not None:
2536 chandransh 2823 
      raise result.ex
2824 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2825 
 
2764 chandransh 2826 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2827 
    """
2828 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2829 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2830 
 
2764 chandransh 2831 
    Parameters:
2832 
     - providerId
2833 
     - pickupDetails
2834 
    """
2835 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2836 
    return self.recv_markDoasAsPickedUp()
2837 
 
2838 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2839 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2840 
    args = markDoasAsPickedUp_args()
2841 
    args.providerId = providerId
2842 
    args.pickupDetails = pickupDetails
2843 
    args.write(self._oprot)
2844 
    self._oprot.writeMessageEnd()
2845 
    self._oprot.trans.flush()
2846 
 
2847 
  def recv_markDoasAsPickedUp(self, ):
2848 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2849 
    if mtype == TMessageType.EXCEPTION:
2850 
      x = TApplicationException()
2851 
      x.read(self._iprot)
2852 
      self._iprot.readMessageEnd()
2853 
      raise x
2854 
    result = markDoasAsPickedUp_result()
2855 
    result.read(self._iprot)
2856 
    self._iprot.readMessageEnd()
3431 rajveer 2857 
    if result.success is not None:
2764 chandransh 2858 
      return result.success
2859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2860 
 
4741 phani.kuma 2861 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
2862 
    """
2863 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
2864 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
2865 
 
2866 
    Parameters:
2867 
     - providerId
2868 
     - pickupDetails
2869 
    """
2870 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
2871 
    return self.recv_markReturnOrdersAsPickedUp()
2872 
 
2873 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
2874 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2875 
    args = markReturnOrdersAsPickedUp_args()
2876 
    args.providerId = providerId
2877 
    args.pickupDetails = pickupDetails
2878 
    args.write(self._oprot)
2879 
    self._oprot.writeMessageEnd()
2880 
    self._oprot.trans.flush()
2881 
 
2882 
  def recv_markReturnOrdersAsPickedUp(self, ):
2883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2884 
    if mtype == TMessageType.EXCEPTION:
2885 
      x = TApplicationException()
2886 
      x.read(self._iprot)
2887 
      self._iprot.readMessageEnd()
2888 
      raise x
2889 
    result = markReturnOrdersAsPickedUp_result()
2890 
    result.read(self._iprot)
2891 
    self._iprot.readMessageEnd()
2892 
    if result.success is not None:
2893 
      return result.success
2894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markReturnOrdersAsPickedUp failed: unknown result");
2895 
 
4479 rajveer 2896 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2897 
    """
4452 rajveer 2898 
    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 2899 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2900 
    If the order is in any other state, it returns false.
2901 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2902 
 
2591 chandransh 2903 
    Parameters:
2904 
     - orderId
4479 rajveer 2905 
     - receiveCondition
2591 chandransh 2906 
    """
4479 rajveer 2907 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2908 
    return self.recv_receiveReturn()
2536 chandransh 2909 
 
4479 rajveer 2910 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2911 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2912 
    args = receiveReturn_args()
2591 chandransh 2913 
    args.orderId = orderId
4479 rajveer 2914 
    args.receiveCondition = receiveCondition
2591 chandransh 2915 
    args.write(self._oprot)
2916 
    self._oprot.writeMessageEnd()
2917 
    self._oprot.trans.flush()
2918 
 
2616 chandransh 2919 
  def recv_receiveReturn(self, ):
2591 chandransh 2920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2921 
    if mtype == TMessageType.EXCEPTION:
2922 
      x = TApplicationException()
2923 
      x.read(self._iprot)
2924 
      self._iprot.readMessageEnd()
2925 
      raise x
2616 chandransh 2926 
    result = receiveReturn_result()
2591 chandransh 2927 
    result.read(self._iprot)
2928 
    self._iprot.readMessageEnd()
3431 rajveer 2929 
    if result.success is not None:
2591 chandransh 2930 
      return result.success
3431 rajveer 2931 
    if result.ex is not None:
2591 chandransh 2932 
      raise result.ex
2616 chandransh 2933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2934 
 
2935 
  def validateDoa(self, orderId, isValid):
2936 
    """
4452 rajveer 2937 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2938 
    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 2939 
    If the order is in any other state, it returns false.
2940 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2941 
 
2591 chandransh 2942 
    Parameters:
2943 
     - orderId
2944 
     - isValid
2945 
    """
2946 
    self.send_validateDoa(orderId, isValid)
2947 
    return self.recv_validateDoa()
2948 
 
2949 
  def send_validateDoa(self, orderId, isValid):
2950 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2951 
    args = validateDoa_args()
2952 
    args.orderId = orderId
2953 
    args.isValid = isValid
2954 
    args.write(self._oprot)
2955 
    self._oprot.writeMessageEnd()
2956 
    self._oprot.trans.flush()
2957 
 
2958 
  def recv_validateDoa(self, ):
2959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2960 
    if mtype == TMessageType.EXCEPTION:
2961 
      x = TApplicationException()
2962 
      x.read(self._iprot)
2963 
      self._iprot.readMessageEnd()
2964 
      raise x
2965 
    result = validateDoa_result()
2966 
    result.read(self._iprot)
2967 
    self._iprot.readMessageEnd()
3431 rajveer 2968 
    if result.success is not None:
2591 chandransh 2969 
      return result.success
3431 rajveer 2970 
    if result.ex is not None:
2591 chandransh 2971 
      raise result.ex
2972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2973 
 
4495 rajveer 2974 
  def validateReturnProduct(self, orderId, isUsable):
2975 
    """
2976 
    Parameters:
2977 
     - orderId
2978 
     - isUsable
2979 
    """
2980 
    self.send_validateReturnProduct(orderId, isUsable)
2981 
    return self.recv_validateReturnProduct()
2982 
 
2983 
  def send_validateReturnProduct(self, orderId, isUsable):
2984 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2985 
    args = validateReturnProduct_args()
2986 
    args.orderId = orderId
2987 
    args.isUsable = isUsable
2988 
    args.write(self._oprot)
2989 
    self._oprot.writeMessageEnd()
2990 
    self._oprot.trans.flush()
2991 
 
2992 
  def recv_validateReturnProduct(self, ):
2993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2994 
    if mtype == TMessageType.EXCEPTION:
2995 
      x = TApplicationException()
2996 
      x.read(self._iprot)
2997 
      self._iprot.readMessageEnd()
2998 
      raise x
2999 
    result = validateReturnProduct_result()
3000 
    result.read(self._iprot)
3001 
    self._iprot.readMessageEnd()
3002 
    if result.success is not None:
3003 
      return result.success
3004 
    if result.ex is not None:
3005 
      raise result.ex
3006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3007 
 
2616 chandransh 3008 
  def reshipOrder(self, orderId):
3009 
    """
4484 rajveer 3010 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3011 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3012 
    	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 3013 
 
3014 
    If the order is in DOA_CERT_VALID state, it does the following:
3015 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3016 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3017 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3018 
 
2616 chandransh 3019 
    Returns the id of the newly created order.
3431 rajveer 3020 
 
2616 chandransh 3021 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3022 
 
2616 chandransh 3023 
    Parameters:
3024 
     - orderId
3025 
    """
3026 
    self.send_reshipOrder(orderId)
3027 
    return self.recv_reshipOrder()
2591 chandransh 3028 
 
2616 chandransh 3029 
  def send_reshipOrder(self, orderId):
3030 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3031 
    args = reshipOrder_args()
3032 
    args.orderId = orderId
3033 
    args.write(self._oprot)
3034 
    self._oprot.writeMessageEnd()
3035 
    self._oprot.trans.flush()
3036 
 
3037 
  def recv_reshipOrder(self, ):
3038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3039 
    if mtype == TMessageType.EXCEPTION:
3040 
      x = TApplicationException()
3041 
      x.read(self._iprot)
3042 
      self._iprot.readMessageEnd()
3043 
      raise x
3044 
    result = reshipOrder_result()
3045 
    result.read(self._iprot)
3046 
    self._iprot.readMessageEnd()
3431 rajveer 3047 
    if result.success is not None:
2616 chandransh 3048 
      return result.success
3431 rajveer 3049 
    if result.ex is not None:
2616 chandransh 3050 
      raise result.ex
3051 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3052 
 
3226 chandransh 3053 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3054 
    """
4484 rajveer 3055 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3056 
    	1. Creates a refund request for batch processing.
3057 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3058 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3059 
 
2616 chandransh 3060 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3061 
    	1. Creates a refund request for batch processing.
3226 chandransh 3062 
    	2. Cancels the reservation of the item in the warehouse.
3063 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3064 
 
3226 chandransh 3065 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3066 
    	1. Cancels the reservation of the item in the warehouse.
3067 
    	2. Marks the current order as CANCELED.
3068 
 
3069 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3070 
 
2616 chandransh 3071 
    Returns True if it is successful, False otherwise.
3431 rajveer 3072 
 
2616 chandransh 3073 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3074 
 
2616 chandransh 3075 
    Parameters:
3076 
     - orderId
3226 chandransh 3077 
     - refundedBy
3078 
     - reason
2616 chandransh 3079 
    """
3226 chandransh 3080 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3081 
    return self.recv_refundOrder()
3082 
 
3226 chandransh 3083 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3084 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3085 
    args = refundOrder_args()
3086 
    args.orderId = orderId
3226 chandransh 3087 
    args.refundedBy = refundedBy
3088 
    args.reason = reason
2616 chandransh 3089 
    args.write(self._oprot)
3090 
    self._oprot.writeMessageEnd()
3091 
    self._oprot.trans.flush()
3092 
 
3093 
  def recv_refundOrder(self, ):
3094 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3095 
    if mtype == TMessageType.EXCEPTION:
3096 
      x = TApplicationException()
3097 
      x.read(self._iprot)
3098 
      self._iprot.readMessageEnd()
3099 
      raise x
3100 
    result = refundOrder_result()
3101 
    result.read(self._iprot)
3102 
    self._iprot.readMessageEnd()
3431 rajveer 3103 
    if result.success is not None:
2616 chandransh 3104 
      return result.success
3431 rajveer 3105 
    if result.ex is not None:
2616 chandransh 3106 
      raise result.ex
3107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3108 
 
2690 chandransh 3109 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3110 
    """
3111 
    Get all return orders created between the from and to dates for the given warehouse.
3112 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3113 
 
2690 chandransh 3114 
    Parameters:
3115 
     - warehouseId
3116 
     - fromDate
3117 
     - toDate
3118 
    """
3119 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3120 
    return self.recv_getReturnOrders()
2616 chandransh 3121 
 
2690 chandransh 3122 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3123 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3124 
    args = getReturnOrders_args()
3125 
    args.warehouseId = warehouseId
3126 
    args.fromDate = fromDate
3127 
    args.toDate = toDate
3128 
    args.write(self._oprot)
3129 
    self._oprot.writeMessageEnd()
3130 
    self._oprot.trans.flush()
3131 
 
3132 
  def recv_getReturnOrders(self, ):
3133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3134 
    if mtype == TMessageType.EXCEPTION:
3135 
      x = TApplicationException()
3136 
      x.read(self._iprot)
3137 
      self._iprot.readMessageEnd()
3138 
      raise x
3139 
    result = getReturnOrders_result()
3140 
    result.read(self._iprot)
3141 
    self._iprot.readMessageEnd()
3431 rajveer 3142 
    if result.success is not None:
2690 chandransh 3143 
      return result.success
3144 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3145 
 
2700 chandransh 3146 
  def getReturnOrder(self, id):
3147 
    """
3148 
    Returns the ReturnOrder corresponding to the given id.
3149 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3150 
 
2700 chandransh 3151 
    Parameters:
3152 
     - id
3153 
    """
3154 
    self.send_getReturnOrder(id)
3155 
    return self.recv_getReturnOrder()
3156 
 
3157 
  def send_getReturnOrder(self, id):
3158 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3159 
    args = getReturnOrder_args()
3160 
    args.id = id
3161 
    args.write(self._oprot)
3162 
    self._oprot.writeMessageEnd()
3163 
    self._oprot.trans.flush()
3164 
 
3165 
  def recv_getReturnOrder(self, ):
3166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3167 
    if mtype == TMessageType.EXCEPTION:
3168 
      x = TApplicationException()
3169 
      x.read(self._iprot)
3170 
      self._iprot.readMessageEnd()
3171 
      raise x
3172 
    result = getReturnOrder_result()
3173 
    result.read(self._iprot)
3174 
    self._iprot.readMessageEnd()
3431 rajveer 3175 
    if result.success is not None:
2700 chandransh 3176 
      return result.success
3431 rajveer 3177 
    if result.ex is not None:
2700 chandransh 3178 
      raise result.ex
3179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3180 
 
2690 chandransh 3181 
  def processReturn(self, returnOrderId):
3182 
    """
3183 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3184 
 
2690 chandransh 3185 
    Parameters:
3186 
     - returnOrderId
3187 
    """
3188 
    self.send_processReturn(returnOrderId)
3189 
    self.recv_processReturn()
3190 
 
3191 
  def send_processReturn(self, returnOrderId):
3192 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3193 
    args = processReturn_args()
3194 
    args.returnOrderId = returnOrderId
3195 
    args.write(self._oprot)
3196 
    self._oprot.writeMessageEnd()
3197 
    self._oprot.trans.flush()
3198 
 
3199 
  def recv_processReturn(self, ):
3200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3201 
    if mtype == TMessageType.EXCEPTION:
3202 
      x = TApplicationException()
3203 
      x.read(self._iprot)
3204 
      self._iprot.readMessageEnd()
3205 
      raise x
3206 
    result = processReturn_result()
3207 
    result.read(self._iprot)
3208 
    self._iprot.readMessageEnd()
3431 rajveer 3209 
    if result.ex is not None:
2690 chandransh 3210 
      raise result.ex
3211 
    return
3212 
 
3451 chandransh 3213 
  def updateWeight(self, orderId, weight):
3214 
    """
3215 
    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 3216 
 
3451 chandransh 3217 
    Parameters:
3218 
     - orderId
3219 
     - weight
3220 
    """
3221 
    self.send_updateWeight(orderId, weight)
3222 
    return self.recv_updateWeight()
3223 
 
3224 
  def send_updateWeight(self, orderId, weight):
3225 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3226 
    args = updateWeight_args()
3227 
    args.orderId = orderId
3228 
    args.weight = weight
3229 
    args.write(self._oprot)
3230 
    self._oprot.writeMessageEnd()
3231 
    self._oprot.trans.flush()
3232 
 
3233 
  def recv_updateWeight(self, ):
3234 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3235 
    if mtype == TMessageType.EXCEPTION:
3236 
      x = TApplicationException()
3237 
      x.read(self._iprot)
3238 
      self._iprot.readMessageEnd()
3239 
      raise x
3240 
    result = updateWeight_result()
3241 
    result.read(self._iprot)
3242 
    self._iprot.readMessageEnd()
3243 
    if result.success is not None:
3244 
      return result.success
3245 
    if result.ex is not None:
3246 
      raise result.ex
3247 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3248 
 
3469 chandransh 3249 
  def changeItem(self, orderId, itemId):
3250 
    """
3251 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3252 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3253 
 
3469 chandransh 3254 
    Parameters:
3255 
     - orderId
3256 
     - itemId
3257 
    """
3258 
    self.send_changeItem(orderId, itemId)
3259 
    return self.recv_changeItem()
3260 
 
3261 
  def send_changeItem(self, orderId, itemId):
3262 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3263 
    args = changeItem_args()
3264 
    args.orderId = orderId
3265 
    args.itemId = itemId
3266 
    args.write(self._oprot)
3267 
    self._oprot.writeMessageEnd()
3268 
    self._oprot.trans.flush()
3269 
 
3270 
  def recv_changeItem(self, ):
3271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3272 
    if mtype == TMessageType.EXCEPTION:
3273 
      x = TApplicationException()
3274 
      x.read(self._iprot)
3275 
      self._iprot.readMessageEnd()
3276 
      raise x
3277 
    result = changeItem_result()
3278 
    result.read(self._iprot)
3279 
    self._iprot.readMessageEnd()
3280 
    if result.success is not None:
3281 
      return result.success
3282 
    if result.ex is not None:
3283 
      raise result.ex
3284 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3285 
 
3286 
  def shiftToWarehouse(self, orderId, warehouseId):
3287 
    """
3288 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3289 
 
3290 
    Parameters:
3291 
     - orderId
3292 
     - warehouseId
3293 
    """
3294 
    self.send_shiftToWarehouse(orderId, warehouseId)
3295 
    return self.recv_shiftToWarehouse()
3296 
 
3297 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3298 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3299 
    args = shiftToWarehouse_args()
3300 
    args.orderId = orderId
3301 
    args.warehouseId = warehouseId
3302 
    args.write(self._oprot)
3303 
    self._oprot.writeMessageEnd()
3304 
    self._oprot.trans.flush()
3305 
 
3306 
  def recv_shiftToWarehouse(self, ):
3307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3308 
    if mtype == TMessageType.EXCEPTION:
3309 
      x = TApplicationException()
3310 
      x.read(self._iprot)
3311 
      self._iprot.readMessageEnd()
3312 
      raise x
3313 
    result = shiftToWarehouse_result()
3314 
    result.read(self._iprot)
3315 
    self._iprot.readMessageEnd()
3316 
    if result.success is not None:
3317 
      return result.success
3318 
    if result.ex is not None:
3319 
      raise result.ex
3320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3321 
 
4647 rajveer 3322 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3323 
    """
3324 
    Adds the given delay reason to the given order.
3986 chandransh 3325 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3326 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3327 
 
3553 chandransh 3328 
    Parameters:
3329 
     - orderId
3330 
     - delayReason
3986 chandransh 3331 
     - furtherDelay
4647 rajveer 3332 
     - delayReasonText
3553 chandransh 3333 
    """
4647 rajveer 3334 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3335 
    return self.recv_addDelayReason()
3336 
 
4647 rajveer 3337 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3338 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3339 
    args = addDelayReason_args()
3340 
    args.orderId = orderId
3341 
    args.delayReason = delayReason
3986 chandransh 3342 
    args.furtherDelay = furtherDelay
4647 rajveer 3343 
    args.delayReasonText = delayReasonText
3553 chandransh 3344 
    args.write(self._oprot)
3345 
    self._oprot.writeMessageEnd()
3346 
    self._oprot.trans.flush()
3347 
 
3348 
  def recv_addDelayReason(self, ):
3349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3350 
    if mtype == TMessageType.EXCEPTION:
3351 
      x = TApplicationException()
3352 
      x.read(self._iprot)
3353 
      self._iprot.readMessageEnd()
3354 
      raise x
3355 
    result = addDelayReason_result()
3356 
    result.read(self._iprot)
3357 
    self._iprot.readMessageEnd()
3358 
    if result.success is not None:
3359 
      return result.success
3360 
    if result.ex is not None:
3361 
      raise result.ex
3362 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3363 
 
3956 chandransh 3364 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3365 
    """
3366 
    Marks the COD orders with given AWB nos. as having been processed.
3367 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3368 
 
3956 chandransh 3369 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3370 
    1. There is no order corresponding to an AWB number.
3371 
    2. The captured amount for a payment exceeds the total payment.
3372 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3373 
 
3374 
    Parameters:
3375 
     - collectedAmountMap
3376 
     - xferBy
3377 
     - xferTxnId
3378 
     - xferDate
3379 
    """
3380 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3381 
    return self.recv_reconcileCodCollection()
3382 
 
3383 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3384 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3385 
    args = reconcileCodCollection_args()
3386 
    args.collectedAmountMap = collectedAmountMap
3387 
    args.xferBy = xferBy
3388 
    args.xferTxnId = xferTxnId
3389 
    args.xferDate = xferDate
3390 
    args.write(self._oprot)
3391 
    self._oprot.writeMessageEnd()
3392 
    self._oprot.trans.flush()
3393 
 
3394 
  def recv_reconcileCodCollection(self, ):
3395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3396 
    if mtype == TMessageType.EXCEPTION:
3397 
      x = TApplicationException()
3398 
      x.read(self._iprot)
3399 
      self._iprot.readMessageEnd()
3400 
      raise x
3401 
    result = reconcileCodCollection_result()
3402 
    result.read(self._iprot)
3403 
    self._iprot.readMessageEnd()
3404 
    if result.success is not None:
3405 
      return result.success
3406 
    if result.ex is not None:
3407 
      raise result.ex
3408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3409 
 
4008 mandeep.dh 3410 
  def getTransactionsRequiringExtraProcessing(self, category):
3411 
    """
4065 mandeep.dh 3412 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3413 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3414 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3415 
 
4008 mandeep.dh 3416 
    Parameters:
3417 
     - category
3418 
    """
3419 
    self.send_getTransactionsRequiringExtraProcessing(category)
3420 
    return self.recv_getTransactionsRequiringExtraProcessing()
3421 
 
3422 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3423 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3424 
    args = getTransactionsRequiringExtraProcessing_args()
3425 
    args.category = category
3426 
    args.write(self._oprot)
3427 
    self._oprot.writeMessageEnd()
3428 
    self._oprot.trans.flush()
3429 
 
3430 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3432 
    if mtype == TMessageType.EXCEPTION:
3433 
      x = TApplicationException()
3434 
      x.read(self._iprot)
3435 
      self._iprot.readMessageEnd()
3436 
      raise x
3437 
    result = getTransactionsRequiringExtraProcessing_result()
3438 
    result.read(self._iprot)
3439 
    self._iprot.readMessageEnd()
3440 
    if result.success is not None:
3441 
      return result.success
3442 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3443 
 
3444 
  def markTransactionAsProcessed(self, transactionId, category):
3445 
    """
3446 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3447 
    It essentially deletes the transaction id record for a particular
3448 
    processing type category (if present) from DB.
3449 
    This is currently used by CRM application.
4008 mandeep.dh 3450 
 
3451 
    Parameters:
3452 
     - transactionId
3453 
     - category
3454 
    """
3455 
    self.send_markTransactionAsProcessed(transactionId, category)
3456 
    self.recv_markTransactionAsProcessed()
3457 
 
3458 
  def send_markTransactionAsProcessed(self, transactionId, category):
3459 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3460 
    args = markTransactionAsProcessed_args()
3461 
    args.transactionId = transactionId
3462 
    args.category = category
3463 
    args.write(self._oprot)
3464 
    self._oprot.writeMessageEnd()
3465 
    self._oprot.trans.flush()
3466 
 
3467 
  def recv_markTransactionAsProcessed(self, ):
3468 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3469 
    if mtype == TMessageType.EXCEPTION:
3470 
      x = TApplicationException()
3471 
      x.read(self._iprot)
3472 
      self._iprot.readMessageEnd()
3473 
      raise x
3474 
    result = markTransactionAsProcessed_result()
3475 
    result.read(self._iprot)
3476 
    self._iprot.readMessageEnd()
3477 
    return
3478 
 
4018 chandransh 3479 
  def getItemWiseRiskyOrdersCount(self, ):
3480 
    """
3481 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3482 
    is defined as one whose shipping date is about to expire.
3483 
    """
3484 
    self.send_getItemWiseRiskyOrdersCount()
3485 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3486 
 
4018 chandransh 3487 
  def send_getItemWiseRiskyOrdersCount(self, ):
3488 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3489 
    args = getItemWiseRiskyOrdersCount_args()
3490 
    args.write(self._oprot)
3491 
    self._oprot.writeMessageEnd()
3492 
    self._oprot.trans.flush()
3493 
 
3494 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3496 
    if mtype == TMessageType.EXCEPTION:
3497 
      x = TApplicationException()
3498 
      x.read(self._iprot)
3499 
      self._iprot.readMessageEnd()
3500 
      raise x
3501 
    result = getItemWiseRiskyOrdersCount_result()
3502 
    result.read(self._iprot)
3503 
    self._iprot.readMessageEnd()
3504 
    if result.success is not None:
3505 
      return result.success
3506 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3507 
 
4295 varun.gupt 3508 
  def getOrdersForItemIds(self, itemIds):
3509 
    """
3510 
    Returns a list of all orders which have items with given id
3511 
 
3512 
    Parameters:
3513 
     - itemIds
3514 
    """
3515 
    self.send_getOrdersForItemIds(itemIds)
3516 
    return self.recv_getOrdersForItemIds()
3517 
 
3518 
  def send_getOrdersForItemIds(self, itemIds):
3519 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3520 
    args = getOrdersForItemIds_args()
3521 
    args.itemIds = itemIds
3522 
    args.write(self._oprot)
3523 
    self._oprot.writeMessageEnd()
3524 
    self._oprot.trans.flush()
3525 
 
3526 
  def recv_getOrdersForItemIds(self, ):
3527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3528 
    if mtype == TMessageType.EXCEPTION:
3529 
      x = TApplicationException()
3530 
      x.read(self._iprot)
3531 
      self._iprot.readMessageEnd()
3532 
      raise x
3533 
    result = getOrdersForItemIds_result()
3534 
    result.read(self._iprot)
3535 
    self._iprot.readMessageEnd()
3536 
    if result.success is not None:
3537 
      return result.success
3538 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3539 
 
4247 rajveer 3540 
  def markOrderCancellationRequestReceived(self, orderId):
3541 
    """
3542 
    Mark order as cancellation request received. If customer sends request of cancellation of
3543 
    a particular order, this method will be called. It will just change status of the order
3544 
    depending on its current status. It also records the previous status, so that we can move
3545 
    back to that status if cancellation request is denied.
4018 chandransh 3546 
 
4247 rajveer 3547 
    Parameters:
3548 
     - orderId
3549 
    """
3550 
    self.send_markOrderCancellationRequestReceived(orderId)
3551 
    self.recv_markOrderCancellationRequestReceived()
3552 
 
3553 
  def send_markOrderCancellationRequestReceived(self, orderId):
3554 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3555 
    args = markOrderCancellationRequestReceived_args()
3556 
    args.orderId = orderId
3557 
    args.write(self._oprot)
3558 
    self._oprot.writeMessageEnd()
3559 
    self._oprot.trans.flush()
3560 
 
3561 
  def recv_markOrderCancellationRequestReceived(self, ):
3562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3563 
    if mtype == TMessageType.EXCEPTION:
3564 
      x = TApplicationException()
3565 
      x.read(self._iprot)
3566 
      self._iprot.readMessageEnd()
3567 
      raise x
3568 
    result = markOrderCancellationRequestReceived_result()
3569 
    result.read(self._iprot)
3570 
    self._iprot.readMessageEnd()
3571 
    if result.ex is not None:
3572 
      raise result.ex
3573 
    return
3574 
 
3575 
  def markOrderCancellationRequestConfirmed(self, orderId):
3576 
    """
3577 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3578 
    cancellation request confirmed. After this OM will be able to cancel the order.
3579 
 
3580 
    Parameters:
3581 
     - orderId
3582 
    """
3583 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3584 
    self.recv_markOrderCancellationRequestConfirmed()
3585 
 
3586 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3587 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3588 
    args = markOrderCancellationRequestConfirmed_args()
3589 
    args.orderId = orderId
3590 
    args.write(self._oprot)
3591 
    self._oprot.writeMessageEnd()
3592 
    self._oprot.trans.flush()
3593 
 
3594 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3596 
    if mtype == TMessageType.EXCEPTION:
3597 
      x = TApplicationException()
3598 
      x.read(self._iprot)
3599 
      self._iprot.readMessageEnd()
3600 
      raise x
3601 
    result = markOrderCancellationRequestConfirmed_result()
3602 
    result.read(self._iprot)
3603 
    self._iprot.readMessageEnd()
3604 
    if result.ex is not None:
3605 
      raise result.ex
3606 
    return
3607 
 
3608 
  def markOrderCancellationRequestDenied(self, orderId):
3609 
    """
3610 
    If we decide to not to cancel order, we will move the order ro previous status.
3611 
 
3612 
    Parameters:
3613 
     - orderId
3614 
    """
3615 
    self.send_markOrderCancellationRequestDenied(orderId)
3616 
    self.recv_markOrderCancellationRequestDenied()
3617 
 
3618 
  def send_markOrderCancellationRequestDenied(self, orderId):
3619 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3620 
    args = markOrderCancellationRequestDenied_args()
3621 
    args.orderId = orderId
3622 
    args.write(self._oprot)
3623 
    self._oprot.writeMessageEnd()
3624 
    self._oprot.trans.flush()
3625 
 
3626 
  def recv_markOrderCancellationRequestDenied(self, ):
3627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3628 
    if mtype == TMessageType.EXCEPTION:
3629 
      x = TApplicationException()
3630 
      x.read(self._iprot)
3631 
      self._iprot.readMessageEnd()
3632 
      raise x
3633 
    result = markOrderCancellationRequestDenied_result()
3634 
    result.read(self._iprot)
3635 
    self._iprot.readMessageEnd()
3636 
    if result.ex is not None:
3637 
      raise result.ex
3638 
    return
3639 
 
4258 rajveer 3640 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3641 
    """
4258 rajveer 3642 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3643 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3644 
 
3645 
    Parameters:
4258 rajveer 3646 
     - transactionId
4247 rajveer 3647 
    """
4258 rajveer 3648 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3649 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3650 
 
4258 rajveer 3651 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3652 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3653 
    args = markTransactionAsPaymentFlagRemoved_args()
3654 
    args.transactionId = transactionId
4247 rajveer 3655 
    args.write(self._oprot)
3656 
    self._oprot.writeMessageEnd()
3657 
    self._oprot.trans.flush()
3658 
 
4258 rajveer 3659 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3661 
    if mtype == TMessageType.EXCEPTION:
3662 
      x = TApplicationException()
3663 
      x.read(self._iprot)
3664 
      self._iprot.readMessageEnd()
3665 
      raise x
4258 rajveer 3666 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3667 
    result.read(self._iprot)
3668 
    self._iprot.readMessageEnd()
3669 
    if result.ex is not None:
3670 
      raise result.ex
3671 
    return
3672 
 
4259 anupam.sin 3673 
  def refundTransaction(self, transactionId, refundedBy, reason):
3674 
    """
3675 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3676 
    need to be cancelled
4247 rajveer 3677 
 
4259 anupam.sin 3678 
    Parameters:
3679 
     - transactionId
3680 
     - refundedBy
3681 
     - reason
3682 
    """
3683 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3684 
    self.recv_refundTransaction()
3685 
 
3686 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3687 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3688 
    args = refundTransaction_args()
3689 
    args.transactionId = transactionId
3690 
    args.refundedBy = refundedBy
3691 
    args.reason = reason
3692 
    args.write(self._oprot)
3693 
    self._oprot.writeMessageEnd()
3694 
    self._oprot.trans.flush()
3695 
 
3696 
  def recv_refundTransaction(self, ):
3697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3698 
    if mtype == TMessageType.EXCEPTION:
3699 
      x = TApplicationException()
3700 
      x.read(self._iprot)
3701 
      self._iprot.readMessageEnd()
3702 
      raise x
3703 
    result = refundTransaction_result()
3704 
    result.read(self._iprot)
3705 
    self._iprot.readMessageEnd()
3706 
    if result.ex is not None:
3707 
      raise result.ex
3708 
    return
3709 
 
4324 mandeep.dh 3710 
  def updateShipmentAddress(self, orderId, addressId):
3711 
    """
3712 
    Updates shipment address of an order. Delivery and shipping date estimates
3713 
    etc. are also updated here.
3714 
 
3715 
    Throws TransactionServiceException in case address change is not
3716 
    possible due to certain reasons such as new pincode in address is
3717 
    not serviceable etc.
3718 
 
3719 
    Parameters:
3720 
     - orderId
3721 
     - addressId
3722 
    """
3723 
    self.send_updateShipmentAddress(orderId, addressId)
3724 
    self.recv_updateShipmentAddress()
3725 
 
3726 
  def send_updateShipmentAddress(self, orderId, addressId):
3727 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3728 
    args = updateShipmentAddress_args()
3729 
    args.orderId = orderId
3730 
    args.addressId = addressId
3731 
    args.write(self._oprot)
3732 
    self._oprot.writeMessageEnd()
3733 
    self._oprot.trans.flush()
3734 
 
3735 
  def recv_updateShipmentAddress(self, ):
3736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3737 
    if mtype == TMessageType.EXCEPTION:
3738 
      x = TApplicationException()
3739 
      x.read(self._iprot)
3740 
      self._iprot.readMessageEnd()
3741 
      raise x
3742 
    result = updateShipmentAddress_result()
3743 
    result.read(self._iprot)
3744 
    self._iprot.readMessageEnd()
3745 
    if result.ex is not None:
3746 
      raise result.ex
3747 
    return
3748 
 
4285 rajveer 3749 
  def acceptOrdersForItemId(self, itemId, inventory):
3750 
    """
3751 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3752 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3753 
 
4285 rajveer 3754 
    Parameters:
3755 
     - itemId
3756 
     - inventory
3757 
    """
3758 
    self.send_acceptOrdersForItemId(itemId, inventory)
3759 
    return self.recv_acceptOrdersForItemId()
3760 
 
3761 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3762 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3763 
    args = acceptOrdersForItemId_args()
3764 
    args.itemId = itemId
3765 
    args.inventory = inventory
3766 
    args.write(self._oprot)
3767 
    self._oprot.writeMessageEnd()
3768 
    self._oprot.trans.flush()
3769 
 
3770 
  def recv_acceptOrdersForItemId(self, ):
3771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3772 
    if mtype == TMessageType.EXCEPTION:
3773 
      x = TApplicationException()
3774 
      x.read(self._iprot)
3775 
      self._iprot.readMessageEnd()
3776 
      raise x
3777 
    result = acceptOrdersForItemId_result()
3778 
    result.read(self._iprot)
3779 
    self._iprot.readMessageEnd()
3780 
    if result.success is not None:
3781 
      return result.success
3782 
    if result.ex is not None:
3783 
      raise result.ex
3784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3785 
 
4369 rajveer 3786 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3787 
    """
3788 
    Parameters:
3789 
     - vendorId
3790 
     - itemId
3791 
     - quantity
3792 
     - estimate
4369 rajveer 3793 
     - isReminder
4303 rajveer 3794 
    """
4369 rajveer 3795 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3796 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3797 
 
4369 rajveer 3798 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3799 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3800 
    args = markOrdersAsPORaised_args()
3801 
    args.vendorId = vendorId
3802 
    args.itemId = itemId
3803 
    args.quantity = quantity
3804 
    args.estimate = estimate
4369 rajveer 3805 
    args.isReminder = isReminder
4303 rajveer 3806 
    args.write(self._oprot)
3807 
    self._oprot.writeMessageEnd()
3808 
    self._oprot.trans.flush()
3809 
 
3810 
  def recv_markOrdersAsPORaised(self, ):
3811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3812 
    if mtype == TMessageType.EXCEPTION:
3813 
      x = TApplicationException()
3814 
      x.read(self._iprot)
3815 
      self._iprot.readMessageEnd()
3816 
      raise x
3817 
    result = markOrdersAsPORaised_result()
3818 
    result.read(self._iprot)
3819 
    self._iprot.readMessageEnd()
3820 
    if result.ex is not None:
3821 
      raise result.ex
3822 
    return
3823 
 
4369 rajveer 3824 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3825 
    """
3826 
    Parameters:
3827 
     - vendorId
3828 
     - itemId
3829 
     - quantity
3830 
     - estimate
4369 rajveer 3831 
     - isReminder
4303 rajveer 3832 
    """
4369 rajveer 3833 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3834 
    self.recv_markOrdersAsReversalInitiated()
3835 
 
4369 rajveer 3836 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3837 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3838 
    args = markOrdersAsReversalInitiated_args()
3839 
    args.vendorId = vendorId
3840 
    args.itemId = itemId
3841 
    args.quantity = quantity
3842 
    args.estimate = estimate
4369 rajveer 3843 
    args.isReminder = isReminder
4303 rajveer 3844 
    args.write(self._oprot)
3845 
    self._oprot.writeMessageEnd()
3846 
    self._oprot.trans.flush()
3847 
 
3848 
  def recv_markOrdersAsReversalInitiated(self, ):
3849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3850 
    if mtype == TMessageType.EXCEPTION:
3851 
      x = TApplicationException()
3852 
      x.read(self._iprot)
3853 
      self._iprot.readMessageEnd()
3854 
      raise x
3855 
    result = markOrdersAsReversalInitiated_result()
3856 
    result.read(self._iprot)
3857 
    self._iprot.readMessageEnd()
3858 
    if result.ex is not None:
3859 
      raise result.ex
3860 
    return
3861 
 
4369 rajveer 3862 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3863 
    """
3864 
    Parameters:
3865 
     - vendorId
3866 
     - itemId
3867 
     - quantity
3868 
     - estimate
4369 rajveer 3869 
     - isReminder
4303 rajveer 3870 
    """
4369 rajveer 3871 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3872 
    self.recv_markOrdersAsNotAvailabke()
3873 
 
4369 rajveer 3874 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3875 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3876 
    args = markOrdersAsNotAvailabke_args()
3877 
    args.vendorId = vendorId
3878 
    args.itemId = itemId
3879 
    args.quantity = quantity
3880 
    args.estimate = estimate
4369 rajveer 3881 
    args.isReminder = isReminder
4303 rajveer 3882 
    args.write(self._oprot)
3883 
    self._oprot.writeMessageEnd()
3884 
    self._oprot.trans.flush()
3885 
 
3886 
  def recv_markOrdersAsNotAvailabke(self, ):
3887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3888 
    if mtype == TMessageType.EXCEPTION:
3889 
      x = TApplicationException()
3890 
      x.read(self._iprot)
3891 
      self._iprot.readMessageEnd()
3892 
      raise x
3893 
    result = markOrdersAsNotAvailabke_result()
3894 
    result.read(self._iprot)
3895 
    self._iprot.readMessageEnd()
3896 
    if result.ex is not None:
3897 
      raise result.ex
3898 
    return
3899 
 
4369 rajveer 3900 
  def markOrdersAsTimeout(self, vendorId):
3901 
    """
3902 
    Parameters:
3903 
     - vendorId
3904 
    """
3905 
    self.send_markOrdersAsTimeout(vendorId)
3906 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3907 
 
4369 rajveer 3908 
  def send_markOrdersAsTimeout(self, vendorId):
3909 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3910 
    args = markOrdersAsTimeout_args()
3911 
    args.vendorId = vendorId
3912 
    args.write(self._oprot)
3913 
    self._oprot.writeMessageEnd()
3914 
    self._oprot.trans.flush()
3915 
 
3916 
  def recv_markOrdersAsTimeout(self, ):
3917 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3918 
    if mtype == TMessageType.EXCEPTION:
3919 
      x = TApplicationException()
3920 
      x.read(self._iprot)
3921 
      self._iprot.readMessageEnd()
3922 
      raise x
3923 
    result = markOrdersAsTimeout_result()
3924 
    result.read(self._iprot)
3925 
    self._iprot.readMessageEnd()
3926 
    if result.success is not None:
3927 
      return result.success
3928 
    if result.ex is not None:
3929 
      raise result.ex
3930 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3931 
 
4662 rajveer 3932 
  def markOrderAsLostInTransit(self, orderId):
3933 
    """
3934 
    Mark order as LOST_IN_TRANSIT
3935 
 
3936 
    Parameters:
3937 
     - orderId
3938 
    """
3939 
    self.send_markOrderAsLostInTransit(orderId)
3940 
    return self.recv_markOrderAsLostInTransit()
3941 
 
3942 
  def send_markOrderAsLostInTransit(self, orderId):
3943 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
3944 
    args = markOrderAsLostInTransit_args()
3945 
    args.orderId = orderId
3946 
    args.write(self._oprot)
3947 
    self._oprot.writeMessageEnd()
3948 
    self._oprot.trans.flush()
3949 
 
3950 
  def recv_markOrderAsLostInTransit(self, ):
3951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3952 
    if mtype == TMessageType.EXCEPTION:
3953 
      x = TApplicationException()
3954 
      x.read(self._iprot)
3955 
      self._iprot.readMessageEnd()
3956 
      raise x
3957 
    result = markOrderAsLostInTransit_result()
3958 
    result.read(self._iprot)
3959 
    self._iprot.readMessageEnd()
3960 
    if result.success is not None:
3961 
      return result.success
3962 
    if result.ex is not None:
3963 
      raise result.ex
3964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
3965 
 
4386 anupam.sin 3966 
  def getOrderForAwb(self, awb):
3967 
    """
3968 
    Returns the order corresponding to an AWB number
4369 rajveer 3969 
 
4386 anupam.sin 3970 
    Parameters:
3971 
     - awb
3972 
    """
3973 
    self.send_getOrderForAwb(awb)
3974 
    return self.recv_getOrderForAwb()
3975 
 
3976 
  def send_getOrderForAwb(self, awb):
3977 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3978 
    args = getOrderForAwb_args()
3979 
    args.awb = awb
3980 
    args.write(self._oprot)
3981 
    self._oprot.writeMessageEnd()
3982 
    self._oprot.trans.flush()
3983 
 
3984 
  def recv_getOrderForAwb(self, ):
3985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3986 
    if mtype == TMessageType.EXCEPTION:
3987 
      x = TApplicationException()
3988 
      x.read(self._iprot)
3989 
      self._iprot.readMessageEnd()
3990 
      raise x
3991 
    result = getOrderForAwb_result()
3992 
    result.read(self._iprot)
3993 
    self._iprot.readMessageEnd()
3994 
    if result.success is not None:
3995 
      return result.success
3996 
    if result.ex is not None:
3997 
      raise result.ex
3998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3999 
 
4506 phani.kuma 4000 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
4001 
    """
4002 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 4003 
 
4506 phani.kuma 4004 
    Parameters:
4005 
     - logistics_provider_id
4006 
     - order_status
4007 
    """
4008 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
4009 
    return self.recv_getOrdersForProviderForStatus()
4010 
 
4011 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
4012 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4013 
    args = getOrdersForProviderForStatus_args()
4014 
    args.logistics_provider_id = logistics_provider_id
4015 
    args.order_status = order_status
4016 
    args.write(self._oprot)
4017 
    self._oprot.writeMessageEnd()
4018 
    self._oprot.trans.flush()
4019 
 
4020 
  def recv_getOrdersForProviderForStatus(self, ):
4021 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4022 
    if mtype == TMessageType.EXCEPTION:
4023 
      x = TApplicationException()
4024 
      x.read(self._iprot)
4025 
      self._iprot.readMessageEnd()
4026 
      raise x
4027 
    result = getOrdersForProviderForStatus_result()
4028 
    result.read(self._iprot)
4029 
    self._iprot.readMessageEnd()
4030 
    if result.success is not None:
4031 
      return result.success
4032 
    if result.ex is not None:
4033 
      raise result.ex
4034 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4035 
 
4600 varun.gupt 4036 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4037 
    """
4038 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4039 
 
4600 varun.gupt 4040 
    Parameters:
4041 
     - vendorId
4042 
     - billingDateFrom
4043 
     - billingDateTo
4044 
    """
4045 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4046 
    return self.recv_getBilledOrdersForVendor()
4047 
 
4048 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4049 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4050 
    args = getBilledOrdersForVendor_args()
4051 
    args.vendorId = vendorId
4052 
    args.billingDateFrom = billingDateFrom
4053 
    args.billingDateTo = billingDateTo
4054 
    args.write(self._oprot)
4055 
    self._oprot.writeMessageEnd()
4056 
    self._oprot.trans.flush()
4057 
 
4058 
  def recv_getBilledOrdersForVendor(self, ):
4059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4060 
    if mtype == TMessageType.EXCEPTION:
4061 
      x = TApplicationException()
4062 
      x.read(self._iprot)
4063 
      self._iprot.readMessageEnd()
4064 
      raise x
4065 
    result = getBilledOrdersForVendor_result()
4066 
    result.read(self._iprot)
4067 
    self._iprot.readMessageEnd()
4068 
    if result.success is not None:
4069 
      return result.success
4070 
    if result.ex is not None:
4071 
      raise result.ex
4072 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4073 
 
4607 rajveer 4074 
  def getSlippedSippingDateOrders(self, ):
4075 
    self.send_getSlippedSippingDateOrders()
4076 
    return self.recv_getSlippedSippingDateOrders()
4077 
 
4078 
  def send_getSlippedSippingDateOrders(self, ):
4079 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4080 
    args = getSlippedSippingDateOrders_args()
4081 
    args.write(self._oprot)
4082 
    self._oprot.writeMessageEnd()
4083 
    self._oprot.trans.flush()
4084 
 
4085 
  def recv_getSlippedSippingDateOrders(self, ):
4086 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4087 
    if mtype == TMessageType.EXCEPTION:
4088 
      x = TApplicationException()
4089 
      x.read(self._iprot)
4090 
      self._iprot.readMessageEnd()
4091 
      raise x
4092 
    result = getSlippedSippingDateOrders_result()
4093 
    result.read(self._iprot)
4094 
    self._iprot.readMessageEnd()
4095 
    if result.success is not None:
4096 
      return result.success
4097 
    if result.ex is not None:
4098 
      raise result.ex
4099 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4100 
 
4709 rajveer 4101 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4102 
    """
4103 
    Parameters:
4104 
     - cancelDateFrom
4105 
     - cancelDateTo
4106 
    """
4107 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4108 
    return self.recv_getCancelledOrders()
4109 
 
4110 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4111 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4112 
    args = getCancelledOrders_args()
4113 
    args.cancelDateFrom = cancelDateFrom
4114 
    args.cancelDateTo = cancelDateTo
4115 
    args.write(self._oprot)
4116 
    self._oprot.writeMessageEnd()
4117 
    self._oprot.trans.flush()
4118 
 
4119 
  def recv_getCancelledOrders(self, ):
4120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4121 
    if mtype == TMessageType.EXCEPTION:
4122 
      x = TApplicationException()
4123 
      x.read(self._iprot)
4124 
      self._iprot.readMessageEnd()
4125 
      raise x
4126 
    result = getCancelledOrders_result()
4127 
    result.read(self._iprot)
4128 
    self._iprot.readMessageEnd()
4129 
    if result.success is not None:
4130 
      return result.success
4131 
    if result.ex is not None:
4132 
      raise result.ex
4133 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4134 
 
4600 varun.gupt 4135 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4136 
    """
4137 
    Parameters:
4138 
     - mapAWBAndAmount
4139 
    """
4140 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4141 
    self.recv_saveBluedartSettlements()
4142 
 
4143 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4144 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4145 
    args = saveBluedartSettlements_args()
4146 
    args.mapAWBAndAmount = mapAWBAndAmount
4147 
    args.write(self._oprot)
4148 
    self._oprot.writeMessageEnd()
4149 
    self._oprot.trans.flush()
4150 
 
4151 
  def recv_saveBluedartSettlements(self, ):
4152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4153 
    if mtype == TMessageType.EXCEPTION:
4154 
      x = TApplicationException()
4155 
      x.read(self._iprot)
4156 
      self._iprot.readMessageEnd()
4157 
      raise x
4158 
    result = saveBluedartSettlements_result()
4159 
    result.read(self._iprot)
4160 
    self._iprot.readMessageEnd()
4161 
    if result.ex is not None:
4162 
      raise result.ex
4163 
    return
4164 
 
4905 varun.gupt 4165 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4166 
    """
4167 
    Parameters:
4168 
     - settlementDate
4169 
     - paymentGatewayId
4905 varun.gupt 4170 
     - referenceId
4600 varun.gupt 4171 
     - serviceTax
4172 
     - otherCharges
4173 
     - netCollection
4174 
    """
4905 varun.gupt 4175 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4176 
    self.recv_savePaymentSettlements()
4177 
 
4905 varun.gupt 4178 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4179 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4180 
    args = savePaymentSettlements_args()
4181 
    args.settlementDate = settlementDate
4182 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4183 
    args.referenceId = referenceId
4600 varun.gupt 4184 
    args.serviceTax = serviceTax
4185 
    args.otherCharges = otherCharges
4186 
    args.netCollection = netCollection
4187 
    args.write(self._oprot)
4188 
    self._oprot.writeMessageEnd()
4189 
    self._oprot.trans.flush()
4190 
 
4191 
  def recv_savePaymentSettlements(self, ):
4192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4193 
    if mtype == TMessageType.EXCEPTION:
4194 
      x = TApplicationException()
4195 
      x.read(self._iprot)
4196 
      self._iprot.readMessageEnd()
4197 
      raise x
4198 
    result = savePaymentSettlements_result()
4199 
    result.read(self._iprot)
4200 
    self._iprot.readMessageEnd()
4201 
    if result.ex is not None:
4202 
      raise result.ex
4203 
    return
4204 
 
4205 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4206 
    """
4207 
    Parameters:
4208 
     - settlementId
4209 
     - settlementDate
4210 
     - transactionDateFrom
4211 
     - transactionDateTo
4212 
     - amount
4213 
    """
4214 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4215 
    self.recv_saveEBSSettlementSummary()
4216 
 
4217 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4218 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4219 
    args = saveEBSSettlementSummary_args()
4220 
    args.settlementId = settlementId
4221 
    args.settlementDate = settlementDate
4222 
    args.transactionDateFrom = transactionDateFrom
4223 
    args.transactionDateTo = transactionDateTo
4224 
    args.amount = amount
4225 
    args.write(self._oprot)
4226 
    self._oprot.writeMessageEnd()
4227 
    self._oprot.trans.flush()
4228 
 
4229 
  def recv_saveEBSSettlementSummary(self, ):
4230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4231 
    if mtype == TMessageType.EXCEPTION:
4232 
      x = TApplicationException()
4233 
      x.read(self._iprot)
4234 
      self._iprot.readMessageEnd()
4235 
      raise x
4236 
    result = saveEBSSettlementSummary_result()
4237 
    result.read(self._iprot)
4238 
    self._iprot.readMessageEnd()
4239 
    if result.ex is not None:
4240 
      raise result.ex
4241 
    return
4242 
 
4243 
  def getSettlementForPaymentId(self, paymentId):
4244 
    """
4245 
    Parameters:
4246 
     - paymentId
4247 
    """
4248 
    self.send_getSettlementForPaymentId(paymentId)
4249 
    return self.recv_getSettlementForPaymentId()
4250 
 
4251 
  def send_getSettlementForPaymentId(self, paymentId):
4252 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4253 
    args = getSettlementForPaymentId_args()
4254 
    args.paymentId = paymentId
4255 
    args.write(self._oprot)
4256 
    self._oprot.writeMessageEnd()
4257 
    self._oprot.trans.flush()
4258 
 
4259 
  def recv_getSettlementForPaymentId(self, ):
4260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4261 
    if mtype == TMessageType.EXCEPTION:
4262 
      x = TApplicationException()
4263 
      x.read(self._iprot)
4264 
      self._iprot.readMessageEnd()
4265 
      raise x
4266 
    result = getSettlementForPaymentId_result()
4267 
    result.read(self._iprot)
4268 
    self._iprot.readMessageEnd()
4269 
    if result.success is not None:
4270 
      return result.success
4271 
    if result.ex is not None:
4272 
      raise result.ex
4273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4274 
 
4275 
  def getEBSSettlementSummaries(self, ):
4276 
    self.send_getEBSSettlementSummaries()
4277 
    return self.recv_getEBSSettlementSummaries()
4278 
 
4279 
  def send_getEBSSettlementSummaries(self, ):
4280 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4281 
    args = getEBSSettlementSummaries_args()
4282 
    args.write(self._oprot)
4283 
    self._oprot.writeMessageEnd()
4284 
    self._oprot.trans.flush()
4285 
 
4286 
  def recv_getEBSSettlementSummaries(self, ):
4287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4288 
    if mtype == TMessageType.EXCEPTION:
4289 
      x = TApplicationException()
4290 
      x.read(self._iprot)
4291 
      self._iprot.readMessageEnd()
4292 
      raise x
4293 
    result = getEBSSettlementSummaries_result()
4294 
    result.read(self._iprot)
4295 
    self._iprot.readMessageEnd()
4296 
    if result.success is not None:
4297 
      return result.success
4298 
    if result.ex is not None:
4299 
      raise result.ex
4300 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4301 
 
4302 
  def markEBSSettlementUploaded(self, settlementId):
4303 
    """
4304 
    Parameters:
4305 
     - settlementId
4306 
    """
4307 
    self.send_markEBSSettlementUploaded(settlementId)
4308 
    self.recv_markEBSSettlementUploaded()
4309 
 
4310 
  def send_markEBSSettlementUploaded(self, settlementId):
4311 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4312 
    args = markEBSSettlementUploaded_args()
4313 
    args.settlementId = settlementId
4314 
    args.write(self._oprot)
4315 
    self._oprot.writeMessageEnd()
4316 
    self._oprot.trans.flush()
4317 
 
4318 
  def recv_markEBSSettlementUploaded(self, ):
4319 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4320 
    if mtype == TMessageType.EXCEPTION:
4321 
      x = TApplicationException()
4322 
      x.read(self._iprot)
4323 
      self._iprot.readMessageEnd()
4324 
      raise x
4325 
    result = markEBSSettlementUploaded_result()
4326 
    result.read(self._iprot)
4327 
    self._iprot.readMessageEnd()
4328 
    if result.ex is not None:
4329 
      raise result.ex
4330 
    return
4331 
 
4332 
  def getEBSSettlementDate(self, settlementId):
4333 
    """
4334 
    Parameters:
4335 
     - settlementId
4336 
    """
4337 
    self.send_getEBSSettlementDate(settlementId)
4338 
    return self.recv_getEBSSettlementDate()
4339 
 
4340 
  def send_getEBSSettlementDate(self, settlementId):
4341 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4342 
    args = getEBSSettlementDate_args()
4343 
    args.settlementId = settlementId
4344 
    args.write(self._oprot)
4345 
    self._oprot.writeMessageEnd()
4346 
    self._oprot.trans.flush()
4347 
 
4348 
  def recv_getEBSSettlementDate(self, ):
4349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4350 
    if mtype == TMessageType.EXCEPTION:
4351 
      x = TApplicationException()
4352 
      x.read(self._iprot)
4353 
      self._iprot.readMessageEnd()
4354 
      raise x
4355 
    result = getEBSSettlementDate_result()
4356 
    result.read(self._iprot)
4357 
    self._iprot.readMessageEnd()
4358 
    if result.success is not None:
4359 
      return result.success
4360 
    if result.ex is not None:
4361 
      raise result.ex
4362 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4363 
 
4715 varun.gupt 4364 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4365 
    """
4366 
    Parameters:
4367 
     - settlementDateFrom
4368 
     - settlementDateTo
4369 
     - isRefund
4370 
    """
4371 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4372 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4373 
 
4715 varun.gupt 4374 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4375 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4376 
    args = getSettlementsByDate_args()
4377 
    args.settlementDateFrom = settlementDateFrom
4378 
    args.settlementDateTo = settlementDateTo
4379 
    args.isRefund = isRefund
4380 
    args.write(self._oprot)
4381 
    self._oprot.writeMessageEnd()
4382 
    self._oprot.trans.flush()
4383 
 
4384 
  def recv_getSettlementsByDate(self, ):
4385 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4386 
    if mtype == TMessageType.EXCEPTION:
4387 
      x = TApplicationException()
4388 
      x.read(self._iprot)
4389 
      self._iprot.readMessageEnd()
4390 
      raise x
4391 
    result = getSettlementsByDate_result()
4392 
    result.read(self._iprot)
4393 
    self._iprot.readMessageEnd()
4394 
    if result.success is not None:
4395 
      return result.success
4396 
    if result.ex is not None:
4397 
      raise result.ex
4398 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4399 
 
4400 
  def getReshippedOrderIds(self, orderIds):
4401 
    """
4402 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4403 
 
4404 
    Parameters:
4405 
     - orderIds
4406 
    """
4407 
    self.send_getReshippedOrderIds(orderIds)
4408 
    return self.recv_getReshippedOrderIds()
4409 
 
4410 
  def send_getReshippedOrderIds(self, orderIds):
4411 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4412 
    args = getReshippedOrderIds_args()
4413 
    args.orderIds = orderIds
4414 
    args.write(self._oprot)
4415 
    self._oprot.writeMessageEnd()
4416 
    self._oprot.trans.flush()
4417 
 
4418 
  def recv_getReshippedOrderIds(self, ):
4419 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4420 
    if mtype == TMessageType.EXCEPTION:
4421 
      x = TApplicationException()
4422 
      x.read(self._iprot)
4423 
      self._iprot.readMessageEnd()
4424 
      raise x
4425 
    result = getReshippedOrderIds_result()
4426 
    result.read(self._iprot)
4427 
    self._iprot.readMessageEnd()
4428 
    if result.success is not None:
4429 
      return result.success
4430 
    if result.ex is not None:
4431 
      raise result.ex
4432 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4433 
 
4757 mandeep.dh 4434 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4435 
    """
4436 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
4437 
    the quantities for which the PO is raised.
4715 varun.gupt 4438 
 
4757 mandeep.dh 4439 
    Parameters:
4440 
     - itemIdQuantityMap
4441 
     - purchaseOrderId
4442 
     - warehouseId
4443 
    """
4444 
    self.send_updateOrdersAsPORaised(itemIdQuantityMap, purchaseOrderId, warehouseId)
4445 
    self.recv_updateOrdersAsPORaised()
4446 
 
4447 
  def send_updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4448 
    self._oprot.writeMessageBegin('updateOrdersAsPORaised', TMessageType.CALL, self._seqid)
4449 
    args = updateOrdersAsPORaised_args()
4450 
    args.itemIdQuantityMap = itemIdQuantityMap
4451 
    args.purchaseOrderId = purchaseOrderId
4452 
    args.warehouseId = warehouseId
4453 
    args.write(self._oprot)
4454 
    self._oprot.writeMessageEnd()
4455 
    self._oprot.trans.flush()
4456 
 
4457 
  def recv_updateOrdersAsPORaised(self, ):
4458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4459 
    if mtype == TMessageType.EXCEPTION:
4460 
      x = TApplicationException()
4461 
      x.read(self._iprot)
4462 
      self._iprot.readMessageEnd()
4463 
      raise x
4464 
    result = updateOrdersAsPORaised_result()
4465 
    result.read(self._iprot)
4466 
    self._iprot.readMessageEnd()
4467 
    if result.ex is not None:
4468 
      raise result.ex
4469 
    return
4470 
 
4875 varun.gupt 4471 
  def getOrdersWhereVendorNotPaid(self, vendorId):
4472 
    """
4473 
    Parameters:
4474 
     - vendorId
4475 
    """
4476 
    self.send_getOrdersWhereVendorNotPaid(vendorId)
4477 
    return self.recv_getOrdersWhereVendorNotPaid()
4757 mandeep.dh 4478 
 
4875 varun.gupt 4479 
  def send_getOrdersWhereVendorNotPaid(self, vendorId):
4480 
    self._oprot.writeMessageBegin('getOrdersWhereVendorNotPaid', TMessageType.CALL, self._seqid)
4481 
    args = getOrdersWhereVendorNotPaid_args()
4482 
    args.vendorId = vendorId
4483 
    args.write(self._oprot)
4484 
    self._oprot.writeMessageEnd()
4485 
    self._oprot.trans.flush()
4486 
 
4487 
  def recv_getOrdersWhereVendorNotPaid(self, ):
4488 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4489 
    if mtype == TMessageType.EXCEPTION:
4490 
      x = TApplicationException()
4491 
      x.read(self._iprot)
4492 
      self._iprot.readMessageEnd()
4493 
      raise x
4494 
    result = getOrdersWhereVendorNotPaid_result()
4495 
    result.read(self._iprot)
4496 
    self._iprot.readMessageEnd()
4497 
    if result.success is not None:
4498 
      return result.success
4499 
    if result.ex is not None:
4500 
      raise result.ex
4501 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersWhereVendorNotPaid failed: unknown result");
4502 
 
4503 
 
3376 rajveer 4504 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4505 
  def __init__(self, handler):
3376 rajveer 4506 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4507 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4508 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4509 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4510 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4511 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4512 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4513 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4514 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4515 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4516 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4517 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4518 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4519 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4520 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4521 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4522 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4523 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4524 
    self._processMap["createOrder"] = Processor.process_createOrder
4525 
    self._processMap["getOrder"] = Processor.process_getOrder
4526 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4527 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4528 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4529 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4530 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4531 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4532 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4533 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4534 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4535 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4536 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4537 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4538 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4539 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4540 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 4541 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 4542 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4543 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 4544 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 4545 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 4546 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 4547 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 4548 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 4549 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 4550 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 4551 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4552 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4553 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4554 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4555 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4556 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4557 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4741 phani.kuma 4558 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
2616 chandransh 4559 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4560 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4561 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4562 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4563 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4564 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4565 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4566 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 4567 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4568 
    self._processMap["changeItem"] = Processor.process_changeItem
4569 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4570 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4571 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4572 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4573 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4574 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4575 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4576 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4577 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4578 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4579 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4580 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4581 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4582 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4583 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4584 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4585 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4586 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 4587 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 4588 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4589 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4590 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4591 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 4592 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 4593 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4594 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4595 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4596 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4597 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4598 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4599 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 4600 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
4601 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4757 mandeep.dh 4602 
    self._processMap["updateOrdersAsPORaised"] = Processor.process_updateOrdersAsPORaised
4875 varun.gupt 4603 
    self._processMap["getOrdersWhereVendorNotPaid"] = Processor.process_getOrdersWhereVendorNotPaid
94 ashish 4604 
 
4605 
  def process(self, iprot, oprot):
4606 
    (name, type, seqid) = iprot.readMessageBegin()
4607 
    if name not in self._processMap:
4608 
      iprot.skip(TType.STRUCT)
4609 
      iprot.readMessageEnd()
4610 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4611 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4612 
      x.write(oprot)
4613 
      oprot.writeMessageEnd()
4614 
      oprot.trans.flush()
4615 
      return
4616 
    else:
4617 
      self._processMap[name](self, seqid, iprot, oprot)
4618 
    return True
4619 
 
4620 
  def process_createTransaction(self, seqid, iprot, oprot):
4621 
    args = createTransaction_args()
4622 
    args.read(iprot)
4623 
    iprot.readMessageEnd()
4624 
    result = createTransaction_result()
4625 
    try:
132 ashish 4626 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4627 
    except TransactionServiceException, ex:
4628 
      result.ex = ex
4629 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4630 
    result.write(oprot)
4631 
    oprot.writeMessageEnd()
4632 
    oprot.trans.flush()
4633 
 
4634 
  def process_getTransaction(self, seqid, iprot, oprot):
4635 
    args = getTransaction_args()
4636 
    args.read(iprot)
4637 
    iprot.readMessageEnd()
4638 
    result = getTransaction_result()
4639 
    try:
4640 
      result.success = self._handler.getTransaction(args.id)
4641 
    except TransactionServiceException, ex:
4642 
      result.ex = ex
4643 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4644 
    result.write(oprot)
4645 
    oprot.writeMessageEnd()
4646 
    oprot.trans.flush()
4647 
 
4648 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4649 
    args = getTransactionsForCustomer_args()
4650 
    args.read(iprot)
4651 
    iprot.readMessageEnd()
4652 
    result = getTransactionsForCustomer_result()
4653 
    try:
4654 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4655 
    except TransactionServiceException, ex:
4656 
      result.ex = ex
4657 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4658 
    result.write(oprot)
4659 
    oprot.writeMessageEnd()
4660 
    oprot.trans.flush()
4661 
 
132 ashish 4662 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4663 
    args = getTransactionsForShoppingCartId_args()
4664 
    args.read(iprot)
4665 
    iprot.readMessageEnd()
4666 
    result = getTransactionsForShoppingCartId_result()
4667 
    try:
4668 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4669 
    except TransactionServiceException, ex:
4670 
      result.ex = ex
4671 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4672 
    result.write(oprot)
4673 
    oprot.writeMessageEnd()
4674 
    oprot.trans.flush()
4675 
 
94 ashish 4676 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4677 
    args = getTransactionStatus_args()
4678 
    args.read(iprot)
4679 
    iprot.readMessageEnd()
4680 
    result = getTransactionStatus_result()
4681 
    try:
4682 
      result.success = self._handler.getTransactionStatus(args.transactionId)
4683 
    except TransactionServiceException, ex:
4684 
      result.ex = ex
4685 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
4686 
    result.write(oprot)
4687 
    oprot.writeMessageEnd()
4688 
    oprot.trans.flush()
4689 
 
4690 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
4691 
    args = changeTransactionStatus_args()
4692 
    args.read(iprot)
4693 
    iprot.readMessageEnd()
4694 
    result = changeTransactionStatus_result()
4695 
    try:
4696 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
4697 
    except TransactionServiceException, ex:
4698 
      result.ex = ex
4699 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
4700 
    result.write(oprot)
4701 
    oprot.writeMessageEnd()
4702 
    oprot.trans.flush()
4703 
 
1398 varun.gupt 4704 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
4705 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 4706 
    args.read(iprot)
4707 
    iprot.readMessageEnd()
1398 varun.gupt 4708 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 4709 
    try:
1398 varun.gupt 4710 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 4711 
    except TransactionServiceException, ex:
4712 
      result.ex = ex
1398 varun.gupt 4713 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 4714 
    result.write(oprot)
4715 
    oprot.writeMessageEnd()
4716 
    oprot.trans.flush()
4717 
 
483 rajveer 4718 
  def process_getAllOrders(self, seqid, iprot, oprot):
4719 
    args = getAllOrders_args()
94 ashish 4720 
    args.read(iprot)
4721 
    iprot.readMessageEnd()
483 rajveer 4722 
    result = getAllOrders_result()
94 ashish 4723 
    try:
4801 anupam.sin 4724 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 4725 
    except TransactionServiceException, ex:
4726 
      result.ex = ex
483 rajveer 4727 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 4728 
    result.write(oprot)
4729 
    oprot.writeMessageEnd()
4730 
    oprot.trans.flush()
4731 
 
4133 chandransh 4732 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
4733 
    args = getOrdersInBatch_args()
4734 
    args.read(iprot)
4735 
    iprot.readMessageEnd()
4736 
    result = getOrdersInBatch_result()
4737 
    try:
4738 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4739 
    except TransactionServiceException, ex:
4740 
      result.ex = ex
4741 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4742 
    result.write(oprot)
4743 
    oprot.writeMessageEnd()
4744 
    oprot.trans.flush()
4745 
 
4746 
  def process_getOrderCount(self, seqid, iprot, oprot):
4747 
    args = getOrderCount_args()
4748 
    args.read(iprot)
4749 
    iprot.readMessageEnd()
4750 
    result = getOrderCount_result()
4751 
    try:
4752 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4753 
    except TransactionServiceException, ex:
4754 
      result.ex = ex
4755 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4756 
    result.write(oprot)
4757 
    oprot.writeMessageEnd()
4758 
    oprot.trans.flush()
4759 
 
999 varun.gupt 4760 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4761 
    args = getOrdersByBillingDate_args()
4762 
    args.read(iprot)
4763 
    iprot.readMessageEnd()
4764 
    result = getOrdersByBillingDate_result()
4765 
    try:
4766 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4767 
    except TransactionServiceException, ex:
4768 
      result.ex = ex
4769 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4770 
    result.write(oprot)
4771 
    oprot.writeMessageEnd()
4772 
    oprot.trans.flush()
4773 
 
3427 chandransh 4774 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4775 
    args = getOrdersByShippingDate_args()
4776 
    args.read(iprot)
4777 
    iprot.readMessageEnd()
4778 
    result = getOrdersByShippingDate_result()
4779 
    try:
3451 chandransh 4780 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4781 
    except TransactionServiceException, ex:
4782 
      result.ex = ex
4783 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4784 
    result.write(oprot)
4785 
    oprot.writeMessageEnd()
4786 
    oprot.trans.flush()
4787 
 
1382 varun.gupt 4788 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4789 
    args = getReturnableOrdersForCustomer_args()
4790 
    args.read(iprot)
4791 
    iprot.readMessageEnd()
4792 
    result = getReturnableOrdersForCustomer_result()
4793 
    try:
4794 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4795 
    except TransactionServiceException, ex:
4796 
      result.ex = ex
4797 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4798 
    result.write(oprot)
4799 
    oprot.writeMessageEnd()
4800 
    oprot.trans.flush()
4801 
 
4802 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4803 
    args = getCancellableOrdersForCustomer_args()
4804 
    args.read(iprot)
4805 
    iprot.readMessageEnd()
4806 
    result = getCancellableOrdersForCustomer_result()
4807 
    try:
4808 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4809 
    except TransactionServiceException, ex:
4810 
      result.ex = ex
4811 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4812 
    result.write(oprot)
4813 
    oprot.writeMessageEnd()
4814 
    oprot.trans.flush()
4815 
 
483 rajveer 4816 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4817 
    args = changeOrderStatus_args()
94 ashish 4818 
    args.read(iprot)
4819 
    iprot.readMessageEnd()
483 rajveer 4820 
    result = changeOrderStatus_result()
94 ashish 4821 
    try:
483 rajveer 4822 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4823 
    except TransactionServiceException, ex:
4824 
      result.ex = ex
483 rajveer 4825 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4826 
    result.write(oprot)
4827 
    oprot.writeMessageEnd()
4828 
    oprot.trans.flush()
4829 
 
483 rajveer 4830 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4831 
    args = getOrdersForTransaction_args()
94 ashish 4832 
    args.read(iprot)
4833 
    iprot.readMessageEnd()
483 rajveer 4834 
    result = getOrdersForTransaction_result()
94 ashish 4835 
    try:
1528 ankur.sing 4836 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4837 
    except TransactionServiceException, ex:
4838 
      result.ex = ex
483 rajveer 4839 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4840 
    result.write(oprot)
4841 
    oprot.writeMessageEnd()
4842 
    oprot.trans.flush()
4843 
 
483 rajveer 4844 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4845 
    args = getOrdersForCustomer_args()
94 ashish 4846 
    args.read(iprot)
4847 
    iprot.readMessageEnd()
483 rajveer 4848 
    result = getOrdersForCustomer_result()
94 ashish 4849 
    try:
3014 chandransh 4850 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4851 
    except TransactionServiceException, ex:
4852 
      result.ex = ex
483 rajveer 4853 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4854 
    result.write(oprot)
4855 
    oprot.writeMessageEnd()
4856 
    oprot.trans.flush()
4857 
 
483 rajveer 4858 
  def process_createOrder(self, seqid, iprot, oprot):
4859 
    args = createOrder_args()
94 ashish 4860 
    args.read(iprot)
4861 
    iprot.readMessageEnd()
483 rajveer 4862 
    result = createOrder_result()
94 ashish 4863 
    try:
483 rajveer 4864 
      result.success = self._handler.createOrder(args.order)
94 ashish 4865 
    except TransactionServiceException, ex:
4866 
      result.ex = ex
483 rajveer 4867 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4868 
    result.write(oprot)
4869 
    oprot.writeMessageEnd()
4870 
    oprot.trans.flush()
4871 
 
483 rajveer 4872 
  def process_getOrder(self, seqid, iprot, oprot):
4873 
    args = getOrder_args()
94 ashish 4874 
    args.read(iprot)
4875 
    iprot.readMessageEnd()
483 rajveer 4876 
    result = getOrder_result()
94 ashish 4877 
    try:
483 rajveer 4878 
      result.success = self._handler.getOrder(args.id)
94 ashish 4879 
    except TransactionServiceException, ex:
4880 
      result.ex = ex
483 rajveer 4881 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4882 
    result.write(oprot)
4883 
    oprot.writeMessageEnd()
4884 
    oprot.trans.flush()
4885 
 
483 rajveer 4886 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4887 
    args = getLineItemsForOrder_args()
94 ashish 4888 
    args.read(iprot)
4889 
    iprot.readMessageEnd()
483 rajveer 4890 
    result = getLineItemsForOrder_result()
94 ashish 4891 
    try:
483 rajveer 4892 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4893 
    except TransactionServiceException, ex:
4894 
      result.ex = ex
483 rajveer 4895 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4896 
    result.write(oprot)
4897 
    oprot.writeMessageEnd()
4898 
    oprot.trans.flush()
4899 
 
1528 ankur.sing 4900 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4901 
    args = getOrderForCustomer_args()
4902 
    args.read(iprot)
4903 
    iprot.readMessageEnd()
4904 
    result = getOrderForCustomer_result()
4905 
    try:
4906 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4907 
    except TransactionServiceException, ex:
4908 
      result.ex = ex
4909 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4910 
    result.write(oprot)
4911 
    oprot.writeMessageEnd()
4912 
    oprot.trans.flush()
4913 
 
3064 chandransh 4914 
  def process_getAlerts(self, seqid, iprot, oprot):
4915 
    args = getAlerts_args()
4916 
    args.read(iprot)
4917 
    iprot.readMessageEnd()
4918 
    result = getAlerts_result()
4444 rajveer 4919 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4920 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4921 
    result.write(oprot)
4922 
    oprot.writeMessageEnd()
4923 
    oprot.trans.flush()
4924 
 
4394 rajveer 4925 
  def process_addAlert(self, seqid, iprot, oprot):
4926 
    args = addAlert_args()
3064 chandransh 4927 
    args.read(iprot)
4928 
    iprot.readMessageEnd()
4394 rajveer 4929 
    result = addAlert_result()
4444 rajveer 4930 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4931 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4932 
    result.write(oprot)
4933 
    oprot.writeMessageEnd()
4934 
    oprot.trans.flush()
4935 
 
4444 rajveer 4936 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4937 
    args = markAlertsAsSeen_args()
4938 
    args.read(iprot)
4939 
    iprot.readMessageEnd()
4940 
    result = markAlertsAsSeen_result()
4941 
    self._handler.markAlertsAsSeen(args.warehouseId)
4942 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4943 
    result.write(oprot)
4944 
    oprot.writeMessageEnd()
4945 
    oprot.trans.flush()
4946 
 
3064 chandransh 4947 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4948 
    args = getValidOrderCount_args()
4949 
    args.read(iprot)
4950 
    iprot.readMessageEnd()
4951 
    result = getValidOrderCount_result()
4952 
    result.success = self._handler.getValidOrderCount()
4953 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4954 
    result.write(oprot)
4955 
    oprot.writeMessageEnd()
4956 
    oprot.trans.flush()
4957 
 
4958 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4959 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4960 
    args.read(iprot)
4961 
    iprot.readMessageEnd()
4962 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4963 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4964 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4965 
    result.write(oprot)
4966 
    oprot.writeMessageEnd()
4967 
    oprot.trans.flush()
4968 
 
4969 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4970 
    args = getValidOrdersAmountRange_args()
4971 
    args.read(iprot)
4972 
    iprot.readMessageEnd()
4973 
    result = getValidOrdersAmountRange_result()
4974 
    result.success = self._handler.getValidOrdersAmountRange()
4975 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4976 
    result.write(oprot)
4977 
    oprot.writeMessageEnd()
4978 
    oprot.trans.flush()
4979 
 
4980 
  def process_getValidOrders(self, seqid, iprot, oprot):
4981 
    args = getValidOrders_args()
4982 
    args.read(iprot)
4983 
    iprot.readMessageEnd()
4984 
    result = getValidOrders_result()
4985 
    result.success = self._handler.getValidOrders(args.limit)
4986 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4987 
    result.write(oprot)
4988 
    oprot.writeMessageEnd()
4989 
    oprot.trans.flush()
4990 
 
1220 chandransh 4991 
  def process_batchOrders(self, seqid, iprot, oprot):
4992 
    args = batchOrders_args()
4993 
    args.read(iprot)
4994 
    iprot.readMessageEnd()
4995 
    result = batchOrders_result()
4996 
    try:
4997 
      result.success = self._handler.batchOrders(args.warehouseId)
4998 
    except TransactionServiceException, ex:
4999 
      result.ex = ex
5000 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5001 
    result.write(oprot)
5002 
    oprot.writeMessageEnd()
5003 
    oprot.trans.flush()
5004 
 
1208 chandransh 5005 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5006 
    args = markOrderAsOutOfStock_args()
5007 
    args.read(iprot)
5008 
    iprot.readMessageEnd()
5009 
    result = markOrderAsOutOfStock_result()
5010 
    try:
5011 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5012 
    except TransactionServiceException, ex:
5013 
      result.ex = ex
5014 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5015 
    result.write(oprot)
5016 
    oprot.writeMessageEnd()
5017 
    oprot.trans.flush()
5018 
 
3064 chandransh 5019 
  def process_verifyOrder(self, seqid, iprot, oprot):
5020 
    args = verifyOrder_args()
759 chandransh 5021 
    args.read(iprot)
5022 
    iprot.readMessageEnd()
3064 chandransh 5023 
    result = verifyOrder_result()
759 chandransh 5024 
    try:
3064 chandransh 5025 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5026 
    except TransactionServiceException, ex:
5027 
      result.ex = ex
3064 chandransh 5028 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5029 
    result.write(oprot)
5030 
    oprot.writeMessageEnd()
5031 
    oprot.trans.flush()
5032 
 
3064 chandransh 5033 
  def process_acceptOrder(self, seqid, iprot, oprot):
5034 
    args = acceptOrder_args()
1113 chandransh 5035 
    args.read(iprot)
5036 
    iprot.readMessageEnd()
3064 chandransh 5037 
    result = acceptOrder_result()
1113 chandransh 5038 
    try:
3064 chandransh 5039 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5040 
    except TransactionServiceException, ex:
5041 
      result.ex = ex
3064 chandransh 5042 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5043 
    result.write(oprot)
5044 
    oprot.writeMessageEnd()
5045 
    oprot.trans.flush()
5046 
 
3064 chandransh 5047 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5048 
    args = addBillingDetails_args()
1135 chandransh 5049 
    args.read(iprot)
5050 
    iprot.readMessageEnd()
3064 chandransh 5051 
    result = addBillingDetails_result()
1135 chandransh 5052 
    try:
4763 rajveer 5053 
      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 5054 
    except TransactionServiceException, ex:
5055 
      result.ex = ex
3064 chandransh 5056 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5057 
    result.write(oprot)
5058 
    oprot.writeMessageEnd()
5059 
    oprot.trans.flush()
5060 
 
4579 rajveer 5061 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5062 
    args = addInvoiceNumber_args()
5063 
    args.read(iprot)
5064 
    iprot.readMessageEnd()
5065 
    result = addInvoiceNumber_result()
5066 
    try:
4763 rajveer 5067 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5068 
    except TransactionServiceException, ex:
5069 
      result.ex = ex
5070 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5071 
    result.write(oprot)
5072 
    oprot.writeMessageEnd()
5073 
    oprot.trans.flush()
5074 
 
3064 chandransh 5075 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
5076 
    args = markOrdersAsManifested_args()
1408 ankur.sing 5077 
    args.read(iprot)
5078 
    iprot.readMessageEnd()
3064 chandransh 5079 
    result = markOrdersAsManifested_result()
5080 
    try:
5081 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
5082 
    except TransactionServiceException, ex:
5083 
      result.ex = ex
5084 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 5085 
    result.write(oprot)
5086 
    oprot.writeMessageEnd()
5087 
    oprot.trans.flush()
5088 
 
4410 rajveer 5089 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5090 
    args = markOrdersAsShippedFromWarehouse_args()
5091 
    args.read(iprot)
5092 
    iprot.readMessageEnd()
5093 
    result = markOrdersAsShippedFromWarehouse_result()
5094 
    try:
4789 rajveer 5095 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5096 
    except TransactionServiceException, ex:
5097 
      result.ex = ex
5098 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5099 
    result.write(oprot)
5100 
    oprot.writeMessageEnd()
5101 
    oprot.trans.flush()
5102 
 
3064 chandransh 5103 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5104 
    args = markOrdersAsPickedUp_args()
304 ashish 5105 
    args.read(iprot)
5106 
    iprot.readMessageEnd()
3064 chandransh 5107 
    result = markOrdersAsPickedUp_result()
5108 
    try:
5109 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
5110 
    except TransactionServiceException, ex:
5111 
      result.ex = ex
5112 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5113 
    result.write(oprot)
5114 
    oprot.writeMessageEnd()
5115 
    oprot.trans.flush()
94 ashish 5116 
 
3064 chandransh 5117 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5118 
    args = markOrdersAsDelivered_args()
304 ashish 5119 
    args.read(iprot)
5120 
    iprot.readMessageEnd()
3064 chandransh 5121 
    result = markOrdersAsDelivered_result()
5122 
    try:
5123 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5124 
    except TransactionServiceException, ex:
5125 
      result.ex = ex
5126 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5127 
    result.write(oprot)
5128 
    oprot.writeMessageEnd()
5129 
    oprot.trans.flush()
5130 
 
3064 chandransh 5131 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
5132 
    args = markOrdersAsFailed_args()
1596 ankur.sing 5133 
    args.read(iprot)
5134 
    iprot.readMessageEnd()
3064 chandransh 5135 
    result = markOrdersAsFailed_result()
5136 
    try:
5137 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
5138 
    except TransactionServiceException, ex:
5139 
      result.ex = ex
5140 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 5141 
    result.write(oprot)
5142 
    oprot.writeMessageEnd()
5143 
    oprot.trans.flush()
304 ashish 5144 
 
3064 chandransh 5145 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5146 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5147 
    args.read(iprot)
5148 
    iprot.readMessageEnd()
3064 chandransh 5149 
    result = updateNonDeliveryReason_result()
5150 
    try:
4581 phani.kuma 5151 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5152 
    except TransactionServiceException, ex:
5153 
      result.ex = ex
5154 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5155 
    result.write(oprot)
5156 
    oprot.writeMessageEnd()
5157 
    oprot.trans.flush()
1596 ankur.sing 5158 
 
3064 chandransh 5159 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5160 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5161 
    args.read(iprot)
5162 
    iprot.readMessageEnd()
3064 chandransh 5163 
    result = getUndeliveredOrders_result()
5164 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5165 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5166 
    result.write(oprot)
5167 
    oprot.writeMessageEnd()
5168 
    oprot.trans.flush()
5169 
 
4783 phani.kuma 5170 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5171 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5172 
    args.read(iprot)
5173 
    iprot.readMessageEnd()
5174 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5175 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5176 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5177 
    result.write(oprot)
5178 
    oprot.writeMessageEnd()
5179 
    oprot.trans.flush()
5180 
 
2536 chandransh 5181 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5182 
    args = toggleDOAFlag_args()
5183 
    args.read(iprot)
5184 
    iprot.readMessageEnd()
5185 
    result = toggleDOAFlag_result()
5186 
    try:
5187 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5188 
    except TransactionServiceException, ex:
5189 
      result.ex = ex
5190 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5191 
    result.write(oprot)
5192 
    oprot.writeMessageEnd()
5193 
    oprot.trans.flush()
1886 ankur.sing 5194 
 
4712 rajveer 5195 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5196 
    args = markOrderAsDelivered_args()
5197 
    args.read(iprot)
5198 
    iprot.readMessageEnd()
5199 
    result = markOrderAsDelivered_result()
5200 
    try:
5201 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5202 
    except TransactionServiceException, ex:
5203 
      result.ex = ex
5204 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5205 
    result.write(oprot)
5206 
    oprot.writeMessageEnd()
5207 
    oprot.trans.flush()
5208 
 
4454 rajveer 5209 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5210 
    args = markOrderDoaRequestReceived_args()
5211 
    args.read(iprot)
5212 
    iprot.readMessageEnd()
5213 
    result = markOrderDoaRequestReceived_result()
5214 
    try:
5215 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5216 
    except TransactionServiceException, ex:
5217 
      result.ex = ex
5218 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5219 
    result.write(oprot)
5220 
    oprot.writeMessageEnd()
5221 
    oprot.trans.flush()
5222 
 
5223 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5224 
    args = markOrderDoaRequestAuthorized_args()
5225 
    args.read(iprot)
5226 
    iprot.readMessageEnd()
5227 
    result = markOrderDoaRequestAuthorized_result()
5228 
    try:
5229 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5230 
    except TransactionServiceException, ex:
5231 
      result.ex = ex
5232 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5233 
    result.write(oprot)
5234 
    oprot.writeMessageEnd()
5235 
    oprot.trans.flush()
5236 
 
4488 rajveer 5237 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5238 
    args = markOrderReturnRequestReceived_args()
5239 
    args.read(iprot)
5240 
    iprot.readMessageEnd()
5241 
    result = markOrderReturnRequestReceived_result()
5242 
    try:
5243 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5244 
    except TransactionServiceException, ex:
5245 
      result.ex = ex
5246 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5247 
    result.write(oprot)
5248 
    oprot.writeMessageEnd()
5249 
    oprot.trans.flush()
5250 
 
5251 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5252 
    args = markOrderReturnRequestAuthorized_args()
5253 
    args.read(iprot)
5254 
    iprot.readMessageEnd()
5255 
    result = markOrderReturnRequestAuthorized_result()
5256 
    try:
5257 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5258 
    except TransactionServiceException, ex:
5259 
      result.ex = ex
5260 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5261 
    result.write(oprot)
5262 
    oprot.writeMessageEnd()
5263 
    oprot.trans.flush()
5264 
 
2536 chandransh 5265 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5266 
    args = requestPickupNumber_args()
5267 
    args.read(iprot)
5268 
    iprot.readMessageEnd()
5269 
    result = requestPickupNumber_result()
5270 
    try:
4579 rajveer 5271 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5272 
    except TransactionServiceException, ex:
5273 
      result.ex = ex
5274 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5275 
    result.write(oprot)
5276 
    oprot.writeMessageEnd()
5277 
    oprot.trans.flush()
5278 
 
5279 
  def process_authorizePickup(self, seqid, iprot, oprot):
5280 
    args = authorizePickup_args()
5281 
    args.read(iprot)
5282 
    iprot.readMessageEnd()
5283 
    result = authorizePickup_result()
5284 
    try:
4602 rajveer 5285 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5286 
    except TransactionServiceException, ex:
5287 
      result.ex = ex
5288 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5289 
    result.write(oprot)
5290 
    oprot.writeMessageEnd()
5291 
    oprot.trans.flush()
5292 
 
2764 chandransh 5293 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5294 
    args = markDoasAsPickedUp_args()
5295 
    args.read(iprot)
5296 
    iprot.readMessageEnd()
5297 
    result = markDoasAsPickedUp_result()
5298 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
5299 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5300 
    result.write(oprot)
5301 
    oprot.writeMessageEnd()
5302 
    oprot.trans.flush()
5303 
 
4741 phani.kuma 5304 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5305 
    args = markReturnOrdersAsPickedUp_args()
5306 
    args.read(iprot)
5307 
    iprot.readMessageEnd()
5308 
    result = markReturnOrdersAsPickedUp_result()
5309 
    result.success = self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
5310 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5311 
    result.write(oprot)
5312 
    oprot.writeMessageEnd()
5313 
    oprot.trans.flush()
5314 
 
2616 chandransh 5315 
  def process_receiveReturn(self, seqid, iprot, oprot):
5316 
    args = receiveReturn_args()
2591 chandransh 5317 
    args.read(iprot)
5318 
    iprot.readMessageEnd()
2616 chandransh 5319 
    result = receiveReturn_result()
2591 chandransh 5320 
    try:
4479 rajveer 5321 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5322 
    except TransactionServiceException, ex:
5323 
      result.ex = ex
2616 chandransh 5324 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5325 
    result.write(oprot)
5326 
    oprot.writeMessageEnd()
5327 
    oprot.trans.flush()
2536 chandransh 5328 
 
2591 chandransh 5329 
  def process_validateDoa(self, seqid, iprot, oprot):
5330 
    args = validateDoa_args()
5331 
    args.read(iprot)
5332 
    iprot.readMessageEnd()
5333 
    result = validateDoa_result()
5334 
    try:
5335 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5336 
    except TransactionServiceException, ex:
5337 
      result.ex = ex
5338 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5339 
    result.write(oprot)
5340 
    oprot.writeMessageEnd()
5341 
    oprot.trans.flush()
5342 
 
4495 rajveer 5343 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5344 
    args = validateReturnProduct_args()
5345 
    args.read(iprot)
5346 
    iprot.readMessageEnd()
5347 
    result = validateReturnProduct_result()
5348 
    try:
5349 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5350 
    except TransactionServiceException, ex:
5351 
      result.ex = ex
5352 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5353 
    result.write(oprot)
5354 
    oprot.writeMessageEnd()
5355 
    oprot.trans.flush()
5356 
 
2616 chandransh 5357 
  def process_reshipOrder(self, seqid, iprot, oprot):
5358 
    args = reshipOrder_args()
5359 
    args.read(iprot)
5360 
    iprot.readMessageEnd()
5361 
    result = reshipOrder_result()
5362 
    try:
5363 
      result.success = self._handler.reshipOrder(args.orderId)
5364 
    except TransactionServiceException, ex:
5365 
      result.ex = ex
5366 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5367 
    result.write(oprot)
5368 
    oprot.writeMessageEnd()
5369 
    oprot.trans.flush()
2591 chandransh 5370 
 
2616 chandransh 5371 
  def process_refundOrder(self, seqid, iprot, oprot):
5372 
    args = refundOrder_args()
5373 
    args.read(iprot)
5374 
    iprot.readMessageEnd()
5375 
    result = refundOrder_result()
5376 
    try:
3226 chandransh 5377 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5378 
    except TransactionServiceException, ex:
5379 
      result.ex = ex
5380 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5381 
    result.write(oprot)
5382 
    oprot.writeMessageEnd()
5383 
    oprot.trans.flush()
5384 
 
2690 chandransh 5385 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5386 
    args = getReturnOrders_args()
5387 
    args.read(iprot)
5388 
    iprot.readMessageEnd()
5389 
    result = getReturnOrders_result()
5390 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5391 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5392 
    result.write(oprot)
5393 
    oprot.writeMessageEnd()
5394 
    oprot.trans.flush()
2616 chandransh 5395 
 
2700 chandransh 5396 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5397 
    args = getReturnOrder_args()
5398 
    args.read(iprot)
5399 
    iprot.readMessageEnd()
5400 
    result = getReturnOrder_result()
5401 
    try:
5402 
      result.success = self._handler.getReturnOrder(args.id)
5403 
    except TransactionServiceException, ex:
5404 
      result.ex = ex
5405 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5406 
    result.write(oprot)
5407 
    oprot.writeMessageEnd()
5408 
    oprot.trans.flush()
5409 
 
2690 chandransh 5410 
  def process_processReturn(self, seqid, iprot, oprot):
5411 
    args = processReturn_args()
5412 
    args.read(iprot)
5413 
    iprot.readMessageEnd()
5414 
    result = processReturn_result()
5415 
    try:
5416 
      self._handler.processReturn(args.returnOrderId)
5417 
    except TransactionServiceException, ex:
5418 
      result.ex = ex
5419 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5420 
    result.write(oprot)
5421 
    oprot.writeMessageEnd()
5422 
    oprot.trans.flush()
5423 
 
3451 chandransh 5424 
  def process_updateWeight(self, seqid, iprot, oprot):
5425 
    args = updateWeight_args()
5426 
    args.read(iprot)
5427 
    iprot.readMessageEnd()
5428 
    result = updateWeight_result()
5429 
    try:
5430 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5431 
    except TransactionServiceException, ex:
5432 
      result.ex = ex
5433 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5434 
    result.write(oprot)
5435 
    oprot.writeMessageEnd()
5436 
    oprot.trans.flush()
2819 chandransh 5437 
 
3469 chandransh 5438 
  def process_changeItem(self, seqid, iprot, oprot):
5439 
    args = changeItem_args()
5440 
    args.read(iprot)
5441 
    iprot.readMessageEnd()
5442 
    result = changeItem_result()
5443 
    try:
5444 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5445 
    except TransactionServiceException, ex:
5446 
      result.ex = ex
5447 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5448 
    result.write(oprot)
5449 
    oprot.writeMessageEnd()
5450 
    oprot.trans.flush()
3451 chandransh 5451 
 
3469 chandransh 5452 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5453 
    args = shiftToWarehouse_args()
5454 
    args.read(iprot)
5455 
    iprot.readMessageEnd()
5456 
    result = shiftToWarehouse_result()
5457 
    try:
5458 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5459 
    except TransactionServiceException, ex:
5460 
      result.ex = ex
5461 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5462 
    result.write(oprot)
5463 
    oprot.writeMessageEnd()
5464 
    oprot.trans.flush()
5465 
 
3553 chandransh 5466 
  def process_addDelayReason(self, seqid, iprot, oprot):
5467 
    args = addDelayReason_args()
5468 
    args.read(iprot)
5469 
    iprot.readMessageEnd()
5470 
    result = addDelayReason_result()
5471 
    try:
4647 rajveer 5472 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 5473 
    except TransactionServiceException, ex:
5474 
      result.ex = ex
5475 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5476 
    result.write(oprot)
5477 
    oprot.writeMessageEnd()
5478 
    oprot.trans.flush()
3469 chandransh 5479 
 
3956 chandransh 5480 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5481 
    args = reconcileCodCollection_args()
5482 
    args.read(iprot)
5483 
    iprot.readMessageEnd()
5484 
    result = reconcileCodCollection_result()
5485 
    try:
5486 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5487 
    except TransactionServiceException, ex:
5488 
      result.ex = ex
5489 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5490 
    result.write(oprot)
5491 
    oprot.writeMessageEnd()
5492 
    oprot.trans.flush()
3553 chandransh 5493 
 
4008 mandeep.dh 5494 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5495 
    args = getTransactionsRequiringExtraProcessing_args()
5496 
    args.read(iprot)
5497 
    iprot.readMessageEnd()
5498 
    result = getTransactionsRequiringExtraProcessing_result()
5499 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5500 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5501 
    result.write(oprot)
5502 
    oprot.writeMessageEnd()
5503 
    oprot.trans.flush()
3956 chandransh 5504 
 
4008 mandeep.dh 5505 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5506 
    args = markTransactionAsProcessed_args()
5507 
    args.read(iprot)
5508 
    iprot.readMessageEnd()
5509 
    result = markTransactionAsProcessed_result()
5510 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5511 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5512 
    result.write(oprot)
5513 
    oprot.writeMessageEnd()
5514 
    oprot.trans.flush()
5515 
 
4018 chandransh 5516 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5517 
    args = getItemWiseRiskyOrdersCount_args()
5518 
    args.read(iprot)
5519 
    iprot.readMessageEnd()
5520 
    result = getItemWiseRiskyOrdersCount_result()
5521 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5522 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5523 
    result.write(oprot)
5524 
    oprot.writeMessageEnd()
5525 
    oprot.trans.flush()
4008 mandeep.dh 5526 
 
4295 varun.gupt 5527 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5528 
    args = getOrdersForItemIds_args()
5529 
    args.read(iprot)
5530 
    iprot.readMessageEnd()
5531 
    result = getOrdersForItemIds_result()
5532 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5533 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5534 
    result.write(oprot)
5535 
    oprot.writeMessageEnd()
5536 
    oprot.trans.flush()
5537 
 
4247 rajveer 5538 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5539 
    args = markOrderCancellationRequestReceived_args()
5540 
    args.read(iprot)
5541 
    iprot.readMessageEnd()
5542 
    result = markOrderCancellationRequestReceived_result()
5543 
    try:
5544 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5545 
    except TransactionServiceException, ex:
5546 
      result.ex = ex
5547 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5548 
    result.write(oprot)
5549 
    oprot.writeMessageEnd()
5550 
    oprot.trans.flush()
4018 chandransh 5551 
 
4247 rajveer 5552 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5553 
    args = markOrderCancellationRequestConfirmed_args()
5554 
    args.read(iprot)
5555 
    iprot.readMessageEnd()
5556 
    result = markOrderCancellationRequestConfirmed_result()
5557 
    try:
5558 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5559 
    except TransactionServiceException, ex:
5560 
      result.ex = ex
5561 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5562 
    result.write(oprot)
5563 
    oprot.writeMessageEnd()
5564 
    oprot.trans.flush()
5565 
 
5566 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5567 
    args = markOrderCancellationRequestDenied_args()
5568 
    args.read(iprot)
5569 
    iprot.readMessageEnd()
5570 
    result = markOrderCancellationRequestDenied_result()
5571 
    try:
5572 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5573 
    except TransactionServiceException, ex:
5574 
      result.ex = ex
5575 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5576 
    result.write(oprot)
5577 
    oprot.writeMessageEnd()
5578 
    oprot.trans.flush()
5579 
 
4258 rajveer 5580 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5581 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5582 
    args.read(iprot)
5583 
    iprot.readMessageEnd()
4258 rajveer 5584 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5585 
    try:
4258 rajveer 5586 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 5587 
    except TransactionServiceException, ex:
5588 
      result.ex = ex
4258 rajveer 5589 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 5590 
    result.write(oprot)
5591 
    oprot.writeMessageEnd()
5592 
    oprot.trans.flush()
5593 
 
4259 anupam.sin 5594 
  def process_refundTransaction(self, seqid, iprot, oprot):
5595 
    args = refundTransaction_args()
5596 
    args.read(iprot)
5597 
    iprot.readMessageEnd()
5598 
    result = refundTransaction_result()
5599 
    try:
5600 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
5601 
    except TransactionServiceException, ex:
5602 
      result.ex = ex
5603 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
5604 
    result.write(oprot)
5605 
    oprot.writeMessageEnd()
5606 
    oprot.trans.flush()
4247 rajveer 5607 
 
4324 mandeep.dh 5608 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
5609 
    args = updateShipmentAddress_args()
5610 
    args.read(iprot)
5611 
    iprot.readMessageEnd()
5612 
    result = updateShipmentAddress_result()
5613 
    try:
5614 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
5615 
    except TransactionServiceException, ex:
5616 
      result.ex = ex
5617 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
5618 
    result.write(oprot)
5619 
    oprot.writeMessageEnd()
5620 
    oprot.trans.flush()
5621 
 
4285 rajveer 5622 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
5623 
    args = acceptOrdersForItemId_args()
5624 
    args.read(iprot)
5625 
    iprot.readMessageEnd()
5626 
    result = acceptOrdersForItemId_result()
5627 
    try:
5628 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
5629 
    except TransactionServiceException, ex:
5630 
      result.ex = ex
5631 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
5632 
    result.write(oprot)
5633 
    oprot.writeMessageEnd()
5634 
    oprot.trans.flush()
4259 anupam.sin 5635 
 
4303 rajveer 5636 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
5637 
    args = markOrdersAsPORaised_args()
5638 
    args.read(iprot)
5639 
    iprot.readMessageEnd()
5640 
    result = markOrdersAsPORaised_result()
5641 
    try:
4369 rajveer 5642 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5643 
    except TransactionServiceException, ex:
5644 
      result.ex = ex
5645 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
5646 
    result.write(oprot)
5647 
    oprot.writeMessageEnd()
5648 
    oprot.trans.flush()
4285 rajveer 5649 
 
4303 rajveer 5650 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
5651 
    args = markOrdersAsReversalInitiated_args()
5652 
    args.read(iprot)
5653 
    iprot.readMessageEnd()
5654 
    result = markOrdersAsReversalInitiated_result()
5655 
    try:
4369 rajveer 5656 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5657 
    except TransactionServiceException, ex:
5658 
      result.ex = ex
5659 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
5660 
    result.write(oprot)
5661 
    oprot.writeMessageEnd()
5662 
    oprot.trans.flush()
5663 
 
5664 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
5665 
    args = markOrdersAsNotAvailabke_args()
5666 
    args.read(iprot)
5667 
    iprot.readMessageEnd()
5668 
    result = markOrdersAsNotAvailabke_result()
5669 
    try:
4369 rajveer 5670 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5671 
    except TransactionServiceException, ex:
5672 
      result.ex = ex
5673 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
5674 
    result.write(oprot)
5675 
    oprot.writeMessageEnd()
5676 
    oprot.trans.flush()
5677 
 
4369 rajveer 5678 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
5679 
    args = markOrdersAsTimeout_args()
5680 
    args.read(iprot)
5681 
    iprot.readMessageEnd()
5682 
    result = markOrdersAsTimeout_result()
5683 
    try:
5684 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
5685 
    except TransactionServiceException, ex:
5686 
      result.ex = ex
5687 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
5688 
    result.write(oprot)
5689 
    oprot.writeMessageEnd()
5690 
    oprot.trans.flush()
4303 rajveer 5691 
 
4662 rajveer 5692 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
5693 
    args = markOrderAsLostInTransit_args()
5694 
    args.read(iprot)
5695 
    iprot.readMessageEnd()
5696 
    result = markOrderAsLostInTransit_result()
5697 
    try:
5698 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
5699 
    except TransactionServiceException, ex:
5700 
      result.ex = ex
5701 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
5702 
    result.write(oprot)
5703 
    oprot.writeMessageEnd()
5704 
    oprot.trans.flush()
5705 
 
4386 anupam.sin 5706 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
5707 
    args = getOrderForAwb_args()
5708 
    args.read(iprot)
5709 
    iprot.readMessageEnd()
5710 
    result = getOrderForAwb_result()
5711 
    try:
5712 
      result.success = self._handler.getOrderForAwb(args.awb)
5713 
    except TransactionServiceException, ex:
5714 
      result.ex = ex
5715 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
5716 
    result.write(oprot)
5717 
    oprot.writeMessageEnd()
5718 
    oprot.trans.flush()
4369 rajveer 5719 
 
4506 phani.kuma 5720 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
5721 
    args = getOrdersForProviderForStatus_args()
5722 
    args.read(iprot)
5723 
    iprot.readMessageEnd()
5724 
    result = getOrdersForProviderForStatus_result()
5725 
    try:
5726 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
5727 
    except TransactionServiceException, ex:
5728 
      result.ex = ex
5729 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
5730 
    result.write(oprot)
5731 
    oprot.writeMessageEnd()
5732 
    oprot.trans.flush()
4386 anupam.sin 5733 
 
4600 varun.gupt 5734 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
5735 
    args = getBilledOrdersForVendor_args()
5736 
    args.read(iprot)
5737 
    iprot.readMessageEnd()
5738 
    result = getBilledOrdersForVendor_result()
5739 
    try:
5740 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
5741 
    except TransactionServiceException, ex:
5742 
      result.ex = ex
5743 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
5744 
    result.write(oprot)
5745 
    oprot.writeMessageEnd()
5746 
    oprot.trans.flush()
4506 phani.kuma 5747 
 
4607 rajveer 5748 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
5749 
    args = getSlippedSippingDateOrders_args()
5750 
    args.read(iprot)
5751 
    iprot.readMessageEnd()
5752 
    result = getSlippedSippingDateOrders_result()
5753 
    try:
5754 
      result.success = self._handler.getSlippedSippingDateOrders()
5755 
    except TransactionServiceException, ex:
5756 
      result.ex = ex
5757 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
5758 
    result.write(oprot)
5759 
    oprot.writeMessageEnd()
5760 
    oprot.trans.flush()
5761 
 
4709 rajveer 5762 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
5763 
    args = getCancelledOrders_args()
5764 
    args.read(iprot)
5765 
    iprot.readMessageEnd()
5766 
    result = getCancelledOrders_result()
5767 
    try:
5768 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
5769 
    except TransactionServiceException, ex:
5770 
      result.ex = ex
5771 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
5772 
    result.write(oprot)
5773 
    oprot.writeMessageEnd()
5774 
    oprot.trans.flush()
5775 
 
4600 varun.gupt 5776 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
5777 
    args = saveBluedartSettlements_args()
5778 
    args.read(iprot)
5779 
    iprot.readMessageEnd()
5780 
    result = saveBluedartSettlements_result()
5781 
    try:
5782 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
5783 
    except TransactionServiceException, ex:
5784 
      result.ex = ex
5785 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
5786 
    result.write(oprot)
5787 
    oprot.writeMessageEnd()
5788 
    oprot.trans.flush()
5789 
 
5790 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
5791 
    args = savePaymentSettlements_args()
5792 
    args.read(iprot)
5793 
    iprot.readMessageEnd()
5794 
    result = savePaymentSettlements_result()
5795 
    try:
4905 varun.gupt 5796 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 5797 
    except TransactionServiceException, ex:
5798 
      result.ex = ex
5799 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
5800 
    result.write(oprot)
5801 
    oprot.writeMessageEnd()
5802 
    oprot.trans.flush()
5803 
 
5804 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
5805 
    args = saveEBSSettlementSummary_args()
5806 
    args.read(iprot)
5807 
    iprot.readMessageEnd()
5808 
    result = saveEBSSettlementSummary_result()
5809 
    try:
5810 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
5811 
    except TransactionServiceException, ex:
5812 
      result.ex = ex
5813 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
5814 
    result.write(oprot)
5815 
    oprot.writeMessageEnd()
5816 
    oprot.trans.flush()
5817 
 
5818 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
5819 
    args = getSettlementForPaymentId_args()
5820 
    args.read(iprot)
5821 
    iprot.readMessageEnd()
5822 
    result = getSettlementForPaymentId_result()
5823 
    try:
5824 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
5825 
    except TransactionServiceException, ex:
5826 
      result.ex = ex
5827 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
5828 
    result.write(oprot)
5829 
    oprot.writeMessageEnd()
5830 
    oprot.trans.flush()
5831 
 
5832 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
5833 
    args = getEBSSettlementSummaries_args()
5834 
    args.read(iprot)
5835 
    iprot.readMessageEnd()
5836 
    result = getEBSSettlementSummaries_result()
5837 
    try:
5838 
      result.success = self._handler.getEBSSettlementSummaries()
5839 
    except TransactionServiceException, ex:
5840 
      result.ex = ex
5841 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
5842 
    result.write(oprot)
5843 
    oprot.writeMessageEnd()
5844 
    oprot.trans.flush()
5845 
 
5846 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
5847 
    args = markEBSSettlementUploaded_args()
5848 
    args.read(iprot)
5849 
    iprot.readMessageEnd()
5850 
    result = markEBSSettlementUploaded_result()
5851 
    try:
5852 
      self._handler.markEBSSettlementUploaded(args.settlementId)
5853 
    except TransactionServiceException, ex:
5854 
      result.ex = ex
5855 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
5856 
    result.write(oprot)
5857 
    oprot.writeMessageEnd()
5858 
    oprot.trans.flush()
5859 
 
5860 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
5861 
    args = getEBSSettlementDate_args()
5862 
    args.read(iprot)
5863 
    iprot.readMessageEnd()
5864 
    result = getEBSSettlementDate_result()
5865 
    try:
5866 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
5867 
    except TransactionServiceException, ex:
5868 
      result.ex = ex
5869 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
5870 
    result.write(oprot)
5871 
    oprot.writeMessageEnd()
5872 
    oprot.trans.flush()
5873 
 
4715 varun.gupt 5874 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
5875 
    args = getSettlementsByDate_args()
5876 
    args.read(iprot)
5877 
    iprot.readMessageEnd()
5878 
    result = getSettlementsByDate_result()
5879 
    try:
5880 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
5881 
    except TransactionServiceException, ex:
5882 
      result.ex = ex
5883 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
5884 
    result.write(oprot)
5885 
    oprot.writeMessageEnd()
5886 
    oprot.trans.flush()
4600 varun.gupt 5887 
 
4715 varun.gupt 5888 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
5889 
    args = getReshippedOrderIds_args()
5890 
    args.read(iprot)
5891 
    iprot.readMessageEnd()
5892 
    result = getReshippedOrderIds_result()
5893 
    try:
5894 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
5895 
    except TransactionServiceException, ex:
5896 
      result.ex = ex
5897 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
5898 
    result.write(oprot)
5899 
    oprot.writeMessageEnd()
5900 
    oprot.trans.flush()
5901 
 
4757 mandeep.dh 5902 
  def process_updateOrdersAsPORaised(self, seqid, iprot, oprot):
5903 
    args = updateOrdersAsPORaised_args()
5904 
    args.read(iprot)
5905 
    iprot.readMessageEnd()
5906 
    result = updateOrdersAsPORaised_result()
5907 
    try:
5908 
      self._handler.updateOrdersAsPORaised(args.itemIdQuantityMap, args.purchaseOrderId, args.warehouseId)
5909 
    except TransactionServiceException, ex:
5910 
      result.ex = ex
5911 
    oprot.writeMessageBegin("updateOrdersAsPORaised", TMessageType.REPLY, seqid)
5912 
    result.write(oprot)
5913 
    oprot.writeMessageEnd()
5914 
    oprot.trans.flush()
4715 varun.gupt 5915 
 
4875 varun.gupt 5916 
  def process_getOrdersWhereVendorNotPaid(self, seqid, iprot, oprot):
5917 
    args = getOrdersWhereVendorNotPaid_args()
5918 
    args.read(iprot)
5919 
    iprot.readMessageEnd()
5920 
    result = getOrdersWhereVendorNotPaid_result()
5921 
    try:
5922 
      result.success = self._handler.getOrdersWhereVendorNotPaid(args.vendorId)
5923 
    except TransactionServiceException, ex:
5924 
      result.ex = ex
5925 
    oprot.writeMessageBegin("getOrdersWhereVendorNotPaid", TMessageType.REPLY, seqid)
5926 
    result.write(oprot)
5927 
    oprot.writeMessageEnd()
5928 
    oprot.trans.flush()
4757 mandeep.dh 5929 
 
4875 varun.gupt 5930 
 
94 ashish 5931 
# HELPER FUNCTIONS AND STRUCTURES
5932 
 
5933 
class createTransaction_args:
5934 
  """
5935 
  Attributes:
5936 
   - transaction
5937 
  """
5938 
 
5939 
  thrift_spec = (
5940 
    None, # 0
5941 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
5942 
  )
5943 
 
5944 
  def __init__(self, transaction=None,):
5945 
    self.transaction = transaction
5946 
 
5947 
  def read(self, iprot):
5948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5950 
      return
5951 
    iprot.readStructBegin()
5952 
    while True:
5953 
      (fname, ftype, fid) = iprot.readFieldBegin()
5954 
      if ftype == TType.STOP:
5955 
        break
5956 
      if fid == 1:
5957 
        if ftype == TType.STRUCT:
5958 
          self.transaction = Transaction()
5959 
          self.transaction.read(iprot)
5960 
        else:
5961 
          iprot.skip(ftype)
5962 
      else:
5963 
        iprot.skip(ftype)
5964 
      iprot.readFieldEnd()
5965 
    iprot.readStructEnd()
5966 
 
5967 
  def write(self, oprot):
5968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5970 
      return
5971 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 5972 
    if self.transaction is not None:
94 ashish 5973 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5974 
      self.transaction.write(oprot)
5975 
      oprot.writeFieldEnd()
5976 
    oprot.writeFieldStop()
5977 
    oprot.writeStructEnd()
5978 
 
3431 rajveer 5979 
  def validate(self):
5980 
    return
5981 
 
5982 
 
94 ashish 5983 
  def __repr__(self):
5984 
    L = ['%s=%r' % (key, value)
5985 
      for key, value in self.__dict__.iteritems()]
5986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5987 
 
5988 
  def __eq__(self, other):
5989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5990 
 
5991 
  def __ne__(self, other):
5992 
    return not (self == other)
5993 
 
5994 
class createTransaction_result:
5995 
  """
5996 
  Attributes:
132 ashish 5997 
   - success
94 ashish 5998 
   - ex
5999 
  """
6000 
 
6001 
  thrift_spec = (
132 ashish 6002 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6003 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6004 
  )
6005 
 
132 ashish 6006 
  def __init__(self, success=None, ex=None,):
6007 
    self.success = success
94 ashish 6008 
    self.ex = ex
6009 
 
6010 
  def read(self, iprot):
6011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6013 
      return
6014 
    iprot.readStructBegin()
6015 
    while True:
6016 
      (fname, ftype, fid) = iprot.readFieldBegin()
6017 
      if ftype == TType.STOP:
6018 
        break
132 ashish 6019 
      if fid == 0:
6020 
        if ftype == TType.I64:
6021 
          self.success = iprot.readI64();
6022 
        else:
6023 
          iprot.skip(ftype)
6024 
      elif fid == 1:
94 ashish 6025 
        if ftype == TType.STRUCT:
6026 
          self.ex = TransactionServiceException()
6027 
          self.ex.read(iprot)
6028 
        else:
6029 
          iprot.skip(ftype)
6030 
      else:
6031 
        iprot.skip(ftype)
6032 
      iprot.readFieldEnd()
6033 
    iprot.readStructEnd()
6034 
 
6035 
  def write(self, oprot):
6036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6038 
      return
6039 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 6040 
    if self.success is not None:
132 ashish 6041 
      oprot.writeFieldBegin('success', TType.I64, 0)
6042 
      oprot.writeI64(self.success)
6043 
      oprot.writeFieldEnd()
3431 rajveer 6044 
    if self.ex is not None:
94 ashish 6045 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6046 
      self.ex.write(oprot)
6047 
      oprot.writeFieldEnd()
6048 
    oprot.writeFieldStop()
6049 
    oprot.writeStructEnd()
6050 
 
3431 rajveer 6051 
  def validate(self):
6052 
    return
6053 
 
6054 
 
94 ashish 6055 
  def __repr__(self):
6056 
    L = ['%s=%r' % (key, value)
6057 
      for key, value in self.__dict__.iteritems()]
6058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6059 
 
6060 
  def __eq__(self, other):
6061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6062 
 
6063 
  def __ne__(self, other):
6064 
    return not (self == other)
6065 
 
6066 
class getTransaction_args:
6067 
  """
6068 
  Attributes:
6069 
   - id
6070 
  """
6071 
 
6072 
  thrift_spec = (
6073 
    None, # 0
6074 
    (1, TType.I64, 'id', None, None, ), # 1
6075 
  )
6076 
 
6077 
  def __init__(self, id=None,):
6078 
    self.id = id
6079 
 
6080 
  def read(self, iprot):
6081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6083 
      return
6084 
    iprot.readStructBegin()
6085 
    while True:
6086 
      (fname, ftype, fid) = iprot.readFieldBegin()
6087 
      if ftype == TType.STOP:
6088 
        break
6089 
      if fid == 1:
6090 
        if ftype == TType.I64:
6091 
          self.id = iprot.readI64();
6092 
        else:
6093 
          iprot.skip(ftype)
6094 
      else:
6095 
        iprot.skip(ftype)
6096 
      iprot.readFieldEnd()
6097 
    iprot.readStructEnd()
6098 
 
6099 
  def write(self, oprot):
6100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6102 
      return
6103 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6104 
    if self.id is not None:
94 ashish 6105 
      oprot.writeFieldBegin('id', TType.I64, 1)
6106 
      oprot.writeI64(self.id)
6107 
      oprot.writeFieldEnd()
6108 
    oprot.writeFieldStop()
6109 
    oprot.writeStructEnd()
6110 
 
3431 rajveer 6111 
  def validate(self):
6112 
    return
6113 
 
6114 
 
94 ashish 6115 
  def __repr__(self):
6116 
    L = ['%s=%r' % (key, value)
6117 
      for key, value in self.__dict__.iteritems()]
6118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6119 
 
6120 
  def __eq__(self, other):
6121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6122 
 
6123 
  def __ne__(self, other):
6124 
    return not (self == other)
6125 
 
6126 
class getTransaction_result:
6127 
  """
6128 
  Attributes:
6129 
   - success
6130 
   - ex
6131 
  """
6132 
 
6133 
  thrift_spec = (
6134 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6135 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6136 
  )
6137 
 
6138 
  def __init__(self, success=None, ex=None,):
6139 
    self.success = success
6140 
    self.ex = ex
6141 
 
6142 
  def read(self, iprot):
6143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6145 
      return
6146 
    iprot.readStructBegin()
6147 
    while True:
6148 
      (fname, ftype, fid) = iprot.readFieldBegin()
6149 
      if ftype == TType.STOP:
6150 
        break
6151 
      if fid == 0:
6152 
        if ftype == TType.STRUCT:
6153 
          self.success = Transaction()
6154 
          self.success.read(iprot)
6155 
        else:
6156 
          iprot.skip(ftype)
6157 
      elif fid == 1:
6158 
        if ftype == TType.STRUCT:
6159 
          self.ex = TransactionServiceException()
6160 
          self.ex.read(iprot)
6161 
        else:
6162 
          iprot.skip(ftype)
6163 
      else:
6164 
        iprot.skip(ftype)
6165 
      iprot.readFieldEnd()
6166 
    iprot.readStructEnd()
6167 
 
6168 
  def write(self, oprot):
6169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6171 
      return
6172 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6173 
    if self.success is not None:
94 ashish 6174 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6175 
      self.success.write(oprot)
6176 
      oprot.writeFieldEnd()
3431 rajveer 6177 
    if self.ex is not None:
94 ashish 6178 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6179 
      self.ex.write(oprot)
6180 
      oprot.writeFieldEnd()
6181 
    oprot.writeFieldStop()
6182 
    oprot.writeStructEnd()
6183 
 
3431 rajveer 6184 
  def validate(self):
6185 
    return
6186 
 
6187 
 
94 ashish 6188 
  def __repr__(self):
6189 
    L = ['%s=%r' % (key, value)
6190 
      for key, value in self.__dict__.iteritems()]
6191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6192 
 
6193 
  def __eq__(self, other):
6194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6195 
 
6196 
  def __ne__(self, other):
6197 
    return not (self == other)
6198 
 
6199 
class getTransactionsForCustomer_args:
6200 
  """
6201 
  Attributes:
6202 
   - customerId
6203 
   - from_date
6204 
   - to_date
6205 
   - status
6206 
  """
6207 
 
6208 
  thrift_spec = (
6209 
    None, # 0
6210 
    (1, TType.I64, 'customerId', None, None, ), # 1
6211 
    (2, TType.I64, 'from_date', None, None, ), # 2
6212 
    (3, TType.I64, 'to_date', None, None, ), # 3
6213 
    (4, TType.I32, 'status', None, None, ), # 4
6214 
  )
6215 
 
6216 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6217 
    self.customerId = customerId
6218 
    self.from_date = from_date
6219 
    self.to_date = to_date
6220 
    self.status = status
6221 
 
6222 
  def read(self, iprot):
6223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6225 
      return
6226 
    iprot.readStructBegin()
6227 
    while True:
6228 
      (fname, ftype, fid) = iprot.readFieldBegin()
6229 
      if ftype == TType.STOP:
6230 
        break
6231 
      if fid == 1:
6232 
        if ftype == TType.I64:
6233 
          self.customerId = iprot.readI64();
6234 
        else:
6235 
          iprot.skip(ftype)
6236 
      elif fid == 2:
6237 
        if ftype == TType.I64:
6238 
          self.from_date = iprot.readI64();
6239 
        else:
6240 
          iprot.skip(ftype)
6241 
      elif fid == 3:
6242 
        if ftype == TType.I64:
6243 
          self.to_date = iprot.readI64();
6244 
        else:
6245 
          iprot.skip(ftype)
6246 
      elif fid == 4:
6247 
        if ftype == TType.I32:
6248 
          self.status = iprot.readI32();
6249 
        else:
6250 
          iprot.skip(ftype)
6251 
      else:
6252 
        iprot.skip(ftype)
6253 
      iprot.readFieldEnd()
6254 
    iprot.readStructEnd()
6255 
 
6256 
  def write(self, oprot):
6257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6259 
      return
6260 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6261 
    if self.customerId is not None:
94 ashish 6262 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6263 
      oprot.writeI64(self.customerId)
6264 
      oprot.writeFieldEnd()
3431 rajveer 6265 
    if self.from_date is not None:
94 ashish 6266 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6267 
      oprot.writeI64(self.from_date)
6268 
      oprot.writeFieldEnd()
3431 rajveer 6269 
    if self.to_date is not None:
94 ashish 6270 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6271 
      oprot.writeI64(self.to_date)
6272 
      oprot.writeFieldEnd()
3431 rajveer 6273 
    if self.status is not None:
94 ashish 6274 
      oprot.writeFieldBegin('status', TType.I32, 4)
6275 
      oprot.writeI32(self.status)
6276 
      oprot.writeFieldEnd()
6277 
    oprot.writeFieldStop()
6278 
    oprot.writeStructEnd()
6279 
 
3431 rajveer 6280 
  def validate(self):
6281 
    return
6282 
 
6283 
 
94 ashish 6284 
  def __repr__(self):
6285 
    L = ['%s=%r' % (key, value)
6286 
      for key, value in self.__dict__.iteritems()]
6287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6288 
 
6289 
  def __eq__(self, other):
6290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6291 
 
6292 
  def __ne__(self, other):
6293 
    return not (self == other)
6294 
 
6295 
class getTransactionsForCustomer_result:
6296 
  """
6297 
  Attributes:
6298 
   - success
6299 
   - ex
6300 
  """
6301 
 
6302 
  thrift_spec = (
6303 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6304 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6305 
  )
6306 
 
6307 
  def __init__(self, success=None, ex=None,):
6308 
    self.success = success
6309 
    self.ex = ex
6310 
 
6311 
  def read(self, iprot):
6312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6314 
      return
6315 
    iprot.readStructBegin()
6316 
    while True:
6317 
      (fname, ftype, fid) = iprot.readFieldBegin()
6318 
      if ftype == TType.STOP:
6319 
        break
6320 
      if fid == 0:
6321 
        if ftype == TType.LIST:
6322 
          self.success = []
4837 varun.gupt 6323 
          (_etype45, _size42) = iprot.readListBegin()
6324 
          for _i46 in xrange(_size42):
6325 
            _elem47 = Transaction()
6326 
            _elem47.read(iprot)
6327 
            self.success.append(_elem47)
94 ashish 6328 
          iprot.readListEnd()
6329 
        else:
6330 
          iprot.skip(ftype)
6331 
      elif fid == 1:
6332 
        if ftype == TType.STRUCT:
6333 
          self.ex = TransactionServiceException()
6334 
          self.ex.read(iprot)
6335 
        else:
6336 
          iprot.skip(ftype)
6337 
      else:
6338 
        iprot.skip(ftype)
6339 
      iprot.readFieldEnd()
6340 
    iprot.readStructEnd()
6341 
 
6342 
  def write(self, oprot):
6343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6345 
      return
6346 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6347 
    if self.success is not None:
94 ashish 6348 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6349 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 6350 
      for iter48 in self.success:
6351 
        iter48.write(oprot)
94 ashish 6352 
      oprot.writeListEnd()
6353 
      oprot.writeFieldEnd()
3431 rajveer 6354 
    if self.ex is not None:
94 ashish 6355 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6356 
      self.ex.write(oprot)
6357 
      oprot.writeFieldEnd()
6358 
    oprot.writeFieldStop()
6359 
    oprot.writeStructEnd()
6360 
 
3431 rajveer 6361 
  def validate(self):
6362 
    return
6363 
 
6364 
 
94 ashish 6365 
  def __repr__(self):
6366 
    L = ['%s=%r' % (key, value)
6367 
      for key, value in self.__dict__.iteritems()]
6368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6369 
 
6370 
  def __eq__(self, other):
6371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6372 
 
6373 
  def __ne__(self, other):
6374 
    return not (self == other)
6375 
 
132 ashish 6376 
class getTransactionsForShoppingCartId_args:
6377 
  """
6378 
  Attributes:
6379 
   - shoppingCartId
6380 
  """
6381 
 
6382 
  thrift_spec = (
6383 
    None, # 0
6384 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
6385 
  )
6386 
 
6387 
  def __init__(self, shoppingCartId=None,):
6388 
    self.shoppingCartId = shoppingCartId
6389 
 
6390 
  def read(self, iprot):
6391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6393 
      return
6394 
    iprot.readStructBegin()
6395 
    while True:
6396 
      (fname, ftype, fid) = iprot.readFieldBegin()
6397 
      if ftype == TType.STOP:
6398 
        break
6399 
      if fid == 1:
6400 
        if ftype == TType.I64:
6401 
          self.shoppingCartId = iprot.readI64();
6402 
        else:
6403 
          iprot.skip(ftype)
6404 
      else:
6405 
        iprot.skip(ftype)
6406 
      iprot.readFieldEnd()
6407 
    iprot.readStructEnd()
6408 
 
6409 
  def write(self, oprot):
6410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6412 
      return
6413 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 6414 
    if self.shoppingCartId is not None:
132 ashish 6415 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
6416 
      oprot.writeI64(self.shoppingCartId)
6417 
      oprot.writeFieldEnd()
6418 
    oprot.writeFieldStop()
6419 
    oprot.writeStructEnd()
6420 
 
3431 rajveer 6421 
  def validate(self):
6422 
    return
6423 
 
6424 
 
132 ashish 6425 
  def __repr__(self):
6426 
    L = ['%s=%r' % (key, value)
6427 
      for key, value in self.__dict__.iteritems()]
6428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6429 
 
6430 
  def __eq__(self, other):
6431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6432 
 
6433 
  def __ne__(self, other):
6434 
    return not (self == other)
6435 
 
6436 
class getTransactionsForShoppingCartId_result:
6437 
  """
6438 
  Attributes:
6439 
   - success
6440 
   - ex
6441 
  """
6442 
 
6443 
  thrift_spec = (
6444 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6445 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6446 
  )
6447 
 
6448 
  def __init__(self, success=None, ex=None,):
6449 
    self.success = success
6450 
    self.ex = ex
6451 
 
6452 
  def read(self, iprot):
6453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6455 
      return
6456 
    iprot.readStructBegin()
6457 
    while True:
6458 
      (fname, ftype, fid) = iprot.readFieldBegin()
6459 
      if ftype == TType.STOP:
6460 
        break
6461 
      if fid == 0:
6462 
        if ftype == TType.LIST:
6463 
          self.success = []
4837 varun.gupt 6464 
          (_etype52, _size49) = iprot.readListBegin()
6465 
          for _i53 in xrange(_size49):
6466 
            _elem54 = Transaction()
6467 
            _elem54.read(iprot)
6468 
            self.success.append(_elem54)
132 ashish 6469 
          iprot.readListEnd()
6470 
        else:
6471 
          iprot.skip(ftype)
6472 
      elif fid == 1:
6473 
        if ftype == TType.STRUCT:
6474 
          self.ex = TransactionServiceException()
6475 
          self.ex.read(iprot)
6476 
        else:
6477 
          iprot.skip(ftype)
6478 
      else:
6479 
        iprot.skip(ftype)
6480 
      iprot.readFieldEnd()
6481 
    iprot.readStructEnd()
6482 
 
6483 
  def write(self, oprot):
6484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6486 
      return
6487 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 6488 
    if self.success is not None:
132 ashish 6489 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6490 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 6491 
      for iter55 in self.success:
6492 
        iter55.write(oprot)
132 ashish 6493 
      oprot.writeListEnd()
6494 
      oprot.writeFieldEnd()
3431 rajveer 6495 
    if self.ex is not None:
132 ashish 6496 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6497 
      self.ex.write(oprot)
6498 
      oprot.writeFieldEnd()
6499 
    oprot.writeFieldStop()
6500 
    oprot.writeStructEnd()
6501 
 
3431 rajveer 6502 
  def validate(self):
6503 
    return
6504 
 
6505 
 
132 ashish 6506 
  def __repr__(self):
6507 
    L = ['%s=%r' % (key, value)
6508 
      for key, value in self.__dict__.iteritems()]
6509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6510 
 
6511 
  def __eq__(self, other):
6512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6513 
 
6514 
  def __ne__(self, other):
6515 
    return not (self == other)
6516 
 
94 ashish 6517 
class getTransactionStatus_args:
6518 
  """
6519 
  Attributes:
6520 
   - transactionId
6521 
  """
6522 
 
6523 
  thrift_spec = (
6524 
    None, # 0
6525 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6526 
  )
6527 
 
6528 
  def __init__(self, transactionId=None,):
6529 
    self.transactionId = transactionId
6530 
 
6531 
  def read(self, iprot):
6532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6534 
      return
6535 
    iprot.readStructBegin()
6536 
    while True:
6537 
      (fname, ftype, fid) = iprot.readFieldBegin()
6538 
      if ftype == TType.STOP:
6539 
        break
6540 
      if fid == 1:
6541 
        if ftype == TType.I64:
6542 
          self.transactionId = iprot.readI64();
6543 
        else:
6544 
          iprot.skip(ftype)
6545 
      else:
6546 
        iprot.skip(ftype)
6547 
      iprot.readFieldEnd()
6548 
    iprot.readStructEnd()
6549 
 
6550 
  def write(self, oprot):
6551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6553 
      return
6554 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6555 
    if self.transactionId is not None:
94 ashish 6556 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6557 
      oprot.writeI64(self.transactionId)
6558 
      oprot.writeFieldEnd()
6559 
    oprot.writeFieldStop()
6560 
    oprot.writeStructEnd()
6561 
 
3431 rajveer 6562 
  def validate(self):
6563 
    return
6564 
 
6565 
 
94 ashish 6566 
  def __repr__(self):
6567 
    L = ['%s=%r' % (key, value)
6568 
      for key, value in self.__dict__.iteritems()]
6569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6570 
 
6571 
  def __eq__(self, other):
6572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6573 
 
6574 
  def __ne__(self, other):
6575 
    return not (self == other)
6576 
 
6577 
class getTransactionStatus_result:
6578 
  """
6579 
  Attributes:
6580 
   - success
6581 
   - ex
6582 
  """
6583 
 
6584 
  thrift_spec = (
6585 
    (0, TType.I32, 'success', None, None, ), # 0
6586 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6587 
  )
6588 
 
6589 
  def __init__(self, success=None, ex=None,):
6590 
    self.success = success
6591 
    self.ex = ex
6592 
 
6593 
  def read(self, iprot):
6594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6596 
      return
6597 
    iprot.readStructBegin()
6598 
    while True:
6599 
      (fname, ftype, fid) = iprot.readFieldBegin()
6600 
      if ftype == TType.STOP:
6601 
        break
6602 
      if fid == 0:
6603 
        if ftype == TType.I32:
6604 
          self.success = iprot.readI32();
6605 
        else:
6606 
          iprot.skip(ftype)
6607 
      elif fid == 1:
6608 
        if ftype == TType.STRUCT:
6609 
          self.ex = TransactionServiceException()
6610 
          self.ex.read(iprot)
6611 
        else:
6612 
          iprot.skip(ftype)
6613 
      else:
6614 
        iprot.skip(ftype)
6615 
      iprot.readFieldEnd()
6616 
    iprot.readStructEnd()
6617 
 
6618 
  def write(self, oprot):
6619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6621 
      return
6622 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 6623 
    if self.success is not None:
94 ashish 6624 
      oprot.writeFieldBegin('success', TType.I32, 0)
6625 
      oprot.writeI32(self.success)
6626 
      oprot.writeFieldEnd()
3431 rajveer 6627 
    if self.ex is not None:
94 ashish 6628 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6629 
      self.ex.write(oprot)
6630 
      oprot.writeFieldEnd()
6631 
    oprot.writeFieldStop()
6632 
    oprot.writeStructEnd()
6633 
 
3431 rajveer 6634 
  def validate(self):
6635 
    return
6636 
 
6637 
 
94 ashish 6638 
  def __repr__(self):
6639 
    L = ['%s=%r' % (key, value)
6640 
      for key, value in self.__dict__.iteritems()]
6641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6642 
 
6643 
  def __eq__(self, other):
6644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6645 
 
6646 
  def __ne__(self, other):
6647 
    return not (self == other)
6648 
 
6649 
class changeTransactionStatus_args:
6650 
  """
6651 
  Attributes:
6652 
   - transactionId
6653 
   - status
6654 
   - description
6655 
  """
6656 
 
6657 
  thrift_spec = (
6658 
    None, # 0
6659 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6660 
    (2, TType.I32, 'status', None, None, ), # 2
6661 
    (3, TType.STRING, 'description', None, None, ), # 3
6662 
  )
6663 
 
6664 
  def __init__(self, transactionId=None, status=None, description=None,):
6665 
    self.transactionId = transactionId
6666 
    self.status = status
6667 
    self.description = description
6668 
 
6669 
  def read(self, iprot):
6670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6672 
      return
6673 
    iprot.readStructBegin()
6674 
    while True:
6675 
      (fname, ftype, fid) = iprot.readFieldBegin()
6676 
      if ftype == TType.STOP:
6677 
        break
6678 
      if fid == 1:
6679 
        if ftype == TType.I64:
6680 
          self.transactionId = iprot.readI64();
6681 
        else:
6682 
          iprot.skip(ftype)
6683 
      elif fid == 2:
6684 
        if ftype == TType.I32:
6685 
          self.status = iprot.readI32();
6686 
        else:
6687 
          iprot.skip(ftype)
6688 
      elif fid == 3:
6689 
        if ftype == TType.STRING:
6690 
          self.description = iprot.readString();
6691 
        else:
6692 
          iprot.skip(ftype)
6693 
      else:
6694 
        iprot.skip(ftype)
6695 
      iprot.readFieldEnd()
6696 
    iprot.readStructEnd()
6697 
 
6698 
  def write(self, oprot):
6699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6701 
      return
6702 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 6703 
    if self.transactionId is not None:
94 ashish 6704 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6705 
      oprot.writeI64(self.transactionId)
6706 
      oprot.writeFieldEnd()
3431 rajveer 6707 
    if self.status is not None:
94 ashish 6708 
      oprot.writeFieldBegin('status', TType.I32, 2)
6709 
      oprot.writeI32(self.status)
6710 
      oprot.writeFieldEnd()
3431 rajveer 6711 
    if self.description is not None:
94 ashish 6712 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6713 
      oprot.writeString(self.description)
6714 
      oprot.writeFieldEnd()
6715 
    oprot.writeFieldStop()
6716 
    oprot.writeStructEnd()
6717 
 
3431 rajveer 6718 
  def validate(self):
6719 
    return
6720 
 
6721 
 
94 ashish 6722 
  def __repr__(self):
6723 
    L = ['%s=%r' % (key, value)
6724 
      for key, value in self.__dict__.iteritems()]
6725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6726 
 
6727 
  def __eq__(self, other):
6728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6729 
 
6730 
  def __ne__(self, other):
6731 
    return not (self == other)
6732 
 
6733 
class changeTransactionStatus_result:
6734 
  """
6735 
  Attributes:
6736 
   - success
6737 
   - ex
6738 
  """
6739 
 
6740 
  thrift_spec = (
6741 
    (0, TType.BOOL, 'success', None, None, ), # 0
6742 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6743 
  )
6744 
 
6745 
  def __init__(self, success=None, ex=None,):
6746 
    self.success = success
6747 
    self.ex = ex
6748 
 
6749 
  def read(self, iprot):
6750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6752 
      return
6753 
    iprot.readStructBegin()
6754 
    while True:
6755 
      (fname, ftype, fid) = iprot.readFieldBegin()
6756 
      if ftype == TType.STOP:
6757 
        break
6758 
      if fid == 0:
6759 
        if ftype == TType.BOOL:
6760 
          self.success = iprot.readBool();
6761 
        else:
6762 
          iprot.skip(ftype)
6763 
      elif fid == 1:
6764 
        if ftype == TType.STRUCT:
6765 
          self.ex = TransactionServiceException()
6766 
          self.ex.read(iprot)
6767 
        else:
6768 
          iprot.skip(ftype)
6769 
      else:
6770 
        iprot.skip(ftype)
6771 
      iprot.readFieldEnd()
6772 
    iprot.readStructEnd()
6773 
 
6774 
  def write(self, oprot):
6775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6777 
      return
6778 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 6779 
    if self.success is not None:
94 ashish 6780 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6781 
      oprot.writeBool(self.success)
6782 
      oprot.writeFieldEnd()
3431 rajveer 6783 
    if self.ex is not None:
94 ashish 6784 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6785 
      self.ex.write(oprot)
6786 
      oprot.writeFieldEnd()
6787 
    oprot.writeFieldStop()
6788 
    oprot.writeStructEnd()
6789 
 
3431 rajveer 6790 
  def validate(self):
6791 
    return
6792 
 
6793 
 
94 ashish 6794 
  def __repr__(self):
6795 
    L = ['%s=%r' % (key, value)
6796 
      for key, value in self.__dict__.iteritems()]
6797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6798 
 
6799 
  def __eq__(self, other):
6800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6801 
 
6802 
  def __ne__(self, other):
6803 
    return not (self == other)
6804 
 
1398 varun.gupt 6805 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 6806 
  """
6807 
  Attributes:
6808 
   - transactionId
6809 
  """
6810 
 
6811 
  thrift_spec = (
6812 
    None, # 0
6813 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6814 
  )
6815 
 
6816 
  def __init__(self, transactionId=None,):
6817 
    self.transactionId = transactionId
6818 
 
6819 
  def read(self, iprot):
6820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6822 
      return
6823 
    iprot.readStructBegin()
6824 
    while True:
6825 
      (fname, ftype, fid) = iprot.readFieldBegin()
6826 
      if ftype == TType.STOP:
6827 
        break
6828 
      if fid == 1:
6829 
        if ftype == TType.I64:
6830 
          self.transactionId = iprot.readI64();
6831 
        else:
6832 
          iprot.skip(ftype)
6833 
      else:
6834 
        iprot.skip(ftype)
6835 
      iprot.readFieldEnd()
6836 
    iprot.readStructEnd()
6837 
 
6838 
  def write(self, oprot):
6839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6841 
      return
1398 varun.gupt 6842 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 6843 
    if self.transactionId is not None:
1382 varun.gupt 6844 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6845 
      oprot.writeI64(self.transactionId)
6846 
      oprot.writeFieldEnd()
6847 
    oprot.writeFieldStop()
6848 
    oprot.writeStructEnd()
6849 
 
3431 rajveer 6850 
  def validate(self):
6851 
    return
6852 
 
6853 
 
1382 varun.gupt 6854 
  def __repr__(self):
6855 
    L = ['%s=%r' % (key, value)
6856 
      for key, value in self.__dict__.iteritems()]
6857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6858 
 
6859 
  def __eq__(self, other):
6860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6861 
 
6862 
  def __ne__(self, other):
6863 
    return not (self == other)
6864 
 
1398 varun.gupt 6865 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 6866 
  """
6867 
  Attributes:
6868 
   - success
6869 
   - ex
6870 
  """
6871 
 
6872 
  thrift_spec = (
6873 
    (0, TType.BOOL, 'success', None, None, ), # 0
6874 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6875 
  )
6876 
 
6877 
  def __init__(self, success=None, ex=None,):
6878 
    self.success = success
6879 
    self.ex = ex
6880 
 
6881 
  def read(self, iprot):
6882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6884 
      return
6885 
    iprot.readStructBegin()
6886 
    while True:
6887 
      (fname, ftype, fid) = iprot.readFieldBegin()
6888 
      if ftype == TType.STOP:
6889 
        break
6890 
      if fid == 0:
6891 
        if ftype == TType.BOOL:
6892 
          self.success = iprot.readBool();
6893 
        else:
6894 
          iprot.skip(ftype)
6895 
      elif fid == 1:
6896 
        if ftype == TType.STRUCT:
6897 
          self.ex = TransactionServiceException()
6898 
          self.ex.read(iprot)
6899 
        else:
6900 
          iprot.skip(ftype)
6901 
      else:
6902 
        iprot.skip(ftype)
6903 
      iprot.readFieldEnd()
6904 
    iprot.readStructEnd()
6905 
 
6906 
  def write(self, oprot):
6907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6909 
      return
1398 varun.gupt 6910 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 6911 
    if self.success is not None:
1382 varun.gupt 6912 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6913 
      oprot.writeBool(self.success)
6914 
      oprot.writeFieldEnd()
3431 rajveer 6915 
    if self.ex is not None:
1382 varun.gupt 6916 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6917 
      self.ex.write(oprot)
6918 
      oprot.writeFieldEnd()
6919 
    oprot.writeFieldStop()
6920 
    oprot.writeStructEnd()
6921 
 
3431 rajveer 6922 
  def validate(self):
6923 
    return
6924 
 
6925 
 
1382 varun.gupt 6926 
  def __repr__(self):
6927 
    L = ['%s=%r' % (key, value)
6928 
      for key, value in self.__dict__.iteritems()]
6929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6930 
 
6931 
  def __eq__(self, other):
6932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6933 
 
6934 
  def __ne__(self, other):
6935 
    return not (self == other)
6936 
 
483 rajveer 6937 
class getAllOrders_args:
94 ashish 6938 
  """
6939 
  Attributes:
4801 anupam.sin 6940 
   - statuses
483 rajveer 6941 
   - from_date
6942 
   - to_date
6943 
   - warehouse_id
94 ashish 6944 
  """
6945 
 
6946 
  thrift_spec = (
6947 
    None, # 0
4801 anupam.sin 6948 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 6949 
    (2, TType.I64, 'from_date', None, None, ), # 2
6950 
    (3, TType.I64, 'to_date', None, None, ), # 3
6951 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 6952 
  )
6953 
 
4801 anupam.sin 6954 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
6955 
    self.statuses = statuses
483 rajveer 6956 
    self.from_date = from_date
6957 
    self.to_date = to_date
6958 
    self.warehouse_id = warehouse_id
94 ashish 6959 
 
6960 
  def read(self, iprot):
6961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6963 
      return
6964 
    iprot.readStructBegin()
6965 
    while True:
6966 
      (fname, ftype, fid) = iprot.readFieldBegin()
6967 
      if ftype == TType.STOP:
6968 
        break
6969 
      if fid == 1:
4801 anupam.sin 6970 
        if ftype == TType.LIST:
6971 
          self.statuses = []
4837 varun.gupt 6972 
          (_etype59, _size56) = iprot.readListBegin()
6973 
          for _i60 in xrange(_size56):
6974 
            _elem61 = iprot.readI32();
6975 
            self.statuses.append(_elem61)
4801 anupam.sin 6976 
          iprot.readListEnd()
94 ashish 6977 
        else:
6978 
          iprot.skip(ftype)
483 rajveer 6979 
      elif fid == 2:
6980 
        if ftype == TType.I64:
6981 
          self.from_date = iprot.readI64();
94 ashish 6982 
        else:
6983 
          iprot.skip(ftype)
483 rajveer 6984 
      elif fid == 3:
6985 
        if ftype == TType.I64:
6986 
          self.to_date = iprot.readI64();
94 ashish 6987 
        else:
6988 
          iprot.skip(ftype)
483 rajveer 6989 
      elif fid == 4:
94 ashish 6990 
        if ftype == TType.I64:
483 rajveer 6991 
          self.warehouse_id = iprot.readI64();
94 ashish 6992 
        else:
6993 
          iprot.skip(ftype)
6994 
      else:
6995 
        iprot.skip(ftype)
6996 
      iprot.readFieldEnd()
6997 
    iprot.readStructEnd()
6998 
 
6999 
  def write(self, oprot):
7000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7002 
      return
483 rajveer 7003 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 7004 
    if self.statuses is not None:
7005 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7006 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4837 varun.gupt 7007 
      for iter62 in self.statuses:
7008 
        oprot.writeI32(iter62)
4801 anupam.sin 7009 
      oprot.writeListEnd()
94 ashish 7010 
      oprot.writeFieldEnd()
3431 rajveer 7011 
    if self.from_date is not None:
483 rajveer 7012 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7013 
      oprot.writeI64(self.from_date)
94 ashish 7014 
      oprot.writeFieldEnd()
3431 rajveer 7015 
    if self.to_date is not None:
483 rajveer 7016 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7017 
      oprot.writeI64(self.to_date)
94 ashish 7018 
      oprot.writeFieldEnd()
3431 rajveer 7019 
    if self.warehouse_id is not None:
483 rajveer 7020 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7021 
      oprot.writeI64(self.warehouse_id)
94 ashish 7022 
      oprot.writeFieldEnd()
7023 
    oprot.writeFieldStop()
7024 
    oprot.writeStructEnd()
7025 
 
3431 rajveer 7026 
  def validate(self):
7027 
    return
7028 
 
7029 
 
94 ashish 7030 
  def __repr__(self):
7031 
    L = ['%s=%r' % (key, value)
7032 
      for key, value in self.__dict__.iteritems()]
7033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7034 
 
7035 
  def __eq__(self, other):
7036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7037 
 
7038 
  def __ne__(self, other):
7039 
    return not (self == other)
7040 
 
483 rajveer 7041 
class getAllOrders_result:
94 ashish 7042 
  """
7043 
  Attributes:
7044 
   - success
7045 
   - ex
7046 
  """
7047 
 
7048 
  thrift_spec = (
483 rajveer 7049 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 7050 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7051 
  )
7052 
 
7053 
  def __init__(self, success=None, ex=None,):
7054 
    self.success = success
7055 
    self.ex = ex
7056 
 
7057 
  def read(self, iprot):
7058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7060 
      return
7061 
    iprot.readStructBegin()
7062 
    while True:
7063 
      (fname, ftype, fid) = iprot.readFieldBegin()
7064 
      if ftype == TType.STOP:
7065 
        break
7066 
      if fid == 0:
483 rajveer 7067 
        if ftype == TType.LIST:
7068 
          self.success = []
4837 varun.gupt 7069 
          (_etype66, _size63) = iprot.readListBegin()
7070 
          for _i67 in xrange(_size63):
7071 
            _elem68 = Order()
7072 
            _elem68.read(iprot)
7073 
            self.success.append(_elem68)
483 rajveer 7074 
          iprot.readListEnd()
94 ashish 7075 
        else:
7076 
          iprot.skip(ftype)
7077 
      elif fid == 1:
7078 
        if ftype == TType.STRUCT:
7079 
          self.ex = TransactionServiceException()
7080 
          self.ex.read(iprot)
7081 
        else:
7082 
          iprot.skip(ftype)
7083 
      else:
7084 
        iprot.skip(ftype)
7085 
      iprot.readFieldEnd()
7086 
    iprot.readStructEnd()
7087 
 
7088 
  def write(self, oprot):
7089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7091 
      return
483 rajveer 7092 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7093 
    if self.success is not None:
483 rajveer 7094 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7095 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 7096 
      for iter69 in self.success:
7097 
        iter69.write(oprot)
483 rajveer 7098 
      oprot.writeListEnd()
94 ashish 7099 
      oprot.writeFieldEnd()
3431 rajveer 7100 
    if self.ex is not None:
94 ashish 7101 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7102 
      self.ex.write(oprot)
7103 
      oprot.writeFieldEnd()
7104 
    oprot.writeFieldStop()
7105 
    oprot.writeStructEnd()
7106 
 
3431 rajveer 7107 
  def validate(self):
7108 
    return
7109 
 
7110 
 
94 ashish 7111 
  def __repr__(self):
7112 
    L = ['%s=%r' % (key, value)
7113 
      for key, value in self.__dict__.iteritems()]
7114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7115 
 
7116 
  def __eq__(self, other):
7117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7118 
 
7119 
  def __ne__(self, other):
7120 
    return not (self == other)
7121 
 
4133 chandransh 7122 
class getOrdersInBatch_args:
7123 
  """
7124 
  Attributes:
7125 
   - statuses
7126 
   - offset
7127 
   - limit
7128 
   - warehouse_id
7129 
  """
7130 
 
7131 
  thrift_spec = (
7132 
    None, # 0
7133 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7134 
    (2, TType.I64, 'offset', None, None, ), # 2
7135 
    (3, TType.I64, 'limit', None, None, ), # 3
7136 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7137 
  )
7138 
 
7139 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7140 
    self.statuses = statuses
7141 
    self.offset = offset
7142 
    self.limit = limit
7143 
    self.warehouse_id = warehouse_id
7144 
 
7145 
  def read(self, iprot):
7146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7148 
      return
7149 
    iprot.readStructBegin()
7150 
    while True:
7151 
      (fname, ftype, fid) = iprot.readFieldBegin()
7152 
      if ftype == TType.STOP:
7153 
        break
7154 
      if fid == 1:
7155 
        if ftype == TType.LIST:
7156 
          self.statuses = []
4837 varun.gupt 7157 
          (_etype73, _size70) = iprot.readListBegin()
7158 
          for _i74 in xrange(_size70):
7159 
            _elem75 = iprot.readI32();
7160 
            self.statuses.append(_elem75)
4133 chandransh 7161 
          iprot.readListEnd()
7162 
        else:
7163 
          iprot.skip(ftype)
7164 
      elif fid == 2:
7165 
        if ftype == TType.I64:
7166 
          self.offset = iprot.readI64();
7167 
        else:
7168 
          iprot.skip(ftype)
7169 
      elif fid == 3:
7170 
        if ftype == TType.I64:
7171 
          self.limit = iprot.readI64();
7172 
        else:
7173 
          iprot.skip(ftype)
7174 
      elif fid == 4:
7175 
        if ftype == TType.I64:
7176 
          self.warehouse_id = iprot.readI64();
7177 
        else:
7178 
          iprot.skip(ftype)
7179 
      else:
7180 
        iprot.skip(ftype)
7181 
      iprot.readFieldEnd()
7182 
    iprot.readStructEnd()
7183 
 
7184 
  def write(self, oprot):
7185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7187 
      return
7188 
    oprot.writeStructBegin('getOrdersInBatch_args')
7189 
    if self.statuses is not None:
7190 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7191 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4837 varun.gupt 7192 
      for iter76 in self.statuses:
7193 
        oprot.writeI32(iter76)
4133 chandransh 7194 
      oprot.writeListEnd()
7195 
      oprot.writeFieldEnd()
7196 
    if self.offset is not None:
7197 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7198 
      oprot.writeI64(self.offset)
7199 
      oprot.writeFieldEnd()
7200 
    if self.limit is not None:
7201 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7202 
      oprot.writeI64(self.limit)
7203 
      oprot.writeFieldEnd()
7204 
    if self.warehouse_id is not None:
7205 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7206 
      oprot.writeI64(self.warehouse_id)
7207 
      oprot.writeFieldEnd()
7208 
    oprot.writeFieldStop()
7209 
    oprot.writeStructEnd()
7210 
 
7211 
  def validate(self):
7212 
    return
7213 
 
7214 
 
7215 
  def __repr__(self):
7216 
    L = ['%s=%r' % (key, value)
7217 
      for key, value in self.__dict__.iteritems()]
7218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7219 
 
7220 
  def __eq__(self, other):
7221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7222 
 
7223 
  def __ne__(self, other):
7224 
    return not (self == other)
7225 
 
7226 
class getOrdersInBatch_result:
7227 
  """
7228 
  Attributes:
7229 
   - success
7230 
   - ex
7231 
  """
7232 
 
7233 
  thrift_spec = (
7234 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7235 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7236 
  )
7237 
 
7238 
  def __init__(self, success=None, ex=None,):
7239 
    self.success = success
7240 
    self.ex = ex
7241 
 
7242 
  def read(self, iprot):
7243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7245 
      return
7246 
    iprot.readStructBegin()
7247 
    while True:
7248 
      (fname, ftype, fid) = iprot.readFieldBegin()
7249 
      if ftype == TType.STOP:
7250 
        break
7251 
      if fid == 0:
7252 
        if ftype == TType.LIST:
7253 
          self.success = []
4837 varun.gupt 7254 
          (_etype80, _size77) = iprot.readListBegin()
7255 
          for _i81 in xrange(_size77):
7256 
            _elem82 = Order()
7257 
            _elem82.read(iprot)
7258 
            self.success.append(_elem82)
4133 chandransh 7259 
          iprot.readListEnd()
7260 
        else:
7261 
          iprot.skip(ftype)
7262 
      elif fid == 1:
7263 
        if ftype == TType.STRUCT:
7264 
          self.ex = TransactionServiceException()
7265 
          self.ex.read(iprot)
7266 
        else:
7267 
          iprot.skip(ftype)
7268 
      else:
7269 
        iprot.skip(ftype)
7270 
      iprot.readFieldEnd()
7271 
    iprot.readStructEnd()
7272 
 
7273 
  def write(self, oprot):
7274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7276 
      return
7277 
    oprot.writeStructBegin('getOrdersInBatch_result')
7278 
    if self.success is not None:
7279 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7280 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 7281 
      for iter83 in self.success:
7282 
        iter83.write(oprot)
4133 chandransh 7283 
      oprot.writeListEnd()
7284 
      oprot.writeFieldEnd()
7285 
    if self.ex is not None:
7286 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7287 
      self.ex.write(oprot)
7288 
      oprot.writeFieldEnd()
7289 
    oprot.writeFieldStop()
7290 
    oprot.writeStructEnd()
7291 
 
7292 
  def validate(self):
7293 
    return
7294 
 
7295 
 
7296 
  def __repr__(self):
7297 
    L = ['%s=%r' % (key, value)
7298 
      for key, value in self.__dict__.iteritems()]
7299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7300 
 
7301 
  def __eq__(self, other):
7302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7303 
 
7304 
  def __ne__(self, other):
7305 
    return not (self == other)
7306 
 
7307 
class getOrderCount_args:
7308 
  """
7309 
  Attributes:
7310 
   - statuses
7311 
   - warehouseId
7312 
  """
7313 
 
7314 
  thrift_spec = (
7315 
    None, # 0
7316 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7317 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7318 
  )
7319 
 
7320 
  def __init__(self, statuses=None, warehouseId=None,):
7321 
    self.statuses = statuses
7322 
    self.warehouseId = warehouseId
7323 
 
7324 
  def read(self, iprot):
7325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7327 
      return
7328 
    iprot.readStructBegin()
7329 
    while True:
7330 
      (fname, ftype, fid) = iprot.readFieldBegin()
7331 
      if ftype == TType.STOP:
7332 
        break
7333 
      if fid == 1:
7334 
        if ftype == TType.LIST:
7335 
          self.statuses = []
4837 varun.gupt 7336 
          (_etype87, _size84) = iprot.readListBegin()
7337 
          for _i88 in xrange(_size84):
7338 
            _elem89 = iprot.readI32();
7339 
            self.statuses.append(_elem89)
4133 chandransh 7340 
          iprot.readListEnd()
7341 
        else:
7342 
          iprot.skip(ftype)
7343 
      elif fid == 2:
7344 
        if ftype == TType.I64:
7345 
          self.warehouseId = iprot.readI64();
7346 
        else:
7347 
          iprot.skip(ftype)
7348 
      else:
7349 
        iprot.skip(ftype)
7350 
      iprot.readFieldEnd()
7351 
    iprot.readStructEnd()
7352 
 
7353 
  def write(self, oprot):
7354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7356 
      return
7357 
    oprot.writeStructBegin('getOrderCount_args')
7358 
    if self.statuses is not None:
7359 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7360 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4837 varun.gupt 7361 
      for iter90 in self.statuses:
7362 
        oprot.writeI32(iter90)
4133 chandransh 7363 
      oprot.writeListEnd()
7364 
      oprot.writeFieldEnd()
7365 
    if self.warehouseId is not None:
7366 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7367 
      oprot.writeI64(self.warehouseId)
7368 
      oprot.writeFieldEnd()
7369 
    oprot.writeFieldStop()
7370 
    oprot.writeStructEnd()
7371 
 
7372 
  def validate(self):
7373 
    return
7374 
 
7375 
 
7376 
  def __repr__(self):
7377 
    L = ['%s=%r' % (key, value)
7378 
      for key, value in self.__dict__.iteritems()]
7379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7380 
 
7381 
  def __eq__(self, other):
7382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7383 
 
7384 
  def __ne__(self, other):
7385 
    return not (self == other)
7386 
 
7387 
class getOrderCount_result:
7388 
  """
7389 
  Attributes:
7390 
   - success
7391 
   - ex
7392 
  """
7393 
 
7394 
  thrift_spec = (
7395 
    (0, TType.I32, 'success', None, None, ), # 0
7396 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7397 
  )
7398 
 
7399 
  def __init__(self, success=None, ex=None,):
7400 
    self.success = success
7401 
    self.ex = ex
7402 
 
7403 
  def read(self, iprot):
7404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7406 
      return
7407 
    iprot.readStructBegin()
7408 
    while True:
7409 
      (fname, ftype, fid) = iprot.readFieldBegin()
7410 
      if ftype == TType.STOP:
7411 
        break
7412 
      if fid == 0:
7413 
        if ftype == TType.I32:
7414 
          self.success = iprot.readI32();
7415 
        else:
7416 
          iprot.skip(ftype)
7417 
      elif fid == 1:
7418 
        if ftype == TType.STRUCT:
7419 
          self.ex = TransactionServiceException()
7420 
          self.ex.read(iprot)
7421 
        else:
7422 
          iprot.skip(ftype)
7423 
      else:
7424 
        iprot.skip(ftype)
7425 
      iprot.readFieldEnd()
7426 
    iprot.readStructEnd()
7427 
 
7428 
  def write(self, oprot):
7429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7431 
      return
7432 
    oprot.writeStructBegin('getOrderCount_result')
7433 
    if self.success is not None:
7434 
      oprot.writeFieldBegin('success', TType.I32, 0)
7435 
      oprot.writeI32(self.success)
7436 
      oprot.writeFieldEnd()
7437 
    if self.ex is not None:
7438 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7439 
      self.ex.write(oprot)
7440 
      oprot.writeFieldEnd()
7441 
    oprot.writeFieldStop()
7442 
    oprot.writeStructEnd()
7443 
 
7444 
  def validate(self):
7445 
    return
7446 
 
7447 
 
7448 
  def __repr__(self):
7449 
    L = ['%s=%r' % (key, value)
7450 
      for key, value in self.__dict__.iteritems()]
7451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7452 
 
7453 
  def __eq__(self, other):
7454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7455 
 
7456 
  def __ne__(self, other):
7457 
    return not (self == other)
7458 
 
999 varun.gupt 7459 
class getOrdersByBillingDate_args:
7460 
  """
7461 
  Attributes:
7462 
   - status
7463 
   - start_billing_date
7464 
   - end_billing_date
7465 
   - warehouse_id
7466 
  """
7467 
 
7468 
  thrift_spec = (
7469 
    None, # 0
7470 
    (1, TType.I32, 'status', None, None, ), # 1
7471 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
7472 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
7473 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7474 
  )
7475 
 
7476 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7477 
    self.status = status
7478 
    self.start_billing_date = start_billing_date
7479 
    self.end_billing_date = end_billing_date
7480 
    self.warehouse_id = warehouse_id
7481 
 
7482 
  def read(self, iprot):
7483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7485 
      return
7486 
    iprot.readStructBegin()
7487 
    while True:
7488 
      (fname, ftype, fid) = iprot.readFieldBegin()
7489 
      if ftype == TType.STOP:
7490 
        break
7491 
      if fid == 1:
7492 
        if ftype == TType.I32:
7493 
          self.status = iprot.readI32();
7494 
        else:
7495 
          iprot.skip(ftype)
7496 
      elif fid == 2:
7497 
        if ftype == TType.I64:
7498 
          self.start_billing_date = iprot.readI64();
7499 
        else:
7500 
          iprot.skip(ftype)
7501 
      elif fid == 3:
7502 
        if ftype == TType.I64:
7503 
          self.end_billing_date = iprot.readI64();
7504 
        else:
7505 
          iprot.skip(ftype)
7506 
      elif fid == 4:
7507 
        if ftype == TType.I64:
7508 
          self.warehouse_id = iprot.readI64();
7509 
        else:
7510 
          iprot.skip(ftype)
7511 
      else:
7512 
        iprot.skip(ftype)
7513 
      iprot.readFieldEnd()
7514 
    iprot.readStructEnd()
7515 
 
7516 
  def write(self, oprot):
7517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7519 
      return
7520 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7521 
    if self.status is not None:
999 varun.gupt 7522 
      oprot.writeFieldBegin('status', TType.I32, 1)
7523 
      oprot.writeI32(self.status)
7524 
      oprot.writeFieldEnd()
3431 rajveer 7525 
    if self.start_billing_date is not None:
999 varun.gupt 7526 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7527 
      oprot.writeI64(self.start_billing_date)
7528 
      oprot.writeFieldEnd()
3431 rajveer 7529 
    if self.end_billing_date is not None:
999 varun.gupt 7530 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7531 
      oprot.writeI64(self.end_billing_date)
7532 
      oprot.writeFieldEnd()
3431 rajveer 7533 
    if self.warehouse_id is not None:
999 varun.gupt 7534 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7535 
      oprot.writeI64(self.warehouse_id)
7536 
      oprot.writeFieldEnd()
7537 
    oprot.writeFieldStop()
7538 
    oprot.writeStructEnd()
7539 
 
3431 rajveer 7540 
  def validate(self):
7541 
    return
7542 
 
7543 
 
999 varun.gupt 7544 
  def __repr__(self):
7545 
    L = ['%s=%r' % (key, value)
7546 
      for key, value in self.__dict__.iteritems()]
7547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7548 
 
7549 
  def __eq__(self, other):
7550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7551 
 
7552 
  def __ne__(self, other):
7553 
    return not (self == other)
7554 
 
7555 
class getOrdersByBillingDate_result:
7556 
  """
7557 
  Attributes:
7558 
   - success
7559 
   - ex
7560 
  """
7561 
 
7562 
  thrift_spec = (
7563 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7564 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7565 
  )
7566 
 
7567 
  def __init__(self, success=None, ex=None,):
7568 
    self.success = success
7569 
    self.ex = ex
7570 
 
7571 
  def read(self, iprot):
7572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7574 
      return
7575 
    iprot.readStructBegin()
7576 
    while True:
7577 
      (fname, ftype, fid) = iprot.readFieldBegin()
7578 
      if ftype == TType.STOP:
7579 
        break
7580 
      if fid == 0:
7581 
        if ftype == TType.LIST:
7582 
          self.success = []
4837 varun.gupt 7583 
          (_etype94, _size91) = iprot.readListBegin()
7584 
          for _i95 in xrange(_size91):
7585 
            _elem96 = Order()
7586 
            _elem96.read(iprot)
7587 
            self.success.append(_elem96)
999 varun.gupt 7588 
          iprot.readListEnd()
7589 
        else:
7590 
          iprot.skip(ftype)
7591 
      elif fid == 1:
7592 
        if ftype == TType.STRUCT:
7593 
          self.ex = TransactionServiceException()
7594 
          self.ex.read(iprot)
7595 
        else:
7596 
          iprot.skip(ftype)
7597 
      else:
7598 
        iprot.skip(ftype)
7599 
      iprot.readFieldEnd()
7600 
    iprot.readStructEnd()
7601 
 
7602 
  def write(self, oprot):
7603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7605 
      return
7606 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 7607 
    if self.success is not None:
999 varun.gupt 7608 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7609 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 7610 
      for iter97 in self.success:
7611 
        iter97.write(oprot)
999 varun.gupt 7612 
      oprot.writeListEnd()
7613 
      oprot.writeFieldEnd()
3431 rajveer 7614 
    if self.ex is not None:
999 varun.gupt 7615 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7616 
      self.ex.write(oprot)
7617 
      oprot.writeFieldEnd()
7618 
    oprot.writeFieldStop()
7619 
    oprot.writeStructEnd()
7620 
 
3431 rajveer 7621 
  def validate(self):
7622 
    return
7623 
 
7624 
 
999 varun.gupt 7625 
  def __repr__(self):
7626 
    L = ['%s=%r' % (key, value)
7627 
      for key, value in self.__dict__.iteritems()]
7628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7629 
 
7630 
  def __eq__(self, other):
7631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7632 
 
7633 
  def __ne__(self, other):
7634 
    return not (self == other)
7635 
 
3427 chandransh 7636 
class getOrdersByShippingDate_args:
7637 
  """
7638 
  Attributes:
7639 
   - fromShippingDate
7640 
   - toShippingDate
7641 
   - providerId
7642 
   - warehouseId
3451 chandransh 7643 
   - cod
3427 chandransh 7644 
  """
7645 
 
7646 
  thrift_spec = (
7647 
    None, # 0
7648 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
7649 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
7650 
    (3, TType.I64, 'providerId', None, None, ), # 3
7651 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 7652 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 7653 
  )
7654 
 
3451 chandransh 7655 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 7656 
    self.fromShippingDate = fromShippingDate
7657 
    self.toShippingDate = toShippingDate
7658 
    self.providerId = providerId
7659 
    self.warehouseId = warehouseId
3451 chandransh 7660 
    self.cod = cod
3427 chandransh 7661 
 
7662 
  def read(self, iprot):
7663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7665 
      return
7666 
    iprot.readStructBegin()
7667 
    while True:
7668 
      (fname, ftype, fid) = iprot.readFieldBegin()
7669 
      if ftype == TType.STOP:
7670 
        break
7671 
      if fid == 1:
7672 
        if ftype == TType.I64:
7673 
          self.fromShippingDate = iprot.readI64();
7674 
        else:
7675 
          iprot.skip(ftype)
7676 
      elif fid == 2:
7677 
        if ftype == TType.I64:
7678 
          self.toShippingDate = iprot.readI64();
7679 
        else:
7680 
          iprot.skip(ftype)
7681 
      elif fid == 3:
7682 
        if ftype == TType.I64:
7683 
          self.providerId = iprot.readI64();
7684 
        else:
7685 
          iprot.skip(ftype)
7686 
      elif fid == 4:
7687 
        if ftype == TType.I64:
7688 
          self.warehouseId = iprot.readI64();
7689 
        else:
7690 
          iprot.skip(ftype)
3451 chandransh 7691 
      elif fid == 5:
7692 
        if ftype == TType.BOOL:
7693 
          self.cod = iprot.readBool();
7694 
        else:
7695 
          iprot.skip(ftype)
3427 chandransh 7696 
      else:
7697 
        iprot.skip(ftype)
7698 
      iprot.readFieldEnd()
7699 
    iprot.readStructEnd()
7700 
 
7701 
  def write(self, oprot):
7702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7704 
      return
7705 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 7706 
    if self.fromShippingDate is not None:
3427 chandransh 7707 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
7708 
      oprot.writeI64(self.fromShippingDate)
7709 
      oprot.writeFieldEnd()
3431 rajveer 7710 
    if self.toShippingDate is not None:
3427 chandransh 7711 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
7712 
      oprot.writeI64(self.toShippingDate)
7713 
      oprot.writeFieldEnd()
3431 rajveer 7714 
    if self.providerId is not None:
3427 chandransh 7715 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
7716 
      oprot.writeI64(self.providerId)
7717 
      oprot.writeFieldEnd()
3431 rajveer 7718 
    if self.warehouseId is not None:
3427 chandransh 7719 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
7720 
      oprot.writeI64(self.warehouseId)
7721 
      oprot.writeFieldEnd()
3451 chandransh 7722 
    if self.cod is not None:
7723 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
7724 
      oprot.writeBool(self.cod)
7725 
      oprot.writeFieldEnd()
3427 chandransh 7726 
    oprot.writeFieldStop()
7727 
    oprot.writeStructEnd()
7728 
 
3431 rajveer 7729 
  def validate(self):
7730 
    return
7731 
 
7732 
 
3427 chandransh 7733 
  def __repr__(self):
7734 
    L = ['%s=%r' % (key, value)
7735 
      for key, value in self.__dict__.iteritems()]
7736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7737 
 
7738 
  def __eq__(self, other):
7739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7740 
 
7741 
  def __ne__(self, other):
7742 
    return not (self == other)
7743 
 
7744 
class getOrdersByShippingDate_result:
7745 
  """
7746 
  Attributes:
7747 
   - success
7748 
   - ex
7749 
  """
7750 
 
7751 
  thrift_spec = (
7752 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7753 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7754 
  )
7755 
 
7756 
  def __init__(self, success=None, ex=None,):
7757 
    self.success = success
7758 
    self.ex = ex
7759 
 
7760 
  def read(self, iprot):
7761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7763 
      return
7764 
    iprot.readStructBegin()
7765 
    while True:
7766 
      (fname, ftype, fid) = iprot.readFieldBegin()
7767 
      if ftype == TType.STOP:
7768 
        break
7769 
      if fid == 0:
7770 
        if ftype == TType.LIST:
7771 
          self.success = []
4837 varun.gupt 7772 
          (_etype101, _size98) = iprot.readListBegin()
7773 
          for _i102 in xrange(_size98):
7774 
            _elem103 = Order()
7775 
            _elem103.read(iprot)
7776 
            self.success.append(_elem103)
3427 chandransh 7777 
          iprot.readListEnd()
7778 
        else:
7779 
          iprot.skip(ftype)
7780 
      elif fid == 1:
7781 
        if ftype == TType.STRUCT:
7782 
          self.ex = TransactionServiceException()
7783 
          self.ex.read(iprot)
7784 
        else:
7785 
          iprot.skip(ftype)
7786 
      else:
7787 
        iprot.skip(ftype)
7788 
      iprot.readFieldEnd()
7789 
    iprot.readStructEnd()
7790 
 
7791 
  def write(self, oprot):
7792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7794 
      return
7795 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 7796 
    if self.success is not None:
3427 chandransh 7797 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7798 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 7799 
      for iter104 in self.success:
7800 
        iter104.write(oprot)
3427 chandransh 7801 
      oprot.writeListEnd()
7802 
      oprot.writeFieldEnd()
3431 rajveer 7803 
    if self.ex is not None:
3427 chandransh 7804 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7805 
      self.ex.write(oprot)
7806 
      oprot.writeFieldEnd()
7807 
    oprot.writeFieldStop()
7808 
    oprot.writeStructEnd()
7809 
 
3431 rajveer 7810 
  def validate(self):
7811 
    return
7812 
 
7813 
 
3427 chandransh 7814 
  def __repr__(self):
7815 
    L = ['%s=%r' % (key, value)
7816 
      for key, value in self.__dict__.iteritems()]
7817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7818 
 
7819 
  def __eq__(self, other):
7820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7821 
 
7822 
  def __ne__(self, other):
7823 
    return not (self == other)
7824 
 
1382 varun.gupt 7825 
class getReturnableOrdersForCustomer_args:
7826 
  """
7827 
  Attributes:
7828 
   - customer_id
7829 
   - limit
7830 
  """
7831 
 
7832 
  thrift_spec = (
7833 
    None, # 0
7834 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7835 
    (2, TType.I64, 'limit', None, None, ), # 2
7836 
  )
7837 
 
7838 
  def __init__(self, customer_id=None, limit=None,):
7839 
    self.customer_id = customer_id
7840 
    self.limit = limit
7841 
 
7842 
  def read(self, iprot):
7843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7845 
      return
7846 
    iprot.readStructBegin()
7847 
    while True:
7848 
      (fname, ftype, fid) = iprot.readFieldBegin()
7849 
      if ftype == TType.STOP:
7850 
        break
7851 
      if fid == 1:
7852 
        if ftype == TType.I64:
7853 
          self.customer_id = iprot.readI64();
7854 
        else:
7855 
          iprot.skip(ftype)
7856 
      elif fid == 2:
7857 
        if ftype == TType.I64:
7858 
          self.limit = iprot.readI64();
7859 
        else:
7860 
          iprot.skip(ftype)
7861 
      else:
7862 
        iprot.skip(ftype)
7863 
      iprot.readFieldEnd()
7864 
    iprot.readStructEnd()
7865 
 
7866 
  def write(self, oprot):
7867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7869 
      return
7870 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 7871 
    if self.customer_id is not None:
1382 varun.gupt 7872 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7873 
      oprot.writeI64(self.customer_id)
7874 
      oprot.writeFieldEnd()
3431 rajveer 7875 
    if self.limit is not None:
1382 varun.gupt 7876 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7877 
      oprot.writeI64(self.limit)
7878 
      oprot.writeFieldEnd()
7879 
    oprot.writeFieldStop()
7880 
    oprot.writeStructEnd()
7881 
 
3431 rajveer 7882 
  def validate(self):
7883 
    return
7884 
 
7885 
 
1382 varun.gupt 7886 
  def __repr__(self):
7887 
    L = ['%s=%r' % (key, value)
7888 
      for key, value in self.__dict__.iteritems()]
7889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7890 
 
7891 
  def __eq__(self, other):
7892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7893 
 
7894 
  def __ne__(self, other):
7895 
    return not (self == other)
7896 
 
7897 
class getReturnableOrdersForCustomer_result:
7898 
  """
7899 
  Attributes:
7900 
   - success
7901 
   - ex
7902 
  """
7903 
 
7904 
  thrift_spec = (
7905 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7906 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7907 
  )
7908 
 
7909 
  def __init__(self, success=None, ex=None,):
7910 
    self.success = success
7911 
    self.ex = ex
7912 
 
7913 
  def read(self, iprot):
7914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7916 
      return
7917 
    iprot.readStructBegin()
7918 
    while True:
7919 
      (fname, ftype, fid) = iprot.readFieldBegin()
7920 
      if ftype == TType.STOP:
7921 
        break
7922 
      if fid == 0:
7923 
        if ftype == TType.LIST:
7924 
          self.success = []
4837 varun.gupt 7925 
          (_etype108, _size105) = iprot.readListBegin()
7926 
          for _i109 in xrange(_size105):
7927 
            _elem110 = iprot.readI64();
7928 
            self.success.append(_elem110)
1382 varun.gupt 7929 
          iprot.readListEnd()
7930 
        else:
7931 
          iprot.skip(ftype)
7932 
      elif fid == 1:
7933 
        if ftype == TType.STRUCT:
7934 
          self.ex = TransactionServiceException()
7935 
          self.ex.read(iprot)
7936 
        else:
7937 
          iprot.skip(ftype)
7938 
      else:
7939 
        iprot.skip(ftype)
7940 
      iprot.readFieldEnd()
7941 
    iprot.readStructEnd()
7942 
 
7943 
  def write(self, oprot):
7944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7946 
      return
7947 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 7948 
    if self.success is not None:
1382 varun.gupt 7949 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7950 
      oprot.writeListBegin(TType.I64, len(self.success))
4837 varun.gupt 7951 
      for iter111 in self.success:
7952 
        oprot.writeI64(iter111)
1382 varun.gupt 7953 
      oprot.writeListEnd()
7954 
      oprot.writeFieldEnd()
3431 rajveer 7955 
    if self.ex is not None:
1382 varun.gupt 7956 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7957 
      self.ex.write(oprot)
7958 
      oprot.writeFieldEnd()
7959 
    oprot.writeFieldStop()
7960 
    oprot.writeStructEnd()
7961 
 
3431 rajveer 7962 
  def validate(self):
7963 
    return
7964 
 
7965 
 
1382 varun.gupt 7966 
  def __repr__(self):
7967 
    L = ['%s=%r' % (key, value)
7968 
      for key, value in self.__dict__.iteritems()]
7969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7970 
 
7971 
  def __eq__(self, other):
7972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7973 
 
7974 
  def __ne__(self, other):
7975 
    return not (self == other)
7976 
 
7977 
class getCancellableOrdersForCustomer_args:
7978 
  """
7979 
  Attributes:
7980 
   - customer_id
7981 
   - limit
7982 
  """
7983 
 
7984 
  thrift_spec = (
7985 
    None, # 0
7986 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7987 
    (2, TType.I64, 'limit', None, None, ), # 2
7988 
  )
7989 
 
7990 
  def __init__(self, customer_id=None, limit=None,):
7991 
    self.customer_id = customer_id
7992 
    self.limit = limit
7993 
 
7994 
  def read(self, iprot):
7995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7997 
      return
7998 
    iprot.readStructBegin()
7999 
    while True:
8000 
      (fname, ftype, fid) = iprot.readFieldBegin()
8001 
      if ftype == TType.STOP:
8002 
        break
8003 
      if fid == 1:
8004 
        if ftype == TType.I64:
8005 
          self.customer_id = iprot.readI64();
8006 
        else:
8007 
          iprot.skip(ftype)
8008 
      elif fid == 2:
8009 
        if ftype == TType.I64:
8010 
          self.limit = iprot.readI64();
8011 
        else:
8012 
          iprot.skip(ftype)
8013 
      else:
8014 
        iprot.skip(ftype)
8015 
      iprot.readFieldEnd()
8016 
    iprot.readStructEnd()
8017 
 
8018 
  def write(self, oprot):
8019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8021 
      return
8022 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 8023 
    if self.customer_id is not None:
1382 varun.gupt 8024 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8025 
      oprot.writeI64(self.customer_id)
8026 
      oprot.writeFieldEnd()
3431 rajveer 8027 
    if self.limit is not None:
1382 varun.gupt 8028 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8029 
      oprot.writeI64(self.limit)
8030 
      oprot.writeFieldEnd()
8031 
    oprot.writeFieldStop()
8032 
    oprot.writeStructEnd()
8033 
 
3431 rajveer 8034 
  def validate(self):
8035 
    return
8036 
 
8037 
 
1382 varun.gupt 8038 
  def __repr__(self):
8039 
    L = ['%s=%r' % (key, value)
8040 
      for key, value in self.__dict__.iteritems()]
8041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8042 
 
8043 
  def __eq__(self, other):
8044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8045 
 
8046 
  def __ne__(self, other):
8047 
    return not (self == other)
8048 
 
8049 
class getCancellableOrdersForCustomer_result:
8050 
  """
8051 
  Attributes:
8052 
   - success
8053 
   - ex
8054 
  """
8055 
 
8056 
  thrift_spec = (
8057 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8058 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8059 
  )
8060 
 
8061 
  def __init__(self, success=None, ex=None,):
8062 
    self.success = success
8063 
    self.ex = ex
8064 
 
8065 
  def read(self, iprot):
8066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8068 
      return
8069 
    iprot.readStructBegin()
8070 
    while True:
8071 
      (fname, ftype, fid) = iprot.readFieldBegin()
8072 
      if ftype == TType.STOP:
8073 
        break
8074 
      if fid == 0:
8075 
        if ftype == TType.LIST:
8076 
          self.success = []
4837 varun.gupt 8077 
          (_etype115, _size112) = iprot.readListBegin()
8078 
          for _i116 in xrange(_size112):
8079 
            _elem117 = iprot.readI64();
8080 
            self.success.append(_elem117)
1382 varun.gupt 8081 
          iprot.readListEnd()
8082 
        else:
8083 
          iprot.skip(ftype)
8084 
      elif fid == 1:
8085 
        if ftype == TType.STRUCT:
8086 
          self.ex = TransactionServiceException()
8087 
          self.ex.read(iprot)
8088 
        else:
8089 
          iprot.skip(ftype)
8090 
      else:
8091 
        iprot.skip(ftype)
8092 
      iprot.readFieldEnd()
8093 
    iprot.readStructEnd()
8094 
 
8095 
  def write(self, oprot):
8096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8098 
      return
8099 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8100 
    if self.success is not None:
1382 varun.gupt 8101 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8102 
      oprot.writeListBegin(TType.I64, len(self.success))
4837 varun.gupt 8103 
      for iter118 in self.success:
8104 
        oprot.writeI64(iter118)
1382 varun.gupt 8105 
      oprot.writeListEnd()
8106 
      oprot.writeFieldEnd()
3431 rajveer 8107 
    if self.ex is not None:
1382 varun.gupt 8108 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8109 
      self.ex.write(oprot)
8110 
      oprot.writeFieldEnd()
8111 
    oprot.writeFieldStop()
8112 
    oprot.writeStructEnd()
8113 
 
3431 rajveer 8114 
  def validate(self):
8115 
    return
8116 
 
8117 
 
1382 varun.gupt 8118 
  def __repr__(self):
8119 
    L = ['%s=%r' % (key, value)
8120 
      for key, value in self.__dict__.iteritems()]
8121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8122 
 
8123 
  def __eq__(self, other):
8124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8125 
 
8126 
  def __ne__(self, other):
8127 
    return not (self == other)
8128 
 
483 rajveer 8129 
class changeOrderStatus_args:
94 ashish 8130 
  """
8131 
  Attributes:
483 rajveer 8132 
   - orderId
8133 
   - status
8134 
   - description
94 ashish 8135 
  """
8136 
 
8137 
  thrift_spec = (
8138 
    None, # 0
483 rajveer 8139 
    (1, TType.I64, 'orderId', None, None, ), # 1
8140 
    (2, TType.I32, 'status', None, None, ), # 2
8141 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8142 
  )
8143 
 
483 rajveer 8144 
  def __init__(self, orderId=None, status=None, description=None,):
8145 
    self.orderId = orderId
8146 
    self.status = status
8147 
    self.description = description
94 ashish 8148 
 
8149 
  def read(self, iprot):
8150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8152 
      return
8153 
    iprot.readStructBegin()
8154 
    while True:
8155 
      (fname, ftype, fid) = iprot.readFieldBegin()
8156 
      if ftype == TType.STOP:
8157 
        break
8158 
      if fid == 1:
8159 
        if ftype == TType.I64:
483 rajveer 8160 
          self.orderId = iprot.readI64();
94 ashish 8161 
        else:
8162 
          iprot.skip(ftype)
8163 
      elif fid == 2:
483 rajveer 8164 
        if ftype == TType.I32:
8165 
          self.status = iprot.readI32();
94 ashish 8166 
        else:
8167 
          iprot.skip(ftype)
483 rajveer 8168 
      elif fid == 3:
8169 
        if ftype == TType.STRING:
8170 
          self.description = iprot.readString();
8171 
        else:
8172 
          iprot.skip(ftype)
94 ashish 8173 
      else:
8174 
        iprot.skip(ftype)
8175 
      iprot.readFieldEnd()
8176 
    iprot.readStructEnd()
8177 
 
8178 
  def write(self, oprot):
8179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8181 
      return
483 rajveer 8182 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8183 
    if self.orderId is not None:
483 rajveer 8184 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8185 
      oprot.writeI64(self.orderId)
94 ashish 8186 
      oprot.writeFieldEnd()
3431 rajveer 8187 
    if self.status is not None:
483 rajveer 8188 
      oprot.writeFieldBegin('status', TType.I32, 2)
8189 
      oprot.writeI32(self.status)
94 ashish 8190 
      oprot.writeFieldEnd()
3431 rajveer 8191 
    if self.description is not None:
483 rajveer 8192 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8193 
      oprot.writeString(self.description)
8194 
      oprot.writeFieldEnd()
94 ashish 8195 
    oprot.writeFieldStop()
8196 
    oprot.writeStructEnd()
8197 
 
3431 rajveer 8198 
  def validate(self):
8199 
    return
8200 
 
8201 
 
94 ashish 8202 
  def __repr__(self):
8203 
    L = ['%s=%r' % (key, value)
8204 
      for key, value in self.__dict__.iteritems()]
8205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8206 
 
8207 
  def __eq__(self, other):
8208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8209 
 
8210 
  def __ne__(self, other):
8211 
    return not (self == other)
8212 
 
483 rajveer 8213 
class changeOrderStatus_result:
94 ashish 8214 
  """
8215 
  Attributes:
8216 
   - success
8217 
   - ex
8218 
  """
8219 
 
8220 
  thrift_spec = (
8221 
    (0, TType.BOOL, 'success', None, None, ), # 0
8222 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8223 
  )
8224 
 
8225 
  def __init__(self, success=None, ex=None,):
8226 
    self.success = success
8227 
    self.ex = ex
8228 
 
8229 
  def read(self, iprot):
8230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8232 
      return
8233 
    iprot.readStructBegin()
8234 
    while True:
8235 
      (fname, ftype, fid) = iprot.readFieldBegin()
8236 
      if ftype == TType.STOP:
8237 
        break
8238 
      if fid == 0:
8239 
        if ftype == TType.BOOL:
8240 
          self.success = iprot.readBool();
8241 
        else:
8242 
          iprot.skip(ftype)
8243 
      elif fid == 1:
8244 
        if ftype == TType.STRUCT:
8245 
          self.ex = TransactionServiceException()
8246 
          self.ex.read(iprot)
8247 
        else:
8248 
          iprot.skip(ftype)
8249 
      else:
8250 
        iprot.skip(ftype)
8251 
      iprot.readFieldEnd()
8252 
    iprot.readStructEnd()
8253 
 
8254 
  def write(self, oprot):
8255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8257 
      return
483 rajveer 8258 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8259 
    if self.success is not None:
94 ashish 8260 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8261 
      oprot.writeBool(self.success)
8262 
      oprot.writeFieldEnd()
3431 rajveer 8263 
    if self.ex is not None:
94 ashish 8264 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8265 
      self.ex.write(oprot)
8266 
      oprot.writeFieldEnd()
8267 
    oprot.writeFieldStop()
8268 
    oprot.writeStructEnd()
8269 
 
3431 rajveer 8270 
  def validate(self):
8271 
    return
8272 
 
8273 
 
94 ashish 8274 
  def __repr__(self):
8275 
    L = ['%s=%r' % (key, value)
8276 
      for key, value in self.__dict__.iteritems()]
8277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8278 
 
8279 
  def __eq__(self, other):
8280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8281 
 
8282 
  def __ne__(self, other):
8283 
    return not (self == other)
8284 
 
3064 chandransh 8285 
class getOrdersForTransaction_args:
494 rajveer 8286 
  """
8287 
  Attributes:
3064 chandransh 8288 
   - transactionId
8289 
   - customerId
494 rajveer 8290 
  """
8291 
 
8292 
  thrift_spec = (
8293 
    None, # 0
3064 chandransh 8294 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8295 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8296 
  )
8297 
 
3064 chandransh 8298 
  def __init__(self, transactionId=None, customerId=None,):
8299 
    self.transactionId = transactionId
8300 
    self.customerId = customerId
494 rajveer 8301 
 
8302 
  def read(self, iprot):
8303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8305 
      return
8306 
    iprot.readStructBegin()
8307 
    while True:
8308 
      (fname, ftype, fid) = iprot.readFieldBegin()
8309 
      if ftype == TType.STOP:
8310 
        break
8311 
      if fid == 1:
8312 
        if ftype == TType.I64:
3064 chandransh 8313 
          self.transactionId = iprot.readI64();
494 rajveer 8314 
        else:
8315 
          iprot.skip(ftype)
8316 
      elif fid == 2:
3064 chandransh 8317 
        if ftype == TType.I64:
8318 
          self.customerId = iprot.readI64();
494 rajveer 8319 
        else:
8320 
          iprot.skip(ftype)
8321 
      else:
8322 
        iprot.skip(ftype)
8323 
      iprot.readFieldEnd()
8324 
    iprot.readStructEnd()
8325 
 
8326 
  def write(self, oprot):
8327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8329 
      return
3064 chandransh 8330 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8331 
    if self.transactionId is not None:
3064 chandransh 8332 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8333 
      oprot.writeI64(self.transactionId)
494 rajveer 8334 
      oprot.writeFieldEnd()
3431 rajveer 8335 
    if self.customerId is not None:
3064 chandransh 8336 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8337 
      oprot.writeI64(self.customerId)
494 rajveer 8338 
      oprot.writeFieldEnd()
8339 
    oprot.writeFieldStop()
8340 
    oprot.writeStructEnd()
8341 
 
3431 rajveer 8342 
  def validate(self):
8343 
    return
8344 
 
8345 
 
494 rajveer 8346 
  def __repr__(self):
8347 
    L = ['%s=%r' % (key, value)
8348 
      for key, value in self.__dict__.iteritems()]
8349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8350 
 
8351 
  def __eq__(self, other):
8352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8353 
 
8354 
  def __ne__(self, other):
8355 
    return not (self == other)
8356 
 
3064 chandransh 8357 
class getOrdersForTransaction_result:
494 rajveer 8358 
  """
8359 
  Attributes:
8360 
   - success
8361 
   - ex
8362 
  """
8363 
 
8364 
  thrift_spec = (
3064 chandransh 8365 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8366 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8367 
  )
8368 
 
8369 
  def __init__(self, success=None, ex=None,):
8370 
    self.success = success
8371 
    self.ex = ex
8372 
 
8373 
  def read(self, iprot):
8374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8376 
      return
8377 
    iprot.readStructBegin()
8378 
    while True:
8379 
      (fname, ftype, fid) = iprot.readFieldBegin()
8380 
      if ftype == TType.STOP:
8381 
        break
8382 
      if fid == 0:
3064 chandransh 8383 
        if ftype == TType.LIST:
8384 
          self.success = []
4837 varun.gupt 8385 
          (_etype122, _size119) = iprot.readListBegin()
8386 
          for _i123 in xrange(_size119):
8387 
            _elem124 = Order()
8388 
            _elem124.read(iprot)
8389 
            self.success.append(_elem124)
3064 chandransh 8390 
          iprot.readListEnd()
494 rajveer 8391 
        else:
8392 
          iprot.skip(ftype)
8393 
      elif fid == 1:
8394 
        if ftype == TType.STRUCT:
8395 
          self.ex = TransactionServiceException()
8396 
          self.ex.read(iprot)
8397 
        else:
8398 
          iprot.skip(ftype)
8399 
      else:
8400 
        iprot.skip(ftype)
8401 
      iprot.readFieldEnd()
8402 
    iprot.readStructEnd()
8403 
 
8404 
  def write(self, oprot):
8405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8407 
      return
3064 chandransh 8408 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 8409 
    if self.success is not None:
3064 chandransh 8410 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8411 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 8412 
      for iter125 in self.success:
8413 
        iter125.write(oprot)
3064 chandransh 8414 
      oprot.writeListEnd()
494 rajveer 8415 
      oprot.writeFieldEnd()
3431 rajveer 8416 
    if self.ex is not None:
494 rajveer 8417 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8418 
      self.ex.write(oprot)
8419 
      oprot.writeFieldEnd()
8420 
    oprot.writeFieldStop()
8421 
    oprot.writeStructEnd()
8422 
 
3431 rajveer 8423 
  def validate(self):
8424 
    return
8425 
 
8426 
 
494 rajveer 8427 
  def __repr__(self):
8428 
    L = ['%s=%r' % (key, value)
8429 
      for key, value in self.__dict__.iteritems()]
8430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8431 
 
8432 
  def __eq__(self, other):
8433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8434 
 
8435 
  def __ne__(self, other):
8436 
    return not (self == other)
8437 
 
3064 chandransh 8438 
class getOrdersForCustomer_args:
1149 chandransh 8439 
  """
8440 
  Attributes:
3064 chandransh 8441 
   - customerId
8442 
   - from_date
8443 
   - to_date
8444 
   - statuses
1149 chandransh 8445 
  """
8446 
 
8447 
  thrift_spec = (
8448 
    None, # 0
3064 chandransh 8449 
    (1, TType.I64, 'customerId', None, None, ), # 1
8450 
    (2, TType.I64, 'from_date', None, None, ), # 2
8451 
    (3, TType.I64, 'to_date', None, None, ), # 3
8452 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 8453 
  )
8454 
 
3064 chandransh 8455 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
8456 
    self.customerId = customerId
8457 
    self.from_date = from_date
8458 
    self.to_date = to_date
8459 
    self.statuses = statuses
1149 chandransh 8460 
 
8461 
  def read(self, iprot):
8462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8464 
      return
8465 
    iprot.readStructBegin()
8466 
    while True:
8467 
      (fname, ftype, fid) = iprot.readFieldBegin()
8468 
      if ftype == TType.STOP:
8469 
        break
8470 
      if fid == 1:
8471 
        if ftype == TType.I64:
3064 chandransh 8472 
          self.customerId = iprot.readI64();
1149 chandransh 8473 
        else:
8474 
          iprot.skip(ftype)
8475 
      elif fid == 2:
8476 
        if ftype == TType.I64:
3064 chandransh 8477 
          self.from_date = iprot.readI64();
1149 chandransh 8478 
        else:
8479 
          iprot.skip(ftype)
2783 chandransh 8480 
      elif fid == 3:
8481 
        if ftype == TType.I64:
3064 chandransh 8482 
          self.to_date = iprot.readI64();
2783 chandransh 8483 
        else:
8484 
          iprot.skip(ftype)
8485 
      elif fid == 4:
3064 chandransh 8486 
        if ftype == TType.LIST:
8487 
          self.statuses = []
4837 varun.gupt 8488 
          (_etype129, _size126) = iprot.readListBegin()
8489 
          for _i130 in xrange(_size126):
8490 
            _elem131 = iprot.readI32();
8491 
            self.statuses.append(_elem131)
3064 chandransh 8492 
          iprot.readListEnd()
2783 chandransh 8493 
        else:
8494 
          iprot.skip(ftype)
1149 chandransh 8495 
      else:
8496 
        iprot.skip(ftype)
8497 
      iprot.readFieldEnd()
8498 
    iprot.readStructEnd()
8499 
 
8500 
  def write(self, oprot):
8501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8503 
      return
3064 chandransh 8504 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 8505 
    if self.customerId is not None:
3064 chandransh 8506 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8507 
      oprot.writeI64(self.customerId)
1149 chandransh 8508 
      oprot.writeFieldEnd()
3431 rajveer 8509 
    if self.from_date is not None:
3064 chandransh 8510 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8511 
      oprot.writeI64(self.from_date)
1149 chandransh 8512 
      oprot.writeFieldEnd()
3431 rajveer 8513 
    if self.to_date is not None:
3064 chandransh 8514 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8515 
      oprot.writeI64(self.to_date)
2783 chandransh 8516 
      oprot.writeFieldEnd()
3431 rajveer 8517 
    if self.statuses is not None:
3064 chandransh 8518 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
8519 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4837 varun.gupt 8520 
      for iter132 in self.statuses:
8521 
        oprot.writeI32(iter132)
3064 chandransh 8522 
      oprot.writeListEnd()
2783 chandransh 8523 
      oprot.writeFieldEnd()
1149 chandransh 8524 
    oprot.writeFieldStop()
8525 
    oprot.writeStructEnd()
8526 
 
3431 rajveer 8527 
  def validate(self):
8528 
    return
8529 
 
8530 
 
1149 chandransh 8531 
  def __repr__(self):
8532 
    L = ['%s=%r' % (key, value)
8533 
      for key, value in self.__dict__.iteritems()]
8534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8535 
 
8536 
  def __eq__(self, other):
8537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8538 
 
8539 
  def __ne__(self, other):
8540 
    return not (self == other)
8541 
 
3064 chandransh 8542 
class getOrdersForCustomer_result:
1149 chandransh 8543 
  """
8544 
  Attributes:
8545 
   - success
8546 
   - ex
8547 
  """
8548 
 
8549 
  thrift_spec = (
3064 chandransh 8550 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8551 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8552 
  )
8553 
 
8554 
  def __init__(self, success=None, ex=None,):
8555 
    self.success = success
8556 
    self.ex = ex
8557 
 
8558 
  def read(self, iprot):
8559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8561 
      return
8562 
    iprot.readStructBegin()
8563 
    while True:
8564 
      (fname, ftype, fid) = iprot.readFieldBegin()
8565 
      if ftype == TType.STOP:
8566 
        break
8567 
      if fid == 0:
3064 chandransh 8568 
        if ftype == TType.LIST:
8569 
          self.success = []
4837 varun.gupt 8570 
          (_etype136, _size133) = iprot.readListBegin()
8571 
          for _i137 in xrange(_size133):
8572 
            _elem138 = Order()
8573 
            _elem138.read(iprot)
8574 
            self.success.append(_elem138)
3064 chandransh 8575 
          iprot.readListEnd()
1149 chandransh 8576 
        else:
8577 
          iprot.skip(ftype)
8578 
      elif fid == 1:
8579 
        if ftype == TType.STRUCT:
8580 
          self.ex = TransactionServiceException()
8581 
          self.ex.read(iprot)
8582 
        else:
8583 
          iprot.skip(ftype)
8584 
      else:
8585 
        iprot.skip(ftype)
8586 
      iprot.readFieldEnd()
8587 
    iprot.readStructEnd()
8588 
 
8589 
  def write(self, oprot):
8590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8592 
      return
3064 chandransh 8593 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 8594 
    if self.success is not None:
3064 chandransh 8595 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8596 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 8597 
      for iter139 in self.success:
8598 
        iter139.write(oprot)
3064 chandransh 8599 
      oprot.writeListEnd()
1149 chandransh 8600 
      oprot.writeFieldEnd()
3431 rajveer 8601 
    if self.ex is not None:
1149 chandransh 8602 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8603 
      self.ex.write(oprot)
8604 
      oprot.writeFieldEnd()
8605 
    oprot.writeFieldStop()
8606 
    oprot.writeStructEnd()
8607 
 
3431 rajveer 8608 
  def validate(self):
8609 
    return
8610 
 
8611 
 
1149 chandransh 8612 
  def __repr__(self):
8613 
    L = ['%s=%r' % (key, value)
8614 
      for key, value in self.__dict__.iteritems()]
8615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8616 
 
8617 
  def __eq__(self, other):
8618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8619 
 
8620 
  def __ne__(self, other):
8621 
    return not (self == other)
8622 
 
3064 chandransh 8623 
class createOrder_args:
921 rajveer 8624 
  """
8625 
  Attributes:
3064 chandransh 8626 
   - order
921 rajveer 8627 
  """
8628 
 
8629 
  thrift_spec = (
8630 
    None, # 0
3064 chandransh 8631 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 8632 
  )
8633 
 
3064 chandransh 8634 
  def __init__(self, order=None,):
8635 
    self.order = order
921 rajveer 8636 
 
8637 
  def read(self, iprot):
8638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8640 
      return
8641 
    iprot.readStructBegin()
8642 
    while True:
8643 
      (fname, ftype, fid) = iprot.readFieldBegin()
8644 
      if ftype == TType.STOP:
8645 
        break
8646 
      if fid == 1:
3064 chandransh 8647 
        if ftype == TType.STRUCT:
8648 
          self.order = Order()
8649 
          self.order.read(iprot)
921 rajveer 8650 
        else:
8651 
          iprot.skip(ftype)
8652 
      else:
8653 
        iprot.skip(ftype)
8654 
      iprot.readFieldEnd()
8655 
    iprot.readStructEnd()
8656 
 
8657 
  def write(self, oprot):
8658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8660 
      return
3064 chandransh 8661 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 8662 
    if self.order is not None:
3064 chandransh 8663 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
8664 
      self.order.write(oprot)
921 rajveer 8665 
      oprot.writeFieldEnd()
8666 
    oprot.writeFieldStop()
8667 
    oprot.writeStructEnd()
8668 
 
3431 rajveer 8669 
  def validate(self):
8670 
    return
8671 
 
8672 
 
921 rajveer 8673 
  def __repr__(self):
8674 
    L = ['%s=%r' % (key, value)
8675 
      for key, value in self.__dict__.iteritems()]
8676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8677 
 
8678 
  def __eq__(self, other):
8679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8680 
 
8681 
  def __ne__(self, other):
8682 
    return not (self == other)
8683 
 
3064 chandransh 8684 
class createOrder_result:
921 rajveer 8685 
  """
8686 
  Attributes:
8687 
   - success
8688 
   - ex
8689 
  """
8690 
 
8691 
  thrift_spec = (
3064 chandransh 8692 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 8693 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8694 
  )
8695 
 
8696 
  def __init__(self, success=None, ex=None,):
8697 
    self.success = success
8698 
    self.ex = ex
8699 
 
8700 
  def read(self, iprot):
8701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8703 
      return
8704 
    iprot.readStructBegin()
8705 
    while True:
8706 
      (fname, ftype, fid) = iprot.readFieldBegin()
8707 
      if ftype == TType.STOP:
8708 
        break
8709 
      if fid == 0:
3064 chandransh 8710 
        if ftype == TType.I64:
8711 
          self.success = iprot.readI64();
921 rajveer 8712 
        else:
8713 
          iprot.skip(ftype)
8714 
      elif fid == 1:
8715 
        if ftype == TType.STRUCT:
8716 
          self.ex = TransactionServiceException()
8717 
          self.ex.read(iprot)
8718 
        else:
8719 
          iprot.skip(ftype)
8720 
      else:
8721 
        iprot.skip(ftype)
8722 
      iprot.readFieldEnd()
8723 
    iprot.readStructEnd()
8724 
 
8725 
  def write(self, oprot):
8726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8728 
      return
3064 chandransh 8729 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 8730 
    if self.success is not None:
3064 chandransh 8731 
      oprot.writeFieldBegin('success', TType.I64, 0)
8732 
      oprot.writeI64(self.success)
921 rajveer 8733 
      oprot.writeFieldEnd()
3431 rajveer 8734 
    if self.ex is not None:
921 rajveer 8735 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8736 
      self.ex.write(oprot)
8737 
      oprot.writeFieldEnd()
8738 
    oprot.writeFieldStop()
8739 
    oprot.writeStructEnd()
8740 
 
3431 rajveer 8741 
  def validate(self):
8742 
    return
8743 
 
8744 
 
921 rajveer 8745 
  def __repr__(self):
8746 
    L = ['%s=%r' % (key, value)
8747 
      for key, value in self.__dict__.iteritems()]
8748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8749 
 
8750 
  def __eq__(self, other):
8751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8752 
 
8753 
  def __ne__(self, other):
8754 
    return not (self == other)
8755 
 
3064 chandransh 8756 
class getOrder_args:
921 rajveer 8757 
  """
8758 
  Attributes:
3064 chandransh 8759 
   - id
921 rajveer 8760 
  """
8761 
 
8762 
  thrift_spec = (
8763 
    None, # 0
3064 chandransh 8764 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 8765 
  )
8766 
 
3064 chandransh 8767 
  def __init__(self, id=None,):
8768 
    self.id = id
921 rajveer 8769 
 
8770 
  def read(self, iprot):
8771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8773 
      return
8774 
    iprot.readStructBegin()
8775 
    while True:
8776 
      (fname, ftype, fid) = iprot.readFieldBegin()
8777 
      if ftype == TType.STOP:
8778 
        break
8779 
      if fid == 1:
8780 
        if ftype == TType.I64:
3064 chandransh 8781 
          self.id = iprot.readI64();
921 rajveer 8782 
        else:
8783 
          iprot.skip(ftype)
8784 
      else:
8785 
        iprot.skip(ftype)
8786 
      iprot.readFieldEnd()
8787 
    iprot.readStructEnd()
8788 
 
8789 
  def write(self, oprot):
8790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8792 
      return
3064 chandransh 8793 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 8794 
    if self.id is not None:
3064 chandransh 8795 
      oprot.writeFieldBegin('id', TType.I64, 1)
8796 
      oprot.writeI64(self.id)
921 rajveer 8797 
      oprot.writeFieldEnd()
8798 
    oprot.writeFieldStop()
8799 
    oprot.writeStructEnd()
8800 
 
3431 rajveer 8801 
  def validate(self):
8802 
    return
8803 
 
8804 
 
921 rajveer 8805 
  def __repr__(self):
8806 
    L = ['%s=%r' % (key, value)
8807 
      for key, value in self.__dict__.iteritems()]
8808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8809 
 
8810 
  def __eq__(self, other):
8811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8812 
 
8813 
  def __ne__(self, other):
8814 
    return not (self == other)
8815 
 
3064 chandransh 8816 
class getOrder_result:
921 rajveer 8817 
  """
8818 
  Attributes:
8819 
   - success
8820 
   - ex
8821 
  """
8822 
 
8823 
  thrift_spec = (
3064 chandransh 8824 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 8825 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8826 
  )
8827 
 
8828 
  def __init__(self, success=None, ex=None,):
8829 
    self.success = success
8830 
    self.ex = ex
8831 
 
8832 
  def read(self, iprot):
8833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8835 
      return
8836 
    iprot.readStructBegin()
8837 
    while True:
8838 
      (fname, ftype, fid) = iprot.readFieldBegin()
8839 
      if ftype == TType.STOP:
8840 
        break
8841 
      if fid == 0:
3064 chandransh 8842 
        if ftype == TType.STRUCT:
8843 
          self.success = Order()
8844 
          self.success.read(iprot)
921 rajveer 8845 
        else:
8846 
          iprot.skip(ftype)
8847 
      elif fid == 1:
8848 
        if ftype == TType.STRUCT:
8849 
          self.ex = TransactionServiceException()
8850 
          self.ex.read(iprot)
8851 
        else:
8852 
          iprot.skip(ftype)
8853 
      else:
8854 
        iprot.skip(ftype)
8855 
      iprot.readFieldEnd()
8856 
    iprot.readStructEnd()
8857 
 
8858 
  def write(self, oprot):
8859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8861 
      return
3064 chandransh 8862 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 8863 
    if self.success is not None:
3064 chandransh 8864 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8865 
      self.success.write(oprot)
921 rajveer 8866 
      oprot.writeFieldEnd()
3431 rajveer 8867 
    if self.ex is not None:
921 rajveer 8868 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8869 
      self.ex.write(oprot)
8870 
      oprot.writeFieldEnd()
8871 
    oprot.writeFieldStop()
8872 
    oprot.writeStructEnd()
8873 
 
3431 rajveer 8874 
  def validate(self):
8875 
    return
8876 
 
8877 
 
921 rajveer 8878 
  def __repr__(self):
8879 
    L = ['%s=%r' % (key, value)
8880 
      for key, value in self.__dict__.iteritems()]
8881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8882 
 
8883 
  def __eq__(self, other):
8884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8885 
 
8886 
  def __ne__(self, other):
8887 
    return not (self == other)
8888 
 
3064 chandransh 8889 
class getLineItemsForOrder_args:
94 ashish 8890 
  """
8891 
  Attributes:
3064 chandransh 8892 
   - orderId
94 ashish 8893 
  """
8894 
 
8895 
  thrift_spec = (
8896 
    None, # 0
3064 chandransh 8897 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 8898 
  )
8899 
 
3064 chandransh 8900 
  def __init__(self, orderId=None,):
8901 
    self.orderId = orderId
94 ashish 8902 
 
8903 
  def read(self, iprot):
8904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8906 
      return
8907 
    iprot.readStructBegin()
8908 
    while True:
8909 
      (fname, ftype, fid) = iprot.readFieldBegin()
8910 
      if ftype == TType.STOP:
8911 
        break
8912 
      if fid == 1:
8913 
        if ftype == TType.I64:
3064 chandransh 8914 
          self.orderId = iprot.readI64();
94 ashish 8915 
        else:
8916 
          iprot.skip(ftype)
8917 
      else:
8918 
        iprot.skip(ftype)
8919 
      iprot.readFieldEnd()
8920 
    iprot.readStructEnd()
8921 
 
8922 
  def write(self, oprot):
8923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8925 
      return
3064 chandransh 8926 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 8927 
    if self.orderId is not None:
3064 chandransh 8928 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8929 
      oprot.writeI64(self.orderId)
94 ashish 8930 
      oprot.writeFieldEnd()
8931 
    oprot.writeFieldStop()
8932 
    oprot.writeStructEnd()
8933 
 
3431 rajveer 8934 
  def validate(self):
8935 
    return
8936 
 
8937 
 
94 ashish 8938 
  def __repr__(self):
8939 
    L = ['%s=%r' % (key, value)
8940 
      for key, value in self.__dict__.iteritems()]
8941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8942 
 
8943 
  def __eq__(self, other):
8944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8945 
 
8946 
  def __ne__(self, other):
8947 
    return not (self == other)
8948 
 
3064 chandransh 8949 
class getLineItemsForOrder_result:
94 ashish 8950 
  """
8951 
  Attributes:
8952 
   - success
8953 
   - ex
8954 
  """
8955 
 
8956 
  thrift_spec = (
3064 chandransh 8957 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 8958 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8959 
  )
8960 
 
8961 
  def __init__(self, success=None, ex=None,):
8962 
    self.success = success
8963 
    self.ex = ex
8964 
 
8965 
  def read(self, iprot):
8966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8968 
      return
8969 
    iprot.readStructBegin()
8970 
    while True:
8971 
      (fname, ftype, fid) = iprot.readFieldBegin()
8972 
      if ftype == TType.STOP:
8973 
        break
8974 
      if fid == 0:
483 rajveer 8975 
        if ftype == TType.LIST:
8976 
          self.success = []
4837 varun.gupt 8977 
          (_etype143, _size140) = iprot.readListBegin()
8978 
          for _i144 in xrange(_size140):
8979 
            _elem145 = LineItem()
8980 
            _elem145.read(iprot)
8981 
            self.success.append(_elem145)
483 rajveer 8982 
          iprot.readListEnd()
94 ashish 8983 
        else:
8984 
          iprot.skip(ftype)
8985 
      elif fid == 1:
8986 
        if ftype == TType.STRUCT:
8987 
          self.ex = TransactionServiceException()
8988 
          self.ex.read(iprot)
8989 
        else:
8990 
          iprot.skip(ftype)
8991 
      else:
8992 
        iprot.skip(ftype)
8993 
      iprot.readFieldEnd()
8994 
    iprot.readStructEnd()
8995 
 
8996 
  def write(self, oprot):
8997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8999 
      return
3064 chandransh 9000 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 9001 
    if self.success is not None:
483 rajveer 9002 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9003 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 9004 
      for iter146 in self.success:
9005 
        iter146.write(oprot)
483 rajveer 9006 
      oprot.writeListEnd()
94 ashish 9007 
      oprot.writeFieldEnd()
3431 rajveer 9008 
    if self.ex is not None:
94 ashish 9009 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9010 
      self.ex.write(oprot)
9011 
      oprot.writeFieldEnd()
9012 
    oprot.writeFieldStop()
9013 
    oprot.writeStructEnd()
9014 
 
3431 rajveer 9015 
  def validate(self):
9016 
    return
9017 
 
9018 
 
94 ashish 9019 
  def __repr__(self):
9020 
    L = ['%s=%r' % (key, value)
9021 
      for key, value in self.__dict__.iteritems()]
9022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9023 
 
9024 
  def __eq__(self, other):
9025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9026 
 
9027 
  def __ne__(self, other):
9028 
    return not (self == other)
9029 
 
3064 chandransh 9030 
class getOrderForCustomer_args:
94 ashish 9031 
  """
9032 
  Attributes:
3064 chandransh 9033 
   - orderId
483 rajveer 9034 
   - customerId
94 ashish 9035 
  """
9036 
 
9037 
  thrift_spec = (
9038 
    None, # 0
3064 chandransh 9039 
    (1, TType.I64, 'orderId', None, None, ), # 1
9040 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 9041 
  )
9042 
 
3064 chandransh 9043 
  def __init__(self, orderId=None, customerId=None,):
9044 
    self.orderId = orderId
483 rajveer 9045 
    self.customerId = customerId
94 ashish 9046 
 
9047 
  def read(self, iprot):
9048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9050 
      return
9051 
    iprot.readStructBegin()
9052 
    while True:
9053 
      (fname, ftype, fid) = iprot.readFieldBegin()
9054 
      if ftype == TType.STOP:
9055 
        break
9056 
      if fid == 1:
9057 
        if ftype == TType.I64:
3064 chandransh 9058 
          self.orderId = iprot.readI64();
94 ashish 9059 
        else:
9060 
          iprot.skip(ftype)
9061 
      elif fid == 2:
9062 
        if ftype == TType.I64:
3064 chandransh 9063 
          self.customerId = iprot.readI64();
94 ashish 9064 
        else:
9065 
          iprot.skip(ftype)
9066 
      else:
9067 
        iprot.skip(ftype)
9068 
      iprot.readFieldEnd()
9069 
    iprot.readStructEnd()
9070 
 
9071 
  def write(self, oprot):
9072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9074 
      return
3064 chandransh 9075 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 9076 
    if self.orderId is not None:
3064 chandransh 9077 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9078 
      oprot.writeI64(self.orderId)
9079 
      oprot.writeFieldEnd()
3431 rajveer 9080 
    if self.customerId is not None:
3064 chandransh 9081 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 9082 
      oprot.writeI64(self.customerId)
94 ashish 9083 
      oprot.writeFieldEnd()
9084 
    oprot.writeFieldStop()
9085 
    oprot.writeStructEnd()
9086 
 
3431 rajveer 9087 
  def validate(self):
9088 
    return
9089 
 
9090 
 
94 ashish 9091 
  def __repr__(self):
9092 
    L = ['%s=%r' % (key, value)
9093 
      for key, value in self.__dict__.iteritems()]
9094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9095 
 
9096 
  def __eq__(self, other):
9097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9098 
 
9099 
  def __ne__(self, other):
9100 
    return not (self == other)
9101 
 
3064 chandransh 9102 
class getOrderForCustomer_result:
94 ashish 9103 
  """
9104 
  Attributes:
9105 
   - success
9106 
   - ex
9107 
  """
9108 
 
9109 
  thrift_spec = (
3064 chandransh 9110 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 9111 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9112 
  )
9113 
 
9114 
  def __init__(self, success=None, ex=None,):
9115 
    self.success = success
9116 
    self.ex = ex
9117 
 
9118 
  def read(self, iprot):
9119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9121 
      return
9122 
    iprot.readStructBegin()
9123 
    while True:
9124 
      (fname, ftype, fid) = iprot.readFieldBegin()
9125 
      if ftype == TType.STOP:
9126 
        break
9127 
      if fid == 0:
3064 chandransh 9128 
        if ftype == TType.STRUCT:
9129 
          self.success = Order()
9130 
          self.success.read(iprot)
94 ashish 9131 
        else:
9132 
          iprot.skip(ftype)
9133 
      elif fid == 1:
9134 
        if ftype == TType.STRUCT:
9135 
          self.ex = TransactionServiceException()
9136 
          self.ex.read(iprot)
9137 
        else:
9138 
          iprot.skip(ftype)
9139 
      else:
9140 
        iprot.skip(ftype)
9141 
      iprot.readFieldEnd()
9142 
    iprot.readStructEnd()
9143 
 
9144 
  def write(self, oprot):
9145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9147 
      return
3064 chandransh 9148 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 9149 
    if self.success is not None:
3064 chandransh 9150 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9151 
      self.success.write(oprot)
94 ashish 9152 
      oprot.writeFieldEnd()
3431 rajveer 9153 
    if self.ex is not None:
94 ashish 9154 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9155 
      self.ex.write(oprot)
9156 
      oprot.writeFieldEnd()
9157 
    oprot.writeFieldStop()
9158 
    oprot.writeStructEnd()
9159 
 
3431 rajveer 9160 
  def validate(self):
9161 
    return
9162 
 
9163 
 
94 ashish 9164 
  def __repr__(self):
9165 
    L = ['%s=%r' % (key, value)
9166 
      for key, value in self.__dict__.iteritems()]
9167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9168 
 
9169 
  def __eq__(self, other):
9170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9171 
 
9172 
  def __ne__(self, other):
9173 
    return not (self == other)
9174 
 
3064 chandransh 9175 
class getAlerts_args:
94 ashish 9176 
  """
9177 
  Attributes:
4394 rajveer 9178 
   - type
4444 rajveer 9179 
   - warehouseId
4394 rajveer 9180 
   - status
9181 
   - timestamp
94 ashish 9182 
  """
9183 
 
9184 
  thrift_spec = (
9185 
    None, # 0
4394 rajveer 9186 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9187 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9188 
    (3, TType.I64, 'status', None, None, ), # 3
9189 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 9190 
  )
9191 
 
4444 rajveer 9192 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 9193 
    self.type = type
4444 rajveer 9194 
    self.warehouseId = warehouseId
4394 rajveer 9195 
    self.status = status
9196 
    self.timestamp = timestamp
94 ashish 9197 
 
9198 
  def read(self, iprot):
9199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9201 
      return
9202 
    iprot.readStructBegin()
9203 
    while True:
9204 
      (fname, ftype, fid) = iprot.readFieldBegin()
9205 
      if ftype == TType.STOP:
9206 
        break
9207 
      if fid == 1:
3064 chandransh 9208 
        if ftype == TType.I64:
4394 rajveer 9209 
          self.type = iprot.readI64();
94 ashish 9210 
        else:
9211 
          iprot.skip(ftype)
3064 chandransh 9212 
      elif fid == 2:
4394 rajveer 9213 
        if ftype == TType.I64:
4444 rajveer 9214 
          self.warehouseId = iprot.readI64();
3064 chandransh 9215 
        else:
9216 
          iprot.skip(ftype)
4394 rajveer 9217 
      elif fid == 3:
9218 
        if ftype == TType.I64:
4444 rajveer 9219 
          self.status = iprot.readI64();
9220 
        else:
9221 
          iprot.skip(ftype)
9222 
      elif fid == 4:
9223 
        if ftype == TType.I64:
4394 rajveer 9224 
          self.timestamp = iprot.readI64();
9225 
        else:
9226 
          iprot.skip(ftype)
94 ashish 9227 
      else:
9228 
        iprot.skip(ftype)
9229 
      iprot.readFieldEnd()
9230 
    iprot.readStructEnd()
9231 
 
9232 
  def write(self, oprot):
9233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9235 
      return
3064 chandransh 9236 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 9237 
    if self.type is not None:
9238 
      oprot.writeFieldBegin('type', TType.I64, 1)
9239 
      oprot.writeI64(self.type)
94 ashish 9240 
      oprot.writeFieldEnd()
4444 rajveer 9241 
    if self.warehouseId is not None:
9242 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9243 
      oprot.writeI64(self.warehouseId)
9244 
      oprot.writeFieldEnd()
4394 rajveer 9245 
    if self.status is not None:
4444 rajveer 9246 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 9247 
      oprot.writeI64(self.status)
3064 chandransh 9248 
      oprot.writeFieldEnd()
4394 rajveer 9249 
    if self.timestamp is not None:
4444 rajveer 9250 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 9251 
      oprot.writeI64(self.timestamp)
9252 
      oprot.writeFieldEnd()
94 ashish 9253 
    oprot.writeFieldStop()
9254 
    oprot.writeStructEnd()
9255 
 
3431 rajveer 9256 
  def validate(self):
9257 
    return
9258 
 
9259 
 
94 ashish 9260 
  def __repr__(self):
9261 
    L = ['%s=%r' % (key, value)
9262 
      for key, value in self.__dict__.iteritems()]
9263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9264 
 
9265 
  def __eq__(self, other):
9266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9267 
 
9268 
  def __ne__(self, other):
9269 
    return not (self == other)
9270 
 
3064 chandransh 9271 
class getAlerts_result:
94 ashish 9272 
  """
9273 
  Attributes:
9274 
   - success
9275 
  """
9276 
 
9277 
  thrift_spec = (
3064 chandransh 9278 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 9279 
  )
9280 
 
3064 chandransh 9281 
  def __init__(self, success=None,):
94 ashish 9282 
    self.success = success
9283 
 
9284 
  def read(self, iprot):
9285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9287 
      return
9288 
    iprot.readStructBegin()
9289 
    while True:
9290 
      (fname, ftype, fid) = iprot.readFieldBegin()
9291 
      if ftype == TType.STOP:
9292 
        break
9293 
      if fid == 0:
3064 chandransh 9294 
        if ftype == TType.LIST:
9295 
          self.success = []
4837 varun.gupt 9296 
          (_etype150, _size147) = iprot.readListBegin()
9297 
          for _i151 in xrange(_size147):
9298 
            _elem152 = Alert()
9299 
            _elem152.read(iprot)
9300 
            self.success.append(_elem152)
3064 chandransh 9301 
          iprot.readListEnd()
94 ashish 9302 
        else:
9303 
          iprot.skip(ftype)
9304 
      else:
9305 
        iprot.skip(ftype)
9306 
      iprot.readFieldEnd()
9307 
    iprot.readStructEnd()
9308 
 
9309 
  def write(self, oprot):
9310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9312 
      return
3064 chandransh 9313 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 9314 
    if self.success is not None:
3064 chandransh 9315 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9316 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 9317 
      for iter153 in self.success:
9318 
        iter153.write(oprot)
3064 chandransh 9319 
      oprot.writeListEnd()
94 ashish 9320 
      oprot.writeFieldEnd()
9321 
    oprot.writeFieldStop()
9322 
    oprot.writeStructEnd()
9323 
 
3431 rajveer 9324 
  def validate(self):
9325 
    return
9326 
 
9327 
 
94 ashish 9328 
  def __repr__(self):
9329 
    L = ['%s=%r' % (key, value)
9330 
      for key, value in self.__dict__.iteritems()]
9331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9332 
 
9333 
  def __eq__(self, other):
9334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9335 
 
9336 
  def __ne__(self, other):
9337 
    return not (self == other)
9338 
 
4394 rajveer 9339 
class addAlert_args:
94 ashish 9340 
  """
9341 
  Attributes:
3064 chandransh 9342 
   - type
4444 rajveer 9343 
   - warehouseId
4394 rajveer 9344 
   - description
94 ashish 9345 
  """
9346 
 
9347 
  thrift_spec = (
9348 
    None, # 0
4394 rajveer 9349 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9350 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9351 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9352 
  )
9353 
 
4444 rajveer 9354 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 9355 
    self.type = type
4444 rajveer 9356 
    self.warehouseId = warehouseId
4394 rajveer 9357 
    self.description = description
94 ashish 9358 
 
9359 
  def read(self, iprot):
9360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9362 
      return
9363 
    iprot.readStructBegin()
9364 
    while True:
9365 
      (fname, ftype, fid) = iprot.readFieldBegin()
9366 
      if ftype == TType.STOP:
9367 
        break
9368 
      if fid == 1:
9369 
        if ftype == TType.I64:
4394 rajveer 9370 
          self.type = iprot.readI64();
94 ashish 9371 
        else:
9372 
          iprot.skip(ftype)
3064 chandransh 9373 
      elif fid == 2:
4444 rajveer 9374 
        if ftype == TType.I64:
9375 
          self.warehouseId = iprot.readI64();
9376 
        else:
9377 
          iprot.skip(ftype)
9378 
      elif fid == 3:
3064 chandransh 9379 
        if ftype == TType.STRING:
4394 rajveer 9380 
          self.description = iprot.readString();
3064 chandransh 9381 
        else:
9382 
          iprot.skip(ftype)
94 ashish 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_args')
3431 rajveer 9393 
    if self.type is not None:
4394 rajveer 9394 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 9395 
      oprot.writeI64(self.type)
9396 
      oprot.writeFieldEnd()
4444 rajveer 9397 
    if self.warehouseId is not None:
9398 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9399 
      oprot.writeI64(self.warehouseId)
9400 
      oprot.writeFieldEnd()
4394 rajveer 9401 
    if self.description is not None:
4444 rajveer 9402 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 9403 
      oprot.writeString(self.description)
3064 chandransh 9404 
      oprot.writeFieldEnd()
94 ashish 9405 
    oprot.writeFieldStop()
9406 
    oprot.writeStructEnd()
9407 
 
3431 rajveer 9408 
  def validate(self):
9409 
    return
9410 
 
9411 
 
94 ashish 9412 
  def __repr__(self):
9413 
    L = ['%s=%r' % (key, value)
9414 
      for key, value in self.__dict__.iteritems()]
9415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9416 
 
9417 
  def __eq__(self, other):
9418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9419 
 
9420 
  def __ne__(self, other):
9421 
    return not (self == other)
9422 
 
4394 rajveer 9423 
class addAlert_result:
3064 chandransh 9424 
 
9425 
  thrift_spec = (
9426 
  )
9427 
 
9428 
  def read(self, iprot):
9429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9431 
      return
9432 
    iprot.readStructBegin()
9433 
    while True:
9434 
      (fname, ftype, fid) = iprot.readFieldBegin()
9435 
      if ftype == TType.STOP:
9436 
        break
9437 
      else:
9438 
        iprot.skip(ftype)
9439 
      iprot.readFieldEnd()
9440 
    iprot.readStructEnd()
9441 
 
9442 
  def write(self, oprot):
9443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9445 
      return
4394 rajveer 9446 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 9447 
    oprot.writeFieldStop()
9448 
    oprot.writeStructEnd()
9449 
 
3431 rajveer 9450 
  def validate(self):
9451 
    return
9452 
 
9453 
 
3064 chandransh 9454 
  def __repr__(self):
9455 
    L = ['%s=%r' % (key, value)
9456 
      for key, value in self.__dict__.iteritems()]
9457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9458 
 
9459 
  def __eq__(self, other):
9460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9461 
 
9462 
  def __ne__(self, other):
9463 
    return not (self == other)
9464 
 
4444 rajveer 9465 
class markAlertsAsSeen_args:
9466 
  """
9467 
  Attributes:
9468 
   - warehouseId
9469 
  """
9470 
 
9471 
  thrift_spec = (
9472 
    None, # 0
9473 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9474 
  )
9475 
 
9476 
  def __init__(self, warehouseId=None,):
9477 
    self.warehouseId = warehouseId
9478 
 
9479 
  def read(self, iprot):
9480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9482 
      return
9483 
    iprot.readStructBegin()
9484 
    while True:
9485 
      (fname, ftype, fid) = iprot.readFieldBegin()
9486 
      if ftype == TType.STOP:
9487 
        break
9488 
      if fid == 1:
9489 
        if ftype == TType.I64:
9490 
          self.warehouseId = iprot.readI64();
9491 
        else:
9492 
          iprot.skip(ftype)
9493 
      else:
9494 
        iprot.skip(ftype)
9495 
      iprot.readFieldEnd()
9496 
    iprot.readStructEnd()
9497 
 
9498 
  def write(self, oprot):
9499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9501 
      return
9502 
    oprot.writeStructBegin('markAlertsAsSeen_args')
9503 
    if self.warehouseId is not None:
9504 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9505 
      oprot.writeI64(self.warehouseId)
9506 
      oprot.writeFieldEnd()
9507 
    oprot.writeFieldStop()
9508 
    oprot.writeStructEnd()
9509 
 
9510 
  def validate(self):
9511 
    return
9512 
 
9513 
 
9514 
  def __repr__(self):
9515 
    L = ['%s=%r' % (key, value)
9516 
      for key, value in self.__dict__.iteritems()]
9517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9518 
 
9519 
  def __eq__(self, other):
9520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9521 
 
9522 
  def __ne__(self, other):
9523 
    return not (self == other)
9524 
 
9525 
class markAlertsAsSeen_result:
9526 
 
9527 
  thrift_spec = (
9528 
  )
9529 
 
9530 
  def read(self, iprot):
9531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9533 
      return
9534 
    iprot.readStructBegin()
9535 
    while True:
9536 
      (fname, ftype, fid) = iprot.readFieldBegin()
9537 
      if ftype == TType.STOP:
9538 
        break
9539 
      else:
9540 
        iprot.skip(ftype)
9541 
      iprot.readFieldEnd()
9542 
    iprot.readStructEnd()
9543 
 
9544 
  def write(self, oprot):
9545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9547 
      return
9548 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9549 
    oprot.writeFieldStop()
9550 
    oprot.writeStructEnd()
9551 
 
9552 
  def validate(self):
9553 
    return
9554 
 
9555 
 
9556 
  def __repr__(self):
9557 
    L = ['%s=%r' % (key, value)
9558 
      for key, value in self.__dict__.iteritems()]
9559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9560 
 
9561 
  def __eq__(self, other):
9562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9563 
 
9564 
  def __ne__(self, other):
9565 
    return not (self == other)
9566 
 
3064 chandransh 9567 
class getValidOrderCount_args:
9568 
 
9569 
  thrift_spec = (
9570 
  )
9571 
 
9572 
  def read(self, iprot):
9573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9575 
      return
9576 
    iprot.readStructBegin()
9577 
    while True:
9578 
      (fname, ftype, fid) = iprot.readFieldBegin()
9579 
      if ftype == TType.STOP:
9580 
        break
9581 
      else:
9582 
        iprot.skip(ftype)
9583 
      iprot.readFieldEnd()
9584 
    iprot.readStructEnd()
9585 
 
9586 
  def write(self, oprot):
9587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9589 
      return
9590 
    oprot.writeStructBegin('getValidOrderCount_args')
9591 
    oprot.writeFieldStop()
9592 
    oprot.writeStructEnd()
9593 
 
3431 rajveer 9594 
  def validate(self):
9595 
    return
9596 
 
9597 
 
3064 chandransh 9598 
  def __repr__(self):
9599 
    L = ['%s=%r' % (key, value)
9600 
      for key, value in self.__dict__.iteritems()]
9601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9602 
 
9603 
  def __eq__(self, other):
9604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9605 
 
9606 
  def __ne__(self, other):
9607 
    return not (self == other)
9608 
 
9609 
class getValidOrderCount_result:
94 ashish 9610 
  """
9611 
  Attributes:
9612 
   - success
9613 
  """
9614 
 
9615 
  thrift_spec = (
3064 chandransh 9616 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9617 
  )
9618 
 
3064 chandransh 9619 
  def __init__(self, success=None,):
94 ashish 9620 
    self.success = success
9621 
 
9622 
  def read(self, iprot):
9623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9625 
      return
9626 
    iprot.readStructBegin()
9627 
    while True:
9628 
      (fname, ftype, fid) = iprot.readFieldBegin()
9629 
      if ftype == TType.STOP:
9630 
        break
9631 
      if fid == 0:
3064 chandransh 9632 
        if ftype == TType.I64:
9633 
          self.success = iprot.readI64();
94 ashish 9634 
        else:
9635 
          iprot.skip(ftype)
9636 
      else:
9637 
        iprot.skip(ftype)
9638 
      iprot.readFieldEnd()
9639 
    iprot.readStructEnd()
9640 
 
9641 
  def write(self, oprot):
9642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9644 
      return
3064 chandransh 9645 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 9646 
    if self.success is not None:
3064 chandransh 9647 
      oprot.writeFieldBegin('success', TType.I64, 0)
9648 
      oprot.writeI64(self.success)
94 ashish 9649 
      oprot.writeFieldEnd()
9650 
    oprot.writeFieldStop()
9651 
    oprot.writeStructEnd()
9652 
 
3431 rajveer 9653 
  def validate(self):
9654 
    return
9655 
 
9656 
 
94 ashish 9657 
  def __repr__(self):
9658 
    L = ['%s=%r' % (key, value)
9659 
      for key, value in self.__dict__.iteritems()]
9660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9661 
 
9662 
  def __eq__(self, other):
9663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9664 
 
9665 
  def __ne__(self, other):
9666 
    return not (self == other)
9667 
 
3064 chandransh 9668 
class getNoOfCustomersWithSuccessfulTransaction_args:
9669 
 
9670 
  thrift_spec = (
9671 
  )
9672 
 
9673 
  def read(self, iprot):
9674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9676 
      return
9677 
    iprot.readStructBegin()
9678 
    while True:
9679 
      (fname, ftype, fid) = iprot.readFieldBegin()
9680 
      if ftype == TType.STOP:
9681 
        break
9682 
      else:
9683 
        iprot.skip(ftype)
9684 
      iprot.readFieldEnd()
9685 
    iprot.readStructEnd()
9686 
 
9687 
  def write(self, oprot):
9688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9690 
      return
9691 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
9692 
    oprot.writeFieldStop()
9693 
    oprot.writeStructEnd()
9694 
 
3431 rajveer 9695 
  def validate(self):
9696 
    return
9697 
 
9698 
 
3064 chandransh 9699 
  def __repr__(self):
9700 
    L = ['%s=%r' % (key, value)
9701 
      for key, value in self.__dict__.iteritems()]
9702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9703 
 
9704 
  def __eq__(self, other):
9705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9706 
 
9707 
  def __ne__(self, other):
9708 
    return not (self == other)
9709 
 
9710 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 9711 
  """
9712 
  Attributes:
3064 chandransh 9713 
   - success
94 ashish 9714 
  """
9715 
 
9716 
  thrift_spec = (
3064 chandransh 9717 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9718 
  )
9719 
 
3064 chandransh 9720 
  def __init__(self, success=None,):
9721 
    self.success = success
94 ashish 9722 
 
9723 
  def read(self, iprot):
9724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9726 
      return
9727 
    iprot.readStructBegin()
9728 
    while True:
9729 
      (fname, ftype, fid) = iprot.readFieldBegin()
9730 
      if ftype == TType.STOP:
9731 
        break
3064 chandransh 9732 
      if fid == 0:
94 ashish 9733 
        if ftype == TType.I64:
3064 chandransh 9734 
          self.success = iprot.readI64();
94 ashish 9735 
        else:
9736 
          iprot.skip(ftype)
9737 
      else:
9738 
        iprot.skip(ftype)
9739 
      iprot.readFieldEnd()
9740 
    iprot.readStructEnd()
9741 
 
9742 
  def write(self, oprot):
9743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9745 
      return
3064 chandransh 9746 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 9747 
    if self.success is not None:
3064 chandransh 9748 
      oprot.writeFieldBegin('success', TType.I64, 0)
9749 
      oprot.writeI64(self.success)
94 ashish 9750 
      oprot.writeFieldEnd()
9751 
    oprot.writeFieldStop()
9752 
    oprot.writeStructEnd()
9753 
 
3431 rajveer 9754 
  def validate(self):
9755 
    return
9756 
 
9757 
 
94 ashish 9758 
  def __repr__(self):
9759 
    L = ['%s=%r' % (key, value)
9760 
      for key, value in self.__dict__.iteritems()]
9761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9762 
 
9763 
  def __eq__(self, other):
9764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9765 
 
9766 
  def __ne__(self, other):
9767 
    return not (self == other)
9768 
 
3064 chandransh 9769 
class getValidOrdersAmountRange_args:
9770 
 
9771 
  thrift_spec = (
9772 
  )
9773 
 
9774 
  def read(self, iprot):
9775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9777 
      return
9778 
    iprot.readStructBegin()
9779 
    while True:
9780 
      (fname, ftype, fid) = iprot.readFieldBegin()
9781 
      if ftype == TType.STOP:
9782 
        break
9783 
      else:
9784 
        iprot.skip(ftype)
9785 
      iprot.readFieldEnd()
9786 
    iprot.readStructEnd()
9787 
 
9788 
  def write(self, oprot):
9789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9791 
      return
9792 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
9793 
    oprot.writeFieldStop()
9794 
    oprot.writeStructEnd()
9795 
 
3431 rajveer 9796 
  def validate(self):
9797 
    return
9798 
 
9799 
 
3064 chandransh 9800 
  def __repr__(self):
9801 
    L = ['%s=%r' % (key, value)
9802 
      for key, value in self.__dict__.iteritems()]
9803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9804 
 
9805 
  def __eq__(self, other):
9806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9807 
 
9808 
  def __ne__(self, other):
9809 
    return not (self == other)
9810 
 
9811 
class getValidOrdersAmountRange_result:
94 ashish 9812 
  """
9813 
  Attributes:
9814 
   - success
9815 
  """
9816 
 
9817 
  thrift_spec = (
3064 chandransh 9818 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 9819 
  )
9820 
 
3064 chandransh 9821 
  def __init__(self, success=None,):
94 ashish 9822 
    self.success = success
9823 
 
9824 
  def read(self, iprot):
9825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9827 
      return
9828 
    iprot.readStructBegin()
9829 
    while True:
9830 
      (fname, ftype, fid) = iprot.readFieldBegin()
9831 
      if ftype == TType.STOP:
9832 
        break
9833 
      if fid == 0:
483 rajveer 9834 
        if ftype == TType.LIST:
9835 
          self.success = []
4837 varun.gupt 9836 
          (_etype157, _size154) = iprot.readListBegin()
9837 
          for _i158 in xrange(_size154):
9838 
            _elem159 = iprot.readDouble();
9839 
            self.success.append(_elem159)
483 rajveer 9840 
          iprot.readListEnd()
94 ashish 9841 
        else:
9842 
          iprot.skip(ftype)
9843 
      else:
9844 
        iprot.skip(ftype)
9845 
      iprot.readFieldEnd()
9846 
    iprot.readStructEnd()
9847 
 
9848 
  def write(self, oprot):
9849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9851 
      return
3064 chandransh 9852 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 9853 
    if self.success is not None:
483 rajveer 9854 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 9855 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4837 varun.gupt 9856 
      for iter160 in self.success:
9857 
        oprot.writeDouble(iter160)
483 rajveer 9858 
      oprot.writeListEnd()
94 ashish 9859 
      oprot.writeFieldEnd()
9860 
    oprot.writeFieldStop()
9861 
    oprot.writeStructEnd()
9862 
 
3431 rajveer 9863 
  def validate(self):
9864 
    return
9865 
 
9866 
 
94 ashish 9867 
  def __repr__(self):
9868 
    L = ['%s=%r' % (key, value)
9869 
      for key, value in self.__dict__.iteritems()]
9870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9871 
 
9872 
  def __eq__(self, other):
9873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9874 
 
9875 
  def __ne__(self, other):
9876 
    return not (self == other)
9877 
 
3064 chandransh 9878 
class getValidOrders_args:
1528 ankur.sing 9879 
  """
9880 
  Attributes:
3064 chandransh 9881 
   - limit
1528 ankur.sing 9882 
  """
9883 
 
9884 
  thrift_spec = (
9885 
    None, # 0
3064 chandransh 9886 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 9887 
  )
9888 
 
3064 chandransh 9889 
  def __init__(self, limit=None,):
9890 
    self.limit = limit
1528 ankur.sing 9891 
 
9892 
  def read(self, iprot):
9893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9895 
      return
9896 
    iprot.readStructBegin()
9897 
    while True:
9898 
      (fname, ftype, fid) = iprot.readFieldBegin()
9899 
      if ftype == TType.STOP:
9900 
        break
9901 
      if fid == 1:
9902 
        if ftype == TType.I64:
3064 chandransh 9903 
          self.limit = iprot.readI64();
1528 ankur.sing 9904 
        else:
9905 
          iprot.skip(ftype)
9906 
      else:
9907 
        iprot.skip(ftype)
9908 
      iprot.readFieldEnd()
9909 
    iprot.readStructEnd()
9910 
 
9911 
  def write(self, oprot):
9912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9914 
      return
3064 chandransh 9915 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 9916 
    if self.limit is not None:
3064 chandransh 9917 
      oprot.writeFieldBegin('limit', TType.I64, 1)
9918 
      oprot.writeI64(self.limit)
1528 ankur.sing 9919 
      oprot.writeFieldEnd()
9920 
    oprot.writeFieldStop()
9921 
    oprot.writeStructEnd()
9922 
 
3431 rajveer 9923 
  def validate(self):
9924 
    return
9925 
 
9926 
 
1528 ankur.sing 9927 
  def __repr__(self):
9928 
    L = ['%s=%r' % (key, value)
9929 
      for key, value in self.__dict__.iteritems()]
9930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9931 
 
9932 
  def __eq__(self, other):
9933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9934 
 
9935 
  def __ne__(self, other):
9936 
    return not (self == other)
9937 
 
3064 chandransh 9938 
class getValidOrders_result:
1528 ankur.sing 9939 
  """
9940 
  Attributes:
9941 
   - success
9942 
  """
9943 
 
9944 
  thrift_spec = (
3064 chandransh 9945 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 9946 
  )
9947 
 
3064 chandransh 9948 
  def __init__(self, success=None,):
1528 ankur.sing 9949 
    self.success = success
9950 
 
9951 
  def read(self, iprot):
9952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9954 
      return
9955 
    iprot.readStructBegin()
9956 
    while True:
9957 
      (fname, ftype, fid) = iprot.readFieldBegin()
9958 
      if ftype == TType.STOP:
9959 
        break
9960 
      if fid == 0:
3064 chandransh 9961 
        if ftype == TType.LIST:
9962 
          self.success = []
4837 varun.gupt 9963 
          (_etype164, _size161) = iprot.readListBegin()
9964 
          for _i165 in xrange(_size161):
9965 
            _elem166 = Order()
9966 
            _elem166.read(iprot)
9967 
            self.success.append(_elem166)
3064 chandransh 9968 
          iprot.readListEnd()
1528 ankur.sing 9969 
        else:
9970 
          iprot.skip(ftype)
9971 
      else:
9972 
        iprot.skip(ftype)
9973 
      iprot.readFieldEnd()
9974 
    iprot.readStructEnd()
9975 
 
9976 
  def write(self, oprot):
9977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9979 
      return
3064 chandransh 9980 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9981 
    if self.success is not None:
3064 chandransh 9982 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9983 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 9984 
      for iter167 in self.success:
9985 
        iter167.write(oprot)
3064 chandransh 9986 
      oprot.writeListEnd()
1528 ankur.sing 9987 
      oprot.writeFieldEnd()
9988 
    oprot.writeFieldStop()
9989 
    oprot.writeStructEnd()
9990 
 
3431 rajveer 9991 
  def validate(self):
9992 
    return
9993 
 
9994 
 
1528 ankur.sing 9995 
  def __repr__(self):
9996 
    L = ['%s=%r' % (key, value)
9997 
      for key, value in self.__dict__.iteritems()]
9998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9999 
 
10000 
  def __eq__(self, other):
10001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10002 
 
10003 
  def __ne__(self, other):
10004 
    return not (self == other)
10005 
 
1220 chandransh 10006 
class batchOrders_args:
10007 
  """
10008 
  Attributes:
10009 
   - warehouseId
10010 
  """
10011 
 
10012 
  thrift_spec = (
10013 
    None, # 0
10014 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10015 
  )
10016 
 
10017 
  def __init__(self, warehouseId=None,):
10018 
    self.warehouseId = warehouseId
10019 
 
10020 
  def read(self, iprot):
10021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10023 
      return
10024 
    iprot.readStructBegin()
10025 
    while True:
10026 
      (fname, ftype, fid) = iprot.readFieldBegin()
10027 
      if ftype == TType.STOP:
10028 
        break
10029 
      if fid == 1:
10030 
        if ftype == TType.I64:
10031 
          self.warehouseId = iprot.readI64();
10032 
        else:
10033 
          iprot.skip(ftype)
10034 
      else:
10035 
        iprot.skip(ftype)
10036 
      iprot.readFieldEnd()
10037 
    iprot.readStructEnd()
10038 
 
10039 
  def write(self, oprot):
10040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10042 
      return
10043 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 10044 
    if self.warehouseId is not None:
1220 chandransh 10045 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10046 
      oprot.writeI64(self.warehouseId)
10047 
      oprot.writeFieldEnd()
10048 
    oprot.writeFieldStop()
10049 
    oprot.writeStructEnd()
10050 
 
3431 rajveer 10051 
  def validate(self):
10052 
    return
10053 
 
10054 
 
1220 chandransh 10055 
  def __repr__(self):
10056 
    L = ['%s=%r' % (key, value)
10057 
      for key, value in self.__dict__.iteritems()]
10058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10059 
 
10060 
  def __eq__(self, other):
10061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10062 
 
10063 
  def __ne__(self, other):
10064 
    return not (self == other)
10065 
 
10066 
class batchOrders_result:
10067 
  """
10068 
  Attributes:
10069 
   - success
10070 
   - ex
10071 
  """
10072 
 
10073 
  thrift_spec = (
10074 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10075 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10076 
  )
10077 
 
10078 
  def __init__(self, success=None, ex=None,):
10079 
    self.success = success
10080 
    self.ex = ex
10081 
 
10082 
  def read(self, iprot):
10083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10085 
      return
10086 
    iprot.readStructBegin()
10087 
    while True:
10088 
      (fname, ftype, fid) = iprot.readFieldBegin()
10089 
      if ftype == TType.STOP:
10090 
        break
10091 
      if fid == 0:
10092 
        if ftype == TType.LIST:
10093 
          self.success = []
4837 varun.gupt 10094 
          (_etype171, _size168) = iprot.readListBegin()
10095 
          for _i172 in xrange(_size168):
10096 
            _elem173 = Order()
10097 
            _elem173.read(iprot)
10098 
            self.success.append(_elem173)
1220 chandransh 10099 
          iprot.readListEnd()
10100 
        else:
10101 
          iprot.skip(ftype)
10102 
      elif fid == 1:
10103 
        if ftype == TType.STRUCT:
10104 
          self.ex = TransactionServiceException()
10105 
          self.ex.read(iprot)
10106 
        else:
10107 
          iprot.skip(ftype)
10108 
      else:
10109 
        iprot.skip(ftype)
10110 
      iprot.readFieldEnd()
10111 
    iprot.readStructEnd()
10112 
 
10113 
  def write(self, oprot):
10114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10116 
      return
10117 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 10118 
    if self.success is not None:
1220 chandransh 10119 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10120 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 10121 
      for iter174 in self.success:
10122 
        iter174.write(oprot)
1220 chandransh 10123 
      oprot.writeListEnd()
10124 
      oprot.writeFieldEnd()
3431 rajveer 10125 
    if self.ex is not None:
1220 chandransh 10126 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10127 
      self.ex.write(oprot)
10128 
      oprot.writeFieldEnd()
10129 
    oprot.writeFieldStop()
10130 
    oprot.writeStructEnd()
10131 
 
3431 rajveer 10132 
  def validate(self):
10133 
    return
10134 
 
10135 
 
1220 chandransh 10136 
  def __repr__(self):
10137 
    L = ['%s=%r' % (key, value)
10138 
      for key, value in self.__dict__.iteritems()]
10139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10140 
 
10141 
  def __eq__(self, other):
10142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10143 
 
10144 
  def __ne__(self, other):
10145 
    return not (self == other)
10146 
 
1208 chandransh 10147 
class markOrderAsOutOfStock_args:
10148 
  """
10149 
  Attributes:
10150 
   - orderId
10151 
  """
10152 
 
10153 
  thrift_spec = (
10154 
    None, # 0
10155 
    (1, TType.I64, 'orderId', None, None, ), # 1
10156 
  )
10157 
 
10158 
  def __init__(self, orderId=None,):
10159 
    self.orderId = orderId
10160 
 
10161 
  def read(self, iprot):
10162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10164 
      return
10165 
    iprot.readStructBegin()
10166 
    while True:
10167 
      (fname, ftype, fid) = iprot.readFieldBegin()
10168 
      if ftype == TType.STOP:
10169 
        break
10170 
      if fid == 1:
10171 
        if ftype == TType.I64:
10172 
          self.orderId = iprot.readI64();
10173 
        else:
10174 
          iprot.skip(ftype)
10175 
      else:
10176 
        iprot.skip(ftype)
10177 
      iprot.readFieldEnd()
10178 
    iprot.readStructEnd()
10179 
 
10180 
  def write(self, oprot):
10181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10183 
      return
10184 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 10185 
    if self.orderId is not None:
1208 chandransh 10186 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10187 
      oprot.writeI64(self.orderId)
10188 
      oprot.writeFieldEnd()
10189 
    oprot.writeFieldStop()
10190 
    oprot.writeStructEnd()
10191 
 
3431 rajveer 10192 
  def validate(self):
10193 
    return
10194 
 
10195 
 
1208 chandransh 10196 
  def __repr__(self):
10197 
    L = ['%s=%r' % (key, value)
10198 
      for key, value in self.__dict__.iteritems()]
10199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10200 
 
10201 
  def __eq__(self, other):
10202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10203 
 
10204 
  def __ne__(self, other):
10205 
    return not (self == other)
10206 
 
10207 
class markOrderAsOutOfStock_result:
10208 
  """
10209 
  Attributes:
10210 
   - success
10211 
   - ex
10212 
  """
10213 
 
10214 
  thrift_spec = (
10215 
    (0, TType.BOOL, 'success', None, None, ), # 0
10216 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10217 
  )
10218 
 
10219 
  def __init__(self, success=None, ex=None,):
10220 
    self.success = success
10221 
    self.ex = ex
10222 
 
10223 
  def read(self, iprot):
10224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10226 
      return
10227 
    iprot.readStructBegin()
10228 
    while True:
10229 
      (fname, ftype, fid) = iprot.readFieldBegin()
10230 
      if ftype == TType.STOP:
10231 
        break
10232 
      if fid == 0:
10233 
        if ftype == TType.BOOL:
10234 
          self.success = iprot.readBool();
10235 
        else:
10236 
          iprot.skip(ftype)
10237 
      elif fid == 1:
10238 
        if ftype == TType.STRUCT:
10239 
          self.ex = TransactionServiceException()
10240 
          self.ex.read(iprot)
10241 
        else:
10242 
          iprot.skip(ftype)
10243 
      else:
10244 
        iprot.skip(ftype)
10245 
      iprot.readFieldEnd()
10246 
    iprot.readStructEnd()
10247 
 
10248 
  def write(self, oprot):
10249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10251 
      return
10252 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 10253 
    if self.success is not None:
1208 chandransh 10254 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10255 
      oprot.writeBool(self.success)
10256 
      oprot.writeFieldEnd()
3431 rajveer 10257 
    if self.ex is not None:
1208 chandransh 10258 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10259 
      self.ex.write(oprot)
10260 
      oprot.writeFieldEnd()
10261 
    oprot.writeFieldStop()
10262 
    oprot.writeStructEnd()
10263 
 
3431 rajveer 10264 
  def validate(self):
10265 
    return
10266 
 
10267 
 
1208 chandransh 10268 
  def __repr__(self):
10269 
    L = ['%s=%r' % (key, value)
10270 
      for key, value in self.__dict__.iteritems()]
10271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10272 
 
10273 
  def __eq__(self, other):
10274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10275 
 
10276 
  def __ne__(self, other):
10277 
    return not (self == other)
10278 
 
3064 chandransh 10279 
class verifyOrder_args:
759 chandransh 10280 
  """
10281 
  Attributes:
3064 chandransh 10282 
   - orderId
759 chandransh 10283 
  """
10284 
 
10285 
  thrift_spec = (
10286 
    None, # 0
3064 chandransh 10287 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 10288 
  )
10289 
 
3064 chandransh 10290 
  def __init__(self, orderId=None,):
10291 
    self.orderId = orderId
759 chandransh 10292 
 
10293 
  def read(self, iprot):
10294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10296 
      return
10297 
    iprot.readStructBegin()
10298 
    while True:
10299 
      (fname, ftype, fid) = iprot.readFieldBegin()
10300 
      if ftype == TType.STOP:
10301 
        break
10302 
      if fid == 1:
10303 
        if ftype == TType.I64:
3064 chandransh 10304 
          self.orderId = iprot.readI64();
759 chandransh 10305 
        else:
10306 
          iprot.skip(ftype)
10307 
      else:
10308 
        iprot.skip(ftype)
10309 
      iprot.readFieldEnd()
10310 
    iprot.readStructEnd()
10311 
 
10312 
  def write(self, oprot):
10313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10315 
      return
3064 chandransh 10316 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 10317 
    if self.orderId is not None:
3064 chandransh 10318 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10319 
      oprot.writeI64(self.orderId)
759 chandransh 10320 
      oprot.writeFieldEnd()
10321 
    oprot.writeFieldStop()
10322 
    oprot.writeStructEnd()
10323 
 
3431 rajveer 10324 
  def validate(self):
10325 
    return
10326 
 
10327 
 
759 chandransh 10328 
  def __repr__(self):
10329 
    L = ['%s=%r' % (key, value)
10330 
      for key, value in self.__dict__.iteritems()]
10331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10332 
 
10333 
  def __eq__(self, other):
10334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10335 
 
10336 
  def __ne__(self, other):
10337 
    return not (self == other)
10338 
 
3064 chandransh 10339 
class verifyOrder_result:
759 chandransh 10340 
  """
10341 
  Attributes:
10342 
   - success
10343 
   - ex
10344 
  """
10345 
 
10346 
  thrift_spec = (
10347 
    (0, TType.BOOL, 'success', None, None, ), # 0
10348 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10349 
  )
10350 
 
10351 
  def __init__(self, success=None, ex=None,):
10352 
    self.success = success
10353 
    self.ex = ex
10354 
 
10355 
  def read(self, iprot):
10356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10358 
      return
10359 
    iprot.readStructBegin()
10360 
    while True:
10361 
      (fname, ftype, fid) = iprot.readFieldBegin()
10362 
      if ftype == TType.STOP:
10363 
        break
10364 
      if fid == 0:
10365 
        if ftype == TType.BOOL:
10366 
          self.success = iprot.readBool();
10367 
        else:
10368 
          iprot.skip(ftype)
10369 
      elif fid == 1:
10370 
        if ftype == TType.STRUCT:
10371 
          self.ex = TransactionServiceException()
10372 
          self.ex.read(iprot)
10373 
        else:
10374 
          iprot.skip(ftype)
10375 
      else:
10376 
        iprot.skip(ftype)
10377 
      iprot.readFieldEnd()
10378 
    iprot.readStructEnd()
10379 
 
10380 
  def write(self, oprot):
10381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10383 
      return
3064 chandransh 10384 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 10385 
    if self.success is not None:
759 chandransh 10386 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10387 
      oprot.writeBool(self.success)
10388 
      oprot.writeFieldEnd()
3431 rajveer 10389 
    if self.ex is not None:
759 chandransh 10390 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10391 
      self.ex.write(oprot)
10392 
      oprot.writeFieldEnd()
10393 
    oprot.writeFieldStop()
10394 
    oprot.writeStructEnd()
10395 
 
3431 rajveer 10396 
  def validate(self):
10397 
    return
10398 
 
10399 
 
759 chandransh 10400 
  def __repr__(self):
10401 
    L = ['%s=%r' % (key, value)
10402 
      for key, value in self.__dict__.iteritems()]
10403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10404 
 
10405 
  def __eq__(self, other):
10406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10407 
 
10408 
  def __ne__(self, other):
10409 
    return not (self == other)
10410 
 
3064 chandransh 10411 
class acceptOrder_args:
1113 chandransh 10412 
  """
10413 
  Attributes:
3064 chandransh 10414 
   - orderId
1113 chandransh 10415 
  """
10416 
 
10417 
  thrift_spec = (
10418 
    None, # 0
3064 chandransh 10419 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 10420 
  )
10421 
 
3064 chandransh 10422 
  def __init__(self, orderId=None,):
10423 
    self.orderId = orderId
1113 chandransh 10424 
 
10425 
  def read(self, iprot):
10426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10428 
      return
10429 
    iprot.readStructBegin()
10430 
    while True:
10431 
      (fname, ftype, fid) = iprot.readFieldBegin()
10432 
      if ftype == TType.STOP:
10433 
        break
10434 
      if fid == 1:
10435 
        if ftype == TType.I64:
3064 chandransh 10436 
          self.orderId = iprot.readI64();
1113 chandransh 10437 
        else:
10438 
          iprot.skip(ftype)
10439 
      else:
10440 
        iprot.skip(ftype)
10441 
      iprot.readFieldEnd()
10442 
    iprot.readStructEnd()
10443 
 
10444 
  def write(self, oprot):
10445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10447 
      return
3064 chandransh 10448 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 10449 
    if self.orderId is not None:
3064 chandransh 10450 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10451 
      oprot.writeI64(self.orderId)
1113 chandransh 10452 
      oprot.writeFieldEnd()
10453 
    oprot.writeFieldStop()
10454 
    oprot.writeStructEnd()
10455 
 
3431 rajveer 10456 
  def validate(self):
10457 
    return
10458 
 
10459 
 
1113 chandransh 10460 
  def __repr__(self):
10461 
    L = ['%s=%r' % (key, value)
10462 
      for key, value in self.__dict__.iteritems()]
10463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10464 
 
10465 
  def __eq__(self, other):
10466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10467 
 
10468 
  def __ne__(self, other):
10469 
    return not (self == other)
10470 
 
3064 chandransh 10471 
class acceptOrder_result:
1113 chandransh 10472 
  """
10473 
  Attributes:
10474 
   - success
10475 
   - ex
10476 
  """
10477 
 
10478 
  thrift_spec = (
3064 chandransh 10479 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 10480 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10481 
  )
10482 
 
10483 
  def __init__(self, success=None, ex=None,):
10484 
    self.success = success
10485 
    self.ex = ex
10486 
 
10487 
  def read(self, iprot):
10488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10490 
      return
10491 
    iprot.readStructBegin()
10492 
    while True:
10493 
      (fname, ftype, fid) = iprot.readFieldBegin()
10494 
      if ftype == TType.STOP:
10495 
        break
10496 
      if fid == 0:
3064 chandransh 10497 
        if ftype == TType.BOOL:
10498 
          self.success = iprot.readBool();
1113 chandransh 10499 
        else:
10500 
          iprot.skip(ftype)
10501 
      elif fid == 1:
10502 
        if ftype == TType.STRUCT:
10503 
          self.ex = TransactionServiceException()
10504 
          self.ex.read(iprot)
10505 
        else:
10506 
          iprot.skip(ftype)
10507 
      else:
10508 
        iprot.skip(ftype)
10509 
      iprot.readFieldEnd()
10510 
    iprot.readStructEnd()
10511 
 
10512 
  def write(self, oprot):
10513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10515 
      return
3064 chandransh 10516 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 10517 
    if self.success is not None:
3064 chandransh 10518 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10519 
      oprot.writeBool(self.success)
1113 chandransh 10520 
      oprot.writeFieldEnd()
3431 rajveer 10521 
    if self.ex is not None:
1113 chandransh 10522 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10523 
      self.ex.write(oprot)
10524 
      oprot.writeFieldEnd()
10525 
    oprot.writeFieldStop()
10526 
    oprot.writeStructEnd()
10527 
 
3431 rajveer 10528 
  def validate(self):
10529 
    return
10530 
 
10531 
 
1113 chandransh 10532 
  def __repr__(self):
10533 
    L = ['%s=%r' % (key, value)
10534 
      for key, value in self.__dict__.iteritems()]
10535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10536 
 
10537 
  def __eq__(self, other):
10538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10539 
 
10540 
  def __ne__(self, other):
10541 
    return not (self == other)
10542 
 
3064 chandransh 10543 
class addBillingDetails_args:
1135 chandransh 10544 
  """
10545 
  Attributes:
3064 chandransh 10546 
   - orderId
10547 
   - invoice_number
4658 mandeep.dh 10548 
   - serialNumber
4283 anupam.sin 10549 
   - itemNumber
3064 chandransh 10550 
   - billed_by
4264 rajveer 10551 
   - jacketNumber
4283 anupam.sin 10552 
   - billingType
10553 
   - vendorId
4763 rajveer 10554 
   - authorize
1135 chandransh 10555 
  """
10556 
 
10557 
  thrift_spec = (
10558 
    None, # 0
3064 chandransh 10559 
    (1, TType.I64, 'orderId', None, None, ), # 1
10560 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 10561 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 10562 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10563 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10564 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10565 
    (7, TType.I64, 'billingType', None, None, ), # 7
10566 
    (8, TType.I64, 'vendorId', None, None, ), # 8
4763 rajveer 10567 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 10568 
  )
10569 
 
4763 rajveer 10570 
  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 10571 
    self.orderId = orderId
10572 
    self.invoice_number = invoice_number
4658 mandeep.dh 10573 
    self.serialNumber = serialNumber
4283 anupam.sin 10574 
    self.itemNumber = itemNumber
3064 chandransh 10575 
    self.billed_by = billed_by
4264 rajveer 10576 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10577 
    self.billingType = billingType
10578 
    self.vendorId = vendorId
4763 rajveer 10579 
    self.authorize = authorize
1135 chandransh 10580 
 
10581 
  def read(self, iprot):
10582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10584 
      return
10585 
    iprot.readStructBegin()
10586 
    while True:
10587 
      (fname, ftype, fid) = iprot.readFieldBegin()
10588 
      if ftype == TType.STOP:
10589 
        break
10590 
      if fid == 1:
10591 
        if ftype == TType.I64:
3064 chandransh 10592 
          self.orderId = iprot.readI64();
1135 chandransh 10593 
        else:
10594 
          iprot.skip(ftype)
10595 
      elif fid == 2:
3064 chandransh 10596 
        if ftype == TType.STRING:
10597 
          self.invoice_number = iprot.readString();
1135 chandransh 10598 
        else:
10599 
          iprot.skip(ftype)
3064 chandransh 10600 
      elif fid == 3:
4658 mandeep.dh 10601 
        if ftype == TType.STRING:
10602 
          self.serialNumber = iprot.readString();
3064 chandransh 10603 
        else:
10604 
          iprot.skip(ftype)
10605 
      elif fid == 4:
10606 
        if ftype == TType.STRING:
10607 
          self.itemNumber = iprot.readString();
10608 
        else:
10609 
          iprot.skip(ftype)
10610 
      elif fid == 5:
10611 
        if ftype == TType.STRING:
4283 anupam.sin 10612 
          self.billed_by = iprot.readString();
3064 chandransh 10613 
        else:
10614 
          iprot.skip(ftype)
10615 
      elif fid == 6:
10616 
        if ftype == TType.I64:
4283 anupam.sin 10617 
          self.jacketNumber = iprot.readI64();
10618 
        else:
10619 
          iprot.skip(ftype)
10620 
      elif fid == 7:
10621 
        if ftype == TType.I64:
3064 chandransh 10622 
          self.billingType = iprot.readI64();
10623 
        else:
10624 
          iprot.skip(ftype)
4283 anupam.sin 10625 
      elif fid == 8:
10626 
        if ftype == TType.I64:
10627 
          self.vendorId = iprot.readI64();
10628 
        else:
10629 
          iprot.skip(ftype)
4763 rajveer 10630 
      elif fid == 9:
10631 
        if ftype == TType.BOOL:
10632 
          self.authorize = iprot.readBool();
10633 
        else:
10634 
          iprot.skip(ftype)
1246 chandransh 10635 
      else:
10636 
        iprot.skip(ftype)
10637 
      iprot.readFieldEnd()
10638 
    iprot.readStructEnd()
10639 
 
10640 
  def write(self, oprot):
10641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10643 
      return
4283 anupam.sin 10644 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 10645 
    if self.orderId is not None:
3064 chandransh 10646 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10647 
      oprot.writeI64(self.orderId)
1246 chandransh 10648 
      oprot.writeFieldEnd()
4283 anupam.sin 10649 
    if self.invoice_number is not None:
10650 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
10651 
      oprot.writeString(self.invoice_number)
1246 chandransh 10652 
      oprot.writeFieldEnd()
4658 mandeep.dh 10653 
    if self.serialNumber is not None:
10654 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
10655 
      oprot.writeString(self.serialNumber)
3064 chandransh 10656 
      oprot.writeFieldEnd()
3431 rajveer 10657 
    if self.itemNumber is not None:
3064 chandransh 10658 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
10659 
      oprot.writeString(self.itemNumber)
10660 
      oprot.writeFieldEnd()
4283 anupam.sin 10661 
    if self.billed_by is not None:
10662 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
10663 
      oprot.writeString(self.billed_by)
3064 chandransh 10664 
      oprot.writeFieldEnd()
4283 anupam.sin 10665 
    if self.jacketNumber is not None:
10666 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
10667 
      oprot.writeI64(self.jacketNumber)
10668 
      oprot.writeFieldEnd()
3431 rajveer 10669 
    if self.billingType is not None:
4283 anupam.sin 10670 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 10671 
      oprot.writeI64(self.billingType)
10672 
      oprot.writeFieldEnd()
4283 anupam.sin 10673 
    if self.vendorId is not None:
10674 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
10675 
      oprot.writeI64(self.vendorId)
10676 
      oprot.writeFieldEnd()
4763 rajveer 10677 
    if self.authorize is not None:
10678 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
10679 
      oprot.writeBool(self.authorize)
10680 
      oprot.writeFieldEnd()
1246 chandransh 10681 
    oprot.writeFieldStop()
10682 
    oprot.writeStructEnd()
10683 
 
3431 rajveer 10684 
  def validate(self):
10685 
    return
10686 
 
10687 
 
1246 chandransh 10688 
  def __repr__(self):
10689 
    L = ['%s=%r' % (key, value)
10690 
      for key, value in self.__dict__.iteritems()]
10691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10692 
 
10693 
  def __eq__(self, other):
10694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10695 
 
10696 
  def __ne__(self, other):
10697 
    return not (self == other)
10698 
 
4283 anupam.sin 10699 
class addBillingDetails_result:
1246 chandransh 10700 
  """
10701 
  Attributes:
3064 chandransh 10702 
   - success
1246 chandransh 10703 
   - ex
10704 
  """
10705 
 
10706 
  thrift_spec = (
3064 chandransh 10707 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 10708 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10709 
  )
10710 
 
3064 chandransh 10711 
  def __init__(self, success=None, ex=None,):
10712 
    self.success = success
1246 chandransh 10713 
    self.ex = ex
10714 
 
10715 
  def read(self, iprot):
10716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10718 
      return
10719 
    iprot.readStructBegin()
10720 
    while True:
10721 
      (fname, ftype, fid) = iprot.readFieldBegin()
10722 
      if ftype == TType.STOP:
10723 
        break
3064 chandransh 10724 
      if fid == 0:
10725 
        if ftype == TType.BOOL:
10726 
          self.success = iprot.readBool();
10727 
        else:
10728 
          iprot.skip(ftype)
10729 
      elif fid == 1:
1246 chandransh 10730 
        if ftype == TType.STRUCT:
10731 
          self.ex = TransactionServiceException()
10732 
          self.ex.read(iprot)
10733 
        else:
10734 
          iprot.skip(ftype)
10735 
      else:
10736 
        iprot.skip(ftype)
10737 
      iprot.readFieldEnd()
10738 
    iprot.readStructEnd()
10739 
 
10740 
  def write(self, oprot):
10741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10743 
      return
4283 anupam.sin 10744 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 10745 
    if self.success is not None:
3064 chandransh 10746 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10747 
      oprot.writeBool(self.success)
10748 
      oprot.writeFieldEnd()
3431 rajveer 10749 
    if self.ex is not None:
1246 chandransh 10750 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10751 
      self.ex.write(oprot)
10752 
      oprot.writeFieldEnd()
10753 
    oprot.writeFieldStop()
10754 
    oprot.writeStructEnd()
10755 
 
3431 rajveer 10756 
  def validate(self):
10757 
    return
10758 
 
10759 
 
1246 chandransh 10760 
  def __repr__(self):
10761 
    L = ['%s=%r' % (key, value)
10762 
      for key, value in self.__dict__.iteritems()]
10763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10764 
 
10765 
  def __eq__(self, other):
10766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10767 
 
10768 
  def __ne__(self, other):
10769 
    return not (self == other)
10770 
 
4579 rajveer 10771 
class addInvoiceNumber_args:
10772 
  """
10773 
  Attributes:
10774 
   - orderId
10775 
   - invoiceNumber
4763 rajveer 10776 
   - color
4579 rajveer 10777 
  """
10778 
 
10779 
  thrift_spec = (
10780 
    None, # 0
10781 
    (1, TType.I64, 'orderId', None, None, ), # 1
10782 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 10783 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 10784 
  )
10785 
 
4763 rajveer 10786 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 10787 
    self.orderId = orderId
10788 
    self.invoiceNumber = invoiceNumber
4763 rajveer 10789 
    self.color = color
4579 rajveer 10790 
 
10791 
  def read(self, iprot):
10792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10794 
      return
10795 
    iprot.readStructBegin()
10796 
    while True:
10797 
      (fname, ftype, fid) = iprot.readFieldBegin()
10798 
      if ftype == TType.STOP:
10799 
        break
10800 
      if fid == 1:
10801 
        if ftype == TType.I64:
10802 
          self.orderId = iprot.readI64();
10803 
        else:
10804 
          iprot.skip(ftype)
10805 
      elif fid == 2:
10806 
        if ftype == TType.STRING:
10807 
          self.invoiceNumber = iprot.readString();
10808 
        else:
10809 
          iprot.skip(ftype)
4763 rajveer 10810 
      elif fid == 3:
10811 
        if ftype == TType.STRING:
10812 
          self.color = iprot.readString();
10813 
        else:
10814 
          iprot.skip(ftype)
4579 rajveer 10815 
      else:
10816 
        iprot.skip(ftype)
10817 
      iprot.readFieldEnd()
10818 
    iprot.readStructEnd()
10819 
 
10820 
  def write(self, oprot):
10821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10823 
      return
10824 
    oprot.writeStructBegin('addInvoiceNumber_args')
10825 
    if self.orderId is not None:
10826 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10827 
      oprot.writeI64(self.orderId)
10828 
      oprot.writeFieldEnd()
10829 
    if self.invoiceNumber is not None:
10830 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
10831 
      oprot.writeString(self.invoiceNumber)
10832 
      oprot.writeFieldEnd()
4763 rajveer 10833 
    if self.color is not None:
10834 
      oprot.writeFieldBegin('color', TType.STRING, 3)
10835 
      oprot.writeString(self.color)
10836 
      oprot.writeFieldEnd()
4579 rajveer 10837 
    oprot.writeFieldStop()
10838 
    oprot.writeStructEnd()
10839 
 
10840 
  def validate(self):
10841 
    return
10842 
 
10843 
 
10844 
  def __repr__(self):
10845 
    L = ['%s=%r' % (key, value)
10846 
      for key, value in self.__dict__.iteritems()]
10847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10848 
 
10849 
  def __eq__(self, other):
10850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10851 
 
10852 
  def __ne__(self, other):
10853 
    return not (self == other)
10854 
 
10855 
class addInvoiceNumber_result:
10856 
  """
10857 
  Attributes:
10858 
   - ex
10859 
  """
10860 
 
10861 
  thrift_spec = (
10862 
    None, # 0
10863 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10864 
  )
10865 
 
10866 
  def __init__(self, ex=None,):
10867 
    self.ex = ex
10868 
 
10869 
  def read(self, iprot):
10870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10872 
      return
10873 
    iprot.readStructBegin()
10874 
    while True:
10875 
      (fname, ftype, fid) = iprot.readFieldBegin()
10876 
      if ftype == TType.STOP:
10877 
        break
10878 
      if fid == 1:
10879 
        if ftype == TType.STRUCT:
10880 
          self.ex = TransactionServiceException()
10881 
          self.ex.read(iprot)
10882 
        else:
10883 
          iprot.skip(ftype)
10884 
      else:
10885 
        iprot.skip(ftype)
10886 
      iprot.readFieldEnd()
10887 
    iprot.readStructEnd()
10888 
 
10889 
  def write(self, oprot):
10890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10892 
      return
10893 
    oprot.writeStructBegin('addInvoiceNumber_result')
10894 
    if self.ex is not None:
10895 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10896 
      self.ex.write(oprot)
10897 
      oprot.writeFieldEnd()
10898 
    oprot.writeFieldStop()
10899 
    oprot.writeStructEnd()
10900 
 
10901 
  def validate(self):
10902 
    return
10903 
 
10904 
 
10905 
  def __repr__(self):
10906 
    L = ['%s=%r' % (key, value)
10907 
      for key, value in self.__dict__.iteritems()]
10908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10909 
 
10910 
  def __eq__(self, other):
10911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10912 
 
10913 
  def __ne__(self, other):
10914 
    return not (self == other)
10915 
 
3064 chandransh 10916 
class markOrdersAsManifested_args:
1408 ankur.sing 10917 
  """
10918 
  Attributes:
3064 chandransh 10919 
   - warehouseId
1408 ankur.sing 10920 
   - providerId
3064 chandransh 10921 
   - cod
1408 ankur.sing 10922 
  """
10923 
 
10924 
  thrift_spec = (
10925 
    None, # 0
3064 chandransh 10926 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10927 
    (2, TType.I64, 'providerId', None, None, ), # 2
10928 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 10929 
  )
10930 
 
3064 chandransh 10931 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10932 
    self.warehouseId = warehouseId
1408 ankur.sing 10933 
    self.providerId = providerId
3064 chandransh 10934 
    self.cod = cod
1408 ankur.sing 10935 
 
10936 
  def read(self, iprot):
10937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10939 
      return
10940 
    iprot.readStructBegin()
10941 
    while True:
10942 
      (fname, ftype, fid) = iprot.readFieldBegin()
10943 
      if ftype == TType.STOP:
10944 
        break
10945 
      if fid == 1:
10946 
        if ftype == TType.I64:
3064 chandransh 10947 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 10948 
        else:
10949 
          iprot.skip(ftype)
10950 
      elif fid == 2:
10951 
        if ftype == TType.I64:
3064 chandransh 10952 
          self.providerId = iprot.readI64();
1408 ankur.sing 10953 
        else:
10954 
          iprot.skip(ftype)
3064 chandransh 10955 
      elif fid == 3:
10956 
        if ftype == TType.BOOL:
10957 
          self.cod = iprot.readBool();
10958 
        else:
10959 
          iprot.skip(ftype)
1408 ankur.sing 10960 
      else:
10961 
        iprot.skip(ftype)
10962 
      iprot.readFieldEnd()
10963 
    iprot.readStructEnd()
10964 
 
10965 
  def write(self, oprot):
10966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10968 
      return
3064 chandransh 10969 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 10970 
    if self.warehouseId is not None:
3064 chandransh 10971 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10972 
      oprot.writeI64(self.warehouseId)
10973 
      oprot.writeFieldEnd()
3431 rajveer 10974 
    if self.providerId is not None:
3064 chandransh 10975 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 10976 
      oprot.writeI64(self.providerId)
10977 
      oprot.writeFieldEnd()
3431 rajveer 10978 
    if self.cod is not None:
3064 chandransh 10979 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10980 
      oprot.writeBool(self.cod)
1408 ankur.sing 10981 
      oprot.writeFieldEnd()
10982 
    oprot.writeFieldStop()
10983 
    oprot.writeStructEnd()
10984 
 
3431 rajveer 10985 
  def validate(self):
10986 
    return
10987 
 
10988 
 
1408 ankur.sing 10989 
  def __repr__(self):
10990 
    L = ['%s=%r' % (key, value)
10991 
      for key, value in self.__dict__.iteritems()]
10992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10993 
 
10994 
  def __eq__(self, other):
10995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10996 
 
10997 
  def __ne__(self, other):
10998 
    return not (self == other)
10999 
 
3064 chandransh 11000 
class markOrdersAsManifested_result:
1408 ankur.sing 11001 
  """
11002 
  Attributes:
11003 
   - success
3064 chandransh 11004 
   - ex
1408 ankur.sing 11005 
  """
11006 
 
11007 
  thrift_spec = (
3064 chandransh 11008 
    (0, TType.BOOL, 'success', None, None, ), # 0
11009 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 11010 
  )
11011 
 
3064 chandransh 11012 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 11013 
    self.success = success
3064 chandransh 11014 
    self.ex = ex
1408 ankur.sing 11015 
 
11016 
  def read(self, iprot):
11017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11019 
      return
11020 
    iprot.readStructBegin()
11021 
    while True:
11022 
      (fname, ftype, fid) = iprot.readFieldBegin()
11023 
      if ftype == TType.STOP:
11024 
        break
11025 
      if fid == 0:
3064 chandransh 11026 
        if ftype == TType.BOOL:
11027 
          self.success = iprot.readBool();
1408 ankur.sing 11028 
        else:
11029 
          iprot.skip(ftype)
3064 chandransh 11030 
      elif fid == 1:
11031 
        if ftype == TType.STRUCT:
11032 
          self.ex = TransactionServiceException()
11033 
          self.ex.read(iprot)
11034 
        else:
11035 
          iprot.skip(ftype)
1408 ankur.sing 11036 
      else:
11037 
        iprot.skip(ftype)
11038 
      iprot.readFieldEnd()
11039 
    iprot.readStructEnd()
11040 
 
11041 
  def write(self, oprot):
11042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11044 
      return
3064 chandransh 11045 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 11046 
    if self.success is not None:
3064 chandransh 11047 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11048 
      oprot.writeBool(self.success)
1408 ankur.sing 11049 
      oprot.writeFieldEnd()
3431 rajveer 11050 
    if self.ex is not None:
3064 chandransh 11051 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11052 
      self.ex.write(oprot)
11053 
      oprot.writeFieldEnd()
1408 ankur.sing 11054 
    oprot.writeFieldStop()
11055 
    oprot.writeStructEnd()
11056 
 
3431 rajveer 11057 
  def validate(self):
11058 
    return
11059 
 
11060 
 
1408 ankur.sing 11061 
  def __repr__(self):
11062 
    L = ['%s=%r' % (key, value)
11063 
      for key, value in self.__dict__.iteritems()]
11064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11065 
 
11066 
  def __eq__(self, other):
11067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11068 
 
11069 
  def __ne__(self, other):
11070 
    return not (self == other)
11071 
 
4410 rajveer 11072 
class markOrdersAsShippedFromWarehouse_args:
11073 
  """
11074 
  Attributes:
11075 
   - warehouseId
11076 
   - providerId
11077 
   - cod
4789 rajveer 11078 
   - orderIds
4410 rajveer 11079 
  """
11080 
 
11081 
  thrift_spec = (
11082 
    None, # 0
11083 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11084 
    (2, TType.I64, 'providerId', None, None, ), # 2
11085 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4789 rajveer 11086 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
4410 rajveer 11087 
  )
11088 
 
4789 rajveer 11089 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
4410 rajveer 11090 
    self.warehouseId = warehouseId
11091 
    self.providerId = providerId
11092 
    self.cod = cod
4789 rajveer 11093 
    self.orderIds = orderIds
4410 rajveer 11094 
 
11095 
  def read(self, iprot):
11096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11098 
      return
11099 
    iprot.readStructBegin()
11100 
    while True:
11101 
      (fname, ftype, fid) = iprot.readFieldBegin()
11102 
      if ftype == TType.STOP:
11103 
        break
11104 
      if fid == 1:
11105 
        if ftype == TType.I64:
11106 
          self.warehouseId = iprot.readI64();
11107 
        else:
11108 
          iprot.skip(ftype)
11109 
      elif fid == 2:
11110 
        if ftype == TType.I64:
11111 
          self.providerId = iprot.readI64();
11112 
        else:
11113 
          iprot.skip(ftype)
11114 
      elif fid == 3:
11115 
        if ftype == TType.BOOL:
11116 
          self.cod = iprot.readBool();
11117 
        else:
11118 
          iprot.skip(ftype)
4789 rajveer 11119 
      elif fid == 4:
11120 
        if ftype == TType.LIST:
11121 
          self.orderIds = []
4837 varun.gupt 11122 
          (_etype178, _size175) = iprot.readListBegin()
11123 
          for _i179 in xrange(_size175):
11124 
            _elem180 = iprot.readI64();
11125 
            self.orderIds.append(_elem180)
4789 rajveer 11126 
          iprot.readListEnd()
11127 
        else:
11128 
          iprot.skip(ftype)
4410 rajveer 11129 
      else:
11130 
        iprot.skip(ftype)
11131 
      iprot.readFieldEnd()
11132 
    iprot.readStructEnd()
11133 
 
11134 
  def write(self, oprot):
11135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11137 
      return
11138 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
11139 
    if self.warehouseId is not None:
11140 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11141 
      oprot.writeI64(self.warehouseId)
11142 
      oprot.writeFieldEnd()
11143 
    if self.providerId is not None:
11144 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
11145 
      oprot.writeI64(self.providerId)
11146 
      oprot.writeFieldEnd()
11147 
    if self.cod is not None:
11148 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11149 
      oprot.writeBool(self.cod)
11150 
      oprot.writeFieldEnd()
4789 rajveer 11151 
    if self.orderIds is not None:
11152 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
11153 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
4837 varun.gupt 11154 
      for iter181 in self.orderIds:
11155 
        oprot.writeI64(iter181)
4789 rajveer 11156 
      oprot.writeListEnd()
11157 
      oprot.writeFieldEnd()
4410 rajveer 11158 
    oprot.writeFieldStop()
11159 
    oprot.writeStructEnd()
11160 
 
11161 
  def validate(self):
11162 
    return
11163 
 
11164 
 
11165 
  def __repr__(self):
11166 
    L = ['%s=%r' % (key, value)
11167 
      for key, value in self.__dict__.iteritems()]
11168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11169 
 
11170 
  def __eq__(self, other):
11171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11172 
 
11173 
  def __ne__(self, other):
11174 
    return not (self == other)
11175 
 
11176 
class markOrdersAsShippedFromWarehouse_result:
11177 
  """
11178 
  Attributes:
11179 
   - success
11180 
   - ex
11181 
  """
11182 
 
11183 
  thrift_spec = (
11184 
    (0, TType.BOOL, 'success', None, None, ), # 0
11185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11186 
  )
11187 
 
11188 
  def __init__(self, success=None, ex=None,):
11189 
    self.success = success
11190 
    self.ex = ex
11191 
 
11192 
  def read(self, iprot):
11193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11195 
      return
11196 
    iprot.readStructBegin()
11197 
    while True:
11198 
      (fname, ftype, fid) = iprot.readFieldBegin()
11199 
      if ftype == TType.STOP:
11200 
        break
11201 
      if fid == 0:
11202 
        if ftype == TType.BOOL:
11203 
          self.success = iprot.readBool();
11204 
        else:
11205 
          iprot.skip(ftype)
11206 
      elif fid == 1:
11207 
        if ftype == TType.STRUCT:
11208 
          self.ex = TransactionServiceException()
11209 
          self.ex.read(iprot)
11210 
        else:
11211 
          iprot.skip(ftype)
11212 
      else:
11213 
        iprot.skip(ftype)
11214 
      iprot.readFieldEnd()
11215 
    iprot.readStructEnd()
11216 
 
11217 
  def write(self, oprot):
11218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11220 
      return
11221 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
11222 
    if self.success is not None:
11223 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11224 
      oprot.writeBool(self.success)
11225 
      oprot.writeFieldEnd()
11226 
    if self.ex is not None:
11227 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11228 
      self.ex.write(oprot)
11229 
      oprot.writeFieldEnd()
11230 
    oprot.writeFieldStop()
11231 
    oprot.writeStructEnd()
11232 
 
11233 
  def validate(self):
11234 
    return
11235 
 
11236 
 
11237 
  def __repr__(self):
11238 
    L = ['%s=%r' % (key, value)
11239 
      for key, value in self.__dict__.iteritems()]
11240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11241 
 
11242 
  def __eq__(self, other):
11243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11244 
 
11245 
  def __ne__(self, other):
11246 
    return not (self == other)
11247 
 
3064 chandransh 11248 
class markOrdersAsPickedUp_args:
304 ashish 11249 
  """
11250 
  Attributes:
3064 chandransh 11251 
   - providerId
11252 
   - pickupDetails
304 ashish 11253 
  """
94 ashish 11254 
 
304 ashish 11255 
  thrift_spec = (
11256 
    None, # 0
3064 chandransh 11257 
    (1, TType.I64, 'providerId', None, None, ), # 1
11258 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11259 
  )
11260 
 
3064 chandransh 11261 
  def __init__(self, providerId=None, pickupDetails=None,):
11262 
    self.providerId = providerId
11263 
    self.pickupDetails = pickupDetails
304 ashish 11264 
 
11265 
  def read(self, iprot):
11266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11268 
      return
11269 
    iprot.readStructBegin()
11270 
    while True:
11271 
      (fname, ftype, fid) = iprot.readFieldBegin()
11272 
      if ftype == TType.STOP:
11273 
        break
11274 
      if fid == 1:
11275 
        if ftype == TType.I64:
3064 chandransh 11276 
          self.providerId = iprot.readI64();
304 ashish 11277 
        else:
11278 
          iprot.skip(ftype)
11279 
      elif fid == 2:
3064 chandransh 11280 
        if ftype == TType.MAP:
11281 
          self.pickupDetails = {}
4837 varun.gupt 11282 
          (_ktype183, _vtype184, _size182 ) = iprot.readMapBegin()
11283 
          for _i186 in xrange(_size182):
11284 
            _key187 = iprot.readString();
11285 
            _val188 = iprot.readString();
11286 
            self.pickupDetails[_key187] = _val188
3064 chandransh 11287 
          iprot.readMapEnd()
304 ashish 11288 
        else:
11289 
          iprot.skip(ftype)
11290 
      else:
11291 
        iprot.skip(ftype)
11292 
      iprot.readFieldEnd()
11293 
    iprot.readStructEnd()
11294 
 
11295 
  def write(self, oprot):
11296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11298 
      return
3064 chandransh 11299 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 11300 
    if self.providerId is not None:
3064 chandransh 11301 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11302 
      oprot.writeI64(self.providerId)
304 ashish 11303 
      oprot.writeFieldEnd()
3431 rajveer 11304 
    if self.pickupDetails is not None:
3064 chandransh 11305 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11306 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4837 varun.gupt 11307 
      for kiter189,viter190 in self.pickupDetails.items():
11308 
        oprot.writeString(kiter189)
11309 
        oprot.writeString(viter190)
3064 chandransh 11310 
      oprot.writeMapEnd()
304 ashish 11311 
      oprot.writeFieldEnd()
11312 
    oprot.writeFieldStop()
11313 
    oprot.writeStructEnd()
11314 
 
3431 rajveer 11315 
  def validate(self):
11316 
    return
11317 
 
11318 
 
304 ashish 11319 
  def __repr__(self):
11320 
    L = ['%s=%r' % (key, value)
11321 
      for key, value in self.__dict__.iteritems()]
11322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11323 
 
11324 
  def __eq__(self, other):
11325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11326 
 
11327 
  def __ne__(self, other):
11328 
    return not (self == other)
11329 
 
3064 chandransh 11330 
class markOrdersAsPickedUp_result:
304 ashish 11331 
  """
11332 
  Attributes:
11333 
   - success
3064 chandransh 11334 
   - ex
304 ashish 11335 
  """
11336 
 
11337 
  thrift_spec = (
3064 chandransh 11338 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11339 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11340 
  )
11341 
 
3064 chandransh 11342 
  def __init__(self, success=None, ex=None,):
304 ashish 11343 
    self.success = success
3064 chandransh 11344 
    self.ex = ex
304 ashish 11345 
 
11346 
  def read(self, iprot):
11347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11349 
      return
11350 
    iprot.readStructBegin()
11351 
    while True:
11352 
      (fname, ftype, fid) = iprot.readFieldBegin()
11353 
      if ftype == TType.STOP:
11354 
        break
11355 
      if fid == 0:
11356 
        if ftype == TType.LIST:
11357 
          self.success = []
4837 varun.gupt 11358 
          (_etype194, _size191) = iprot.readListBegin()
11359 
          for _i195 in xrange(_size191):
11360 
            _elem196 = Order()
11361 
            _elem196.read(iprot)
11362 
            self.success.append(_elem196)
304 ashish 11363 
          iprot.readListEnd()
11364 
        else:
11365 
          iprot.skip(ftype)
3064 chandransh 11366 
      elif fid == 1:
11367 
        if ftype == TType.STRUCT:
11368 
          self.ex = TransactionServiceException()
11369 
          self.ex.read(iprot)
11370 
        else:
11371 
          iprot.skip(ftype)
304 ashish 11372 
      else:
11373 
        iprot.skip(ftype)
11374 
      iprot.readFieldEnd()
11375 
    iprot.readStructEnd()
11376 
 
11377 
  def write(self, oprot):
11378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11380 
      return
3064 chandransh 11381 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 11382 
    if self.success is not None:
304 ashish 11383 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11384 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 11385 
      for iter197 in self.success:
11386 
        iter197.write(oprot)
304 ashish 11387 
      oprot.writeListEnd()
11388 
      oprot.writeFieldEnd()
3431 rajveer 11389 
    if self.ex is not None:
3064 chandransh 11390 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11391 
      self.ex.write(oprot)
11392 
      oprot.writeFieldEnd()
304 ashish 11393 
    oprot.writeFieldStop()
11394 
    oprot.writeStructEnd()
11395 
 
3431 rajveer 11396 
  def validate(self):
11397 
    return
11398 
 
11399 
 
304 ashish 11400 
  def __repr__(self):
11401 
    L = ['%s=%r' % (key, value)
11402 
      for key, value in self.__dict__.iteritems()]
11403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11404 
 
11405 
  def __eq__(self, other):
11406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11407 
 
11408 
  def __ne__(self, other):
11409 
    return not (self == other)
11410 
 
3064 chandransh 11411 
class markOrdersAsDelivered_args:
304 ashish 11412 
  """
11413 
  Attributes:
3064 chandransh 11414 
   - providerId
11415 
   - deliveredOrders
304 ashish 11416 
  """
11417 
 
11418 
  thrift_spec = (
11419 
    None, # 0
3064 chandransh 11420 
    (1, TType.I64, 'providerId', None, None, ), # 1
11421 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11422 
  )
11423 
 
3064 chandransh 11424 
  def __init__(self, providerId=None, deliveredOrders=None,):
11425 
    self.providerId = providerId
11426 
    self.deliveredOrders = deliveredOrders
304 ashish 11427 
 
11428 
  def read(self, iprot):
11429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11431 
      return
11432 
    iprot.readStructBegin()
11433 
    while True:
11434 
      (fname, ftype, fid) = iprot.readFieldBegin()
11435 
      if ftype == TType.STOP:
11436 
        break
11437 
      if fid == 1:
11438 
        if ftype == TType.I64:
3064 chandransh 11439 
          self.providerId = iprot.readI64();
304 ashish 11440 
        else:
11441 
          iprot.skip(ftype)
11442 
      elif fid == 2:
3064 chandransh 11443 
        if ftype == TType.MAP:
11444 
          self.deliveredOrders = {}
4837 varun.gupt 11445 
          (_ktype199, _vtype200, _size198 ) = iprot.readMapBegin()
11446 
          for _i202 in xrange(_size198):
11447 
            _key203 = iprot.readString();
11448 
            _val204 = iprot.readString();
11449 
            self.deliveredOrders[_key203] = _val204
3064 chandransh 11450 
          iprot.readMapEnd()
304 ashish 11451 
        else:
11452 
          iprot.skip(ftype)
11453 
      else:
11454 
        iprot.skip(ftype)
11455 
      iprot.readFieldEnd()
11456 
    iprot.readStructEnd()
11457 
 
11458 
  def write(self, oprot):
11459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11461 
      return
3064 chandransh 11462 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 11463 
    if self.providerId is not None:
3064 chandransh 11464 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11465 
      oprot.writeI64(self.providerId)
304 ashish 11466 
      oprot.writeFieldEnd()
3431 rajveer 11467 
    if self.deliveredOrders is not None:
3064 chandransh 11468 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
11469 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4837 varun.gupt 11470 
      for kiter205,viter206 in self.deliveredOrders.items():
11471 
        oprot.writeString(kiter205)
11472 
        oprot.writeString(viter206)
3064 chandransh 11473 
      oprot.writeMapEnd()
304 ashish 11474 
      oprot.writeFieldEnd()
11475 
    oprot.writeFieldStop()
11476 
    oprot.writeStructEnd()
11477 
 
3431 rajveer 11478 
  def validate(self):
11479 
    return
11480 
 
11481 
 
304 ashish 11482 
  def __repr__(self):
11483 
    L = ['%s=%r' % (key, value)
11484 
      for key, value in self.__dict__.iteritems()]
11485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11486 
 
11487 
  def __eq__(self, other):
11488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11489 
 
11490 
  def __ne__(self, other):
11491 
    return not (self == other)
11492 
 
3064 chandransh 11493 
class markOrdersAsDelivered_result:
11494 
  """
11495 
  Attributes:
11496 
   - ex
11497 
  """
304 ashish 11498 
 
11499 
  thrift_spec = (
3064 chandransh 11500 
    None, # 0
11501 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11502 
  )
11503 
 
3064 chandransh 11504 
  def __init__(self, ex=None,):
11505 
    self.ex = ex
304 ashish 11506 
 
1596 ankur.sing 11507 
  def read(self, iprot):
11508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11510 
      return
11511 
    iprot.readStructBegin()
11512 
    while True:
11513 
      (fname, ftype, fid) = iprot.readFieldBegin()
11514 
      if ftype == TType.STOP:
11515 
        break
3064 chandransh 11516 
      if fid == 1:
11517 
        if ftype == TType.STRUCT:
11518 
          self.ex = TransactionServiceException()
11519 
          self.ex.read(iprot)
11520 
        else:
11521 
          iprot.skip(ftype)
1596 ankur.sing 11522 
      else:
11523 
        iprot.skip(ftype)
11524 
      iprot.readFieldEnd()
11525 
    iprot.readStructEnd()
11526 
 
11527 
  def write(self, oprot):
11528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11530 
      return
3064 chandransh 11531 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 11532 
    if self.ex is not None:
3064 chandransh 11533 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11534 
      self.ex.write(oprot)
11535 
      oprot.writeFieldEnd()
1596 ankur.sing 11536 
    oprot.writeFieldStop()
11537 
    oprot.writeStructEnd()
11538 
 
3431 rajveer 11539 
  def validate(self):
11540 
    return
11541 
 
11542 
 
1596 ankur.sing 11543 
  def __repr__(self):
11544 
    L = ['%s=%r' % (key, value)
11545 
      for key, value in self.__dict__.iteritems()]
11546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11547 
 
11548 
  def __eq__(self, other):
11549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11550 
 
11551 
  def __ne__(self, other):
11552 
    return not (self == other)
11553 
 
3064 chandransh 11554 
class markOrdersAsFailed_args:
1596 ankur.sing 11555 
  """
11556 
  Attributes:
3064 chandransh 11557 
   - providerId
11558 
   - returnedOrders
1596 ankur.sing 11559 
  """
11560 
 
11561 
  thrift_spec = (
3064 chandransh 11562 
    None, # 0
11563 
    (1, TType.I64, 'providerId', None, None, ), # 1
11564 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 11565 
  )
11566 
 
3064 chandransh 11567 
  def __init__(self, providerId=None, returnedOrders=None,):
11568 
    self.providerId = providerId
11569 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11570 
 
11571 
  def read(self, iprot):
11572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11574 
      return
11575 
    iprot.readStructBegin()
11576 
    while True:
11577 
      (fname, ftype, fid) = iprot.readFieldBegin()
11578 
      if ftype == TType.STOP:
11579 
        break
3064 chandransh 11580 
      if fid == 1:
1596 ankur.sing 11581 
        if ftype == TType.I64:
3064 chandransh 11582 
          self.providerId = iprot.readI64();
1596 ankur.sing 11583 
        else:
11584 
          iprot.skip(ftype)
3064 chandransh 11585 
      elif fid == 2:
11586 
        if ftype == TType.MAP:
11587 
          self.returnedOrders = {}
4837 varun.gupt 11588 
          (_ktype208, _vtype209, _size207 ) = iprot.readMapBegin()
11589 
          for _i211 in xrange(_size207):
11590 
            _key212 = iprot.readString();
11591 
            _val213 = iprot.readString();
11592 
            self.returnedOrders[_key212] = _val213
3064 chandransh 11593 
          iprot.readMapEnd()
11594 
        else:
11595 
          iprot.skip(ftype)
1596 ankur.sing 11596 
      else:
11597 
        iprot.skip(ftype)
11598 
      iprot.readFieldEnd()
11599 
    iprot.readStructEnd()
11600 
 
11601 
  def write(self, oprot):
11602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11604 
      return
3064 chandransh 11605 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 11606 
    if self.providerId is not None:
3064 chandransh 11607 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11608 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11609 
      oprot.writeFieldEnd()
3431 rajveer 11610 
    if self.returnedOrders is not None:
3064 chandransh 11611 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11612 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4837 varun.gupt 11613 
      for kiter214,viter215 in self.returnedOrders.items():
11614 
        oprot.writeString(kiter214)
11615 
        oprot.writeString(viter215)
3064 chandransh 11616 
      oprot.writeMapEnd()
11617 
      oprot.writeFieldEnd()
1596 ankur.sing 11618 
    oprot.writeFieldStop()
11619 
    oprot.writeStructEnd()
11620 
 
3431 rajveer 11621 
  def validate(self):
11622 
    return
11623 
 
11624 
 
1596 ankur.sing 11625 
  def __repr__(self):
11626 
    L = ['%s=%r' % (key, value)
11627 
      for key, value in self.__dict__.iteritems()]
11628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11629 
 
11630 
  def __eq__(self, other):
11631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11632 
 
11633 
  def __ne__(self, other):
11634 
    return not (self == other)
11635 
 
3064 chandransh 11636 
class markOrdersAsFailed_result:
11637 
  """
11638 
  Attributes:
11639 
   - ex
11640 
  """
1596 ankur.sing 11641 
 
1627 ankur.sing 11642 
  thrift_spec = (
3064 chandransh 11643 
    None, # 0
11644 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11645 
  )
11646 
 
3064 chandransh 11647 
  def __init__(self, ex=None,):
11648 
    self.ex = ex
11649 
 
1627 ankur.sing 11650 
  def read(self, iprot):
11651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11653 
      return
11654 
    iprot.readStructBegin()
11655 
    while True:
11656 
      (fname, ftype, fid) = iprot.readFieldBegin()
11657 
      if ftype == TType.STOP:
11658 
        break
3064 chandransh 11659 
      if fid == 1:
11660 
        if ftype == TType.STRUCT:
11661 
          self.ex = TransactionServiceException()
11662 
          self.ex.read(iprot)
11663 
        else:
11664 
          iprot.skip(ftype)
1627 ankur.sing 11665 
      else:
11666 
        iprot.skip(ftype)
11667 
      iprot.readFieldEnd()
11668 
    iprot.readStructEnd()
11669 
 
11670 
  def write(self, oprot):
11671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11673 
      return
3064 chandransh 11674 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 11675 
    if self.ex is not None:
3064 chandransh 11676 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11677 
      self.ex.write(oprot)
11678 
      oprot.writeFieldEnd()
1627 ankur.sing 11679 
    oprot.writeFieldStop()
11680 
    oprot.writeStructEnd()
11681 
 
3431 rajveer 11682 
  def validate(self):
11683 
    return
11684 
 
11685 
 
1627 ankur.sing 11686 
  def __repr__(self):
11687 
    L = ['%s=%r' % (key, value)
11688 
      for key, value in self.__dict__.iteritems()]
11689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11690 
 
11691 
  def __eq__(self, other):
11692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11693 
 
11694 
  def __ne__(self, other):
11695 
    return not (self == other)
11696 
 
3064 chandransh 11697 
class updateNonDeliveryReason_args:
1627 ankur.sing 11698 
  """
11699 
  Attributes:
3064 chandransh 11700 
   - providerId
11701 
   - undeliveredOrders
1627 ankur.sing 11702 
  """
11703 
 
11704 
  thrift_spec = (
3064 chandransh 11705 
    None, # 0
11706 
    (1, TType.I64, 'providerId', None, None, ), # 1
11707 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 11708 
  )
11709 
 
3064 chandransh 11710 
  def __init__(self, providerId=None, undeliveredOrders=None,):
11711 
    self.providerId = providerId
11712 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 11713 
 
11714 
  def read(self, iprot):
11715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11717 
      return
11718 
    iprot.readStructBegin()
11719 
    while True:
11720 
      (fname, ftype, fid) = iprot.readFieldBegin()
11721 
      if ftype == TType.STOP:
11722 
        break
3064 chandransh 11723 
      if fid == 1:
1627 ankur.sing 11724 
        if ftype == TType.I64:
3064 chandransh 11725 
          self.providerId = iprot.readI64();
1627 ankur.sing 11726 
        else:
11727 
          iprot.skip(ftype)
3064 chandransh 11728 
      elif fid == 2:
11729 
        if ftype == TType.MAP:
11730 
          self.undeliveredOrders = {}
4837 varun.gupt 11731 
          (_ktype217, _vtype218, _size216 ) = iprot.readMapBegin()
11732 
          for _i220 in xrange(_size216):
11733 
            _key221 = iprot.readString();
11734 
            _val222 = iprot.readString();
11735 
            self.undeliveredOrders[_key221] = _val222
3064 chandransh 11736 
          iprot.readMapEnd()
11737 
        else:
11738 
          iprot.skip(ftype)
1627 ankur.sing 11739 
      else:
11740 
        iprot.skip(ftype)
11741 
      iprot.readFieldEnd()
11742 
    iprot.readStructEnd()
11743 
 
11744 
  def write(self, oprot):
11745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11747 
      return
3064 chandransh 11748 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 11749 
    if self.providerId is not None:
3064 chandransh 11750 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11751 
      oprot.writeI64(self.providerId)
1627 ankur.sing 11752 
      oprot.writeFieldEnd()
3431 rajveer 11753 
    if self.undeliveredOrders is not None:
3064 chandransh 11754 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
11755 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4837 varun.gupt 11756 
      for kiter223,viter224 in self.undeliveredOrders.items():
11757 
        oprot.writeString(kiter223)
11758 
        oprot.writeString(viter224)
3064 chandransh 11759 
      oprot.writeMapEnd()
11760 
      oprot.writeFieldEnd()
1627 ankur.sing 11761 
    oprot.writeFieldStop()
11762 
    oprot.writeStructEnd()
11763 
 
3431 rajveer 11764 
  def validate(self):
11765 
    return
11766 
 
11767 
 
1627 ankur.sing 11768 
  def __repr__(self):
11769 
    L = ['%s=%r' % (key, value)
11770 
      for key, value in self.__dict__.iteritems()]
11771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11772 
 
11773 
  def __eq__(self, other):
11774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11775 
 
11776 
  def __ne__(self, other):
11777 
    return not (self == other)
11778 
 
3064 chandransh 11779 
class updateNonDeliveryReason_result:
1627 ankur.sing 11780 
  """
11781 
  Attributes:
4581 phani.kuma 11782 
   - success
3064 chandransh 11783 
   - ex
1627 ankur.sing 11784 
  """
11785 
 
11786 
  thrift_spec = (
4581 phani.kuma 11787 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 11788 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11789 
  )
11790 
 
4581 phani.kuma 11791 
  def __init__(self, success=None, ex=None,):
11792 
    self.success = success
3064 chandransh 11793 
    self.ex = ex
1627 ankur.sing 11794 
 
11795 
  def read(self, iprot):
11796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11798 
      return
11799 
    iprot.readStructBegin()
11800 
    while True:
11801 
      (fname, ftype, fid) = iprot.readFieldBegin()
11802 
      if ftype == TType.STOP:
11803 
        break
4581 phani.kuma 11804 
      if fid == 0:
11805 
        if ftype == TType.LIST:
11806 
          self.success = []
4837 varun.gupt 11807 
          (_etype228, _size225) = iprot.readListBegin()
11808 
          for _i229 in xrange(_size225):
11809 
            _elem230 = Order()
11810 
            _elem230.read(iprot)
11811 
            self.success.append(_elem230)
4581 phani.kuma 11812 
          iprot.readListEnd()
11813 
        else:
11814 
          iprot.skip(ftype)
11815 
      elif fid == 1:
3064 chandransh 11816 
        if ftype == TType.STRUCT:
11817 
          self.ex = TransactionServiceException()
11818 
          self.ex.read(iprot)
1627 ankur.sing 11819 
        else:
11820 
          iprot.skip(ftype)
11821 
      else:
11822 
        iprot.skip(ftype)
11823 
      iprot.readFieldEnd()
11824 
    iprot.readStructEnd()
11825 
 
11826 
  def write(self, oprot):
11827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11829 
      return
3064 chandransh 11830 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 11831 
    if self.success is not None:
11832 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11833 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 11834 
      for iter231 in self.success:
11835 
        iter231.write(oprot)
4581 phani.kuma 11836 
      oprot.writeListEnd()
11837 
      oprot.writeFieldEnd()
3431 rajveer 11838 
    if self.ex is not None:
3064 chandransh 11839 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11840 
      self.ex.write(oprot)
1627 ankur.sing 11841 
      oprot.writeFieldEnd()
11842 
    oprot.writeFieldStop()
11843 
    oprot.writeStructEnd()
11844 
 
3431 rajveer 11845 
  def validate(self):
11846 
    return
11847 
 
11848 
 
1627 ankur.sing 11849 
  def __repr__(self):
11850 
    L = ['%s=%r' % (key, value)
11851 
      for key, value in self.__dict__.iteritems()]
11852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11853 
 
11854 
  def __eq__(self, other):
11855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11856 
 
11857 
  def __ne__(self, other):
11858 
    return not (self == other)
11859 
 
3064 chandransh 11860 
class getUndeliveredOrders_args:
1886 ankur.sing 11861 
  """
11862 
  Attributes:
3064 chandransh 11863 
   - providerId
11864 
   - warehouseId
1886 ankur.sing 11865 
  """
1627 ankur.sing 11866 
 
1886 ankur.sing 11867 
  thrift_spec = (
11868 
    None, # 0
3064 chandransh 11869 
    (1, TType.I64, 'providerId', None, None, ), # 1
11870 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 11871 
  )
11872 
 
3064 chandransh 11873 
  def __init__(self, providerId=None, warehouseId=None,):
11874 
    self.providerId = providerId
11875 
    self.warehouseId = warehouseId
1886 ankur.sing 11876 
 
11877 
  def read(self, iprot):
11878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11880 
      return
11881 
    iprot.readStructBegin()
11882 
    while True:
11883 
      (fname, ftype, fid) = iprot.readFieldBegin()
11884 
      if ftype == TType.STOP:
11885 
        break
11886 
      if fid == 1:
11887 
        if ftype == TType.I64:
3064 chandransh 11888 
          self.providerId = iprot.readI64();
1886 ankur.sing 11889 
        else:
11890 
          iprot.skip(ftype)
3064 chandransh 11891 
      elif fid == 2:
11892 
        if ftype == TType.I64:
11893 
          self.warehouseId = iprot.readI64();
11894 
        else:
11895 
          iprot.skip(ftype)
1886 ankur.sing 11896 
      else:
11897 
        iprot.skip(ftype)
11898 
      iprot.readFieldEnd()
11899 
    iprot.readStructEnd()
11900 
 
11901 
  def write(self, oprot):
11902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11904 
      return
3064 chandransh 11905 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 11906 
    if self.providerId is not None:
3064 chandransh 11907 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11908 
      oprot.writeI64(self.providerId)
1886 ankur.sing 11909 
      oprot.writeFieldEnd()
3431 rajveer 11910 
    if self.warehouseId is not None:
3064 chandransh 11911 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11912 
      oprot.writeI64(self.warehouseId)
11913 
      oprot.writeFieldEnd()
1886 ankur.sing 11914 
    oprot.writeFieldStop()
11915 
    oprot.writeStructEnd()
11916 
 
3431 rajveer 11917 
  def validate(self):
11918 
    return
11919 
 
11920 
 
1886 ankur.sing 11921 
  def __repr__(self):
11922 
    L = ['%s=%r' % (key, value)
11923 
      for key, value in self.__dict__.iteritems()]
11924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11925 
 
11926 
  def __eq__(self, other):
11927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11928 
 
11929 
  def __ne__(self, other):
11930 
    return not (self == other)
11931 
 
3064 chandransh 11932 
class getUndeliveredOrders_result:
1886 ankur.sing 11933 
  """
11934 
  Attributes:
11935 
   - success
11936 
  """
11937 
 
11938 
  thrift_spec = (
11939 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11940 
  )
11941 
 
11942 
  def __init__(self, success=None,):
11943 
    self.success = success
11944 
 
11945 
  def read(self, iprot):
11946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11948 
      return
11949 
    iprot.readStructBegin()
11950 
    while True:
11951 
      (fname, ftype, fid) = iprot.readFieldBegin()
11952 
      if ftype == TType.STOP:
11953 
        break
11954 
      if fid == 0:
11955 
        if ftype == TType.LIST:
11956 
          self.success = []
4837 varun.gupt 11957 
          (_etype235, _size232) = iprot.readListBegin()
11958 
          for _i236 in xrange(_size232):
11959 
            _elem237 = Order()
11960 
            _elem237.read(iprot)
11961 
            self.success.append(_elem237)
1886 ankur.sing 11962 
          iprot.readListEnd()
11963 
        else:
11964 
          iprot.skip(ftype)
11965 
      else:
11966 
        iprot.skip(ftype)
11967 
      iprot.readFieldEnd()
11968 
    iprot.readStructEnd()
11969 
 
11970 
  def write(self, oprot):
11971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11973 
      return
3064 chandransh 11974 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 11975 
    if self.success is not None:
1886 ankur.sing 11976 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11977 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 11978 
      for iter238 in self.success:
11979 
        iter238.write(oprot)
1886 ankur.sing 11980 
      oprot.writeListEnd()
11981 
      oprot.writeFieldEnd()
11982 
    oprot.writeFieldStop()
11983 
    oprot.writeStructEnd()
11984 
 
3431 rajveer 11985 
  def validate(self):
11986 
    return
11987 
 
11988 
 
1886 ankur.sing 11989 
  def __repr__(self):
11990 
    L = ['%s=%r' % (key, value)
11991 
      for key, value in self.__dict__.iteritems()]
11992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11993 
 
11994 
  def __eq__(self, other):
11995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11996 
 
11997 
  def __ne__(self, other):
11998 
    return not (self == other)
11999 
 
4783 phani.kuma 12000 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
12001 
 
12002 
  thrift_spec = (
12003 
  )
12004 
 
12005 
  def read(self, iprot):
12006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12008 
      return
12009 
    iprot.readStructBegin()
12010 
    while True:
12011 
      (fname, ftype, fid) = iprot.readFieldBegin()
12012 
      if ftype == TType.STOP:
12013 
        break
12014 
      else:
12015 
        iprot.skip(ftype)
12016 
      iprot.readFieldEnd()
12017 
    iprot.readStructEnd()
12018 
 
12019 
  def write(self, oprot):
12020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12022 
      return
12023 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
12024 
    oprot.writeFieldStop()
12025 
    oprot.writeStructEnd()
12026 
 
12027 
  def validate(self):
12028 
    return
12029 
 
12030 
 
12031 
  def __repr__(self):
12032 
    L = ['%s=%r' % (key, value)
12033 
      for key, value in self.__dict__.iteritems()]
12034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12035 
 
12036 
  def __eq__(self, other):
12037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12038 
 
12039 
  def __ne__(self, other):
12040 
    return not (self == other)
12041 
 
12042 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
12043 
  """
12044 
  Attributes:
12045 
   - success
12046 
  """
12047 
 
12048 
  thrift_spec = (
12049 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12050 
  )
12051 
 
12052 
  def __init__(self, success=None,):
12053 
    self.success = success
12054 
 
12055 
  def read(self, iprot):
12056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12058 
      return
12059 
    iprot.readStructBegin()
12060 
    while True:
12061 
      (fname, ftype, fid) = iprot.readFieldBegin()
12062 
      if ftype == TType.STOP:
12063 
        break
12064 
      if fid == 0:
12065 
        if ftype == TType.LIST:
12066 
          self.success = []
4837 varun.gupt 12067 
          (_etype242, _size239) = iprot.readListBegin()
12068 
          for _i243 in xrange(_size239):
12069 
            _elem244 = Order()
12070 
            _elem244.read(iprot)
12071 
            self.success.append(_elem244)
4783 phani.kuma 12072 
          iprot.readListEnd()
12073 
        else:
12074 
          iprot.skip(ftype)
12075 
      else:
12076 
        iprot.skip(ftype)
12077 
      iprot.readFieldEnd()
12078 
    iprot.readStructEnd()
12079 
 
12080 
  def write(self, oprot):
12081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12083 
      return
12084 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
12085 
    if self.success is not None:
12086 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12087 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 12088 
      for iter245 in self.success:
12089 
        iter245.write(oprot)
4783 phani.kuma 12090 
      oprot.writeListEnd()
12091 
      oprot.writeFieldEnd()
12092 
    oprot.writeFieldStop()
12093 
    oprot.writeStructEnd()
12094 
 
12095 
  def validate(self):
12096 
    return
12097 
 
12098 
 
12099 
  def __repr__(self):
12100 
    L = ['%s=%r' % (key, value)
12101 
      for key, value in self.__dict__.iteritems()]
12102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12103 
 
12104 
  def __eq__(self, other):
12105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12106 
 
12107 
  def __ne__(self, other):
12108 
    return not (self == other)
12109 
 
2536 chandransh 12110 
class toggleDOAFlag_args:
12111 
  """
12112 
  Attributes:
12113 
   - orderId
12114 
  """
1886 ankur.sing 12115 
 
2536 chandransh 12116 
  thrift_spec = (
12117 
    None, # 0
12118 
    (1, TType.I64, 'orderId', None, None, ), # 1
12119 
  )
12120 
 
12121 
  def __init__(self, orderId=None,):
12122 
    self.orderId = orderId
12123 
 
12124 
  def read(self, iprot):
12125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12127 
      return
12128 
    iprot.readStructBegin()
12129 
    while True:
12130 
      (fname, ftype, fid) = iprot.readFieldBegin()
12131 
      if ftype == TType.STOP:
12132 
        break
12133 
      if fid == 1:
12134 
        if ftype == TType.I64:
12135 
          self.orderId = iprot.readI64();
12136 
        else:
12137 
          iprot.skip(ftype)
12138 
      else:
12139 
        iprot.skip(ftype)
12140 
      iprot.readFieldEnd()
12141 
    iprot.readStructEnd()
12142 
 
12143 
  def write(self, oprot):
12144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12146 
      return
12147 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 12148 
    if self.orderId is not None:
2536 chandransh 12149 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12150 
      oprot.writeI64(self.orderId)
12151 
      oprot.writeFieldEnd()
12152 
    oprot.writeFieldStop()
12153 
    oprot.writeStructEnd()
12154 
 
3431 rajveer 12155 
  def validate(self):
12156 
    return
12157 
 
12158 
 
2536 chandransh 12159 
  def __repr__(self):
12160 
    L = ['%s=%r' % (key, value)
12161 
      for key, value in self.__dict__.iteritems()]
12162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12163 
 
12164 
  def __eq__(self, other):
12165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12166 
 
12167 
  def __ne__(self, other):
12168 
    return not (self == other)
12169 
 
12170 
class toggleDOAFlag_result:
12171 
  """
12172 
  Attributes:
12173 
   - success
12174 
   - ex
12175 
  """
12176 
 
12177 
  thrift_spec = (
12178 
    (0, TType.BOOL, 'success', None, None, ), # 0
12179 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12180 
  )
12181 
 
12182 
  def __init__(self, success=None, ex=None,):
12183 
    self.success = success
12184 
    self.ex = ex
12185 
 
12186 
  def read(self, iprot):
12187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12189 
      return
12190 
    iprot.readStructBegin()
12191 
    while True:
12192 
      (fname, ftype, fid) = iprot.readFieldBegin()
12193 
      if ftype == TType.STOP:
12194 
        break
12195 
      if fid == 0:
12196 
        if ftype == TType.BOOL:
12197 
          self.success = iprot.readBool();
12198 
        else:
12199 
          iprot.skip(ftype)
12200 
      elif fid == 1:
12201 
        if ftype == TType.STRUCT:
12202 
          self.ex = TransactionServiceException()
12203 
          self.ex.read(iprot)
12204 
        else:
12205 
          iprot.skip(ftype)
12206 
      else:
12207 
        iprot.skip(ftype)
12208 
      iprot.readFieldEnd()
12209 
    iprot.readStructEnd()
12210 
 
12211 
  def write(self, oprot):
12212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12214 
      return
12215 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 12216 
    if self.success is not None:
2536 chandransh 12217 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12218 
      oprot.writeBool(self.success)
12219 
      oprot.writeFieldEnd()
3431 rajveer 12220 
    if self.ex is not None:
2536 chandransh 12221 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12222 
      self.ex.write(oprot)
12223 
      oprot.writeFieldEnd()
12224 
    oprot.writeFieldStop()
12225 
    oprot.writeStructEnd()
12226 
 
3431 rajveer 12227 
  def validate(self):
12228 
    return
12229 
 
12230 
 
2536 chandransh 12231 
  def __repr__(self):
12232 
    L = ['%s=%r' % (key, value)
12233 
      for key, value in self.__dict__.iteritems()]
12234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12235 
 
12236 
  def __eq__(self, other):
12237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12238 
 
12239 
  def __ne__(self, other):
12240 
    return not (self == other)
12241 
 
4712 rajveer 12242 
class markOrderAsDelivered_args:
12243 
  """
12244 
  Attributes:
12245 
   - orderId
12246 
   - deliveryTimestamp
12247 
   - receiver
12248 
  """
12249 
 
12250 
  thrift_spec = None
12251 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
12252 
    self.orderId = orderId
12253 
    self.deliveryTimestamp = deliveryTimestamp
12254 
    self.receiver = receiver
12255 
 
12256 
  def read(self, iprot):
12257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12259 
      return
12260 
    iprot.readStructBegin()
12261 
    while True:
12262 
      (fname, ftype, fid) = iprot.readFieldBegin()
12263 
      if ftype == TType.STOP:
12264 
        break
12265 
      if fid == 1:
12266 
        if ftype == TType.I64:
12267 
          self.orderId = iprot.readI64();
12268 
        else:
12269 
          iprot.skip(ftype)
12270 
      elif fid == 2:
12271 
        if ftype == TType.I64:
12272 
          self.deliveryTimestamp = iprot.readI64();
12273 
        else:
12274 
          iprot.skip(ftype)
12275 
      elif fid == -1:
12276 
        if ftype == TType.STRING:
12277 
          self.receiver = iprot.readString();
12278 
        else:
12279 
          iprot.skip(ftype)
12280 
      else:
12281 
        iprot.skip(ftype)
12282 
      iprot.readFieldEnd()
12283 
    iprot.readStructEnd()
12284 
 
12285 
  def write(self, oprot):
12286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12288 
      return
12289 
    oprot.writeStructBegin('markOrderAsDelivered_args')
12290 
    if self.receiver is not None:
12291 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
12292 
      oprot.writeString(self.receiver)
12293 
      oprot.writeFieldEnd()
12294 
    if self.orderId is not None:
12295 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12296 
      oprot.writeI64(self.orderId)
12297 
      oprot.writeFieldEnd()
12298 
    if self.deliveryTimestamp is not None:
12299 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
12300 
      oprot.writeI64(self.deliveryTimestamp)
12301 
      oprot.writeFieldEnd()
12302 
    oprot.writeFieldStop()
12303 
    oprot.writeStructEnd()
12304 
 
12305 
  def validate(self):
12306 
    return
12307 
 
12308 
 
12309 
  def __repr__(self):
12310 
    L = ['%s=%r' % (key, value)
12311 
      for key, value in self.__dict__.iteritems()]
12312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12313 
 
12314 
  def __eq__(self, other):
12315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12316 
 
12317 
  def __ne__(self, other):
12318 
    return not (self == other)
12319 
 
12320 
class markOrderAsDelivered_result:
12321 
  """
12322 
  Attributes:
12323 
   - ex
12324 
  """
12325 
 
12326 
  thrift_spec = (
12327 
    None, # 0
12328 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12329 
  )
12330 
 
12331 
  def __init__(self, ex=None,):
12332 
    self.ex = ex
12333 
 
12334 
  def read(self, iprot):
12335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12337 
      return
12338 
    iprot.readStructBegin()
12339 
    while True:
12340 
      (fname, ftype, fid) = iprot.readFieldBegin()
12341 
      if ftype == TType.STOP:
12342 
        break
12343 
      if fid == 1:
12344 
        if ftype == TType.STRUCT:
12345 
          self.ex = TransactionServiceException()
12346 
          self.ex.read(iprot)
12347 
        else:
12348 
          iprot.skip(ftype)
12349 
      else:
12350 
        iprot.skip(ftype)
12351 
      iprot.readFieldEnd()
12352 
    iprot.readStructEnd()
12353 
 
12354 
  def write(self, oprot):
12355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12357 
      return
12358 
    oprot.writeStructBegin('markOrderAsDelivered_result')
12359 
    if self.ex is not None:
12360 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12361 
      self.ex.write(oprot)
12362 
      oprot.writeFieldEnd()
12363 
    oprot.writeFieldStop()
12364 
    oprot.writeStructEnd()
12365 
 
12366 
  def validate(self):
12367 
    return
12368 
 
12369 
 
12370 
  def __repr__(self):
12371 
    L = ['%s=%r' % (key, value)
12372 
      for key, value in self.__dict__.iteritems()]
12373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12374 
 
12375 
  def __eq__(self, other):
12376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12377 
 
12378 
  def __ne__(self, other):
12379 
    return not (self == other)
12380 
 
4454 rajveer 12381 
class markOrderDoaRequestReceived_args:
12382 
  """
12383 
  Attributes:
12384 
   - orderId
12385 
  """
12386 
 
12387 
  thrift_spec = (
12388 
    None, # 0
12389 
    (1, TType.I64, 'orderId', None, None, ), # 1
12390 
  )
12391 
 
12392 
  def __init__(self, orderId=None,):
12393 
    self.orderId = orderId
12394 
 
12395 
  def read(self, iprot):
12396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12398 
      return
12399 
    iprot.readStructBegin()
12400 
    while True:
12401 
      (fname, ftype, fid) = iprot.readFieldBegin()
12402 
      if ftype == TType.STOP:
12403 
        break
12404 
      if fid == 1:
12405 
        if ftype == TType.I64:
12406 
          self.orderId = iprot.readI64();
12407 
        else:
12408 
          iprot.skip(ftype)
12409 
      else:
12410 
        iprot.skip(ftype)
12411 
      iprot.readFieldEnd()
12412 
    iprot.readStructEnd()
12413 
 
12414 
  def write(self, oprot):
12415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12417 
      return
12418 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
12419 
    if self.orderId is not None:
12420 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12421 
      oprot.writeI64(self.orderId)
12422 
      oprot.writeFieldEnd()
12423 
    oprot.writeFieldStop()
12424 
    oprot.writeStructEnd()
12425 
 
12426 
  def validate(self):
12427 
    return
12428 
 
12429 
 
12430 
  def __repr__(self):
12431 
    L = ['%s=%r' % (key, value)
12432 
      for key, value in self.__dict__.iteritems()]
12433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12434 
 
12435 
  def __eq__(self, other):
12436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12437 
 
12438 
  def __ne__(self, other):
12439 
    return not (self == other)
12440 
 
12441 
class markOrderDoaRequestReceived_result:
12442 
  """
12443 
  Attributes:
12444 
   - success
12445 
   - ex
12446 
  """
12447 
 
12448 
  thrift_spec = (
12449 
    (0, TType.BOOL, 'success', None, None, ), # 0
12450 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12451 
  )
12452 
 
12453 
  def __init__(self, success=None, ex=None,):
12454 
    self.success = success
12455 
    self.ex = ex
12456 
 
12457 
  def read(self, iprot):
12458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12460 
      return
12461 
    iprot.readStructBegin()
12462 
    while True:
12463 
      (fname, ftype, fid) = iprot.readFieldBegin()
12464 
      if ftype == TType.STOP:
12465 
        break
12466 
      if fid == 0:
12467 
        if ftype == TType.BOOL:
12468 
          self.success = iprot.readBool();
12469 
        else:
12470 
          iprot.skip(ftype)
12471 
      elif fid == 1:
12472 
        if ftype == TType.STRUCT:
12473 
          self.ex = TransactionServiceException()
12474 
          self.ex.read(iprot)
12475 
        else:
12476 
          iprot.skip(ftype)
12477 
      else:
12478 
        iprot.skip(ftype)
12479 
      iprot.readFieldEnd()
12480 
    iprot.readStructEnd()
12481 
 
12482 
  def write(self, oprot):
12483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12485 
      return
12486 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
12487 
    if self.success is not None:
12488 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12489 
      oprot.writeBool(self.success)
12490 
      oprot.writeFieldEnd()
12491 
    if self.ex is not None:
12492 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12493 
      self.ex.write(oprot)
12494 
      oprot.writeFieldEnd()
12495 
    oprot.writeFieldStop()
12496 
    oprot.writeStructEnd()
12497 
 
12498 
  def validate(self):
12499 
    return
12500 
 
12501 
 
12502 
  def __repr__(self):
12503 
    L = ['%s=%r' % (key, value)
12504 
      for key, value in self.__dict__.iteritems()]
12505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12506 
 
12507 
  def __eq__(self, other):
12508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12509 
 
12510 
  def __ne__(self, other):
12511 
    return not (self == other)
12512 
 
12513 
class markOrderDoaRequestAuthorized_args:
12514 
  """
12515 
  Attributes:
12516 
   - orderId
12517 
   - isAuthorized
12518 
  """
12519 
 
12520 
  thrift_spec = (
12521 
    None, # 0
12522 
    (1, TType.I64, 'orderId', None, None, ), # 1
12523 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12524 
  )
12525 
 
12526 
  def __init__(self, orderId=None, isAuthorized=None,):
12527 
    self.orderId = orderId
12528 
    self.isAuthorized = isAuthorized
12529 
 
12530 
  def read(self, iprot):
12531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12533 
      return
12534 
    iprot.readStructBegin()
12535 
    while True:
12536 
      (fname, ftype, fid) = iprot.readFieldBegin()
12537 
      if ftype == TType.STOP:
12538 
        break
12539 
      if fid == 1:
12540 
        if ftype == TType.I64:
12541 
          self.orderId = iprot.readI64();
12542 
        else:
12543 
          iprot.skip(ftype)
12544 
      elif fid == 2:
12545 
        if ftype == TType.BOOL:
12546 
          self.isAuthorized = iprot.readBool();
12547 
        else:
12548 
          iprot.skip(ftype)
12549 
      else:
12550 
        iprot.skip(ftype)
12551 
      iprot.readFieldEnd()
12552 
    iprot.readStructEnd()
12553 
 
12554 
  def write(self, oprot):
12555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12557 
      return
12558 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
12559 
    if self.orderId is not None:
12560 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12561 
      oprot.writeI64(self.orderId)
12562 
      oprot.writeFieldEnd()
12563 
    if self.isAuthorized is not None:
12564 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12565 
      oprot.writeBool(self.isAuthorized)
12566 
      oprot.writeFieldEnd()
12567 
    oprot.writeFieldStop()
12568 
    oprot.writeStructEnd()
12569 
 
12570 
  def validate(self):
12571 
    return
12572 
 
12573 
 
12574 
  def __repr__(self):
12575 
    L = ['%s=%r' % (key, value)
12576 
      for key, value in self.__dict__.iteritems()]
12577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12578 
 
12579 
  def __eq__(self, other):
12580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12581 
 
12582 
  def __ne__(self, other):
12583 
    return not (self == other)
12584 
 
12585 
class markOrderDoaRequestAuthorized_result:
12586 
  """
12587 
  Attributes:
12588 
   - success
12589 
   - ex
12590 
  """
12591 
 
12592 
  thrift_spec = (
12593 
    (0, TType.BOOL, 'success', None, None, ), # 0
12594 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12595 
  )
12596 
 
12597 
  def __init__(self, success=None, ex=None,):
12598 
    self.success = success
12599 
    self.ex = ex
12600 
 
12601 
  def read(self, iprot):
12602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12604 
      return
12605 
    iprot.readStructBegin()
12606 
    while True:
12607 
      (fname, ftype, fid) = iprot.readFieldBegin()
12608 
      if ftype == TType.STOP:
12609 
        break
12610 
      if fid == 0:
12611 
        if ftype == TType.BOOL:
12612 
          self.success = iprot.readBool();
12613 
        else:
12614 
          iprot.skip(ftype)
12615 
      elif fid == 1:
12616 
        if ftype == TType.STRUCT:
12617 
          self.ex = TransactionServiceException()
12618 
          self.ex.read(iprot)
12619 
        else:
12620 
          iprot.skip(ftype)
12621 
      else:
12622 
        iprot.skip(ftype)
12623 
      iprot.readFieldEnd()
12624 
    iprot.readStructEnd()
12625 
 
12626 
  def write(self, oprot):
12627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12629 
      return
12630 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
12631 
    if self.success is not None:
12632 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12633 
      oprot.writeBool(self.success)
12634 
      oprot.writeFieldEnd()
12635 
    if self.ex is not None:
12636 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12637 
      self.ex.write(oprot)
12638 
      oprot.writeFieldEnd()
12639 
    oprot.writeFieldStop()
12640 
    oprot.writeStructEnd()
12641 
 
12642 
  def validate(self):
12643 
    return
12644 
 
12645 
 
12646 
  def __repr__(self):
12647 
    L = ['%s=%r' % (key, value)
12648 
      for key, value in self.__dict__.iteritems()]
12649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12650 
 
12651 
  def __eq__(self, other):
12652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12653 
 
12654 
  def __ne__(self, other):
12655 
    return not (self == other)
12656 
 
4488 rajveer 12657 
class markOrderReturnRequestReceived_args:
12658 
  """
12659 
  Attributes:
12660 
   - orderId
12661 
  """
12662 
 
12663 
  thrift_spec = (
12664 
    None, # 0
12665 
    (1, TType.I64, 'orderId', None, None, ), # 1
12666 
  )
12667 
 
12668 
  def __init__(self, orderId=None,):
12669 
    self.orderId = orderId
12670 
 
12671 
  def read(self, iprot):
12672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12674 
      return
12675 
    iprot.readStructBegin()
12676 
    while True:
12677 
      (fname, ftype, fid) = iprot.readFieldBegin()
12678 
      if ftype == TType.STOP:
12679 
        break
12680 
      if fid == 1:
12681 
        if ftype == TType.I64:
12682 
          self.orderId = iprot.readI64();
12683 
        else:
12684 
          iprot.skip(ftype)
12685 
      else:
12686 
        iprot.skip(ftype)
12687 
      iprot.readFieldEnd()
12688 
    iprot.readStructEnd()
12689 
 
12690 
  def write(self, oprot):
12691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12693 
      return
12694 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
12695 
    if self.orderId is not None:
12696 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12697 
      oprot.writeI64(self.orderId)
12698 
      oprot.writeFieldEnd()
12699 
    oprot.writeFieldStop()
12700 
    oprot.writeStructEnd()
12701 
 
12702 
  def validate(self):
12703 
    return
12704 
 
12705 
 
12706 
  def __repr__(self):
12707 
    L = ['%s=%r' % (key, value)
12708 
      for key, value in self.__dict__.iteritems()]
12709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12710 
 
12711 
  def __eq__(self, other):
12712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12713 
 
12714 
  def __ne__(self, other):
12715 
    return not (self == other)
12716 
 
12717 
class markOrderReturnRequestReceived_result:
12718 
  """
12719 
  Attributes:
12720 
   - success
12721 
   - ex
12722 
  """
12723 
 
12724 
  thrift_spec = (
12725 
    (0, TType.BOOL, 'success', None, None, ), # 0
12726 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12727 
  )
12728 
 
12729 
  def __init__(self, success=None, ex=None,):
12730 
    self.success = success
12731 
    self.ex = ex
12732 
 
12733 
  def read(self, iprot):
12734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12736 
      return
12737 
    iprot.readStructBegin()
12738 
    while True:
12739 
      (fname, ftype, fid) = iprot.readFieldBegin()
12740 
      if ftype == TType.STOP:
12741 
        break
12742 
      if fid == 0:
12743 
        if ftype == TType.BOOL:
12744 
          self.success = iprot.readBool();
12745 
        else:
12746 
          iprot.skip(ftype)
12747 
      elif fid == 1:
12748 
        if ftype == TType.STRUCT:
12749 
          self.ex = TransactionServiceException()
12750 
          self.ex.read(iprot)
12751 
        else:
12752 
          iprot.skip(ftype)
12753 
      else:
12754 
        iprot.skip(ftype)
12755 
      iprot.readFieldEnd()
12756 
    iprot.readStructEnd()
12757 
 
12758 
  def write(self, oprot):
12759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12761 
      return
12762 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
12763 
    if self.success is not None:
12764 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12765 
      oprot.writeBool(self.success)
12766 
      oprot.writeFieldEnd()
12767 
    if self.ex is not None:
12768 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12769 
      self.ex.write(oprot)
12770 
      oprot.writeFieldEnd()
12771 
    oprot.writeFieldStop()
12772 
    oprot.writeStructEnd()
12773 
 
12774 
  def validate(self):
12775 
    return
12776 
 
12777 
 
12778 
  def __repr__(self):
12779 
    L = ['%s=%r' % (key, value)
12780 
      for key, value in self.__dict__.iteritems()]
12781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12782 
 
12783 
  def __eq__(self, other):
12784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12785 
 
12786 
  def __ne__(self, other):
12787 
    return not (self == other)
12788 
 
12789 
class markOrderReturnRequestAuthorized_args:
12790 
  """
12791 
  Attributes:
12792 
   - orderId
12793 
   - isAuthorized
12794 
  """
12795 
 
12796 
  thrift_spec = (
12797 
    None, # 0
12798 
    (1, TType.I64, 'orderId', None, None, ), # 1
12799 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12800 
  )
12801 
 
12802 
  def __init__(self, orderId=None, isAuthorized=None,):
12803 
    self.orderId = orderId
12804 
    self.isAuthorized = isAuthorized
12805 
 
12806 
  def read(self, iprot):
12807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12809 
      return
12810 
    iprot.readStructBegin()
12811 
    while True:
12812 
      (fname, ftype, fid) = iprot.readFieldBegin()
12813 
      if ftype == TType.STOP:
12814 
        break
12815 
      if fid == 1:
12816 
        if ftype == TType.I64:
12817 
          self.orderId = iprot.readI64();
12818 
        else:
12819 
          iprot.skip(ftype)
12820 
      elif fid == 2:
12821 
        if ftype == TType.BOOL:
12822 
          self.isAuthorized = iprot.readBool();
12823 
        else:
12824 
          iprot.skip(ftype)
12825 
      else:
12826 
        iprot.skip(ftype)
12827 
      iprot.readFieldEnd()
12828 
    iprot.readStructEnd()
12829 
 
12830 
  def write(self, oprot):
12831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12833 
      return
12834 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
12835 
    if self.orderId is not None:
12836 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12837 
      oprot.writeI64(self.orderId)
12838 
      oprot.writeFieldEnd()
12839 
    if self.isAuthorized is not None:
12840 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12841 
      oprot.writeBool(self.isAuthorized)
12842 
      oprot.writeFieldEnd()
12843 
    oprot.writeFieldStop()
12844 
    oprot.writeStructEnd()
12845 
 
12846 
  def validate(self):
12847 
    return
12848 
 
12849 
 
12850 
  def __repr__(self):
12851 
    L = ['%s=%r' % (key, value)
12852 
      for key, value in self.__dict__.iteritems()]
12853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12854 
 
12855 
  def __eq__(self, other):
12856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12857 
 
12858 
  def __ne__(self, other):
12859 
    return not (self == other)
12860 
 
12861 
class markOrderReturnRequestAuthorized_result:
12862 
  """
12863 
  Attributes:
12864 
   - success
12865 
   - ex
12866 
  """
12867 
 
12868 
  thrift_spec = (
12869 
    (0, TType.BOOL, 'success', None, None, ), # 0
12870 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12871 
  )
12872 
 
12873 
  def __init__(self, success=None, ex=None,):
12874 
    self.success = success
12875 
    self.ex = ex
12876 
 
12877 
  def read(self, iprot):
12878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12880 
      return
12881 
    iprot.readStructBegin()
12882 
    while True:
12883 
      (fname, ftype, fid) = iprot.readFieldBegin()
12884 
      if ftype == TType.STOP:
12885 
        break
12886 
      if fid == 0:
12887 
        if ftype == TType.BOOL:
12888 
          self.success = iprot.readBool();
12889 
        else:
12890 
          iprot.skip(ftype)
12891 
      elif fid == 1:
12892 
        if ftype == TType.STRUCT:
12893 
          self.ex = TransactionServiceException()
12894 
          self.ex.read(iprot)
12895 
        else:
12896 
          iprot.skip(ftype)
12897 
      else:
12898 
        iprot.skip(ftype)
12899 
      iprot.readFieldEnd()
12900 
    iprot.readStructEnd()
12901 
 
12902 
  def write(self, oprot):
12903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12905 
      return
12906 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
12907 
    if self.success is not None:
12908 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12909 
      oprot.writeBool(self.success)
12910 
      oprot.writeFieldEnd()
12911 
    if self.ex is not None:
12912 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12913 
      self.ex.write(oprot)
12914 
      oprot.writeFieldEnd()
12915 
    oprot.writeFieldStop()
12916 
    oprot.writeStructEnd()
12917 
 
12918 
  def validate(self):
12919 
    return
12920 
 
12921 
 
12922 
  def __repr__(self):
12923 
    L = ['%s=%r' % (key, value)
12924 
      for key, value in self.__dict__.iteritems()]
12925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12926 
 
12927 
  def __eq__(self, other):
12928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12929 
 
12930 
  def __ne__(self, other):
12931 
    return not (self == other)
12932 
 
2536 chandransh 12933 
class requestPickupNumber_args:
12934 
  """
12935 
  Attributes:
12936 
   - orderId
4579 rajveer 12937 
   - providerId
2536 chandransh 12938 
  """
12939 
 
12940 
  thrift_spec = (
12941 
    None, # 0
12942 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 12943 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 12944 
  )
12945 
 
4579 rajveer 12946 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 12947 
    self.orderId = orderId
4579 rajveer 12948 
    self.providerId = providerId
2536 chandransh 12949 
 
12950 
  def read(self, iprot):
12951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12953 
      return
12954 
    iprot.readStructBegin()
12955 
    while True:
12956 
      (fname, ftype, fid) = iprot.readFieldBegin()
12957 
      if ftype == TType.STOP:
12958 
        break
12959 
      if fid == 1:
12960 
        if ftype == TType.I64:
12961 
          self.orderId = iprot.readI64();
12962 
        else:
12963 
          iprot.skip(ftype)
4579 rajveer 12964 
      elif fid == 2:
12965 
        if ftype == TType.I64:
12966 
          self.providerId = iprot.readI64();
12967 
        else:
12968 
          iprot.skip(ftype)
2536 chandransh 12969 
      else:
12970 
        iprot.skip(ftype)
12971 
      iprot.readFieldEnd()
12972 
    iprot.readStructEnd()
12973 
 
12974 
  def write(self, oprot):
12975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12977 
      return
12978 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 12979 
    if self.orderId is not None:
2536 chandransh 12980 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12981 
      oprot.writeI64(self.orderId)
12982 
      oprot.writeFieldEnd()
4579 rajveer 12983 
    if self.providerId is not None:
12984 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
12985 
      oprot.writeI64(self.providerId)
12986 
      oprot.writeFieldEnd()
2536 chandransh 12987 
    oprot.writeFieldStop()
12988 
    oprot.writeStructEnd()
12989 
 
3431 rajveer 12990 
  def validate(self):
12991 
    return
12992 
 
12993 
 
2536 chandransh 12994 
  def __repr__(self):
12995 
    L = ['%s=%r' % (key, value)
12996 
      for key, value in self.__dict__.iteritems()]
12997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12998 
 
12999 
  def __eq__(self, other):
13000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13001 
 
13002 
  def __ne__(self, other):
13003 
    return not (self == other)
13004 
 
13005 
class requestPickupNumber_result:
13006 
  """
13007 
  Attributes:
13008 
   - success
13009 
   - ex
13010 
  """
13011 
 
13012 
  thrift_spec = (
13013 
    (0, TType.BOOL, 'success', None, None, ), # 0
13014 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13015 
  )
13016 
 
13017 
  def __init__(self, success=None, ex=None,):
13018 
    self.success = success
13019 
    self.ex = ex
13020 
 
13021 
  def read(self, iprot):
13022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13024 
      return
13025 
    iprot.readStructBegin()
13026 
    while True:
13027 
      (fname, ftype, fid) = iprot.readFieldBegin()
13028 
      if ftype == TType.STOP:
13029 
        break
13030 
      if fid == 0:
13031 
        if ftype == TType.BOOL:
13032 
          self.success = iprot.readBool();
13033 
        else:
13034 
          iprot.skip(ftype)
13035 
      elif fid == 1:
13036 
        if ftype == TType.STRUCT:
13037 
          self.ex = TransactionServiceException()
13038 
          self.ex.read(iprot)
13039 
        else:
13040 
          iprot.skip(ftype)
13041 
      else:
13042 
        iprot.skip(ftype)
13043 
      iprot.readFieldEnd()
13044 
    iprot.readStructEnd()
13045 
 
13046 
  def write(self, oprot):
13047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13049 
      return
13050 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 13051 
    if self.success is not None:
2536 chandransh 13052 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13053 
      oprot.writeBool(self.success)
13054 
      oprot.writeFieldEnd()
3431 rajveer 13055 
    if self.ex is not None:
2536 chandransh 13056 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13057 
      self.ex.write(oprot)
13058 
      oprot.writeFieldEnd()
13059 
    oprot.writeFieldStop()
13060 
    oprot.writeStructEnd()
13061 
 
3431 rajveer 13062 
  def validate(self):
13063 
    return
13064 
 
13065 
 
2536 chandransh 13066 
  def __repr__(self):
13067 
    L = ['%s=%r' % (key, value)
13068 
      for key, value in self.__dict__.iteritems()]
13069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13070 
 
13071 
  def __eq__(self, other):
13072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13073 
 
13074 
  def __ne__(self, other):
13075 
    return not (self == other)
13076 
 
13077 
class authorizePickup_args:
13078 
  """
13079 
  Attributes:
13080 
   - orderId
13081 
   - pickupNumber
4602 rajveer 13082 
   - providerId
2536 chandransh 13083 
  """
13084 
 
13085 
  thrift_spec = (
13086 
    None, # 0
13087 
    (1, TType.I64, 'orderId', None, None, ), # 1
13088 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 13089 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 13090 
  )
13091 
 
4602 rajveer 13092 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 13093 
    self.orderId = orderId
13094 
    self.pickupNumber = pickupNumber
4602 rajveer 13095 
    self.providerId = providerId
2536 chandransh 13096 
 
13097 
  def read(self, iprot):
13098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13100 
      return
13101 
    iprot.readStructBegin()
13102 
    while True:
13103 
      (fname, ftype, fid) = iprot.readFieldBegin()
13104 
      if ftype == TType.STOP:
13105 
        break
13106 
      if fid == 1:
13107 
        if ftype == TType.I64:
13108 
          self.orderId = iprot.readI64();
13109 
        else:
13110 
          iprot.skip(ftype)
13111 
      elif fid == 2:
13112 
        if ftype == TType.STRING:
13113 
          self.pickupNumber = iprot.readString();
13114 
        else:
13115 
          iprot.skip(ftype)
4602 rajveer 13116 
      elif fid == 3:
13117 
        if ftype == TType.I64:
13118 
          self.providerId = iprot.readI64();
13119 
        else:
13120 
          iprot.skip(ftype)
2536 chandransh 13121 
      else:
13122 
        iprot.skip(ftype)
13123 
      iprot.readFieldEnd()
13124 
    iprot.readStructEnd()
13125 
 
13126 
  def write(self, oprot):
13127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13129 
      return
13130 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 13131 
    if self.orderId is not None:
2536 chandransh 13132 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13133 
      oprot.writeI64(self.orderId)
13134 
      oprot.writeFieldEnd()
3431 rajveer 13135 
    if self.pickupNumber is not None:
2536 chandransh 13136 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
13137 
      oprot.writeString(self.pickupNumber)
13138 
      oprot.writeFieldEnd()
4602 rajveer 13139 
    if self.providerId is not None:
13140 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
13141 
      oprot.writeI64(self.providerId)
13142 
      oprot.writeFieldEnd()
2536 chandransh 13143 
    oprot.writeFieldStop()
13144 
    oprot.writeStructEnd()
13145 
 
3431 rajveer 13146 
  def validate(self):
13147 
    return
13148 
 
13149 
 
2536 chandransh 13150 
  def __repr__(self):
13151 
    L = ['%s=%r' % (key, value)
13152 
      for key, value in self.__dict__.iteritems()]
13153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13154 
 
13155 
  def __eq__(self, other):
13156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13157 
 
13158 
  def __ne__(self, other):
13159 
    return not (self == other)
13160 
 
13161 
class authorizePickup_result:
13162 
  """
13163 
  Attributes:
13164 
   - success
13165 
   - ex
13166 
  """
13167 
 
13168 
  thrift_spec = (
13169 
    (0, TType.BOOL, 'success', None, None, ), # 0
13170 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13171 
  )
13172 
 
13173 
  def __init__(self, success=None, ex=None,):
13174 
    self.success = success
13175 
    self.ex = ex
13176 
 
13177 
  def read(self, iprot):
13178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13180 
      return
13181 
    iprot.readStructBegin()
13182 
    while True:
13183 
      (fname, ftype, fid) = iprot.readFieldBegin()
13184 
      if ftype == TType.STOP:
13185 
        break
13186 
      if fid == 0:
13187 
        if ftype == TType.BOOL:
13188 
          self.success = iprot.readBool();
13189 
        else:
13190 
          iprot.skip(ftype)
13191 
      elif fid == 1:
13192 
        if ftype == TType.STRUCT:
13193 
          self.ex = TransactionServiceException()
13194 
          self.ex.read(iprot)
13195 
        else:
13196 
          iprot.skip(ftype)
13197 
      else:
13198 
        iprot.skip(ftype)
13199 
      iprot.readFieldEnd()
13200 
    iprot.readStructEnd()
13201 
 
13202 
  def write(self, oprot):
13203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13205 
      return
13206 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 13207 
    if self.success is not None:
2536 chandransh 13208 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13209 
      oprot.writeBool(self.success)
13210 
      oprot.writeFieldEnd()
3431 rajveer 13211 
    if self.ex is not None:
2536 chandransh 13212 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13213 
      self.ex.write(oprot)
13214 
      oprot.writeFieldEnd()
13215 
    oprot.writeFieldStop()
13216 
    oprot.writeStructEnd()
13217 
 
3431 rajveer 13218 
  def validate(self):
13219 
    return
13220 
 
13221 
 
2536 chandransh 13222 
  def __repr__(self):
13223 
    L = ['%s=%r' % (key, value)
13224 
      for key, value in self.__dict__.iteritems()]
13225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13226 
 
13227 
  def __eq__(self, other):
13228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13229 
 
13230 
  def __ne__(self, other):
13231 
    return not (self == other)
13232 
 
2764 chandransh 13233 
class markDoasAsPickedUp_args:
13234 
  """
13235 
  Attributes:
13236 
   - providerId
13237 
   - pickupDetails
13238 
  """
13239 
 
13240 
  thrift_spec = (
13241 
    None, # 0
13242 
    (1, TType.I64, 'providerId', None, None, ), # 1
13243 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
13244 
  )
13245 
 
13246 
  def __init__(self, providerId=None, pickupDetails=None,):
13247 
    self.providerId = providerId
13248 
    self.pickupDetails = pickupDetails
13249 
 
13250 
  def read(self, iprot):
13251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13253 
      return
13254 
    iprot.readStructBegin()
13255 
    while True:
13256 
      (fname, ftype, fid) = iprot.readFieldBegin()
13257 
      if ftype == TType.STOP:
13258 
        break
13259 
      if fid == 1:
13260 
        if ftype == TType.I64:
13261 
          self.providerId = iprot.readI64();
13262 
        else:
13263 
          iprot.skip(ftype)
13264 
      elif fid == 2:
13265 
        if ftype == TType.MAP:
13266 
          self.pickupDetails = {}
4837 varun.gupt 13267 
          (_ktype247, _vtype248, _size246 ) = iprot.readMapBegin()
13268 
          for _i250 in xrange(_size246):
13269 
            _key251 = iprot.readString();
13270 
            _val252 = iprot.readString();
13271 
            self.pickupDetails[_key251] = _val252
2764 chandransh 13272 
          iprot.readMapEnd()
13273 
        else:
13274 
          iprot.skip(ftype)
13275 
      else:
13276 
        iprot.skip(ftype)
13277 
      iprot.readFieldEnd()
13278 
    iprot.readStructEnd()
13279 
 
13280 
  def write(self, oprot):
13281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13283 
      return
13284 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 13285 
    if self.providerId is not None:
2764 chandransh 13286 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13287 
      oprot.writeI64(self.providerId)
13288 
      oprot.writeFieldEnd()
3431 rajveer 13289 
    if self.pickupDetails is not None:
2764 chandransh 13290 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13291 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4837 varun.gupt 13292 
      for kiter253,viter254 in self.pickupDetails.items():
13293 
        oprot.writeString(kiter253)
13294 
        oprot.writeString(viter254)
2764 chandransh 13295 
      oprot.writeMapEnd()
13296 
      oprot.writeFieldEnd()
13297 
    oprot.writeFieldStop()
13298 
    oprot.writeStructEnd()
13299 
 
3431 rajveer 13300 
  def validate(self):
13301 
    return
13302 
 
13303 
 
2764 chandransh 13304 
  def __repr__(self):
13305 
    L = ['%s=%r' % (key, value)
13306 
      for key, value in self.__dict__.iteritems()]
13307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13308 
 
13309 
  def __eq__(self, other):
13310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13311 
 
13312 
  def __ne__(self, other):
13313 
    return not (self == other)
13314 
 
13315 
class markDoasAsPickedUp_result:
13316 
  """
13317 
  Attributes:
13318 
   - success
13319 
  """
13320 
 
13321 
  thrift_spec = (
13322 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13323 
  )
13324 
 
13325 
  def __init__(self, success=None,):
13326 
    self.success = success
13327 
 
13328 
  def read(self, iprot):
13329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13331 
      return
13332 
    iprot.readStructBegin()
13333 
    while True:
13334 
      (fname, ftype, fid) = iprot.readFieldBegin()
13335 
      if ftype == TType.STOP:
13336 
        break
13337 
      if fid == 0:
13338 
        if ftype == TType.LIST:
13339 
          self.success = []
4837 varun.gupt 13340 
          (_etype258, _size255) = iprot.readListBegin()
13341 
          for _i259 in xrange(_size255):
13342 
            _elem260 = Order()
13343 
            _elem260.read(iprot)
13344 
            self.success.append(_elem260)
2764 chandransh 13345 
          iprot.readListEnd()
13346 
        else:
13347 
          iprot.skip(ftype)
13348 
      else:
13349 
        iprot.skip(ftype)
13350 
      iprot.readFieldEnd()
13351 
    iprot.readStructEnd()
13352 
 
13353 
  def write(self, oprot):
13354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13356 
      return
13357 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 13358 
    if self.success is not None:
2764 chandransh 13359 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13360 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 13361 
      for iter261 in self.success:
13362 
        iter261.write(oprot)
2764 chandransh 13363 
      oprot.writeListEnd()
13364 
      oprot.writeFieldEnd()
13365 
    oprot.writeFieldStop()
13366 
    oprot.writeStructEnd()
13367 
 
3431 rajveer 13368 
  def validate(self):
13369 
    return
13370 
 
13371 
 
2764 chandransh 13372 
  def __repr__(self):
13373 
    L = ['%s=%r' % (key, value)
13374 
      for key, value in self.__dict__.iteritems()]
13375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13376 
 
13377 
  def __eq__(self, other):
13378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13379 
 
13380 
  def __ne__(self, other):
13381 
    return not (self == other)
13382 
 
4741 phani.kuma 13383 
class markReturnOrdersAsPickedUp_args:
13384 
  """
13385 
  Attributes:
13386 
   - providerId
13387 
   - pickupDetails
13388 
  """
13389 
 
13390 
  thrift_spec = (
13391 
    None, # 0
13392 
    (1, TType.I64, 'providerId', None, None, ), # 1
13393 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
13394 
  )
13395 
 
13396 
  def __init__(self, providerId=None, pickupDetails=None,):
13397 
    self.providerId = providerId
13398 
    self.pickupDetails = pickupDetails
13399 
 
13400 
  def read(self, iprot):
13401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13403 
      return
13404 
    iprot.readStructBegin()
13405 
    while True:
13406 
      (fname, ftype, fid) = iprot.readFieldBegin()
13407 
      if ftype == TType.STOP:
13408 
        break
13409 
      if fid == 1:
13410 
        if ftype == TType.I64:
13411 
          self.providerId = iprot.readI64();
13412 
        else:
13413 
          iprot.skip(ftype)
13414 
      elif fid == 2:
13415 
        if ftype == TType.MAP:
13416 
          self.pickupDetails = {}
4837 varun.gupt 13417 
          (_ktype263, _vtype264, _size262 ) = iprot.readMapBegin()
13418 
          for _i266 in xrange(_size262):
13419 
            _key267 = iprot.readString();
13420 
            _val268 = iprot.readString();
13421 
            self.pickupDetails[_key267] = _val268
4741 phani.kuma 13422 
          iprot.readMapEnd()
13423 
        else:
13424 
          iprot.skip(ftype)
13425 
      else:
13426 
        iprot.skip(ftype)
13427 
      iprot.readFieldEnd()
13428 
    iprot.readStructEnd()
13429 
 
13430 
  def write(self, oprot):
13431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13433 
      return
13434 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
13435 
    if self.providerId is not None:
13436 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13437 
      oprot.writeI64(self.providerId)
13438 
      oprot.writeFieldEnd()
13439 
    if self.pickupDetails is not None:
13440 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13441 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4837 varun.gupt 13442 
      for kiter269,viter270 in self.pickupDetails.items():
13443 
        oprot.writeString(kiter269)
13444 
        oprot.writeString(viter270)
4741 phani.kuma 13445 
      oprot.writeMapEnd()
13446 
      oprot.writeFieldEnd()
13447 
    oprot.writeFieldStop()
13448 
    oprot.writeStructEnd()
13449 
 
13450 
  def validate(self):
13451 
    return
13452 
 
13453 
 
13454 
  def __repr__(self):
13455 
    L = ['%s=%r' % (key, value)
13456 
      for key, value in self.__dict__.iteritems()]
13457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13458 
 
13459 
  def __eq__(self, other):
13460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13461 
 
13462 
  def __ne__(self, other):
13463 
    return not (self == other)
13464 
 
13465 
class markReturnOrdersAsPickedUp_result:
13466 
  """
13467 
  Attributes:
13468 
   - success
13469 
  """
13470 
 
13471 
  thrift_spec = (
13472 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13473 
  )
13474 
 
13475 
  def __init__(self, success=None,):
13476 
    self.success = success
13477 
 
13478 
  def read(self, iprot):
13479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13481 
      return
13482 
    iprot.readStructBegin()
13483 
    while True:
13484 
      (fname, ftype, fid) = iprot.readFieldBegin()
13485 
      if ftype == TType.STOP:
13486 
        break
13487 
      if fid == 0:
13488 
        if ftype == TType.LIST:
13489 
          self.success = []
4837 varun.gupt 13490 
          (_etype274, _size271) = iprot.readListBegin()
13491 
          for _i275 in xrange(_size271):
13492 
            _elem276 = Order()
13493 
            _elem276.read(iprot)
13494 
            self.success.append(_elem276)
4741 phani.kuma 13495 
          iprot.readListEnd()
13496 
        else:
13497 
          iprot.skip(ftype)
13498 
      else:
13499 
        iprot.skip(ftype)
13500 
      iprot.readFieldEnd()
13501 
    iprot.readStructEnd()
13502 
 
13503 
  def write(self, oprot):
13504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13506 
      return
13507 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
13508 
    if self.success is not None:
13509 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13510 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 13511 
      for iter277 in self.success:
13512 
        iter277.write(oprot)
4741 phani.kuma 13513 
      oprot.writeListEnd()
13514 
      oprot.writeFieldEnd()
13515 
    oprot.writeFieldStop()
13516 
    oprot.writeStructEnd()
13517 
 
13518 
  def validate(self):
13519 
    return
13520 
 
13521 
 
13522 
  def __repr__(self):
13523 
    L = ['%s=%r' % (key, value)
13524 
      for key, value in self.__dict__.iteritems()]
13525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13526 
 
13527 
  def __eq__(self, other):
13528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13529 
 
13530 
  def __ne__(self, other):
13531 
    return not (self == other)
13532 
 
2616 chandransh 13533 
class receiveReturn_args:
2591 chandransh 13534 
  """
13535 
  Attributes:
13536 
   - orderId
4479 rajveer 13537 
   - receiveCondition
2591 chandransh 13538 
  """
2536 chandransh 13539 
 
2591 chandransh 13540 
  thrift_spec = (
13541 
    None, # 0
13542 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 13543 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 13544 
  )
13545 
 
4479 rajveer 13546 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 13547 
    self.orderId = orderId
4479 rajveer 13548 
    self.receiveCondition = receiveCondition
2591 chandransh 13549 
 
13550 
  def read(self, iprot):
13551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13553 
      return
13554 
    iprot.readStructBegin()
13555 
    while True:
13556 
      (fname, ftype, fid) = iprot.readFieldBegin()
13557 
      if ftype == TType.STOP:
13558 
        break
13559 
      if fid == 1:
13560 
        if ftype == TType.I64:
13561 
          self.orderId = iprot.readI64();
13562 
        else:
13563 
          iprot.skip(ftype)
4479 rajveer 13564 
      elif fid == 2:
13565 
        if ftype == TType.I64:
13566 
          self.receiveCondition = iprot.readI64();
13567 
        else:
13568 
          iprot.skip(ftype)
2591 chandransh 13569 
      else:
13570 
        iprot.skip(ftype)
13571 
      iprot.readFieldEnd()
13572 
    iprot.readStructEnd()
13573 
 
13574 
  def write(self, oprot):
13575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13577 
      return
2616 chandransh 13578 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 13579 
    if self.orderId is not None:
2591 chandransh 13580 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13581 
      oprot.writeI64(self.orderId)
13582 
      oprot.writeFieldEnd()
4479 rajveer 13583 
    if self.receiveCondition is not None:
13584 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
13585 
      oprot.writeI64(self.receiveCondition)
13586 
      oprot.writeFieldEnd()
2591 chandransh 13587 
    oprot.writeFieldStop()
13588 
    oprot.writeStructEnd()
13589 
 
3431 rajveer 13590 
  def validate(self):
13591 
    return
13592 
 
13593 
 
2591 chandransh 13594 
  def __repr__(self):
13595 
    L = ['%s=%r' % (key, value)
13596 
      for key, value in self.__dict__.iteritems()]
13597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13598 
 
13599 
  def __eq__(self, other):
13600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13601 
 
13602 
  def __ne__(self, other):
13603 
    return not (self == other)
13604 
 
2616 chandransh 13605 
class receiveReturn_result:
2591 chandransh 13606 
  """
13607 
  Attributes:
13608 
   - success
13609 
   - ex
13610 
  """
13611 
 
13612 
  thrift_spec = (
13613 
    (0, TType.BOOL, 'success', None, None, ), # 0
13614 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13615 
  )
13616 
 
13617 
  def __init__(self, success=None, ex=None,):
13618 
    self.success = success
13619 
    self.ex = ex
13620 
 
13621 
  def read(self, iprot):
13622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13624 
      return
13625 
    iprot.readStructBegin()
13626 
    while True:
13627 
      (fname, ftype, fid) = iprot.readFieldBegin()
13628 
      if ftype == TType.STOP:
13629 
        break
13630 
      if fid == 0:
13631 
        if ftype == TType.BOOL:
13632 
          self.success = iprot.readBool();
13633 
        else:
13634 
          iprot.skip(ftype)
13635 
      elif fid == 1:
13636 
        if ftype == TType.STRUCT:
13637 
          self.ex = TransactionServiceException()
13638 
          self.ex.read(iprot)
13639 
        else:
13640 
          iprot.skip(ftype)
13641 
      else:
13642 
        iprot.skip(ftype)
13643 
      iprot.readFieldEnd()
13644 
    iprot.readStructEnd()
13645 
 
13646 
  def write(self, oprot):
13647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13649 
      return
2616 chandransh 13650 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 13651 
    if self.success is not None:
2591 chandransh 13652 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13653 
      oprot.writeBool(self.success)
13654 
      oprot.writeFieldEnd()
3431 rajveer 13655 
    if self.ex is not None:
2591 chandransh 13656 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13657 
      self.ex.write(oprot)
13658 
      oprot.writeFieldEnd()
13659 
    oprot.writeFieldStop()
13660 
    oprot.writeStructEnd()
13661 
 
3431 rajveer 13662 
  def validate(self):
13663 
    return
13664 
 
13665 
 
2591 chandransh 13666 
  def __repr__(self):
13667 
    L = ['%s=%r' % (key, value)
13668 
      for key, value in self.__dict__.iteritems()]
13669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13670 
 
13671 
  def __eq__(self, other):
13672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13673 
 
13674 
  def __ne__(self, other):
13675 
    return not (self == other)
13676 
 
13677 
class validateDoa_args:
13678 
  """
13679 
  Attributes:
13680 
   - orderId
13681 
   - isValid
13682 
  """
13683 
 
13684 
  thrift_spec = (
13685 
    None, # 0
13686 
    (1, TType.I64, 'orderId', None, None, ), # 1
13687 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
13688 
  )
13689 
 
13690 
  def __init__(self, orderId=None, isValid=None,):
13691 
    self.orderId = orderId
13692 
    self.isValid = isValid
13693 
 
13694 
  def read(self, iprot):
13695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13697 
      return
13698 
    iprot.readStructBegin()
13699 
    while True:
13700 
      (fname, ftype, fid) = iprot.readFieldBegin()
13701 
      if ftype == TType.STOP:
13702 
        break
13703 
      if fid == 1:
13704 
        if ftype == TType.I64:
13705 
          self.orderId = iprot.readI64();
13706 
        else:
13707 
          iprot.skip(ftype)
13708 
      elif fid == 2:
13709 
        if ftype == TType.BOOL:
13710 
          self.isValid = iprot.readBool();
13711 
        else:
13712 
          iprot.skip(ftype)
13713 
      else:
13714 
        iprot.skip(ftype)
13715 
      iprot.readFieldEnd()
13716 
    iprot.readStructEnd()
13717 
 
13718 
  def write(self, oprot):
13719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13721 
      return
13722 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 13723 
    if self.orderId is not None:
2591 chandransh 13724 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13725 
      oprot.writeI64(self.orderId)
13726 
      oprot.writeFieldEnd()
3431 rajveer 13727 
    if self.isValid is not None:
2591 chandransh 13728 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
13729 
      oprot.writeBool(self.isValid)
13730 
      oprot.writeFieldEnd()
13731 
    oprot.writeFieldStop()
13732 
    oprot.writeStructEnd()
13733 
 
3431 rajveer 13734 
  def validate(self):
13735 
    return
13736 
 
13737 
 
2591 chandransh 13738 
  def __repr__(self):
13739 
    L = ['%s=%r' % (key, value)
13740 
      for key, value in self.__dict__.iteritems()]
13741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13742 
 
13743 
  def __eq__(self, other):
13744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13745 
 
13746 
  def __ne__(self, other):
13747 
    return not (self == other)
13748 
 
13749 
class validateDoa_result:
13750 
  """
13751 
  Attributes:
13752 
   - success
13753 
   - ex
13754 
  """
13755 
 
13756 
  thrift_spec = (
13757 
    (0, TType.BOOL, 'success', None, None, ), # 0
13758 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13759 
  )
13760 
 
13761 
  def __init__(self, success=None, ex=None,):
13762 
    self.success = success
13763 
    self.ex = ex
13764 
 
13765 
  def read(self, iprot):
13766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13768 
      return
13769 
    iprot.readStructBegin()
13770 
    while True:
13771 
      (fname, ftype, fid) = iprot.readFieldBegin()
13772 
      if ftype == TType.STOP:
13773 
        break
13774 
      if fid == 0:
13775 
        if ftype == TType.BOOL:
13776 
          self.success = iprot.readBool();
13777 
        else:
13778 
          iprot.skip(ftype)
13779 
      elif fid == 1:
13780 
        if ftype == TType.STRUCT:
13781 
          self.ex = TransactionServiceException()
13782 
          self.ex.read(iprot)
13783 
        else:
13784 
          iprot.skip(ftype)
13785 
      else:
13786 
        iprot.skip(ftype)
13787 
      iprot.readFieldEnd()
13788 
    iprot.readStructEnd()
13789 
 
13790 
  def write(self, oprot):
13791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13793 
      return
13794 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 13795 
    if self.success is not None:
2591 chandransh 13796 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13797 
      oprot.writeBool(self.success)
13798 
      oprot.writeFieldEnd()
3431 rajveer 13799 
    if self.ex is not None:
2591 chandransh 13800 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13801 
      self.ex.write(oprot)
13802 
      oprot.writeFieldEnd()
13803 
    oprot.writeFieldStop()
13804 
    oprot.writeStructEnd()
13805 
 
3431 rajveer 13806 
  def validate(self):
13807 
    return
13808 
 
13809 
 
2591 chandransh 13810 
  def __repr__(self):
13811 
    L = ['%s=%r' % (key, value)
13812 
      for key, value in self.__dict__.iteritems()]
13813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13814 
 
13815 
  def __eq__(self, other):
13816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13817 
 
13818 
  def __ne__(self, other):
13819 
    return not (self == other)
13820 
 
4495 rajveer 13821 
class validateReturnProduct_args:
13822 
  """
13823 
  Attributes:
13824 
   - orderId
13825 
   - isUsable
13826 
  """
13827 
 
13828 
  thrift_spec = (
13829 
    None, # 0
13830 
    (1, TType.I64, 'orderId', None, None, ), # 1
13831 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
13832 
  )
13833 
 
13834 
  def __init__(self, orderId=None, isUsable=None,):
13835 
    self.orderId = orderId
13836 
    self.isUsable = isUsable
13837 
 
13838 
  def read(self, iprot):
13839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13841 
      return
13842 
    iprot.readStructBegin()
13843 
    while True:
13844 
      (fname, ftype, fid) = iprot.readFieldBegin()
13845 
      if ftype == TType.STOP:
13846 
        break
13847 
      if fid == 1:
13848 
        if ftype == TType.I64:
13849 
          self.orderId = iprot.readI64();
13850 
        else:
13851 
          iprot.skip(ftype)
13852 
      elif fid == 2:
13853 
        if ftype == TType.BOOL:
13854 
          self.isUsable = iprot.readBool();
13855 
        else:
13856 
          iprot.skip(ftype)
13857 
      else:
13858 
        iprot.skip(ftype)
13859 
      iprot.readFieldEnd()
13860 
    iprot.readStructEnd()
13861 
 
13862 
  def write(self, oprot):
13863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13865 
      return
13866 
    oprot.writeStructBegin('validateReturnProduct_args')
13867 
    if self.orderId is not None:
13868 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13869 
      oprot.writeI64(self.orderId)
13870 
      oprot.writeFieldEnd()
13871 
    if self.isUsable is not None:
13872 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
13873 
      oprot.writeBool(self.isUsable)
13874 
      oprot.writeFieldEnd()
13875 
    oprot.writeFieldStop()
13876 
    oprot.writeStructEnd()
13877 
 
13878 
  def validate(self):
13879 
    return
13880 
 
13881 
 
13882 
  def __repr__(self):
13883 
    L = ['%s=%r' % (key, value)
13884 
      for key, value in self.__dict__.iteritems()]
13885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13886 
 
13887 
  def __eq__(self, other):
13888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13889 
 
13890 
  def __ne__(self, other):
13891 
    return not (self == other)
13892 
 
13893 
class validateReturnProduct_result:
13894 
  """
13895 
  Attributes:
13896 
   - success
13897 
   - ex
13898 
  """
13899 
 
13900 
  thrift_spec = (
13901 
    (0, TType.BOOL, 'success', None, None, ), # 0
13902 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13903 
  )
13904 
 
13905 
  def __init__(self, success=None, ex=None,):
13906 
    self.success = success
13907 
    self.ex = ex
13908 
 
13909 
  def read(self, iprot):
13910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13912 
      return
13913 
    iprot.readStructBegin()
13914 
    while True:
13915 
      (fname, ftype, fid) = iprot.readFieldBegin()
13916 
      if ftype == TType.STOP:
13917 
        break
13918 
      if fid == 0:
13919 
        if ftype == TType.BOOL:
13920 
          self.success = iprot.readBool();
13921 
        else:
13922 
          iprot.skip(ftype)
13923 
      elif fid == 1:
13924 
        if ftype == TType.STRUCT:
13925 
          self.ex = TransactionServiceException()
13926 
          self.ex.read(iprot)
13927 
        else:
13928 
          iprot.skip(ftype)
13929 
      else:
13930 
        iprot.skip(ftype)
13931 
      iprot.readFieldEnd()
13932 
    iprot.readStructEnd()
13933 
 
13934 
  def write(self, oprot):
13935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13937 
      return
13938 
    oprot.writeStructBegin('validateReturnProduct_result')
13939 
    if self.success is not None:
13940 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13941 
      oprot.writeBool(self.success)
13942 
      oprot.writeFieldEnd()
13943 
    if self.ex is not None:
13944 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13945 
      self.ex.write(oprot)
13946 
      oprot.writeFieldEnd()
13947 
    oprot.writeFieldStop()
13948 
    oprot.writeStructEnd()
13949 
 
13950 
  def validate(self):
13951 
    return
13952 
 
13953 
 
13954 
  def __repr__(self):
13955 
    L = ['%s=%r' % (key, value)
13956 
      for key, value in self.__dict__.iteritems()]
13957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13958 
 
13959 
  def __eq__(self, other):
13960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13961 
 
13962 
  def __ne__(self, other):
13963 
    return not (self == other)
13964 
 
2616 chandransh 13965 
class reshipOrder_args:
13966 
  """
13967 
  Attributes:
13968 
   - orderId
13969 
  """
2591 chandransh 13970 
 
2616 chandransh 13971 
  thrift_spec = (
13972 
    None, # 0
13973 
    (1, TType.I64, 'orderId', None, None, ), # 1
13974 
  )
13975 
 
13976 
  def __init__(self, orderId=None,):
13977 
    self.orderId = orderId
13978 
 
13979 
  def read(self, iprot):
13980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13982 
      return
13983 
    iprot.readStructBegin()
13984 
    while True:
13985 
      (fname, ftype, fid) = iprot.readFieldBegin()
13986 
      if ftype == TType.STOP:
13987 
        break
13988 
      if fid == 1:
13989 
        if ftype == TType.I64:
13990 
          self.orderId = iprot.readI64();
13991 
        else:
13992 
          iprot.skip(ftype)
13993 
      else:
13994 
        iprot.skip(ftype)
13995 
      iprot.readFieldEnd()
13996 
    iprot.readStructEnd()
13997 
 
13998 
  def write(self, oprot):
13999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14001 
      return
14002 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 14003 
    if self.orderId is not None:
2616 chandransh 14004 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14005 
      oprot.writeI64(self.orderId)
14006 
      oprot.writeFieldEnd()
14007 
    oprot.writeFieldStop()
14008 
    oprot.writeStructEnd()
14009 
 
3431 rajveer 14010 
  def validate(self):
14011 
    return
14012 
 
14013 
 
2616 chandransh 14014 
  def __repr__(self):
14015 
    L = ['%s=%r' % (key, value)
14016 
      for key, value in self.__dict__.iteritems()]
14017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14018 
 
14019 
  def __eq__(self, other):
14020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14021 
 
14022 
  def __ne__(self, other):
14023 
    return not (self == other)
14024 
 
14025 
class reshipOrder_result:
14026 
  """
14027 
  Attributes:
14028 
   - success
14029 
   - ex
14030 
  """
14031 
 
14032 
  thrift_spec = (
14033 
    (0, TType.I64, 'success', None, None, ), # 0
14034 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14035 
  )
14036 
 
14037 
  def __init__(self, success=None, ex=None,):
14038 
    self.success = success
14039 
    self.ex = ex
14040 
 
14041 
  def read(self, iprot):
14042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14044 
      return
14045 
    iprot.readStructBegin()
14046 
    while True:
14047 
      (fname, ftype, fid) = iprot.readFieldBegin()
14048 
      if ftype == TType.STOP:
14049 
        break
14050 
      if fid == 0:
14051 
        if ftype == TType.I64:
14052 
          self.success = iprot.readI64();
14053 
        else:
14054 
          iprot.skip(ftype)
14055 
      elif fid == 1:
14056 
        if ftype == TType.STRUCT:
14057 
          self.ex = TransactionServiceException()
14058 
          self.ex.read(iprot)
14059 
        else:
14060 
          iprot.skip(ftype)
14061 
      else:
14062 
        iprot.skip(ftype)
14063 
      iprot.readFieldEnd()
14064 
    iprot.readStructEnd()
14065 
 
14066 
  def write(self, oprot):
14067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14069 
      return
14070 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 14071 
    if self.success is not None:
2616 chandransh 14072 
      oprot.writeFieldBegin('success', TType.I64, 0)
14073 
      oprot.writeI64(self.success)
14074 
      oprot.writeFieldEnd()
3431 rajveer 14075 
    if self.ex is not None:
2616 chandransh 14076 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14077 
      self.ex.write(oprot)
14078 
      oprot.writeFieldEnd()
14079 
    oprot.writeFieldStop()
14080 
    oprot.writeStructEnd()
14081 
 
3431 rajveer 14082 
  def validate(self):
14083 
    return
14084 
 
14085 
 
2616 chandransh 14086 
  def __repr__(self):
14087 
    L = ['%s=%r' % (key, value)
14088 
      for key, value in self.__dict__.iteritems()]
14089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14090 
 
14091 
  def __eq__(self, other):
14092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14093 
 
14094 
  def __ne__(self, other):
14095 
    return not (self == other)
14096 
 
14097 
class refundOrder_args:
14098 
  """
14099 
  Attributes:
14100 
   - orderId
3226 chandransh 14101 
   - refundedBy
14102 
   - reason
2616 chandransh 14103 
  """
14104 
 
14105 
  thrift_spec = (
14106 
    None, # 0
14107 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 14108 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
14109 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 14110 
  )
14111 
 
3226 chandransh 14112 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 14113 
    self.orderId = orderId
3226 chandransh 14114 
    self.refundedBy = refundedBy
14115 
    self.reason = reason
2616 chandransh 14116 
 
14117 
  def read(self, iprot):
14118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14120 
      return
14121 
    iprot.readStructBegin()
14122 
    while True:
14123 
      (fname, ftype, fid) = iprot.readFieldBegin()
14124 
      if ftype == TType.STOP:
14125 
        break
14126 
      if fid == 1:
14127 
        if ftype == TType.I64:
14128 
          self.orderId = iprot.readI64();
14129 
        else:
14130 
          iprot.skip(ftype)
3226 chandransh 14131 
      elif fid == 2:
14132 
        if ftype == TType.STRING:
14133 
          self.refundedBy = iprot.readString();
14134 
        else:
14135 
          iprot.skip(ftype)
14136 
      elif fid == 3:
14137 
        if ftype == TType.STRING:
14138 
          self.reason = iprot.readString();
14139 
        else:
14140 
          iprot.skip(ftype)
2616 chandransh 14141 
      else:
14142 
        iprot.skip(ftype)
14143 
      iprot.readFieldEnd()
14144 
    iprot.readStructEnd()
14145 
 
14146 
  def write(self, oprot):
14147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14149 
      return
14150 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 14151 
    if self.orderId is not None:
2616 chandransh 14152 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14153 
      oprot.writeI64(self.orderId)
14154 
      oprot.writeFieldEnd()
3431 rajveer 14155 
    if self.refundedBy is not None:
3226 chandransh 14156 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
14157 
      oprot.writeString(self.refundedBy)
14158 
      oprot.writeFieldEnd()
3431 rajveer 14159 
    if self.reason is not None:
3226 chandransh 14160 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14161 
      oprot.writeString(self.reason)
14162 
      oprot.writeFieldEnd()
2616 chandransh 14163 
    oprot.writeFieldStop()
14164 
    oprot.writeStructEnd()
14165 
 
3431 rajveer 14166 
  def validate(self):
14167 
    return
14168 
 
14169 
 
2616 chandransh 14170 
  def __repr__(self):
14171 
    L = ['%s=%r' % (key, value)
14172 
      for key, value in self.__dict__.iteritems()]
14173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14174 
 
14175 
  def __eq__(self, other):
14176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14177 
 
14178 
  def __ne__(self, other):
14179 
    return not (self == other)
14180 
 
14181 
class refundOrder_result:
14182 
  """
14183 
  Attributes:
14184 
   - success
14185 
   - ex
14186 
  """
14187 
 
14188 
  thrift_spec = (
14189 
    (0, TType.BOOL, 'success', None, None, ), # 0
14190 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14191 
  )
14192 
 
14193 
  def __init__(self, success=None, ex=None,):
14194 
    self.success = success
14195 
    self.ex = ex
14196 
 
14197 
  def read(self, iprot):
14198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14200 
      return
14201 
    iprot.readStructBegin()
14202 
    while True:
14203 
      (fname, ftype, fid) = iprot.readFieldBegin()
14204 
      if ftype == TType.STOP:
14205 
        break
14206 
      if fid == 0:
14207 
        if ftype == TType.BOOL:
14208 
          self.success = iprot.readBool();
14209 
        else:
14210 
          iprot.skip(ftype)
14211 
      elif fid == 1:
14212 
        if ftype == TType.STRUCT:
14213 
          self.ex = TransactionServiceException()
14214 
          self.ex.read(iprot)
14215 
        else:
14216 
          iprot.skip(ftype)
14217 
      else:
14218 
        iprot.skip(ftype)
14219 
      iprot.readFieldEnd()
14220 
    iprot.readStructEnd()
14221 
 
14222 
  def write(self, oprot):
14223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14225 
      return
14226 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 14227 
    if self.success is not None:
2616 chandransh 14228 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14229 
      oprot.writeBool(self.success)
14230 
      oprot.writeFieldEnd()
3431 rajveer 14231 
    if self.ex is not None:
2616 chandransh 14232 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14233 
      self.ex.write(oprot)
14234 
      oprot.writeFieldEnd()
14235 
    oprot.writeFieldStop()
14236 
    oprot.writeStructEnd()
14237 
 
3431 rajveer 14238 
  def validate(self):
14239 
    return
14240 
 
14241 
 
2616 chandransh 14242 
  def __repr__(self):
14243 
    L = ['%s=%r' % (key, value)
14244 
      for key, value in self.__dict__.iteritems()]
14245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14246 
 
14247 
  def __eq__(self, other):
14248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14249 
 
14250 
  def __ne__(self, other):
14251 
    return not (self == other)
14252 
 
2690 chandransh 14253 
class getReturnOrders_args:
14254 
  """
14255 
  Attributes:
14256 
   - warehouseId
14257 
   - fromDate
14258 
   - toDate
14259 
  """
2616 chandransh 14260 
 
2690 chandransh 14261 
  thrift_spec = (
14262 
    None, # 0
14263 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14264 
    (2, TType.I64, 'fromDate', None, None, ), # 2
14265 
    (3, TType.I64, 'toDate', None, None, ), # 3
14266 
  )
14267 
 
14268 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
14269 
    self.warehouseId = warehouseId
14270 
    self.fromDate = fromDate
14271 
    self.toDate = toDate
14272 
 
14273 
  def read(self, iprot):
14274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14276 
      return
14277 
    iprot.readStructBegin()
14278 
    while True:
14279 
      (fname, ftype, fid) = iprot.readFieldBegin()
14280 
      if ftype == TType.STOP:
14281 
        break
14282 
      if fid == 1:
14283 
        if ftype == TType.I64:
14284 
          self.warehouseId = iprot.readI64();
14285 
        else:
14286 
          iprot.skip(ftype)
14287 
      elif fid == 2:
14288 
        if ftype == TType.I64:
14289 
          self.fromDate = iprot.readI64();
14290 
        else:
14291 
          iprot.skip(ftype)
14292 
      elif fid == 3:
14293 
        if ftype == TType.I64:
14294 
          self.toDate = iprot.readI64();
14295 
        else:
14296 
          iprot.skip(ftype)
14297 
      else:
14298 
        iprot.skip(ftype)
14299 
      iprot.readFieldEnd()
14300 
    iprot.readStructEnd()
14301 
 
14302 
  def write(self, oprot):
14303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14305 
      return
14306 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 14307 
    if self.warehouseId is not None:
2690 chandransh 14308 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14309 
      oprot.writeI64(self.warehouseId)
14310 
      oprot.writeFieldEnd()
3431 rajveer 14311 
    if self.fromDate is not None:
2690 chandransh 14312 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
14313 
      oprot.writeI64(self.fromDate)
14314 
      oprot.writeFieldEnd()
3431 rajveer 14315 
    if self.toDate is not None:
2690 chandransh 14316 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
14317 
      oprot.writeI64(self.toDate)
14318 
      oprot.writeFieldEnd()
14319 
    oprot.writeFieldStop()
14320 
    oprot.writeStructEnd()
14321 
 
3431 rajveer 14322 
  def validate(self):
14323 
    return
14324 
 
14325 
 
2690 chandransh 14326 
  def __repr__(self):
14327 
    L = ['%s=%r' % (key, value)
14328 
      for key, value in self.__dict__.iteritems()]
14329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14330 
 
14331 
  def __eq__(self, other):
14332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14333 
 
14334 
  def __ne__(self, other):
14335 
    return not (self == other)
14336 
 
14337 
class getReturnOrders_result:
14338 
  """
14339 
  Attributes:
14340 
   - success
14341 
  """
14342 
 
14343 
  thrift_spec = (
14344 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
14345 
  )
14346 
 
14347 
  def __init__(self, success=None,):
14348 
    self.success = success
14349 
 
14350 
  def read(self, iprot):
14351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14353 
      return
14354 
    iprot.readStructBegin()
14355 
    while True:
14356 
      (fname, ftype, fid) = iprot.readFieldBegin()
14357 
      if ftype == TType.STOP:
14358 
        break
14359 
      if fid == 0:
14360 
        if ftype == TType.LIST:
14361 
          self.success = []
4837 varun.gupt 14362 
          (_etype281, _size278) = iprot.readListBegin()
14363 
          for _i282 in xrange(_size278):
14364 
            _elem283 = ReturnOrder()
14365 
            _elem283.read(iprot)
14366 
            self.success.append(_elem283)
2690 chandransh 14367 
          iprot.readListEnd()
14368 
        else:
14369 
          iprot.skip(ftype)
14370 
      else:
14371 
        iprot.skip(ftype)
14372 
      iprot.readFieldEnd()
14373 
    iprot.readStructEnd()
14374 
 
14375 
  def write(self, oprot):
14376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14378 
      return
14379 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 14380 
    if self.success is not None:
2690 chandransh 14381 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14382 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 14383 
      for iter284 in self.success:
14384 
        iter284.write(oprot)
2690 chandransh 14385 
      oprot.writeListEnd()
14386 
      oprot.writeFieldEnd()
14387 
    oprot.writeFieldStop()
14388 
    oprot.writeStructEnd()
14389 
 
3431 rajveer 14390 
  def validate(self):
14391 
    return
14392 
 
14393 
 
2690 chandransh 14394 
  def __repr__(self):
14395 
    L = ['%s=%r' % (key, value)
14396 
      for key, value in self.__dict__.iteritems()]
14397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14398 
 
14399 
  def __eq__(self, other):
14400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14401 
 
14402 
  def __ne__(self, other):
14403 
    return not (self == other)
14404 
 
2700 chandransh 14405 
class getReturnOrder_args:
14406 
  """
14407 
  Attributes:
14408 
   - id
14409 
  """
14410 
 
14411 
  thrift_spec = (
14412 
    None, # 0
14413 
    (1, TType.I64, 'id', None, None, ), # 1
14414 
  )
14415 
 
14416 
  def __init__(self, id=None,):
14417 
    self.id = id
14418 
 
14419 
  def read(self, iprot):
14420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14422 
      return
14423 
    iprot.readStructBegin()
14424 
    while True:
14425 
      (fname, ftype, fid) = iprot.readFieldBegin()
14426 
      if ftype == TType.STOP:
14427 
        break
14428 
      if fid == 1:
14429 
        if ftype == TType.I64:
14430 
          self.id = iprot.readI64();
14431 
        else:
14432 
          iprot.skip(ftype)
14433 
      else:
14434 
        iprot.skip(ftype)
14435 
      iprot.readFieldEnd()
14436 
    iprot.readStructEnd()
14437 
 
14438 
  def write(self, oprot):
14439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14441 
      return
14442 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 14443 
    if self.id is not None:
2700 chandransh 14444 
      oprot.writeFieldBegin('id', TType.I64, 1)
14445 
      oprot.writeI64(self.id)
14446 
      oprot.writeFieldEnd()
14447 
    oprot.writeFieldStop()
14448 
    oprot.writeStructEnd()
14449 
 
3431 rajveer 14450 
  def validate(self):
14451 
    return
14452 
 
14453 
 
2700 chandransh 14454 
  def __repr__(self):
14455 
    L = ['%s=%r' % (key, value)
14456 
      for key, value in self.__dict__.iteritems()]
14457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14458 
 
14459 
  def __eq__(self, other):
14460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14461 
 
14462 
  def __ne__(self, other):
14463 
    return not (self == other)
14464 
 
14465 
class getReturnOrder_result:
14466 
  """
14467 
  Attributes:
14468 
   - success
14469 
   - ex
14470 
  """
14471 
 
14472 
  thrift_spec = (
14473 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
14474 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14475 
  )
14476 
 
14477 
  def __init__(self, success=None, ex=None,):
14478 
    self.success = success
14479 
    self.ex = ex
14480 
 
14481 
  def read(self, iprot):
14482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14484 
      return
14485 
    iprot.readStructBegin()
14486 
    while True:
14487 
      (fname, ftype, fid) = iprot.readFieldBegin()
14488 
      if ftype == TType.STOP:
14489 
        break
14490 
      if fid == 0:
14491 
        if ftype == TType.STRUCT:
14492 
          self.success = ReturnOrder()
14493 
          self.success.read(iprot)
14494 
        else:
14495 
          iprot.skip(ftype)
14496 
      elif fid == 1:
14497 
        if ftype == TType.STRUCT:
14498 
          self.ex = TransactionServiceException()
14499 
          self.ex.read(iprot)
14500 
        else:
14501 
          iprot.skip(ftype)
14502 
      else:
14503 
        iprot.skip(ftype)
14504 
      iprot.readFieldEnd()
14505 
    iprot.readStructEnd()
14506 
 
14507 
  def write(self, oprot):
14508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14510 
      return
14511 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 14512 
    if self.success is not None:
2700 chandransh 14513 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14514 
      self.success.write(oprot)
14515 
      oprot.writeFieldEnd()
3431 rajveer 14516 
    if self.ex is not None:
2700 chandransh 14517 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14518 
      self.ex.write(oprot)
14519 
      oprot.writeFieldEnd()
14520 
    oprot.writeFieldStop()
14521 
    oprot.writeStructEnd()
14522 
 
3431 rajveer 14523 
  def validate(self):
14524 
    return
14525 
 
14526 
 
2700 chandransh 14527 
  def __repr__(self):
14528 
    L = ['%s=%r' % (key, value)
14529 
      for key, value in self.__dict__.iteritems()]
14530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14531 
 
14532 
  def __eq__(self, other):
14533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14534 
 
14535 
  def __ne__(self, other):
14536 
    return not (self == other)
14537 
 
2690 chandransh 14538 
class processReturn_args:
14539 
  """
14540 
  Attributes:
14541 
   - returnOrderId
14542 
  """
14543 
 
14544 
  thrift_spec = (
14545 
    None, # 0
14546 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
14547 
  )
14548 
 
14549 
  def __init__(self, returnOrderId=None,):
14550 
    self.returnOrderId = returnOrderId
14551 
 
14552 
  def read(self, iprot):
14553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14555 
      return
14556 
    iprot.readStructBegin()
14557 
    while True:
14558 
      (fname, ftype, fid) = iprot.readFieldBegin()
14559 
      if ftype == TType.STOP:
14560 
        break
14561 
      if fid == 1:
14562 
        if ftype == TType.I64:
14563 
          self.returnOrderId = iprot.readI64();
14564 
        else:
14565 
          iprot.skip(ftype)
14566 
      else:
14567 
        iprot.skip(ftype)
14568 
      iprot.readFieldEnd()
14569 
    iprot.readStructEnd()
14570 
 
14571 
  def write(self, oprot):
14572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14574 
      return
14575 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 14576 
    if self.returnOrderId is not None:
2690 chandransh 14577 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
14578 
      oprot.writeI64(self.returnOrderId)
14579 
      oprot.writeFieldEnd()
14580 
    oprot.writeFieldStop()
14581 
    oprot.writeStructEnd()
14582 
 
3431 rajveer 14583 
  def validate(self):
14584 
    return
14585 
 
14586 
 
2690 chandransh 14587 
  def __repr__(self):
14588 
    L = ['%s=%r' % (key, value)
14589 
      for key, value in self.__dict__.iteritems()]
14590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14591 
 
14592 
  def __eq__(self, other):
14593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14594 
 
14595 
  def __ne__(self, other):
14596 
    return not (self == other)
14597 
 
14598 
class processReturn_result:
14599 
  """
14600 
  Attributes:
14601 
   - ex
14602 
  """
14603 
 
14604 
  thrift_spec = (
14605 
    None, # 0
14606 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14607 
  )
14608 
 
14609 
  def __init__(self, ex=None,):
14610 
    self.ex = ex
14611 
 
14612 
  def read(self, iprot):
14613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14615 
      return
14616 
    iprot.readStructBegin()
14617 
    while True:
14618 
      (fname, ftype, fid) = iprot.readFieldBegin()
14619 
      if ftype == TType.STOP:
14620 
        break
14621 
      if fid == 1:
14622 
        if ftype == TType.STRUCT:
14623 
          self.ex = TransactionServiceException()
14624 
          self.ex.read(iprot)
14625 
        else:
14626 
          iprot.skip(ftype)
14627 
      else:
14628 
        iprot.skip(ftype)
14629 
      iprot.readFieldEnd()
14630 
    iprot.readStructEnd()
14631 
 
14632 
  def write(self, oprot):
14633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14635 
      return
14636 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 14637 
    if self.ex is not None:
2690 chandransh 14638 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14639 
      self.ex.write(oprot)
14640 
      oprot.writeFieldEnd()
14641 
    oprot.writeFieldStop()
14642 
    oprot.writeStructEnd()
14643 
 
3431 rajveer 14644 
  def validate(self):
14645 
    return
14646 
 
14647 
 
2690 chandransh 14648 
  def __repr__(self):
14649 
    L = ['%s=%r' % (key, value)
14650 
      for key, value in self.__dict__.iteritems()]
14651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14652 
 
14653 
  def __eq__(self, other):
14654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14655 
 
14656 
  def __ne__(self, other):
14657 
    return not (self == other)
14658 
 
3451 chandransh 14659 
class updateWeight_args:
14660 
  """
14661 
  Attributes:
14662 
   - orderId
14663 
   - weight
14664 
  """
14665 
 
14666 
  thrift_spec = (
14667 
    None, # 0
14668 
    (1, TType.I64, 'orderId', None, None, ), # 1
14669 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
14670 
  )
14671 
 
14672 
  def __init__(self, orderId=None, weight=None,):
14673 
    self.orderId = orderId
14674 
    self.weight = weight
14675 
 
14676 
  def read(self, iprot):
14677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14679 
      return
14680 
    iprot.readStructBegin()
14681 
    while True:
14682 
      (fname, ftype, fid) = iprot.readFieldBegin()
14683 
      if ftype == TType.STOP:
14684 
        break
14685 
      if fid == 1:
14686 
        if ftype == TType.I64:
14687 
          self.orderId = iprot.readI64();
14688 
        else:
14689 
          iprot.skip(ftype)
14690 
      elif fid == 2:
14691 
        if ftype == TType.DOUBLE:
14692 
          self.weight = iprot.readDouble();
14693 
        else:
14694 
          iprot.skip(ftype)
14695 
      else:
14696 
        iprot.skip(ftype)
14697 
      iprot.readFieldEnd()
14698 
    iprot.readStructEnd()
14699 
 
14700 
  def write(self, oprot):
14701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14703 
      return
14704 
    oprot.writeStructBegin('updateWeight_args')
14705 
    if self.orderId is not None:
14706 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14707 
      oprot.writeI64(self.orderId)
14708 
      oprot.writeFieldEnd()
14709 
    if self.weight is not None:
14710 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
14711 
      oprot.writeDouble(self.weight)
14712 
      oprot.writeFieldEnd()
14713 
    oprot.writeFieldStop()
14714 
    oprot.writeStructEnd()
14715 
 
14716 
  def validate(self):
14717 
    return
14718 
 
14719 
 
14720 
  def __repr__(self):
14721 
    L = ['%s=%r' % (key, value)
14722 
      for key, value in self.__dict__.iteritems()]
14723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14724 
 
14725 
  def __eq__(self, other):
14726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14727 
 
14728 
  def __ne__(self, other):
14729 
    return not (self == other)
14730 
 
14731 
class updateWeight_result:
14732 
  """
14733 
  Attributes:
14734 
   - success
14735 
   - ex
14736 
  """
14737 
 
14738 
  thrift_spec = (
14739 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14740 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14741 
  )
14742 
 
14743 
  def __init__(self, success=None, ex=None,):
14744 
    self.success = success
14745 
    self.ex = ex
14746 
 
14747 
  def read(self, iprot):
14748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14750 
      return
14751 
    iprot.readStructBegin()
14752 
    while True:
14753 
      (fname, ftype, fid) = iprot.readFieldBegin()
14754 
      if ftype == TType.STOP:
14755 
        break
14756 
      if fid == 0:
14757 
        if ftype == TType.STRUCT:
14758 
          self.success = Order()
14759 
          self.success.read(iprot)
14760 
        else:
14761 
          iprot.skip(ftype)
14762 
      elif fid == 1:
14763 
        if ftype == TType.STRUCT:
14764 
          self.ex = TransactionServiceException()
14765 
          self.ex.read(iprot)
14766 
        else:
14767 
          iprot.skip(ftype)
14768 
      else:
14769 
        iprot.skip(ftype)
14770 
      iprot.readFieldEnd()
14771 
    iprot.readStructEnd()
14772 
 
14773 
  def write(self, oprot):
14774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14776 
      return
14777 
    oprot.writeStructBegin('updateWeight_result')
14778 
    if self.success is not None:
14779 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14780 
      self.success.write(oprot)
14781 
      oprot.writeFieldEnd()
14782 
    if self.ex is not None:
14783 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14784 
      self.ex.write(oprot)
14785 
      oprot.writeFieldEnd()
14786 
    oprot.writeFieldStop()
14787 
    oprot.writeStructEnd()
14788 
 
14789 
  def validate(self):
14790 
    return
14791 
 
14792 
 
14793 
  def __repr__(self):
14794 
    L = ['%s=%r' % (key, value)
14795 
      for key, value in self.__dict__.iteritems()]
14796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14797 
 
14798 
  def __eq__(self, other):
14799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14800 
 
14801 
  def __ne__(self, other):
14802 
    return not (self == other)
3469 chandransh 14803 
 
14804 
class changeItem_args:
14805 
  """
14806 
  Attributes:
14807 
   - orderId
14808 
   - itemId
14809 
  """
14810 
 
14811 
  thrift_spec = (
14812 
    None, # 0
14813 
    (1, TType.I64, 'orderId', None, None, ), # 1
14814 
    (2, TType.I64, 'itemId', None, None, ), # 2
14815 
  )
14816 
 
14817 
  def __init__(self, orderId=None, itemId=None,):
14818 
    self.orderId = orderId
14819 
    self.itemId = itemId
14820 
 
14821 
  def read(self, iprot):
14822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14824 
      return
14825 
    iprot.readStructBegin()
14826 
    while True:
14827 
      (fname, ftype, fid) = iprot.readFieldBegin()
14828 
      if ftype == TType.STOP:
14829 
        break
14830 
      if fid == 1:
14831 
        if ftype == TType.I64:
14832 
          self.orderId = iprot.readI64();
14833 
        else:
14834 
          iprot.skip(ftype)
14835 
      elif fid == 2:
14836 
        if ftype == TType.I64:
14837 
          self.itemId = iprot.readI64();
14838 
        else:
14839 
          iprot.skip(ftype)
14840 
      else:
14841 
        iprot.skip(ftype)
14842 
      iprot.readFieldEnd()
14843 
    iprot.readStructEnd()
14844 
 
14845 
  def write(self, oprot):
14846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14848 
      return
14849 
    oprot.writeStructBegin('changeItem_args')
14850 
    if self.orderId is not None:
14851 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14852 
      oprot.writeI64(self.orderId)
14853 
      oprot.writeFieldEnd()
14854 
    if self.itemId is not None:
14855 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14856 
      oprot.writeI64(self.itemId)
14857 
      oprot.writeFieldEnd()
14858 
    oprot.writeFieldStop()
14859 
    oprot.writeStructEnd()
14860 
 
14861 
  def validate(self):
14862 
    return
14863 
 
14864 
 
14865 
  def __repr__(self):
14866 
    L = ['%s=%r' % (key, value)
14867 
      for key, value in self.__dict__.iteritems()]
14868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14869 
 
14870 
  def __eq__(self, other):
14871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14872 
 
14873 
  def __ne__(self, other):
14874 
    return not (self == other)
14875 
 
14876 
class changeItem_result:
14877 
  """
14878 
  Attributes:
14879 
   - success
14880 
   - ex
14881 
  """
14882 
 
14883 
  thrift_spec = (
14884 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14885 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14886 
  )
14887 
 
14888 
  def __init__(self, success=None, ex=None,):
14889 
    self.success = success
14890 
    self.ex = ex
14891 
 
14892 
  def read(self, iprot):
14893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14895 
      return
14896 
    iprot.readStructBegin()
14897 
    while True:
14898 
      (fname, ftype, fid) = iprot.readFieldBegin()
14899 
      if ftype == TType.STOP:
14900 
        break
14901 
      if fid == 0:
14902 
        if ftype == TType.STRUCT:
14903 
          self.success = Order()
14904 
          self.success.read(iprot)
14905 
        else:
14906 
          iprot.skip(ftype)
14907 
      elif fid == 1:
14908 
        if ftype == TType.STRUCT:
14909 
          self.ex = TransactionServiceException()
14910 
          self.ex.read(iprot)
14911 
        else:
14912 
          iprot.skip(ftype)
14913 
      else:
14914 
        iprot.skip(ftype)
14915 
      iprot.readFieldEnd()
14916 
    iprot.readStructEnd()
14917 
 
14918 
  def write(self, oprot):
14919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14921 
      return
14922 
    oprot.writeStructBegin('changeItem_result')
14923 
    if self.success is not None:
14924 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14925 
      self.success.write(oprot)
14926 
      oprot.writeFieldEnd()
14927 
    if self.ex is not None:
14928 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14929 
      self.ex.write(oprot)
14930 
      oprot.writeFieldEnd()
14931 
    oprot.writeFieldStop()
14932 
    oprot.writeStructEnd()
14933 
 
14934 
  def validate(self):
14935 
    return
14936 
 
14937 
 
14938 
  def __repr__(self):
14939 
    L = ['%s=%r' % (key, value)
14940 
      for key, value in self.__dict__.iteritems()]
14941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14942 
 
14943 
  def __eq__(self, other):
14944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14945 
 
14946 
  def __ne__(self, other):
14947 
    return not (self == other)
14948 
 
14949 
class shiftToWarehouse_args:
14950 
  """
14951 
  Attributes:
14952 
   - orderId
14953 
   - warehouseId
14954 
  """
14955 
 
14956 
  thrift_spec = (
14957 
    None, # 0
14958 
    (1, TType.I64, 'orderId', None, None, ), # 1
14959 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
14960 
  )
14961 
 
14962 
  def __init__(self, orderId=None, warehouseId=None,):
14963 
    self.orderId = orderId
14964 
    self.warehouseId = warehouseId
14965 
 
14966 
  def read(self, iprot):
14967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14969 
      return
14970 
    iprot.readStructBegin()
14971 
    while True:
14972 
      (fname, ftype, fid) = iprot.readFieldBegin()
14973 
      if ftype == TType.STOP:
14974 
        break
14975 
      if fid == 1:
14976 
        if ftype == TType.I64:
14977 
          self.orderId = iprot.readI64();
14978 
        else:
14979 
          iprot.skip(ftype)
14980 
      elif fid == 2:
14981 
        if ftype == TType.I64:
14982 
          self.warehouseId = iprot.readI64();
14983 
        else:
14984 
          iprot.skip(ftype)
14985 
      else:
14986 
        iprot.skip(ftype)
14987 
      iprot.readFieldEnd()
14988 
    iprot.readStructEnd()
14989 
 
14990 
  def write(self, oprot):
14991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14993 
      return
14994 
    oprot.writeStructBegin('shiftToWarehouse_args')
14995 
    if self.orderId is not None:
14996 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14997 
      oprot.writeI64(self.orderId)
14998 
      oprot.writeFieldEnd()
14999 
    if self.warehouseId is not None:
15000 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15001 
      oprot.writeI64(self.warehouseId)
15002 
      oprot.writeFieldEnd()
15003 
    oprot.writeFieldStop()
15004 
    oprot.writeStructEnd()
15005 
 
15006 
  def validate(self):
15007 
    return
15008 
 
15009 
 
15010 
  def __repr__(self):
15011 
    L = ['%s=%r' % (key, value)
15012 
      for key, value in self.__dict__.iteritems()]
15013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15014 
 
15015 
  def __eq__(self, other):
15016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15017 
 
15018 
  def __ne__(self, other):
15019 
    return not (self == other)
15020 
 
15021 
class shiftToWarehouse_result:
15022 
  """
15023 
  Attributes:
15024 
   - success
15025 
   - ex
15026 
  """
15027 
 
15028 
  thrift_spec = (
15029 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
15030 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15031 
  )
15032 
 
15033 
  def __init__(self, success=None, ex=None,):
15034 
    self.success = success
15035 
    self.ex = ex
15036 
 
15037 
  def read(self, iprot):
15038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15040 
      return
15041 
    iprot.readStructBegin()
15042 
    while True:
15043 
      (fname, ftype, fid) = iprot.readFieldBegin()
15044 
      if ftype == TType.STOP:
15045 
        break
15046 
      if fid == 0:
15047 
        if ftype == TType.STRUCT:
15048 
          self.success = Order()
15049 
          self.success.read(iprot)
15050 
        else:
15051 
          iprot.skip(ftype)
15052 
      elif fid == 1:
15053 
        if ftype == TType.STRUCT:
15054 
          self.ex = TransactionServiceException()
15055 
          self.ex.read(iprot)
15056 
        else:
15057 
          iprot.skip(ftype)
15058 
      else:
15059 
        iprot.skip(ftype)
15060 
      iprot.readFieldEnd()
15061 
    iprot.readStructEnd()
15062 
 
15063 
  def write(self, oprot):
15064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15066 
      return
15067 
    oprot.writeStructBegin('shiftToWarehouse_result')
15068 
    if self.success is not None:
15069 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15070 
      self.success.write(oprot)
15071 
      oprot.writeFieldEnd()
15072 
    if self.ex is not None:
15073 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15074 
      self.ex.write(oprot)
15075 
      oprot.writeFieldEnd()
15076 
    oprot.writeFieldStop()
15077 
    oprot.writeStructEnd()
15078 
 
15079 
  def validate(self):
15080 
    return
15081 
 
15082 
 
15083 
  def __repr__(self):
15084 
    L = ['%s=%r' % (key, value)
15085 
      for key, value in self.__dict__.iteritems()]
15086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15087 
 
15088 
  def __eq__(self, other):
15089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15090 
 
15091 
  def __ne__(self, other):
15092 
    return not (self == other)
3553 chandransh 15093 
 
15094 
class addDelayReason_args:
15095 
  """
15096 
  Attributes:
15097 
   - orderId
15098 
   - delayReason
3986 chandransh 15099 
   - furtherDelay
4647 rajveer 15100 
   - delayReasonText
3553 chandransh 15101 
  """
15102 
 
15103 
  thrift_spec = (
15104 
    None, # 0
15105 
    (1, TType.I64, 'orderId', None, None, ), # 1
15106 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 15107 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 15108 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 15109 
  )
15110 
 
4647 rajveer 15111 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 15112 
    self.orderId = orderId
15113 
    self.delayReason = delayReason
3986 chandransh 15114 
    self.furtherDelay = furtherDelay
4647 rajveer 15115 
    self.delayReasonText = delayReasonText
3553 chandransh 15116 
 
15117 
  def read(self, iprot):
15118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15120 
      return
15121 
    iprot.readStructBegin()
15122 
    while True:
15123 
      (fname, ftype, fid) = iprot.readFieldBegin()
15124 
      if ftype == TType.STOP:
15125 
        break
15126 
      if fid == 1:
15127 
        if ftype == TType.I64:
15128 
          self.orderId = iprot.readI64();
15129 
        else:
15130 
          iprot.skip(ftype)
15131 
      elif fid == 2:
15132 
        if ftype == TType.I32:
15133 
          self.delayReason = iprot.readI32();
15134 
        else:
15135 
          iprot.skip(ftype)
3986 chandransh 15136 
      elif fid == 3:
15137 
        if ftype == TType.I64:
15138 
          self.furtherDelay = iprot.readI64();
15139 
        else:
15140 
          iprot.skip(ftype)
4647 rajveer 15141 
      elif fid == 4:
15142 
        if ftype == TType.STRING:
15143 
          self.delayReasonText = iprot.readString();
15144 
        else:
15145 
          iprot.skip(ftype)
3553 chandransh 15146 
      else:
15147 
        iprot.skip(ftype)
15148 
      iprot.readFieldEnd()
15149 
    iprot.readStructEnd()
15150 
 
15151 
  def write(self, oprot):
15152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15154 
      return
15155 
    oprot.writeStructBegin('addDelayReason_args')
15156 
    if self.orderId is not None:
15157 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15158 
      oprot.writeI64(self.orderId)
15159 
      oprot.writeFieldEnd()
15160 
    if self.delayReason is not None:
15161 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
15162 
      oprot.writeI32(self.delayReason)
15163 
      oprot.writeFieldEnd()
3986 chandransh 15164 
    if self.furtherDelay is not None:
15165 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
15166 
      oprot.writeI64(self.furtherDelay)
15167 
      oprot.writeFieldEnd()
4647 rajveer 15168 
    if self.delayReasonText is not None:
15169 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
15170 
      oprot.writeString(self.delayReasonText)
15171 
      oprot.writeFieldEnd()
3553 chandransh 15172 
    oprot.writeFieldStop()
15173 
    oprot.writeStructEnd()
15174 
 
15175 
  def validate(self):
15176 
    return
15177 
 
15178 
 
15179 
  def __repr__(self):
15180 
    L = ['%s=%r' % (key, value)
15181 
      for key, value in self.__dict__.iteritems()]
15182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15183 
 
15184 
  def __eq__(self, other):
15185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15186 
 
15187 
  def __ne__(self, other):
15188 
    return not (self == other)
15189 
 
15190 
class addDelayReason_result:
15191 
  """
15192 
  Attributes:
15193 
   - success
15194 
   - ex
15195 
  """
15196 
 
15197 
  thrift_spec = (
15198 
    (0, TType.BOOL, 'success', None, None, ), # 0
15199 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15200 
  )
15201 
 
15202 
  def __init__(self, success=None, ex=None,):
15203 
    self.success = success
15204 
    self.ex = ex
15205 
 
15206 
  def read(self, iprot):
15207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15209 
      return
15210 
    iprot.readStructBegin()
15211 
    while True:
15212 
      (fname, ftype, fid) = iprot.readFieldBegin()
15213 
      if ftype == TType.STOP:
15214 
        break
15215 
      if fid == 0:
15216 
        if ftype == TType.BOOL:
15217 
          self.success = iprot.readBool();
15218 
        else:
15219 
          iprot.skip(ftype)
15220 
      elif fid == 1:
15221 
        if ftype == TType.STRUCT:
15222 
          self.ex = TransactionServiceException()
15223 
          self.ex.read(iprot)
15224 
        else:
15225 
          iprot.skip(ftype)
15226 
      else:
15227 
        iprot.skip(ftype)
15228 
      iprot.readFieldEnd()
15229 
    iprot.readStructEnd()
15230 
 
15231 
  def write(self, oprot):
15232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15234 
      return
15235 
    oprot.writeStructBegin('addDelayReason_result')
15236 
    if self.success is not None:
15237 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15238 
      oprot.writeBool(self.success)
15239 
      oprot.writeFieldEnd()
15240 
    if self.ex is not None:
15241 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15242 
      self.ex.write(oprot)
15243 
      oprot.writeFieldEnd()
15244 
    oprot.writeFieldStop()
15245 
    oprot.writeStructEnd()
15246 
 
15247 
  def validate(self):
15248 
    return
15249 
 
15250 
 
15251 
  def __repr__(self):
15252 
    L = ['%s=%r' % (key, value)
15253 
      for key, value in self.__dict__.iteritems()]
15254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15255 
 
15256 
  def __eq__(self, other):
15257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15258 
 
15259 
  def __ne__(self, other):
15260 
    return not (self == other)
3956 chandransh 15261 
 
15262 
class reconcileCodCollection_args:
15263 
  """
15264 
  Attributes:
15265 
   - collectedAmountMap
15266 
   - xferBy
15267 
   - xferTxnId
15268 
   - xferDate
15269 
  """
15270 
 
15271 
  thrift_spec = (
15272 
    None, # 0
15273 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
15274 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
15275 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
15276 
    (4, TType.I64, 'xferDate', None, None, ), # 4
15277 
  )
15278 
 
15279 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
15280 
    self.collectedAmountMap = collectedAmountMap
15281 
    self.xferBy = xferBy
15282 
    self.xferTxnId = xferTxnId
15283 
    self.xferDate = xferDate
15284 
 
15285 
  def read(self, iprot):
15286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15288 
      return
15289 
    iprot.readStructBegin()
15290 
    while True:
15291 
      (fname, ftype, fid) = iprot.readFieldBegin()
15292 
      if ftype == TType.STOP:
15293 
        break
15294 
      if fid == 1:
15295 
        if ftype == TType.MAP:
15296 
          self.collectedAmountMap = {}
4837 varun.gupt 15297 
          (_ktype286, _vtype287, _size285 ) = iprot.readMapBegin()
15298 
          for _i289 in xrange(_size285):
15299 
            _key290 = iprot.readString();
15300 
            _val291 = iprot.readDouble();
15301 
            self.collectedAmountMap[_key290] = _val291
3956 chandransh 15302 
          iprot.readMapEnd()
15303 
        else:
15304 
          iprot.skip(ftype)
15305 
      elif fid == 2:
15306 
        if ftype == TType.STRING:
15307 
          self.xferBy = iprot.readString();
15308 
        else:
15309 
          iprot.skip(ftype)
15310 
      elif fid == 3:
15311 
        if ftype == TType.STRING:
15312 
          self.xferTxnId = iprot.readString();
15313 
        else:
15314 
          iprot.skip(ftype)
15315 
      elif fid == 4:
15316 
        if ftype == TType.I64:
15317 
          self.xferDate = iprot.readI64();
15318 
        else:
15319 
          iprot.skip(ftype)
15320 
      else:
15321 
        iprot.skip(ftype)
15322 
      iprot.readFieldEnd()
15323 
    iprot.readStructEnd()
15324 
 
15325 
  def write(self, oprot):
15326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15328 
      return
15329 
    oprot.writeStructBegin('reconcileCodCollection_args')
15330 
    if self.collectedAmountMap is not None:
15331 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
15332 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4837 varun.gupt 15333 
      for kiter292,viter293 in self.collectedAmountMap.items():
15334 
        oprot.writeString(kiter292)
15335 
        oprot.writeDouble(viter293)
3956 chandransh 15336 
      oprot.writeMapEnd()
15337 
      oprot.writeFieldEnd()
15338 
    if self.xferBy is not None:
15339 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
15340 
      oprot.writeString(self.xferBy)
15341 
      oprot.writeFieldEnd()
15342 
    if self.xferTxnId is not None:
15343 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
15344 
      oprot.writeString(self.xferTxnId)
15345 
      oprot.writeFieldEnd()
15346 
    if self.xferDate is not None:
15347 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
15348 
      oprot.writeI64(self.xferDate)
15349 
      oprot.writeFieldEnd()
15350 
    oprot.writeFieldStop()
15351 
    oprot.writeStructEnd()
15352 
 
15353 
  def validate(self):
15354 
    return
15355 
 
15356 
 
15357 
  def __repr__(self):
15358 
    L = ['%s=%r' % (key, value)
15359 
      for key, value in self.__dict__.iteritems()]
15360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15361 
 
15362 
  def __eq__(self, other):
15363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15364 
 
15365 
  def __ne__(self, other):
15366 
    return not (self == other)
15367 
 
15368 
class reconcileCodCollection_result:
15369 
  """
15370 
  Attributes:
15371 
   - success
15372 
   - ex
15373 
  """
15374 
 
15375 
  thrift_spec = (
15376 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15377 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15378 
  )
15379 
 
15380 
  def __init__(self, success=None, ex=None,):
15381 
    self.success = success
15382 
    self.ex = ex
15383 
 
15384 
  def read(self, iprot):
15385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15387 
      return
15388 
    iprot.readStructBegin()
15389 
    while True:
15390 
      (fname, ftype, fid) = iprot.readFieldBegin()
15391 
      if ftype == TType.STOP:
15392 
        break
15393 
      if fid == 0:
15394 
        if ftype == TType.MAP:
15395 
          self.success = {}
4837 varun.gupt 15396 
          (_ktype295, _vtype296, _size294 ) = iprot.readMapBegin()
15397 
          for _i298 in xrange(_size294):
15398 
            _key299 = iprot.readString();
15399 
            _val300 = iprot.readString();
15400 
            self.success[_key299] = _val300
3956 chandransh 15401 
          iprot.readMapEnd()
15402 
        else:
15403 
          iprot.skip(ftype)
15404 
      elif fid == 1:
15405 
        if ftype == TType.STRUCT:
15406 
          self.ex = TransactionServiceException()
15407 
          self.ex.read(iprot)
15408 
        else:
15409 
          iprot.skip(ftype)
15410 
      else:
15411 
        iprot.skip(ftype)
15412 
      iprot.readFieldEnd()
15413 
    iprot.readStructEnd()
15414 
 
15415 
  def write(self, oprot):
15416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15418 
      return
15419 
    oprot.writeStructBegin('reconcileCodCollection_result')
15420 
    if self.success is not None:
15421 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15422 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4837 varun.gupt 15423 
      for kiter301,viter302 in self.success.items():
15424 
        oprot.writeString(kiter301)
15425 
        oprot.writeString(viter302)
3956 chandransh 15426 
      oprot.writeMapEnd()
15427 
      oprot.writeFieldEnd()
15428 
    if self.ex is not None:
15429 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15430 
      self.ex.write(oprot)
15431 
      oprot.writeFieldEnd()
15432 
    oprot.writeFieldStop()
15433 
    oprot.writeStructEnd()
15434 
 
15435 
  def validate(self):
15436 
    return
15437 
 
15438 
 
15439 
  def __repr__(self):
15440 
    L = ['%s=%r' % (key, value)
15441 
      for key, value in self.__dict__.iteritems()]
15442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15443 
 
15444 
  def __eq__(self, other):
15445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15446 
 
15447 
  def __ne__(self, other):
15448 
    return not (self == other)
4008 mandeep.dh 15449 
 
15450 
class getTransactionsRequiringExtraProcessing_args:
15451 
  """
15452 
  Attributes:
15453 
   - category
15454 
  """
15455 
 
15456 
  thrift_spec = (
15457 
    None, # 0
15458 
    (1, TType.I32, 'category', None, None, ), # 1
15459 
  )
15460 
 
15461 
  def __init__(self, category=None,):
15462 
    self.category = category
15463 
 
15464 
  def read(self, iprot):
15465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15467 
      return
15468 
    iprot.readStructBegin()
15469 
    while True:
15470 
      (fname, ftype, fid) = iprot.readFieldBegin()
15471 
      if ftype == TType.STOP:
15472 
        break
15473 
      if fid == 1:
15474 
        if ftype == TType.I32:
15475 
          self.category = iprot.readI32();
15476 
        else:
15477 
          iprot.skip(ftype)
15478 
      else:
15479 
        iprot.skip(ftype)
15480 
      iprot.readFieldEnd()
15481 
    iprot.readStructEnd()
15482 
 
15483 
  def write(self, oprot):
15484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15486 
      return
15487 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
15488 
    if self.category is not None:
15489 
      oprot.writeFieldBegin('category', TType.I32, 1)
15490 
      oprot.writeI32(self.category)
15491 
      oprot.writeFieldEnd()
15492 
    oprot.writeFieldStop()
15493 
    oprot.writeStructEnd()
15494 
 
15495 
  def validate(self):
15496 
    return
15497 
 
15498 
 
15499 
  def __repr__(self):
15500 
    L = ['%s=%r' % (key, value)
15501 
      for key, value in self.__dict__.iteritems()]
15502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15503 
 
15504 
  def __eq__(self, other):
15505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15506 
 
15507 
  def __ne__(self, other):
15508 
    return not (self == other)
15509 
 
15510 
class getTransactionsRequiringExtraProcessing_result:
15511 
  """
15512 
  Attributes:
15513 
   - success
15514 
  """
15515 
 
15516 
  thrift_spec = (
15517 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15518 
  )
15519 
 
15520 
  def __init__(self, success=None,):
15521 
    self.success = success
15522 
 
15523 
  def read(self, iprot):
15524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15526 
      return
15527 
    iprot.readStructBegin()
15528 
    while True:
15529 
      (fname, ftype, fid) = iprot.readFieldBegin()
15530 
      if ftype == TType.STOP:
15531 
        break
15532 
      if fid == 0:
15533 
        if ftype == TType.LIST:
15534 
          self.success = []
4837 varun.gupt 15535 
          (_etype306, _size303) = iprot.readListBegin()
15536 
          for _i307 in xrange(_size303):
15537 
            _elem308 = iprot.readI64();
15538 
            self.success.append(_elem308)
4008 mandeep.dh 15539 
          iprot.readListEnd()
15540 
        else:
15541 
          iprot.skip(ftype)
15542 
      else:
15543 
        iprot.skip(ftype)
15544 
      iprot.readFieldEnd()
15545 
    iprot.readStructEnd()
15546 
 
15547 
  def write(self, oprot):
15548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15550 
      return
15551 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
15552 
    if self.success is not None:
15553 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15554 
      oprot.writeListBegin(TType.I64, len(self.success))
4837 varun.gupt 15555 
      for iter309 in self.success:
15556 
        oprot.writeI64(iter309)
4008 mandeep.dh 15557 
      oprot.writeListEnd()
15558 
      oprot.writeFieldEnd()
15559 
    oprot.writeFieldStop()
15560 
    oprot.writeStructEnd()
15561 
 
15562 
  def validate(self):
15563 
    return
15564 
 
15565 
 
15566 
  def __repr__(self):
15567 
    L = ['%s=%r' % (key, value)
15568 
      for key, value in self.__dict__.iteritems()]
15569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15570 
 
15571 
  def __eq__(self, other):
15572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15573 
 
15574 
  def __ne__(self, other):
15575 
    return not (self == other)
15576 
 
15577 
class markTransactionAsProcessed_args:
15578 
  """
15579 
  Attributes:
15580 
   - transactionId
15581 
   - category
15582 
  """
15583 
 
15584 
  thrift_spec = (
15585 
    None, # 0
15586 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15587 
    (2, TType.I32, 'category', None, None, ), # 2
15588 
  )
15589 
 
15590 
  def __init__(self, transactionId=None, category=None,):
15591 
    self.transactionId = transactionId
15592 
    self.category = category
15593 
 
15594 
  def read(self, iprot):
15595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15597 
      return
15598 
    iprot.readStructBegin()
15599 
    while True:
15600 
      (fname, ftype, fid) = iprot.readFieldBegin()
15601 
      if ftype == TType.STOP:
15602 
        break
15603 
      if fid == 1:
15604 
        if ftype == TType.I64:
15605 
          self.transactionId = iprot.readI64();
15606 
        else:
15607 
          iprot.skip(ftype)
15608 
      elif fid == 2:
15609 
        if ftype == TType.I32:
15610 
          self.category = iprot.readI32();
15611 
        else:
15612 
          iprot.skip(ftype)
15613 
      else:
15614 
        iprot.skip(ftype)
15615 
      iprot.readFieldEnd()
15616 
    iprot.readStructEnd()
15617 
 
15618 
  def write(self, oprot):
15619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15621 
      return
15622 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
15623 
    if self.transactionId is not None:
15624 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15625 
      oprot.writeI64(self.transactionId)
15626 
      oprot.writeFieldEnd()
15627 
    if self.category is not None:
15628 
      oprot.writeFieldBegin('category', TType.I32, 2)
15629 
      oprot.writeI32(self.category)
15630 
      oprot.writeFieldEnd()
15631 
    oprot.writeFieldStop()
15632 
    oprot.writeStructEnd()
15633 
 
15634 
  def validate(self):
15635 
    return
15636 
 
15637 
 
15638 
  def __repr__(self):
15639 
    L = ['%s=%r' % (key, value)
15640 
      for key, value in self.__dict__.iteritems()]
15641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15642 
 
15643 
  def __eq__(self, other):
15644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15645 
 
15646 
  def __ne__(self, other):
15647 
    return not (self == other)
15648 
 
15649 
class markTransactionAsProcessed_result:
15650 
 
15651 
  thrift_spec = (
15652 
  )
15653 
 
15654 
  def read(self, iprot):
15655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15657 
      return
15658 
    iprot.readStructBegin()
15659 
    while True:
15660 
      (fname, ftype, fid) = iprot.readFieldBegin()
15661 
      if ftype == TType.STOP:
15662 
        break
15663 
      else:
15664 
        iprot.skip(ftype)
15665 
      iprot.readFieldEnd()
15666 
    iprot.readStructEnd()
15667 
 
15668 
  def write(self, oprot):
15669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15671 
      return
15672 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
15673 
    oprot.writeFieldStop()
15674 
    oprot.writeStructEnd()
15675 
 
15676 
  def validate(self):
15677 
    return
15678 
 
15679 
 
15680 
  def __repr__(self):
15681 
    L = ['%s=%r' % (key, value)
15682 
      for key, value in self.__dict__.iteritems()]
15683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15684 
 
15685 
  def __eq__(self, other):
15686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15687 
 
15688 
  def __ne__(self, other):
15689 
    return not (self == other)
4018 chandransh 15690 
 
15691 
class getItemWiseRiskyOrdersCount_args:
15692 
 
15693 
  thrift_spec = (
15694 
  )
15695 
 
15696 
  def read(self, iprot):
15697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15699 
      return
15700 
    iprot.readStructBegin()
15701 
    while True:
15702 
      (fname, ftype, fid) = iprot.readFieldBegin()
15703 
      if ftype == TType.STOP:
15704 
        break
15705 
      else:
15706 
        iprot.skip(ftype)
15707 
      iprot.readFieldEnd()
15708 
    iprot.readStructEnd()
15709 
 
15710 
  def write(self, oprot):
15711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15713 
      return
15714 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
15715 
    oprot.writeFieldStop()
15716 
    oprot.writeStructEnd()
15717 
 
15718 
  def validate(self):
15719 
    return
15720 
 
15721 
 
15722 
  def __repr__(self):
15723 
    L = ['%s=%r' % (key, value)
15724 
      for key, value in self.__dict__.iteritems()]
15725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15726 
 
15727 
  def __eq__(self, other):
15728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15729 
 
15730 
  def __ne__(self, other):
15731 
    return not (self == other)
15732 
 
15733 
class getItemWiseRiskyOrdersCount_result:
15734 
  """
15735 
  Attributes:
15736 
   - success
15737 
  """
15738 
 
15739 
  thrift_spec = (
15740 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
15741 
  )
15742 
 
15743 
  def __init__(self, success=None,):
15744 
    self.success = success
15745 
 
15746 
  def read(self, iprot):
15747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15749 
      return
15750 
    iprot.readStructBegin()
15751 
    while True:
15752 
      (fname, ftype, fid) = iprot.readFieldBegin()
15753 
      if ftype == TType.STOP:
15754 
        break
15755 
      if fid == 0:
15756 
        if ftype == TType.MAP:
15757 
          self.success = {}
4837 varun.gupt 15758 
          (_ktype311, _vtype312, _size310 ) = iprot.readMapBegin()
15759 
          for _i314 in xrange(_size310):
15760 
            _key315 = iprot.readI64();
15761 
            _val316 = iprot.readI64();
15762 
            self.success[_key315] = _val316
4018 chandransh 15763 
          iprot.readMapEnd()
15764 
        else:
15765 
          iprot.skip(ftype)
15766 
      else:
15767 
        iprot.skip(ftype)
15768 
      iprot.readFieldEnd()
15769 
    iprot.readStructEnd()
15770 
 
15771 
  def write(self, oprot):
15772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15774 
      return
15775 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
15776 
    if self.success is not None:
15777 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15778 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4837 varun.gupt 15779 
      for kiter317,viter318 in self.success.items():
15780 
        oprot.writeI64(kiter317)
15781 
        oprot.writeI64(viter318)
4018 chandransh 15782 
      oprot.writeMapEnd()
15783 
      oprot.writeFieldEnd()
15784 
    oprot.writeFieldStop()
15785 
    oprot.writeStructEnd()
15786 
 
15787 
  def validate(self):
15788 
    return
15789 
 
15790 
 
15791 
  def __repr__(self):
15792 
    L = ['%s=%r' % (key, value)
15793 
      for key, value in self.__dict__.iteritems()]
15794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15795 
 
15796 
  def __eq__(self, other):
15797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15798 
 
15799 
  def __ne__(self, other):
15800 
    return not (self == other)
4247 rajveer 15801 
 
4295 varun.gupt 15802 
class getOrdersForItemIds_args:
15803 
  """
15804 
  Attributes:
15805 
   - itemIds
15806 
  """
15807 
 
15808 
  thrift_spec = (
15809 
    None, # 0
15810 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15811 
  )
15812 
 
15813 
  def __init__(self, itemIds=None,):
15814 
    self.itemIds = itemIds
15815 
 
15816 
  def read(self, iprot):
15817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15819 
      return
15820 
    iprot.readStructBegin()
15821 
    while True:
15822 
      (fname, ftype, fid) = iprot.readFieldBegin()
15823 
      if ftype == TType.STOP:
15824 
        break
15825 
      if fid == 1:
15826 
        if ftype == TType.LIST:
15827 
          self.itemIds = []
4837 varun.gupt 15828 
          (_etype322, _size319) = iprot.readListBegin()
15829 
          for _i323 in xrange(_size319):
15830 
            _elem324 = iprot.readI64();
15831 
            self.itemIds.append(_elem324)
4295 varun.gupt 15832 
          iprot.readListEnd()
15833 
        else:
15834 
          iprot.skip(ftype)
15835 
      else:
15836 
        iprot.skip(ftype)
15837 
      iprot.readFieldEnd()
15838 
    iprot.readStructEnd()
15839 
 
15840 
  def write(self, oprot):
15841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15843 
      return
15844 
    oprot.writeStructBegin('getOrdersForItemIds_args')
15845 
    if self.itemIds is not None:
15846 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15847 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4837 varun.gupt 15848 
      for iter325 in self.itemIds:
15849 
        oprot.writeI64(iter325)
4295 varun.gupt 15850 
      oprot.writeListEnd()
15851 
      oprot.writeFieldEnd()
15852 
    oprot.writeFieldStop()
15853 
    oprot.writeStructEnd()
15854 
 
15855 
  def validate(self):
15856 
    return
15857 
 
15858 
 
15859 
  def __repr__(self):
15860 
    L = ['%s=%r' % (key, value)
15861 
      for key, value in self.__dict__.iteritems()]
15862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15863 
 
15864 
  def __eq__(self, other):
15865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15866 
 
15867 
  def __ne__(self, other):
15868 
    return not (self == other)
15869 
 
15870 
class getOrdersForItemIds_result:
15871 
  """
15872 
  Attributes:
15873 
   - success
15874 
  """
15875 
 
15876 
  thrift_spec = (
15877 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15878 
  )
15879 
 
15880 
  def __init__(self, success=None,):
15881 
    self.success = success
15882 
 
15883 
  def read(self, iprot):
15884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15886 
      return
15887 
    iprot.readStructBegin()
15888 
    while True:
15889 
      (fname, ftype, fid) = iprot.readFieldBegin()
15890 
      if ftype == TType.STOP:
15891 
        break
15892 
      if fid == 0:
15893 
        if ftype == TType.LIST:
15894 
          self.success = []
4837 varun.gupt 15895 
          (_etype329, _size326) = iprot.readListBegin()
15896 
          for _i330 in xrange(_size326):
15897 
            _elem331 = Order()
15898 
            _elem331.read(iprot)
15899 
            self.success.append(_elem331)
4295 varun.gupt 15900 
          iprot.readListEnd()
15901 
        else:
15902 
          iprot.skip(ftype)
15903 
      else:
15904 
        iprot.skip(ftype)
15905 
      iprot.readFieldEnd()
15906 
    iprot.readStructEnd()
15907 
 
15908 
  def write(self, oprot):
15909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15911 
      return
15912 
    oprot.writeStructBegin('getOrdersForItemIds_result')
15913 
    if self.success is not None:
15914 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15915 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 15916 
      for iter332 in self.success:
15917 
        iter332.write(oprot)
4295 varun.gupt 15918 
      oprot.writeListEnd()
15919 
      oprot.writeFieldEnd()
15920 
    oprot.writeFieldStop()
15921 
    oprot.writeStructEnd()
15922 
 
15923 
  def validate(self):
15924 
    return
15925 
 
15926 
 
15927 
  def __repr__(self):
15928 
    L = ['%s=%r' % (key, value)
15929 
      for key, value in self.__dict__.iteritems()]
15930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15931 
 
15932 
  def __eq__(self, other):
15933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15934 
 
15935 
  def __ne__(self, other):
15936 
    return not (self == other)
15937 
 
4247 rajveer 15938 
class markOrderCancellationRequestReceived_args:
15939 
  """
15940 
  Attributes:
15941 
   - orderId
15942 
  """
15943 
 
15944 
  thrift_spec = (
15945 
    None, # 0
15946 
    (1, TType.I64, 'orderId', None, None, ), # 1
15947 
  )
15948 
 
15949 
  def __init__(self, orderId=None,):
15950 
    self.orderId = orderId
15951 
 
15952 
  def read(self, iprot):
15953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15955 
      return
15956 
    iprot.readStructBegin()
15957 
    while True:
15958 
      (fname, ftype, fid) = iprot.readFieldBegin()
15959 
      if ftype == TType.STOP:
15960 
        break
15961 
      if fid == 1:
15962 
        if ftype == TType.I64:
15963 
          self.orderId = iprot.readI64();
15964 
        else:
15965 
          iprot.skip(ftype)
15966 
      else:
15967 
        iprot.skip(ftype)
15968 
      iprot.readFieldEnd()
15969 
    iprot.readStructEnd()
15970 
 
15971 
  def write(self, oprot):
15972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15974 
      return
15975 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
15976 
    if self.orderId is not None:
15977 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15978 
      oprot.writeI64(self.orderId)
15979 
      oprot.writeFieldEnd()
15980 
    oprot.writeFieldStop()
15981 
    oprot.writeStructEnd()
15982 
 
15983 
  def validate(self):
15984 
    return
15985 
 
15986 
 
15987 
  def __repr__(self):
15988 
    L = ['%s=%r' % (key, value)
15989 
      for key, value in self.__dict__.iteritems()]
15990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15991 
 
15992 
  def __eq__(self, other):
15993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15994 
 
15995 
  def __ne__(self, other):
15996 
    return not (self == other)
15997 
 
15998 
class markOrderCancellationRequestReceived_result:
15999 
  """
16000 
  Attributes:
16001 
   - ex
16002 
  """
16003 
 
16004 
  thrift_spec = (
16005 
    None, # 0
16006 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16007 
  )
16008 
 
16009 
  def __init__(self, ex=None,):
16010 
    self.ex = ex
16011 
 
16012 
  def read(self, iprot):
16013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16015 
      return
16016 
    iprot.readStructBegin()
16017 
    while True:
16018 
      (fname, ftype, fid) = iprot.readFieldBegin()
16019 
      if ftype == TType.STOP:
16020 
        break
16021 
      if fid == 1:
16022 
        if ftype == TType.STRUCT:
16023 
          self.ex = TransactionServiceException()
16024 
          self.ex.read(iprot)
16025 
        else:
16026 
          iprot.skip(ftype)
16027 
      else:
16028 
        iprot.skip(ftype)
16029 
      iprot.readFieldEnd()
16030 
    iprot.readStructEnd()
16031 
 
16032 
  def write(self, oprot):
16033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16035 
      return
16036 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
16037 
    if self.ex is not None:
16038 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16039 
      self.ex.write(oprot)
16040 
      oprot.writeFieldEnd()
16041 
    oprot.writeFieldStop()
16042 
    oprot.writeStructEnd()
16043 
 
16044 
  def validate(self):
16045 
    return
16046 
 
16047 
 
16048 
  def __repr__(self):
16049 
    L = ['%s=%r' % (key, value)
16050 
      for key, value in self.__dict__.iteritems()]
16051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16052 
 
16053 
  def __eq__(self, other):
16054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16055 
 
16056 
  def __ne__(self, other):
16057 
    return not (self == other)
16058 
 
16059 
class markOrderCancellationRequestConfirmed_args:
16060 
  """
16061 
  Attributes:
16062 
   - orderId
16063 
  """
16064 
 
16065 
  thrift_spec = (
16066 
    None, # 0
16067 
    (1, TType.I64, 'orderId', None, None, ), # 1
16068 
  )
16069 
 
16070 
  def __init__(self, orderId=None,):
16071 
    self.orderId = orderId
16072 
 
16073 
  def read(self, iprot):
16074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16076 
      return
16077 
    iprot.readStructBegin()
16078 
    while True:
16079 
      (fname, ftype, fid) = iprot.readFieldBegin()
16080 
      if ftype == TType.STOP:
16081 
        break
16082 
      if fid == 1:
16083 
        if ftype == TType.I64:
16084 
          self.orderId = iprot.readI64();
16085 
        else:
16086 
          iprot.skip(ftype)
16087 
      else:
16088 
        iprot.skip(ftype)
16089 
      iprot.readFieldEnd()
16090 
    iprot.readStructEnd()
16091 
 
16092 
  def write(self, oprot):
16093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16095 
      return
16096 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
16097 
    if self.orderId is not None:
16098 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16099 
      oprot.writeI64(self.orderId)
16100 
      oprot.writeFieldEnd()
16101 
    oprot.writeFieldStop()
16102 
    oprot.writeStructEnd()
16103 
 
16104 
  def validate(self):
16105 
    return
16106 
 
16107 
 
16108 
  def __repr__(self):
16109 
    L = ['%s=%r' % (key, value)
16110 
      for key, value in self.__dict__.iteritems()]
16111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16112 
 
16113 
  def __eq__(self, other):
16114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16115 
 
16116 
  def __ne__(self, other):
16117 
    return not (self == other)
16118 
 
16119 
class markOrderCancellationRequestConfirmed_result:
16120 
  """
16121 
  Attributes:
16122 
   - ex
16123 
  """
16124 
 
16125 
  thrift_spec = (
16126 
    None, # 0
16127 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16128 
  )
16129 
 
16130 
  def __init__(self, ex=None,):
16131 
    self.ex = ex
16132 
 
16133 
  def read(self, iprot):
16134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16136 
      return
16137 
    iprot.readStructBegin()
16138 
    while True:
16139 
      (fname, ftype, fid) = iprot.readFieldBegin()
16140 
      if ftype == TType.STOP:
16141 
        break
16142 
      if fid == 1:
16143 
        if ftype == TType.STRUCT:
16144 
          self.ex = TransactionServiceException()
16145 
          self.ex.read(iprot)
16146 
        else:
16147 
          iprot.skip(ftype)
16148 
      else:
16149 
        iprot.skip(ftype)
16150 
      iprot.readFieldEnd()
16151 
    iprot.readStructEnd()
16152 
 
16153 
  def write(self, oprot):
16154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16156 
      return
16157 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
16158 
    if self.ex is not None:
16159 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16160 
      self.ex.write(oprot)
16161 
      oprot.writeFieldEnd()
16162 
    oprot.writeFieldStop()
16163 
    oprot.writeStructEnd()
16164 
 
16165 
  def validate(self):
16166 
    return
16167 
 
16168 
 
16169 
  def __repr__(self):
16170 
    L = ['%s=%r' % (key, value)
16171 
      for key, value in self.__dict__.iteritems()]
16172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16173 
 
16174 
  def __eq__(self, other):
16175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16176 
 
16177 
  def __ne__(self, other):
16178 
    return not (self == other)
16179 
 
16180 
class markOrderCancellationRequestDenied_args:
16181 
  """
16182 
  Attributes:
16183 
   - orderId
16184 
  """
16185 
 
16186 
  thrift_spec = (
16187 
    None, # 0
16188 
    (1, TType.I64, 'orderId', None, None, ), # 1
16189 
  )
16190 
 
16191 
  def __init__(self, orderId=None,):
16192 
    self.orderId = orderId
16193 
 
16194 
  def read(self, iprot):
16195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16197 
      return
16198 
    iprot.readStructBegin()
16199 
    while True:
16200 
      (fname, ftype, fid) = iprot.readFieldBegin()
16201 
      if ftype == TType.STOP:
16202 
        break
16203 
      if fid == 1:
16204 
        if ftype == TType.I64:
16205 
          self.orderId = iprot.readI64();
16206 
        else:
16207 
          iprot.skip(ftype)
16208 
      else:
16209 
        iprot.skip(ftype)
16210 
      iprot.readFieldEnd()
16211 
    iprot.readStructEnd()
16212 
 
16213 
  def write(self, oprot):
16214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16216 
      return
16217 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
16218 
    if self.orderId is not None:
16219 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16220 
      oprot.writeI64(self.orderId)
16221 
      oprot.writeFieldEnd()
16222 
    oprot.writeFieldStop()
16223 
    oprot.writeStructEnd()
16224 
 
16225 
  def validate(self):
16226 
    return
16227 
 
16228 
 
16229 
  def __repr__(self):
16230 
    L = ['%s=%r' % (key, value)
16231 
      for key, value in self.__dict__.iteritems()]
16232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16233 
 
16234 
  def __eq__(self, other):
16235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16236 
 
16237 
  def __ne__(self, other):
16238 
    return not (self == other)
16239 
 
16240 
class markOrderCancellationRequestDenied_result:
16241 
  """
16242 
  Attributes:
16243 
   - ex
16244 
  """
16245 
 
16246 
  thrift_spec = (
16247 
    None, # 0
16248 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16249 
  )
16250 
 
16251 
  def __init__(self, ex=None,):
16252 
    self.ex = ex
16253 
 
16254 
  def read(self, iprot):
16255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16257 
      return
16258 
    iprot.readStructBegin()
16259 
    while True:
16260 
      (fname, ftype, fid) = iprot.readFieldBegin()
16261 
      if ftype == TType.STOP:
16262 
        break
16263 
      if fid == 1:
16264 
        if ftype == TType.STRUCT:
16265 
          self.ex = TransactionServiceException()
16266 
          self.ex.read(iprot)
16267 
        else:
16268 
          iprot.skip(ftype)
16269 
      else:
16270 
        iprot.skip(ftype)
16271 
      iprot.readFieldEnd()
16272 
    iprot.readStructEnd()
16273 
 
16274 
  def write(self, oprot):
16275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16277 
      return
16278 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
16279 
    if self.ex is not None:
16280 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16281 
      self.ex.write(oprot)
16282 
      oprot.writeFieldEnd()
16283 
    oprot.writeFieldStop()
16284 
    oprot.writeStructEnd()
16285 
 
16286 
  def validate(self):
16287 
    return
16288 
 
16289 
 
16290 
  def __repr__(self):
16291 
    L = ['%s=%r' % (key, value)
16292 
      for key, value in self.__dict__.iteritems()]
16293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16294 
 
16295 
  def __eq__(self, other):
16296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16297 
 
16298 
  def __ne__(self, other):
16299 
    return not (self == other)
16300 
 
4258 rajveer 16301 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 16302 
  """
16303 
  Attributes:
4258 rajveer 16304 
   - transactionId
4247 rajveer 16305 
  """
16306 
 
16307 
  thrift_spec = (
16308 
    None, # 0
4258 rajveer 16309 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 16310 
  )
16311 
 
4258 rajveer 16312 
  def __init__(self, transactionId=None,):
16313 
    self.transactionId = transactionId
4247 rajveer 16314 
 
16315 
  def read(self, iprot):
16316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16318 
      return
16319 
    iprot.readStructBegin()
16320 
    while True:
16321 
      (fname, ftype, fid) = iprot.readFieldBegin()
16322 
      if ftype == TType.STOP:
16323 
        break
16324 
      if fid == 1:
16325 
        if ftype == TType.I64:
4258 rajveer 16326 
          self.transactionId = iprot.readI64();
4247 rajveer 16327 
        else:
16328 
          iprot.skip(ftype)
16329 
      else:
16330 
        iprot.skip(ftype)
16331 
      iprot.readFieldEnd()
16332 
    iprot.readStructEnd()
16333 
 
16334 
  def write(self, oprot):
16335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16337 
      return
4258 rajveer 16338 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
16339 
    if self.transactionId is not None:
16340 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16341 
      oprot.writeI64(self.transactionId)
4247 rajveer 16342 
      oprot.writeFieldEnd()
16343 
    oprot.writeFieldStop()
16344 
    oprot.writeStructEnd()
16345 
 
16346 
  def validate(self):
16347 
    return
16348 
 
16349 
 
16350 
  def __repr__(self):
16351 
    L = ['%s=%r' % (key, value)
16352 
      for key, value in self.__dict__.iteritems()]
16353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16354 
 
16355 
  def __eq__(self, other):
16356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16357 
 
16358 
  def __ne__(self, other):
16359 
    return not (self == other)
16360 
 
4258 rajveer 16361 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 16362 
  """
16363 
  Attributes:
16364 
   - ex
16365 
  """
16366 
 
16367 
  thrift_spec = (
16368 
    None, # 0
16369 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16370 
  )
16371 
 
16372 
  def __init__(self, ex=None,):
16373 
    self.ex = ex
16374 
 
16375 
  def read(self, iprot):
16376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16378 
      return
16379 
    iprot.readStructBegin()
16380 
    while True:
16381 
      (fname, ftype, fid) = iprot.readFieldBegin()
16382 
      if ftype == TType.STOP:
16383 
        break
16384 
      if fid == 1:
16385 
        if ftype == TType.STRUCT:
16386 
          self.ex = TransactionServiceException()
16387 
          self.ex.read(iprot)
16388 
        else:
16389 
          iprot.skip(ftype)
16390 
      else:
16391 
        iprot.skip(ftype)
16392 
      iprot.readFieldEnd()
16393 
    iprot.readStructEnd()
16394 
 
16395 
  def write(self, oprot):
16396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16398 
      return
4258 rajveer 16399 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 16400 
    if self.ex is not None:
16401 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16402 
      self.ex.write(oprot)
16403 
      oprot.writeFieldEnd()
16404 
    oprot.writeFieldStop()
16405 
    oprot.writeStructEnd()
16406 
 
16407 
  def validate(self):
16408 
    return
16409 
 
16410 
 
16411 
  def __repr__(self):
16412 
    L = ['%s=%r' % (key, value)
16413 
      for key, value in self.__dict__.iteritems()]
16414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16415 
 
16416 
  def __eq__(self, other):
16417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16418 
 
16419 
  def __ne__(self, other):
16420 
    return not (self == other)
4259 anupam.sin 16421 
 
16422 
class refundTransaction_args:
16423 
  """
16424 
  Attributes:
16425 
   - transactionId
16426 
   - refundedBy
16427 
   - reason
16428 
  """
16429 
 
16430 
  thrift_spec = (
16431 
    None, # 0
16432 
    (1, TType.I64, 'transactionId', None, None, ), # 1
16433 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
16434 
    (3, TType.STRING, 'reason', None, None, ), # 3
16435 
  )
16436 
 
16437 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
16438 
    self.transactionId = transactionId
16439 
    self.refundedBy = refundedBy
16440 
    self.reason = reason
16441 
 
16442 
  def read(self, iprot):
16443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16445 
      return
16446 
    iprot.readStructBegin()
16447 
    while True:
16448 
      (fname, ftype, fid) = iprot.readFieldBegin()
16449 
      if ftype == TType.STOP:
16450 
        break
16451 
      if fid == 1:
16452 
        if ftype == TType.I64:
16453 
          self.transactionId = iprot.readI64();
16454 
        else:
16455 
          iprot.skip(ftype)
16456 
      elif fid == 2:
16457 
        if ftype == TType.STRING:
16458 
          self.refundedBy = iprot.readString();
16459 
        else:
16460 
          iprot.skip(ftype)
16461 
      elif fid == 3:
16462 
        if ftype == TType.STRING:
16463 
          self.reason = iprot.readString();
16464 
        else:
16465 
          iprot.skip(ftype)
16466 
      else:
16467 
        iprot.skip(ftype)
16468 
      iprot.readFieldEnd()
16469 
    iprot.readStructEnd()
16470 
 
16471 
  def write(self, oprot):
16472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16474 
      return
16475 
    oprot.writeStructBegin('refundTransaction_args')
16476 
    if self.transactionId is not None:
16477 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16478 
      oprot.writeI64(self.transactionId)
16479 
      oprot.writeFieldEnd()
16480 
    if self.refundedBy is not None:
16481 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16482 
      oprot.writeString(self.refundedBy)
16483 
      oprot.writeFieldEnd()
16484 
    if self.reason is not None:
16485 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16486 
      oprot.writeString(self.reason)
16487 
      oprot.writeFieldEnd()
16488 
    oprot.writeFieldStop()
16489 
    oprot.writeStructEnd()
16490 
 
16491 
  def validate(self):
16492 
    return
16493 
 
16494 
 
16495 
  def __repr__(self):
16496 
    L = ['%s=%r' % (key, value)
16497 
      for key, value in self.__dict__.iteritems()]
16498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16499 
 
16500 
  def __eq__(self, other):
16501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16502 
 
16503 
  def __ne__(self, other):
16504 
    return not (self == other)
16505 
 
16506 
class refundTransaction_result:
16507 
  """
16508 
  Attributes:
16509 
   - ex
16510 
  """
16511 
 
16512 
  thrift_spec = (
16513 
    None, # 0
16514 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16515 
  )
16516 
 
16517 
  def __init__(self, ex=None,):
16518 
    self.ex = ex
16519 
 
16520 
  def read(self, iprot):
16521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16523 
      return
16524 
    iprot.readStructBegin()
16525 
    while True:
16526 
      (fname, ftype, fid) = iprot.readFieldBegin()
16527 
      if ftype == TType.STOP:
16528 
        break
16529 
      if fid == 1:
16530 
        if ftype == TType.STRUCT:
16531 
          self.ex = TransactionServiceException()
16532 
          self.ex.read(iprot)
16533 
        else:
16534 
          iprot.skip(ftype)
16535 
      else:
16536 
        iprot.skip(ftype)
16537 
      iprot.readFieldEnd()
16538 
    iprot.readStructEnd()
16539 
 
16540 
  def write(self, oprot):
16541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16543 
      return
16544 
    oprot.writeStructBegin('refundTransaction_result')
16545 
    if self.ex is not None:
16546 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16547 
      self.ex.write(oprot)
16548 
      oprot.writeFieldEnd()
16549 
    oprot.writeFieldStop()
16550 
    oprot.writeStructEnd()
16551 
 
16552 
  def validate(self):
16553 
    return
16554 
 
16555 
 
16556 
  def __repr__(self):
16557 
    L = ['%s=%r' % (key, value)
16558 
      for key, value in self.__dict__.iteritems()]
16559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16560 
 
16561 
  def __eq__(self, other):
16562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16563 
 
16564 
  def __ne__(self, other):
16565 
    return not (self == other)
4285 rajveer 16566 
 
4324 mandeep.dh 16567 
class updateShipmentAddress_args:
16568 
  """
16569 
  Attributes:
16570 
   - orderId
16571 
   - addressId
16572 
  """
16573 
 
16574 
  thrift_spec = (
16575 
    None, # 0
16576 
    (1, TType.I64, 'orderId', None, None, ), # 1
16577 
    (2, TType.I64, 'addressId', None, None, ), # 2
16578 
  )
16579 
 
16580 
  def __init__(self, orderId=None, addressId=None,):
16581 
    self.orderId = orderId
16582 
    self.addressId = addressId
16583 
 
16584 
  def read(self, iprot):
16585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16587 
      return
16588 
    iprot.readStructBegin()
16589 
    while True:
16590 
      (fname, ftype, fid) = iprot.readFieldBegin()
16591 
      if ftype == TType.STOP:
16592 
        break
16593 
      if fid == 1:
16594 
        if ftype == TType.I64:
16595 
          self.orderId = iprot.readI64();
16596 
        else:
16597 
          iprot.skip(ftype)
16598 
      elif fid == 2:
16599 
        if ftype == TType.I64:
16600 
          self.addressId = iprot.readI64();
16601 
        else:
16602 
          iprot.skip(ftype)
16603 
      else:
16604 
        iprot.skip(ftype)
16605 
      iprot.readFieldEnd()
16606 
    iprot.readStructEnd()
16607 
 
16608 
  def write(self, oprot):
16609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16611 
      return
16612 
    oprot.writeStructBegin('updateShipmentAddress_args')
16613 
    if self.orderId is not None:
16614 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16615 
      oprot.writeI64(self.orderId)
16616 
      oprot.writeFieldEnd()
16617 
    if self.addressId is not None:
16618 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
16619 
      oprot.writeI64(self.addressId)
16620 
      oprot.writeFieldEnd()
16621 
    oprot.writeFieldStop()
16622 
    oprot.writeStructEnd()
16623 
 
16624 
  def validate(self):
16625 
    return
16626 
 
16627 
 
16628 
  def __repr__(self):
16629 
    L = ['%s=%r' % (key, value)
16630 
      for key, value in self.__dict__.iteritems()]
16631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16632 
 
16633 
  def __eq__(self, other):
16634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16635 
 
16636 
  def __ne__(self, other):
16637 
    return not (self == other)
16638 
 
16639 
class updateShipmentAddress_result:
16640 
  """
16641 
  Attributes:
16642 
   - ex
16643 
  """
16644 
 
16645 
  thrift_spec = (
16646 
    None, # 0
16647 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16648 
  )
16649 
 
16650 
  def __init__(self, ex=None,):
16651 
    self.ex = ex
16652 
 
16653 
  def read(self, iprot):
16654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16656 
      return
16657 
    iprot.readStructBegin()
16658 
    while True:
16659 
      (fname, ftype, fid) = iprot.readFieldBegin()
16660 
      if ftype == TType.STOP:
16661 
        break
16662 
      if fid == 1:
16663 
        if ftype == TType.STRUCT:
16664 
          self.ex = TransactionServiceException()
16665 
          self.ex.read(iprot)
16666 
        else:
16667 
          iprot.skip(ftype)
16668 
      else:
16669 
        iprot.skip(ftype)
16670 
      iprot.readFieldEnd()
16671 
    iprot.readStructEnd()
16672 
 
16673 
  def write(self, oprot):
16674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16676 
      return
16677 
    oprot.writeStructBegin('updateShipmentAddress_result')
16678 
    if self.ex is not None:
16679 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16680 
      self.ex.write(oprot)
16681 
      oprot.writeFieldEnd()
16682 
    oprot.writeFieldStop()
16683 
    oprot.writeStructEnd()
16684 
 
16685 
  def validate(self):
16686 
    return
16687 
 
16688 
 
16689 
  def __repr__(self):
16690 
    L = ['%s=%r' % (key, value)
16691 
      for key, value in self.__dict__.iteritems()]
16692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16693 
 
16694 
  def __eq__(self, other):
16695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16696 
 
16697 
  def __ne__(self, other):
16698 
    return not (self == other)
16699 
 
4285 rajveer 16700 
class acceptOrdersForItemId_args:
16701 
  """
16702 
  Attributes:
16703 
   - itemId
16704 
   - inventory
16705 
  """
16706 
 
16707 
  thrift_spec = (
16708 
    None, # 0
16709 
    (1, TType.I64, 'itemId', None, None, ), # 1
16710 
    (2, TType.I64, 'inventory', None, None, ), # 2
16711 
  )
16712 
 
16713 
  def __init__(self, itemId=None, inventory=None,):
16714 
    self.itemId = itemId
16715 
    self.inventory = inventory
16716 
 
16717 
  def read(self, iprot):
16718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16720 
      return
16721 
    iprot.readStructBegin()
16722 
    while True:
16723 
      (fname, ftype, fid) = iprot.readFieldBegin()
16724 
      if ftype == TType.STOP:
16725 
        break
16726 
      if fid == 1:
16727 
        if ftype == TType.I64:
16728 
          self.itemId = iprot.readI64();
16729 
        else:
16730 
          iprot.skip(ftype)
16731 
      elif fid == 2:
16732 
        if ftype == TType.I64:
16733 
          self.inventory = iprot.readI64();
16734 
        else:
16735 
          iprot.skip(ftype)
16736 
      else:
16737 
        iprot.skip(ftype)
16738 
      iprot.readFieldEnd()
16739 
    iprot.readStructEnd()
16740 
 
16741 
  def write(self, oprot):
16742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16744 
      return
16745 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
16746 
    if self.itemId is not None:
16747 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16748 
      oprot.writeI64(self.itemId)
16749 
      oprot.writeFieldEnd()
16750 
    if self.inventory is not None:
16751 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
16752 
      oprot.writeI64(self.inventory)
16753 
      oprot.writeFieldEnd()
16754 
    oprot.writeFieldStop()
16755 
    oprot.writeStructEnd()
16756 
 
16757 
  def validate(self):
16758 
    return
16759 
 
16760 
 
16761 
  def __repr__(self):
16762 
    L = ['%s=%r' % (key, value)
16763 
      for key, value in self.__dict__.iteritems()]
16764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16765 
 
16766 
  def __eq__(self, other):
16767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16768 
 
16769 
  def __ne__(self, other):
16770 
    return not (self == other)
16771 
 
16772 
class acceptOrdersForItemId_result:
16773 
  """
16774 
  Attributes:
16775 
   - success
16776 
   - ex
16777 
  """
16778 
 
16779 
  thrift_spec = (
16780 
    (0, TType.BOOL, 'success', None, None, ), # 0
16781 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16782 
  )
16783 
 
16784 
  def __init__(self, success=None, ex=None,):
16785 
    self.success = success
16786 
    self.ex = ex
16787 
 
16788 
  def read(self, iprot):
16789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16791 
      return
16792 
    iprot.readStructBegin()
16793 
    while True:
16794 
      (fname, ftype, fid) = iprot.readFieldBegin()
16795 
      if ftype == TType.STOP:
16796 
        break
16797 
      if fid == 0:
16798 
        if ftype == TType.BOOL:
16799 
          self.success = iprot.readBool();
16800 
        else:
16801 
          iprot.skip(ftype)
16802 
      elif fid == 1:
16803 
        if ftype == TType.STRUCT:
16804 
          self.ex = TransactionServiceException()
16805 
          self.ex.read(iprot)
16806 
        else:
16807 
          iprot.skip(ftype)
16808 
      else:
16809 
        iprot.skip(ftype)
16810 
      iprot.readFieldEnd()
16811 
    iprot.readStructEnd()
16812 
 
16813 
  def write(self, oprot):
16814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16816 
      return
16817 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
16818 
    if self.success is not None:
16819 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16820 
      oprot.writeBool(self.success)
16821 
      oprot.writeFieldEnd()
16822 
    if self.ex is not None:
16823 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16824 
      self.ex.write(oprot)
16825 
      oprot.writeFieldEnd()
16826 
    oprot.writeFieldStop()
16827 
    oprot.writeStructEnd()
16828 
 
16829 
  def validate(self):
16830 
    return
16831 
 
16832 
 
16833 
  def __repr__(self):
16834 
    L = ['%s=%r' % (key, value)
16835 
      for key, value in self.__dict__.iteritems()]
16836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16837 
 
16838 
  def __eq__(self, other):
16839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16840 
 
16841 
  def __ne__(self, other):
16842 
    return not (self == other)
4303 rajveer 16843 
 
16844 
class markOrdersAsPORaised_args:
16845 
  """
16846 
  Attributes:
16847 
   - vendorId
16848 
   - itemId
16849 
   - quantity
16850 
   - estimate
4369 rajveer 16851 
   - isReminder
4303 rajveer 16852 
  """
16853 
 
16854 
  thrift_spec = (
16855 
    None, # 0
16856 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16857 
    (2, TType.I64, 'itemId', None, None, ), # 2
16858 
    (3, TType.I64, 'quantity', None, None, ), # 3
16859 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16860 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16861 
  )
16862 
 
4369 rajveer 16863 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16864 
    self.vendorId = vendorId
16865 
    self.itemId = itemId
16866 
    self.quantity = quantity
16867 
    self.estimate = estimate
4369 rajveer 16868 
    self.isReminder = isReminder
4303 rajveer 16869 
 
16870 
  def read(self, iprot):
16871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16873 
      return
16874 
    iprot.readStructBegin()
16875 
    while True:
16876 
      (fname, ftype, fid) = iprot.readFieldBegin()
16877 
      if ftype == TType.STOP:
16878 
        break
16879 
      if fid == 1:
16880 
        if ftype == TType.I64:
16881 
          self.vendorId = iprot.readI64();
16882 
        else:
16883 
          iprot.skip(ftype)
16884 
      elif fid == 2:
16885 
        if ftype == TType.I64:
16886 
          self.itemId = iprot.readI64();
16887 
        else:
16888 
          iprot.skip(ftype)
16889 
      elif fid == 3:
16890 
        if ftype == TType.I64:
16891 
          self.quantity = iprot.readI64();
16892 
        else:
16893 
          iprot.skip(ftype)
16894 
      elif fid == 4:
16895 
        if ftype == TType.I64:
16896 
          self.estimate = iprot.readI64();
16897 
        else:
16898 
          iprot.skip(ftype)
4369 rajveer 16899 
      elif fid == 5:
16900 
        if ftype == TType.BOOL:
16901 
          self.isReminder = iprot.readBool();
16902 
        else:
16903 
          iprot.skip(ftype)
4303 rajveer 16904 
      else:
16905 
        iprot.skip(ftype)
16906 
      iprot.readFieldEnd()
16907 
    iprot.readStructEnd()
16908 
 
16909 
  def write(self, oprot):
16910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16912 
      return
16913 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
16914 
    if self.vendorId is not None:
16915 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16916 
      oprot.writeI64(self.vendorId)
16917 
      oprot.writeFieldEnd()
16918 
    if self.itemId is not None:
16919 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16920 
      oprot.writeI64(self.itemId)
16921 
      oprot.writeFieldEnd()
16922 
    if self.quantity is not None:
16923 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16924 
      oprot.writeI64(self.quantity)
16925 
      oprot.writeFieldEnd()
16926 
    if self.estimate is not None:
16927 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16928 
      oprot.writeI64(self.estimate)
16929 
      oprot.writeFieldEnd()
4369 rajveer 16930 
    if self.isReminder is not None:
16931 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16932 
      oprot.writeBool(self.isReminder)
16933 
      oprot.writeFieldEnd()
4303 rajveer 16934 
    oprot.writeFieldStop()
16935 
    oprot.writeStructEnd()
16936 
 
16937 
  def validate(self):
16938 
    return
16939 
 
16940 
 
16941 
  def __repr__(self):
16942 
    L = ['%s=%r' % (key, value)
16943 
      for key, value in self.__dict__.iteritems()]
16944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16945 
 
16946 
  def __eq__(self, other):
16947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16948 
 
16949 
  def __ne__(self, other):
16950 
    return not (self == other)
16951 
 
16952 
class markOrdersAsPORaised_result:
16953 
  """
16954 
  Attributes:
16955 
   - ex
16956 
  """
16957 
 
16958 
  thrift_spec = (
16959 
    None, # 0
16960 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16961 
  )
16962 
 
16963 
  def __init__(self, ex=None,):
16964 
    self.ex = ex
16965 
 
16966 
  def read(self, iprot):
16967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16969 
      return
16970 
    iprot.readStructBegin()
16971 
    while True:
16972 
      (fname, ftype, fid) = iprot.readFieldBegin()
16973 
      if ftype == TType.STOP:
16974 
        break
16975 
      if fid == 1:
16976 
        if ftype == TType.STRUCT:
16977 
          self.ex = TransactionServiceException()
16978 
          self.ex.read(iprot)
16979 
        else:
16980 
          iprot.skip(ftype)
16981 
      else:
16982 
        iprot.skip(ftype)
16983 
      iprot.readFieldEnd()
16984 
    iprot.readStructEnd()
16985 
 
16986 
  def write(self, oprot):
16987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16989 
      return
16990 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
16991 
    if self.ex is not None:
16992 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16993 
      self.ex.write(oprot)
16994 
      oprot.writeFieldEnd()
16995 
    oprot.writeFieldStop()
16996 
    oprot.writeStructEnd()
16997 
 
16998 
  def validate(self):
16999 
    return
17000 
 
17001 
 
17002 
  def __repr__(self):
17003 
    L = ['%s=%r' % (key, value)
17004 
      for key, value in self.__dict__.iteritems()]
17005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17006 
 
17007 
  def __eq__(self, other):
17008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17009 
 
17010 
  def __ne__(self, other):
17011 
    return not (self == other)
17012 
 
17013 
class markOrdersAsReversalInitiated_args:
17014 
  """
17015 
  Attributes:
17016 
   - vendorId
17017 
   - itemId
17018 
   - quantity
17019 
   - estimate
4369 rajveer 17020 
   - isReminder
4303 rajveer 17021 
  """
17022 
 
17023 
  thrift_spec = (
17024 
    None, # 0
17025 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17026 
    (2, TType.I64, 'itemId', None, None, ), # 2
17027 
    (3, TType.I64, 'quantity', None, None, ), # 3
17028 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 17029 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 17030 
  )
17031 
 
4369 rajveer 17032 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 17033 
    self.vendorId = vendorId
17034 
    self.itemId = itemId
17035 
    self.quantity = quantity
17036 
    self.estimate = estimate
4369 rajveer 17037 
    self.isReminder = isReminder
4303 rajveer 17038 
 
17039 
  def read(self, iprot):
17040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17042 
      return
17043 
    iprot.readStructBegin()
17044 
    while True:
17045 
      (fname, ftype, fid) = iprot.readFieldBegin()
17046 
      if ftype == TType.STOP:
17047 
        break
17048 
      if fid == 1:
17049 
        if ftype == TType.I64:
17050 
          self.vendorId = iprot.readI64();
17051 
        else:
17052 
          iprot.skip(ftype)
17053 
      elif fid == 2:
17054 
        if ftype == TType.I64:
17055 
          self.itemId = iprot.readI64();
17056 
        else:
17057 
          iprot.skip(ftype)
17058 
      elif fid == 3:
17059 
        if ftype == TType.I64:
17060 
          self.quantity = iprot.readI64();
17061 
        else:
17062 
          iprot.skip(ftype)
17063 
      elif fid == 4:
17064 
        if ftype == TType.I64:
17065 
          self.estimate = iprot.readI64();
17066 
        else:
17067 
          iprot.skip(ftype)
4369 rajveer 17068 
      elif fid == 5:
17069 
        if ftype == TType.BOOL:
17070 
          self.isReminder = iprot.readBool();
17071 
        else:
17072 
          iprot.skip(ftype)
4303 rajveer 17073 
      else:
17074 
        iprot.skip(ftype)
17075 
      iprot.readFieldEnd()
17076 
    iprot.readStructEnd()
17077 
 
17078 
  def write(self, oprot):
17079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17081 
      return
17082 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
17083 
    if self.vendorId is not None:
17084 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17085 
      oprot.writeI64(self.vendorId)
17086 
      oprot.writeFieldEnd()
17087 
    if self.itemId is not None:
17088 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17089 
      oprot.writeI64(self.itemId)
17090 
      oprot.writeFieldEnd()
17091 
    if self.quantity is not None:
17092 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
17093 
      oprot.writeI64(self.quantity)
17094 
      oprot.writeFieldEnd()
17095 
    if self.estimate is not None:
17096 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
17097 
      oprot.writeI64(self.estimate)
17098 
      oprot.writeFieldEnd()
4369 rajveer 17099 
    if self.isReminder is not None:
17100 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
17101 
      oprot.writeBool(self.isReminder)
17102 
      oprot.writeFieldEnd()
4303 rajveer 17103 
    oprot.writeFieldStop()
17104 
    oprot.writeStructEnd()
17105 
 
17106 
  def validate(self):
17107 
    return
17108 
 
17109 
 
17110 
  def __repr__(self):
17111 
    L = ['%s=%r' % (key, value)
17112 
      for key, value in self.__dict__.iteritems()]
17113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17114 
 
17115 
  def __eq__(self, other):
17116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17117 
 
17118 
  def __ne__(self, other):
17119 
    return not (self == other)
17120 
 
17121 
class markOrdersAsReversalInitiated_result:
17122 
  """
17123 
  Attributes:
17124 
   - ex
17125 
  """
17126 
 
17127 
  thrift_spec = (
17128 
    None, # 0
17129 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17130 
  )
17131 
 
17132 
  def __init__(self, ex=None,):
17133 
    self.ex = ex
17134 
 
17135 
  def read(self, iprot):
17136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17138 
      return
17139 
    iprot.readStructBegin()
17140 
    while True:
17141 
      (fname, ftype, fid) = iprot.readFieldBegin()
17142 
      if ftype == TType.STOP:
17143 
        break
17144 
      if fid == 1:
17145 
        if ftype == TType.STRUCT:
17146 
          self.ex = TransactionServiceException()
17147 
          self.ex.read(iprot)
17148 
        else:
17149 
          iprot.skip(ftype)
17150 
      else:
17151 
        iprot.skip(ftype)
17152 
      iprot.readFieldEnd()
17153 
    iprot.readStructEnd()
17154 
 
17155 
  def write(self, oprot):
17156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17158 
      return
17159 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
17160 
    if self.ex is not None:
17161 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17162 
      self.ex.write(oprot)
17163 
      oprot.writeFieldEnd()
17164 
    oprot.writeFieldStop()
17165 
    oprot.writeStructEnd()
17166 
 
17167 
  def validate(self):
17168 
    return
17169 
 
17170 
 
17171 
  def __repr__(self):
17172 
    L = ['%s=%r' % (key, value)
17173 
      for key, value in self.__dict__.iteritems()]
17174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17175 
 
17176 
  def __eq__(self, other):
17177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17178 
 
17179 
  def __ne__(self, other):
17180 
    return not (self == other)
17181 
 
17182 
class markOrdersAsNotAvailabke_args:
17183 
  """
17184 
  Attributes:
17185 
   - vendorId
17186 
   - itemId
17187 
   - quantity
17188 
   - estimate
4369 rajveer 17189 
   - isReminder
4303 rajveer 17190 
  """
17191 
 
17192 
  thrift_spec = (
17193 
    None, # 0
17194 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17195 
    (2, TType.I64, 'itemId', None, None, ), # 2
17196 
    (3, TType.I64, 'quantity', None, None, ), # 3
17197 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 17198 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 17199 
  )
17200 
 
4369 rajveer 17201 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 17202 
    self.vendorId = vendorId
17203 
    self.itemId = itemId
17204 
    self.quantity = quantity
17205 
    self.estimate = estimate
4369 rajveer 17206 
    self.isReminder = isReminder
4303 rajveer 17207 
 
17208 
  def read(self, iprot):
17209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17211 
      return
17212 
    iprot.readStructBegin()
17213 
    while True:
17214 
      (fname, ftype, fid) = iprot.readFieldBegin()
17215 
      if ftype == TType.STOP:
17216 
        break
17217 
      if fid == 1:
17218 
        if ftype == TType.I64:
17219 
          self.vendorId = iprot.readI64();
17220 
        else:
17221 
          iprot.skip(ftype)
17222 
      elif fid == 2:
17223 
        if ftype == TType.I64:
17224 
          self.itemId = iprot.readI64();
17225 
        else:
17226 
          iprot.skip(ftype)
17227 
      elif fid == 3:
17228 
        if ftype == TType.I64:
17229 
          self.quantity = iprot.readI64();
17230 
        else:
17231 
          iprot.skip(ftype)
17232 
      elif fid == 4:
17233 
        if ftype == TType.I64:
17234 
          self.estimate = iprot.readI64();
17235 
        else:
17236 
          iprot.skip(ftype)
4369 rajveer 17237 
      elif fid == 5:
17238 
        if ftype == TType.BOOL:
17239 
          self.isReminder = iprot.readBool();
17240 
        else:
17241 
          iprot.skip(ftype)
4303 rajveer 17242 
      else:
17243 
        iprot.skip(ftype)
17244 
      iprot.readFieldEnd()
17245 
    iprot.readStructEnd()
17246 
 
17247 
  def write(self, oprot):
17248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17250 
      return
17251 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
17252 
    if self.vendorId is not None:
17253 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17254 
      oprot.writeI64(self.vendorId)
17255 
      oprot.writeFieldEnd()
17256 
    if self.itemId is not None:
17257 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17258 
      oprot.writeI64(self.itemId)
17259 
      oprot.writeFieldEnd()
17260 
    if self.quantity is not None:
17261 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
17262 
      oprot.writeI64(self.quantity)
17263 
      oprot.writeFieldEnd()
17264 
    if self.estimate is not None:
17265 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
17266 
      oprot.writeI64(self.estimate)
17267 
      oprot.writeFieldEnd()
4369 rajveer 17268 
    if self.isReminder is not None:
17269 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
17270 
      oprot.writeBool(self.isReminder)
17271 
      oprot.writeFieldEnd()
4303 rajveer 17272 
    oprot.writeFieldStop()
17273 
    oprot.writeStructEnd()
17274 
 
17275 
  def validate(self):
17276 
    return
17277 
 
17278 
 
17279 
  def __repr__(self):
17280 
    L = ['%s=%r' % (key, value)
17281 
      for key, value in self.__dict__.iteritems()]
17282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17283 
 
17284 
  def __eq__(self, other):
17285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17286 
 
17287 
  def __ne__(self, other):
17288 
    return not (self == other)
17289 
 
17290 
class markOrdersAsNotAvailabke_result:
17291 
  """
17292 
  Attributes:
17293 
   - ex
17294 
  """
17295 
 
17296 
  thrift_spec = (
17297 
    None, # 0
17298 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17299 
  )
17300 
 
17301 
  def __init__(self, ex=None,):
17302 
    self.ex = ex
17303 
 
17304 
  def read(self, iprot):
17305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17307 
      return
17308 
    iprot.readStructBegin()
17309 
    while True:
17310 
      (fname, ftype, fid) = iprot.readFieldBegin()
17311 
      if ftype == TType.STOP:
17312 
        break
17313 
      if fid == 1:
17314 
        if ftype == TType.STRUCT:
17315 
          self.ex = TransactionServiceException()
17316 
          self.ex.read(iprot)
17317 
        else:
17318 
          iprot.skip(ftype)
17319 
      else:
17320 
        iprot.skip(ftype)
17321 
      iprot.readFieldEnd()
17322 
    iprot.readStructEnd()
17323 
 
17324 
  def write(self, oprot):
17325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17327 
      return
17328 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
17329 
    if self.ex is not None:
17330 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17331 
      self.ex.write(oprot)
17332 
      oprot.writeFieldEnd()
17333 
    oprot.writeFieldStop()
17334 
    oprot.writeStructEnd()
17335 
 
17336 
  def validate(self):
17337 
    return
17338 
 
17339 
 
17340 
  def __repr__(self):
17341 
    L = ['%s=%r' % (key, value)
17342 
      for key, value in self.__dict__.iteritems()]
17343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17344 
 
17345 
  def __eq__(self, other):
17346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17347 
 
17348 
  def __ne__(self, other):
17349 
    return not (self == other)
4369 rajveer 17350 
 
17351 
class markOrdersAsTimeout_args:
17352 
  """
17353 
  Attributes:
17354 
   - vendorId
17355 
  """
17356 
 
17357 
  thrift_spec = (
17358 
    None, # 0
17359 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17360 
  )
17361 
 
17362 
  def __init__(self, vendorId=None,):
17363 
    self.vendorId = vendorId
17364 
 
17365 
  def read(self, iprot):
17366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17368 
      return
17369 
    iprot.readStructBegin()
17370 
    while True:
17371 
      (fname, ftype, fid) = iprot.readFieldBegin()
17372 
      if ftype == TType.STOP:
17373 
        break
17374 
      if fid == 1:
17375 
        if ftype == TType.I64:
17376 
          self.vendorId = iprot.readI64();
17377 
        else:
17378 
          iprot.skip(ftype)
17379 
      else:
17380 
        iprot.skip(ftype)
17381 
      iprot.readFieldEnd()
17382 
    iprot.readStructEnd()
17383 
 
17384 
  def write(self, oprot):
17385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17387 
      return
17388 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
17389 
    if self.vendorId is not None:
17390 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17391 
      oprot.writeI64(self.vendorId)
17392 
      oprot.writeFieldEnd()
17393 
    oprot.writeFieldStop()
17394 
    oprot.writeStructEnd()
17395 
 
17396 
  def validate(self):
17397 
    return
17398 
 
17399 
 
17400 
  def __repr__(self):
17401 
    L = ['%s=%r' % (key, value)
17402 
      for key, value in self.__dict__.iteritems()]
17403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17404 
 
17405 
  def __eq__(self, other):
17406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17407 
 
17408 
  def __ne__(self, other):
17409 
    return not (self == other)
17410 
 
17411 
class markOrdersAsTimeout_result:
17412 
  """
17413 
  Attributes:
17414 
   - success
17415 
   - ex
17416 
  """
17417 
 
17418 
  thrift_spec = (
17419 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
17420 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17421 
  )
17422 
 
17423 
  def __init__(self, success=None, ex=None,):
17424 
    self.success = success
17425 
    self.ex = ex
17426 
 
17427 
  def read(self, iprot):
17428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17430 
      return
17431 
    iprot.readStructBegin()
17432 
    while True:
17433 
      (fname, ftype, fid) = iprot.readFieldBegin()
17434 
      if ftype == TType.STOP:
17435 
        break
17436 
      if fid == 0:
17437 
        if ftype == TType.MAP:
17438 
          self.success = {}
4837 varun.gupt 17439 
          (_ktype334, _vtype335, _size333 ) = iprot.readMapBegin()
17440 
          for _i337 in xrange(_size333):
17441 
            _key338 = iprot.readI32();
17442 
            _val339 = TimeoutSummary()
17443 
            _val339.read(iprot)
17444 
            self.success[_key338] = _val339
4369 rajveer 17445 
          iprot.readMapEnd()
17446 
        else:
17447 
          iprot.skip(ftype)
17448 
      elif fid == 1:
17449 
        if ftype == TType.STRUCT:
17450 
          self.ex = TransactionServiceException()
17451 
          self.ex.read(iprot)
17452 
        else:
17453 
          iprot.skip(ftype)
17454 
      else:
17455 
        iprot.skip(ftype)
17456 
      iprot.readFieldEnd()
17457 
    iprot.readStructEnd()
17458 
 
17459 
  def write(self, oprot):
17460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17462 
      return
17463 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
17464 
    if self.success is not None:
17465 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17466 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4837 varun.gupt 17467 
      for kiter340,viter341 in self.success.items():
17468 
        oprot.writeI32(kiter340)
17469 
        viter341.write(oprot)
4369 rajveer 17470 
      oprot.writeMapEnd()
17471 
      oprot.writeFieldEnd()
17472 
    if self.ex is not None:
17473 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17474 
      self.ex.write(oprot)
17475 
      oprot.writeFieldEnd()
17476 
    oprot.writeFieldStop()
17477 
    oprot.writeStructEnd()
17478 
 
17479 
  def validate(self):
17480 
    return
17481 
 
17482 
 
17483 
  def __repr__(self):
17484 
    L = ['%s=%r' % (key, value)
17485 
      for key, value in self.__dict__.iteritems()]
17486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17487 
 
17488 
  def __eq__(self, other):
17489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17490 
 
17491 
  def __ne__(self, other):
17492 
    return not (self == other)
4386 anupam.sin 17493 
 
4662 rajveer 17494 
class markOrderAsLostInTransit_args:
17495 
  """
17496 
  Attributes:
17497 
   - orderId
17498 
  """
17499 
 
17500 
  thrift_spec = (
17501 
    None, # 0
17502 
    (1, TType.I64, 'orderId', None, None, ), # 1
17503 
  )
17504 
 
17505 
  def __init__(self, orderId=None,):
17506 
    self.orderId = orderId
17507 
 
17508 
  def read(self, iprot):
17509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17511 
      return
17512 
    iprot.readStructBegin()
17513 
    while True:
17514 
      (fname, ftype, fid) = iprot.readFieldBegin()
17515 
      if ftype == TType.STOP:
17516 
        break
17517 
      if fid == 1:
17518 
        if ftype == TType.I64:
17519 
          self.orderId = iprot.readI64();
17520 
        else:
17521 
          iprot.skip(ftype)
17522 
      else:
17523 
        iprot.skip(ftype)
17524 
      iprot.readFieldEnd()
17525 
    iprot.readStructEnd()
17526 
 
17527 
  def write(self, oprot):
17528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17530 
      return
17531 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
17532 
    if self.orderId is not None:
17533 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17534 
      oprot.writeI64(self.orderId)
17535 
      oprot.writeFieldEnd()
17536 
    oprot.writeFieldStop()
17537 
    oprot.writeStructEnd()
17538 
 
17539 
  def validate(self):
17540 
    return
17541 
 
17542 
 
17543 
  def __repr__(self):
17544 
    L = ['%s=%r' % (key, value)
17545 
      for key, value in self.__dict__.iteritems()]
17546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17547 
 
17548 
  def __eq__(self, other):
17549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17550 
 
17551 
  def __ne__(self, other):
17552 
    return not (self == other)
17553 
 
17554 
class markOrderAsLostInTransit_result:
17555 
  """
17556 
  Attributes:
17557 
   - success
17558 
   - ex
17559 
  """
17560 
 
17561 
  thrift_spec = (
17562 
    (0, TType.BOOL, 'success', None, None, ), # 0
17563 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17564 
  )
17565 
 
17566 
  def __init__(self, success=None, ex=None,):
17567 
    self.success = success
17568 
    self.ex = ex
17569 
 
17570 
  def read(self, iprot):
17571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17573 
      return
17574 
    iprot.readStructBegin()
17575 
    while True:
17576 
      (fname, ftype, fid) = iprot.readFieldBegin()
17577 
      if ftype == TType.STOP:
17578 
        break
17579 
      if fid == 0:
17580 
        if ftype == TType.BOOL:
17581 
          self.success = iprot.readBool();
17582 
        else:
17583 
          iprot.skip(ftype)
17584 
      elif fid == 1:
17585 
        if ftype == TType.STRUCT:
17586 
          self.ex = TransactionServiceException()
17587 
          self.ex.read(iprot)
17588 
        else:
17589 
          iprot.skip(ftype)
17590 
      else:
17591 
        iprot.skip(ftype)
17592 
      iprot.readFieldEnd()
17593 
    iprot.readStructEnd()
17594 
 
17595 
  def write(self, oprot):
17596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17598 
      return
17599 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
17600 
    if self.success is not None:
17601 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17602 
      oprot.writeBool(self.success)
17603 
      oprot.writeFieldEnd()
17604 
    if self.ex is not None:
17605 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17606 
      self.ex.write(oprot)
17607 
      oprot.writeFieldEnd()
17608 
    oprot.writeFieldStop()
17609 
    oprot.writeStructEnd()
17610 
 
17611 
  def validate(self):
17612 
    return
17613 
 
17614 
 
17615 
  def __repr__(self):
17616 
    L = ['%s=%r' % (key, value)
17617 
      for key, value in self.__dict__.iteritems()]
17618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17619 
 
17620 
  def __eq__(self, other):
17621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17622 
 
17623 
  def __ne__(self, other):
17624 
    return not (self == other)
17625 
 
4386 anupam.sin 17626 
class getOrderForAwb_args:
17627 
  """
17628 
  Attributes:
17629 
   - awb
17630 
  """
17631 
 
17632 
  thrift_spec = (
17633 
    None, # 0
17634 
    (1, TType.STRING, 'awb', None, None, ), # 1
17635 
  )
17636 
 
17637 
  def __init__(self, awb=None,):
17638 
    self.awb = awb
17639 
 
17640 
  def read(self, iprot):
17641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17643 
      return
17644 
    iprot.readStructBegin()
17645 
    while True:
17646 
      (fname, ftype, fid) = iprot.readFieldBegin()
17647 
      if ftype == TType.STOP:
17648 
        break
17649 
      if fid == 1:
17650 
        if ftype == TType.STRING:
17651 
          self.awb = iprot.readString();
17652 
        else:
17653 
          iprot.skip(ftype)
17654 
      else:
17655 
        iprot.skip(ftype)
17656 
      iprot.readFieldEnd()
17657 
    iprot.readStructEnd()
17658 
 
17659 
  def write(self, oprot):
17660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17662 
      return
17663 
    oprot.writeStructBegin('getOrderForAwb_args')
17664 
    if self.awb is not None:
17665 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
17666 
      oprot.writeString(self.awb)
17667 
      oprot.writeFieldEnd()
17668 
    oprot.writeFieldStop()
17669 
    oprot.writeStructEnd()
17670 
 
17671 
  def validate(self):
17672 
    return
17673 
 
17674 
 
17675 
  def __repr__(self):
17676 
    L = ['%s=%r' % (key, value)
17677 
      for key, value in self.__dict__.iteritems()]
17678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17679 
 
17680 
  def __eq__(self, other):
17681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17682 
 
17683 
  def __ne__(self, other):
17684 
    return not (self == other)
17685 
 
17686 
class getOrderForAwb_result:
17687 
  """
17688 
  Attributes:
17689 
   - success
17690 
   - ex
17691 
  """
17692 
 
17693 
  thrift_spec = (
17694 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17695 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17696 
  )
17697 
 
17698 
  def __init__(self, success=None, ex=None,):
17699 
    self.success = success
17700 
    self.ex = ex
17701 
 
17702 
  def read(self, iprot):
17703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17705 
      return
17706 
    iprot.readStructBegin()
17707 
    while True:
17708 
      (fname, ftype, fid) = iprot.readFieldBegin()
17709 
      if ftype == TType.STOP:
17710 
        break
17711 
      if fid == 0:
17712 
        if ftype == TType.STRUCT:
17713 
          self.success = Order()
17714 
          self.success.read(iprot)
17715 
        else:
17716 
          iprot.skip(ftype)
17717 
      elif fid == 1:
17718 
        if ftype == TType.STRUCT:
17719 
          self.ex = TransactionServiceException()
17720 
          self.ex.read(iprot)
17721 
        else:
17722 
          iprot.skip(ftype)
17723 
      else:
17724 
        iprot.skip(ftype)
17725 
      iprot.readFieldEnd()
17726 
    iprot.readStructEnd()
17727 
 
17728 
  def write(self, oprot):
17729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17731 
      return
17732 
    oprot.writeStructBegin('getOrderForAwb_result')
17733 
    if self.success is not None:
17734 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17735 
      self.success.write(oprot)
17736 
      oprot.writeFieldEnd()
17737 
    if self.ex is not None:
17738 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17739 
      self.ex.write(oprot)
17740 
      oprot.writeFieldEnd()
17741 
    oprot.writeFieldStop()
17742 
    oprot.writeStructEnd()
17743 
 
17744 
  def validate(self):
17745 
    return
17746 
 
17747 
 
17748 
  def __repr__(self):
17749 
    L = ['%s=%r' % (key, value)
17750 
      for key, value in self.__dict__.iteritems()]
17751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17752 
 
17753 
  def __eq__(self, other):
17754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17755 
 
17756 
  def __ne__(self, other):
17757 
    return not (self == other)
4506 phani.kuma 17758 
 
17759 
class getOrdersForProviderForStatus_args:
17760 
  """
17761 
  Attributes:
17762 
   - logistics_provider_id
17763 
   - order_status
17764 
  """
17765 
 
17766 
  thrift_spec = (
17767 
    None, # 0
17768 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
17769 
    (2, TType.I32, 'order_status', None, None, ), # 2
17770 
  )
17771 
 
17772 
  def __init__(self, logistics_provider_id=None, order_status=None,):
17773 
    self.logistics_provider_id = logistics_provider_id
17774 
    self.order_status = order_status
17775 
 
17776 
  def read(self, iprot):
17777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17779 
      return
17780 
    iprot.readStructBegin()
17781 
    while True:
17782 
      (fname, ftype, fid) = iprot.readFieldBegin()
17783 
      if ftype == TType.STOP:
17784 
        break
17785 
      if fid == 1:
17786 
        if ftype == TType.I64:
17787 
          self.logistics_provider_id = iprot.readI64();
17788 
        else:
17789 
          iprot.skip(ftype)
17790 
      elif fid == 2:
17791 
        if ftype == TType.I32:
17792 
          self.order_status = iprot.readI32();
17793 
        else:
17794 
          iprot.skip(ftype)
17795 
      else:
17796 
        iprot.skip(ftype)
17797 
      iprot.readFieldEnd()
17798 
    iprot.readStructEnd()
17799 
 
17800 
  def write(self, oprot):
17801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17803 
      return
17804 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
17805 
    if self.logistics_provider_id is not None:
17806 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
17807 
      oprot.writeI64(self.logistics_provider_id)
17808 
      oprot.writeFieldEnd()
17809 
    if self.order_status is not None:
17810 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
17811 
      oprot.writeI32(self.order_status)
17812 
      oprot.writeFieldEnd()
17813 
    oprot.writeFieldStop()
17814 
    oprot.writeStructEnd()
17815 
 
17816 
  def validate(self):
17817 
    return
17818 
 
17819 
 
17820 
  def __repr__(self):
17821 
    L = ['%s=%r' % (key, value)
17822 
      for key, value in self.__dict__.iteritems()]
17823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17824 
 
17825 
  def __eq__(self, other):
17826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17827 
 
17828 
  def __ne__(self, other):
17829 
    return not (self == other)
17830 
 
17831 
class getOrdersForProviderForStatus_result:
17832 
  """
17833 
  Attributes:
17834 
   - success
17835 
   - ex
17836 
  """
17837 
 
17838 
  thrift_spec = (
17839 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17840 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17841 
  )
17842 
 
17843 
  def __init__(self, success=None, ex=None,):
17844 
    self.success = success
17845 
    self.ex = ex
17846 
 
17847 
  def read(self, iprot):
17848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17850 
      return
17851 
    iprot.readStructBegin()
17852 
    while True:
17853 
      (fname, ftype, fid) = iprot.readFieldBegin()
17854 
      if ftype == TType.STOP:
17855 
        break
17856 
      if fid == 0:
17857 
        if ftype == TType.LIST:
17858 
          self.success = []
4837 varun.gupt 17859 
          (_etype345, _size342) = iprot.readListBegin()
17860 
          for _i346 in xrange(_size342):
17861 
            _elem347 = Order()
17862 
            _elem347.read(iprot)
17863 
            self.success.append(_elem347)
4506 phani.kuma 17864 
          iprot.readListEnd()
17865 
        else:
17866 
          iprot.skip(ftype)
17867 
      elif fid == 1:
17868 
        if ftype == TType.STRUCT:
17869 
          self.ex = TransactionServiceException()
17870 
          self.ex.read(iprot)
17871 
        else:
17872 
          iprot.skip(ftype)
17873 
      else:
17874 
        iprot.skip(ftype)
17875 
      iprot.readFieldEnd()
17876 
    iprot.readStructEnd()
17877 
 
17878 
  def write(self, oprot):
17879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17881 
      return
17882 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
17883 
    if self.success is not None:
17884 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17885 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 17886 
      for iter348 in self.success:
17887 
        iter348.write(oprot)
4506 phani.kuma 17888 
      oprot.writeListEnd()
17889 
      oprot.writeFieldEnd()
17890 
    if self.ex is not None:
17891 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17892 
      self.ex.write(oprot)
17893 
      oprot.writeFieldEnd()
17894 
    oprot.writeFieldStop()
17895 
    oprot.writeStructEnd()
17896 
 
17897 
  def validate(self):
17898 
    return
17899 
 
17900 
 
17901 
  def __repr__(self):
17902 
    L = ['%s=%r' % (key, value)
17903 
      for key, value in self.__dict__.iteritems()]
17904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17905 
 
17906 
  def __eq__(self, other):
17907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17908 
 
17909 
  def __ne__(self, other):
17910 
    return not (self == other)
4600 varun.gupt 17911 
 
17912 
class getBilledOrdersForVendor_args:
17913 
  """
17914 
  Attributes:
17915 
   - vendorId
17916 
   - billingDateFrom
17917 
   - billingDateTo
17918 
  """
17919 
 
17920 
  thrift_spec = (
17921 
    None, # 0
17922 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17923 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
17924 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
17925 
  )
17926 
 
17927 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
17928 
    self.vendorId = vendorId
17929 
    self.billingDateFrom = billingDateFrom
17930 
    self.billingDateTo = billingDateTo
17931 
 
17932 
  def read(self, iprot):
17933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17935 
      return
17936 
    iprot.readStructBegin()
17937 
    while True:
17938 
      (fname, ftype, fid) = iprot.readFieldBegin()
17939 
      if ftype == TType.STOP:
17940 
        break
17941 
      if fid == 1:
17942 
        if ftype == TType.I64:
17943 
          self.vendorId = iprot.readI64();
17944 
        else:
17945 
          iprot.skip(ftype)
17946 
      elif fid == 2:
17947 
        if ftype == TType.I64:
17948 
          self.billingDateFrom = iprot.readI64();
17949 
        else:
17950 
          iprot.skip(ftype)
17951 
      elif fid == 3:
17952 
        if ftype == TType.I64:
17953 
          self.billingDateTo = iprot.readI64();
17954 
        else:
17955 
          iprot.skip(ftype)
17956 
      else:
17957 
        iprot.skip(ftype)
17958 
      iprot.readFieldEnd()
17959 
    iprot.readStructEnd()
17960 
 
17961 
  def write(self, oprot):
17962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17964 
      return
17965 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
17966 
    if self.vendorId is not None:
17967 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17968 
      oprot.writeI64(self.vendorId)
17969 
      oprot.writeFieldEnd()
17970 
    if self.billingDateFrom is not None:
17971 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
17972 
      oprot.writeI64(self.billingDateFrom)
17973 
      oprot.writeFieldEnd()
17974 
    if self.billingDateTo is not None:
17975 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
17976 
      oprot.writeI64(self.billingDateTo)
17977 
      oprot.writeFieldEnd()
17978 
    oprot.writeFieldStop()
17979 
    oprot.writeStructEnd()
17980 
 
17981 
  def validate(self):
17982 
    return
17983 
 
17984 
 
17985 
  def __repr__(self):
17986 
    L = ['%s=%r' % (key, value)
17987 
      for key, value in self.__dict__.iteritems()]
17988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17989 
 
17990 
  def __eq__(self, other):
17991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17992 
 
17993 
  def __ne__(self, other):
17994 
    return not (self == other)
17995 
 
17996 
class getBilledOrdersForVendor_result:
17997 
  """
17998 
  Attributes:
17999 
   - success
18000 
   - ex
18001 
  """
18002 
 
18003 
  thrift_spec = (
18004 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18005 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18006 
  )
18007 
 
18008 
  def __init__(self, success=None, ex=None,):
18009 
    self.success = success
18010 
    self.ex = ex
18011 
 
18012 
  def read(self, iprot):
18013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18015 
      return
18016 
    iprot.readStructBegin()
18017 
    while True:
18018 
      (fname, ftype, fid) = iprot.readFieldBegin()
18019 
      if ftype == TType.STOP:
18020 
        break
18021 
      if fid == 0:
18022 
        if ftype == TType.LIST:
18023 
          self.success = []
4837 varun.gupt 18024 
          (_etype352, _size349) = iprot.readListBegin()
18025 
          for _i353 in xrange(_size349):
18026 
            _elem354 = Order()
18027 
            _elem354.read(iprot)
18028 
            self.success.append(_elem354)
4600 varun.gupt 18029 
          iprot.readListEnd()
18030 
        else:
18031 
          iprot.skip(ftype)
18032 
      elif fid == 1:
18033 
        if ftype == TType.STRUCT:
18034 
          self.ex = TransactionServiceException()
18035 
          self.ex.read(iprot)
18036 
        else:
18037 
          iprot.skip(ftype)
18038 
      else:
18039 
        iprot.skip(ftype)
18040 
      iprot.readFieldEnd()
18041 
    iprot.readStructEnd()
18042 
 
18043 
  def write(self, oprot):
18044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18046 
      return
18047 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
18048 
    if self.success is not None:
18049 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18050 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 18051 
      for iter355 in self.success:
18052 
        iter355.write(oprot)
4600 varun.gupt 18053 
      oprot.writeListEnd()
18054 
      oprot.writeFieldEnd()
18055 
    if self.ex is not None:
18056 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18057 
      self.ex.write(oprot)
18058 
      oprot.writeFieldEnd()
18059 
    oprot.writeFieldStop()
18060 
    oprot.writeStructEnd()
18061 
 
18062 
  def validate(self):
18063 
    return
18064 
 
18065 
 
18066 
  def __repr__(self):
18067 
    L = ['%s=%r' % (key, value)
18068 
      for key, value in self.__dict__.iteritems()]
18069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18070 
 
18071 
  def __eq__(self, other):
18072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18073 
 
18074 
  def __ne__(self, other):
18075 
    return not (self == other)
18076 
 
4607 rajveer 18077 
class getSlippedSippingDateOrders_args:
18078 
 
18079 
  thrift_spec = (
18080 
  )
18081 
 
18082 
  def read(self, iprot):
18083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18085 
      return
18086 
    iprot.readStructBegin()
18087 
    while True:
18088 
      (fname, ftype, fid) = iprot.readFieldBegin()
18089 
      if ftype == TType.STOP:
18090 
        break
18091 
      else:
18092 
        iprot.skip(ftype)
18093 
      iprot.readFieldEnd()
18094 
    iprot.readStructEnd()
18095 
 
18096 
  def write(self, oprot):
18097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18099 
      return
18100 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
18101 
    oprot.writeFieldStop()
18102 
    oprot.writeStructEnd()
18103 
 
18104 
  def validate(self):
18105 
    return
18106 
 
18107 
 
18108 
  def __repr__(self):
18109 
    L = ['%s=%r' % (key, value)
18110 
      for key, value in self.__dict__.iteritems()]
18111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18112 
 
18113 
  def __eq__(self, other):
18114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18115 
 
18116 
  def __ne__(self, other):
18117 
    return not (self == other)
18118 
 
18119 
class getSlippedSippingDateOrders_result:
18120 
  """
18121 
  Attributes:
18122 
   - success
18123 
   - ex
18124 
  """
18125 
 
18126 
  thrift_spec = (
18127 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18128 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18129 
  )
18130 
 
18131 
  def __init__(self, success=None, ex=None,):
18132 
    self.success = success
18133 
    self.ex = ex
18134 
 
18135 
  def read(self, iprot):
18136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18138 
      return
18139 
    iprot.readStructBegin()
18140 
    while True:
18141 
      (fname, ftype, fid) = iprot.readFieldBegin()
18142 
      if ftype == TType.STOP:
18143 
        break
18144 
      if fid == 0:
18145 
        if ftype == TType.LIST:
18146 
          self.success = []
4837 varun.gupt 18147 
          (_etype359, _size356) = iprot.readListBegin()
18148 
          for _i360 in xrange(_size356):
18149 
            _elem361 = Order()
18150 
            _elem361.read(iprot)
18151 
            self.success.append(_elem361)
4607 rajveer 18152 
          iprot.readListEnd()
18153 
        else:
18154 
          iprot.skip(ftype)
18155 
      elif fid == 1:
18156 
        if ftype == TType.STRUCT:
18157 
          self.ex = TransactionServiceException()
18158 
          self.ex.read(iprot)
18159 
        else:
18160 
          iprot.skip(ftype)
18161 
      else:
18162 
        iprot.skip(ftype)
18163 
      iprot.readFieldEnd()
18164 
    iprot.readStructEnd()
18165 
 
18166 
  def write(self, oprot):
18167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18169 
      return
18170 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
18171 
    if self.success is not None:
18172 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18173 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 18174 
      for iter362 in self.success:
18175 
        iter362.write(oprot)
4607 rajveer 18176 
      oprot.writeListEnd()
18177 
      oprot.writeFieldEnd()
18178 
    if self.ex is not None:
18179 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18180 
      self.ex.write(oprot)
18181 
      oprot.writeFieldEnd()
18182 
    oprot.writeFieldStop()
18183 
    oprot.writeStructEnd()
18184 
 
18185 
  def validate(self):
18186 
    return
18187 
 
18188 
 
18189 
  def __repr__(self):
18190 
    L = ['%s=%r' % (key, value)
18191 
      for key, value in self.__dict__.iteritems()]
18192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18193 
 
18194 
  def __eq__(self, other):
18195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18196 
 
18197 
  def __ne__(self, other):
18198 
    return not (self == other)
18199 
 
4709 rajveer 18200 
class getCancelledOrders_args:
18201 
  """
18202 
  Attributes:
18203 
   - cancelDateFrom
18204 
   - cancelDateTo
18205 
  """
18206 
 
18207 
  thrift_spec = (
18208 
    None, # 0
18209 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
18210 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
18211 
  )
18212 
 
18213 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
18214 
    self.cancelDateFrom = cancelDateFrom
18215 
    self.cancelDateTo = cancelDateTo
18216 
 
18217 
  def read(self, iprot):
18218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18220 
      return
18221 
    iprot.readStructBegin()
18222 
    while True:
18223 
      (fname, ftype, fid) = iprot.readFieldBegin()
18224 
      if ftype == TType.STOP:
18225 
        break
18226 
      if fid == 1:
18227 
        if ftype == TType.I64:
18228 
          self.cancelDateFrom = iprot.readI64();
18229 
        else:
18230 
          iprot.skip(ftype)
18231 
      elif fid == 2:
18232 
        if ftype == TType.I64:
18233 
          self.cancelDateTo = iprot.readI64();
18234 
        else:
18235 
          iprot.skip(ftype)
18236 
      else:
18237 
        iprot.skip(ftype)
18238 
      iprot.readFieldEnd()
18239 
    iprot.readStructEnd()
18240 
 
18241 
  def write(self, oprot):
18242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18244 
      return
18245 
    oprot.writeStructBegin('getCancelledOrders_args')
18246 
    if self.cancelDateFrom is not None:
18247 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
18248 
      oprot.writeI64(self.cancelDateFrom)
18249 
      oprot.writeFieldEnd()
18250 
    if self.cancelDateTo is not None:
18251 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
18252 
      oprot.writeI64(self.cancelDateTo)
18253 
      oprot.writeFieldEnd()
18254 
    oprot.writeFieldStop()
18255 
    oprot.writeStructEnd()
18256 
 
18257 
  def validate(self):
18258 
    return
18259 
 
18260 
 
18261 
  def __repr__(self):
18262 
    L = ['%s=%r' % (key, value)
18263 
      for key, value in self.__dict__.iteritems()]
18264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18265 
 
18266 
  def __eq__(self, other):
18267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18268 
 
18269 
  def __ne__(self, other):
18270 
    return not (self == other)
18271 
 
18272 
class getCancelledOrders_result:
18273 
  """
18274 
  Attributes:
18275 
   - success
18276 
   - ex
18277 
  """
18278 
 
18279 
  thrift_spec = (
18280 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18281 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18282 
  )
18283 
 
18284 
  def __init__(self, success=None, ex=None,):
18285 
    self.success = success
18286 
    self.ex = ex
18287 
 
18288 
  def read(self, iprot):
18289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18291 
      return
18292 
    iprot.readStructBegin()
18293 
    while True:
18294 
      (fname, ftype, fid) = iprot.readFieldBegin()
18295 
      if ftype == TType.STOP:
18296 
        break
18297 
      if fid == 0:
18298 
        if ftype == TType.LIST:
18299 
          self.success = []
4837 varun.gupt 18300 
          (_etype366, _size363) = iprot.readListBegin()
18301 
          for _i367 in xrange(_size363):
18302 
            _elem368 = Order()
18303 
            _elem368.read(iprot)
18304 
            self.success.append(_elem368)
4709 rajveer 18305 
          iprot.readListEnd()
18306 
        else:
18307 
          iprot.skip(ftype)
18308 
      elif fid == 1:
18309 
        if ftype == TType.STRUCT:
18310 
          self.ex = TransactionServiceException()
18311 
          self.ex.read(iprot)
18312 
        else:
18313 
          iprot.skip(ftype)
18314 
      else:
18315 
        iprot.skip(ftype)
18316 
      iprot.readFieldEnd()
18317 
    iprot.readStructEnd()
18318 
 
18319 
  def write(self, oprot):
18320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18322 
      return
18323 
    oprot.writeStructBegin('getCancelledOrders_result')
18324 
    if self.success is not None:
18325 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18326 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 18327 
      for iter369 in self.success:
18328 
        iter369.write(oprot)
4709 rajveer 18329 
      oprot.writeListEnd()
18330 
      oprot.writeFieldEnd()
18331 
    if self.ex is not None:
18332 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18333 
      self.ex.write(oprot)
18334 
      oprot.writeFieldEnd()
18335 
    oprot.writeFieldStop()
18336 
    oprot.writeStructEnd()
18337 
 
18338 
  def validate(self):
18339 
    return
18340 
 
18341 
 
18342 
  def __repr__(self):
18343 
    L = ['%s=%r' % (key, value)
18344 
      for key, value in self.__dict__.iteritems()]
18345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18346 
 
18347 
  def __eq__(self, other):
18348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18349 
 
18350 
  def __ne__(self, other):
18351 
    return not (self == other)
18352 
 
4600 varun.gupt 18353 
class saveBluedartSettlements_args:
18354 
  """
18355 
  Attributes:
18356 
   - mapAWBAndAmount
18357 
  """
18358 
 
18359 
  thrift_spec = (
18360 
    None, # 0
18361 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
18362 
  )
18363 
 
18364 
  def __init__(self, mapAWBAndAmount=None,):
18365 
    self.mapAWBAndAmount = mapAWBAndAmount
18366 
 
18367 
  def read(self, iprot):
18368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18370 
      return
18371 
    iprot.readStructBegin()
18372 
    while True:
18373 
      (fname, ftype, fid) = iprot.readFieldBegin()
18374 
      if ftype == TType.STOP:
18375 
        break
18376 
      if fid == 1:
18377 
        if ftype == TType.MAP:
18378 
          self.mapAWBAndAmount = {}
4837 varun.gupt 18379 
          (_ktype371, _vtype372, _size370 ) = iprot.readMapBegin()
18380 
          for _i374 in xrange(_size370):
18381 
            _key375 = iprot.readI64();
18382 
            _val376 = iprot.readDouble();
18383 
            self.mapAWBAndAmount[_key375] = _val376
4600 varun.gupt 18384 
          iprot.readMapEnd()
18385 
        else:
18386 
          iprot.skip(ftype)
18387 
      else:
18388 
        iprot.skip(ftype)
18389 
      iprot.readFieldEnd()
18390 
    iprot.readStructEnd()
18391 
 
18392 
  def write(self, oprot):
18393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18395 
      return
18396 
    oprot.writeStructBegin('saveBluedartSettlements_args')
18397 
    if self.mapAWBAndAmount is not None:
18398 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
18399 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
4837 varun.gupt 18400 
      for kiter377,viter378 in self.mapAWBAndAmount.items():
18401 
        oprot.writeI64(kiter377)
18402 
        oprot.writeDouble(viter378)
4600 varun.gupt 18403 
      oprot.writeMapEnd()
18404 
      oprot.writeFieldEnd()
18405 
    oprot.writeFieldStop()
18406 
    oprot.writeStructEnd()
18407 
 
18408 
  def validate(self):
18409 
    return
18410 
 
18411 
 
18412 
  def __repr__(self):
18413 
    L = ['%s=%r' % (key, value)
18414 
      for key, value in self.__dict__.iteritems()]
18415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18416 
 
18417 
  def __eq__(self, other):
18418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18419 
 
18420 
  def __ne__(self, other):
18421 
    return not (self == other)
18422 
 
18423 
class saveBluedartSettlements_result:
18424 
  """
18425 
  Attributes:
18426 
   - ex
18427 
  """
18428 
 
18429 
  thrift_spec = (
18430 
    None, # 0
18431 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18432 
  )
18433 
 
18434 
  def __init__(self, ex=None,):
18435 
    self.ex = ex
18436 
 
18437 
  def read(self, iprot):
18438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18440 
      return
18441 
    iprot.readStructBegin()
18442 
    while True:
18443 
      (fname, ftype, fid) = iprot.readFieldBegin()
18444 
      if ftype == TType.STOP:
18445 
        break
18446 
      if fid == 1:
18447 
        if ftype == TType.STRUCT:
18448 
          self.ex = TransactionServiceException()
18449 
          self.ex.read(iprot)
18450 
        else:
18451 
          iprot.skip(ftype)
18452 
      else:
18453 
        iprot.skip(ftype)
18454 
      iprot.readFieldEnd()
18455 
    iprot.readStructEnd()
18456 
 
18457 
  def write(self, oprot):
18458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18460 
      return
18461 
    oprot.writeStructBegin('saveBluedartSettlements_result')
18462 
    if self.ex is not None:
18463 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18464 
      self.ex.write(oprot)
18465 
      oprot.writeFieldEnd()
18466 
    oprot.writeFieldStop()
18467 
    oprot.writeStructEnd()
18468 
 
18469 
  def validate(self):
18470 
    return
18471 
 
18472 
 
18473 
  def __repr__(self):
18474 
    L = ['%s=%r' % (key, value)
18475 
      for key, value in self.__dict__.iteritems()]
18476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18477 
 
18478 
  def __eq__(self, other):
18479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18480 
 
18481 
  def __ne__(self, other):
18482 
    return not (self == other)
18483 
 
18484 
class savePaymentSettlements_args:
18485 
  """
18486 
  Attributes:
18487 
   - settlementDate
18488 
   - paymentGatewayId
4905 varun.gupt 18489 
   - referenceId
4600 varun.gupt 18490 
   - serviceTax
18491 
   - otherCharges
18492 
   - netCollection
18493 
  """
18494 
 
18495 
  thrift_spec = (
18496 
    None, # 0
18497 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
18498 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 18499 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 18500 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
18501 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
18502 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
18503 
  )
18504 
 
4905 varun.gupt 18505 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 18506 
    self.settlementDate = settlementDate
18507 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 18508 
    self.referenceId = referenceId
4600 varun.gupt 18509 
    self.serviceTax = serviceTax
18510 
    self.otherCharges = otherCharges
18511 
    self.netCollection = netCollection
18512 
 
18513 
  def read(self, iprot):
18514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18516 
      return
18517 
    iprot.readStructBegin()
18518 
    while True:
18519 
      (fname, ftype, fid) = iprot.readFieldBegin()
18520 
      if ftype == TType.STOP:
18521 
        break
18522 
      if fid == 1:
18523 
        if ftype == TType.I64:
18524 
          self.settlementDate = iprot.readI64();
18525 
        else:
18526 
          iprot.skip(ftype)
18527 
      elif fid == 2:
18528 
        if ftype == TType.I64:
18529 
          self.paymentGatewayId = iprot.readI64();
18530 
        else:
18531 
          iprot.skip(ftype)
18532 
      elif fid == 3:
18533 
        if ftype == TType.I64:
4905 varun.gupt 18534 
          self.referenceId = iprot.readI64();
4600 varun.gupt 18535 
        else:
18536 
          iprot.skip(ftype)
18537 
      elif fid == 4:
18538 
        if ftype == TType.DOUBLE:
18539 
          self.serviceTax = iprot.readDouble();
18540 
        else:
18541 
          iprot.skip(ftype)
18542 
      elif fid == 5:
18543 
        if ftype == TType.DOUBLE:
18544 
          self.otherCharges = iprot.readDouble();
18545 
        else:
18546 
          iprot.skip(ftype)
18547 
      elif fid == 6:
18548 
        if ftype == TType.DOUBLE:
18549 
          self.netCollection = iprot.readDouble();
18550 
        else:
18551 
          iprot.skip(ftype)
18552 
      else:
18553 
        iprot.skip(ftype)
18554 
      iprot.readFieldEnd()
18555 
    iprot.readStructEnd()
18556 
 
18557 
  def write(self, oprot):
18558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18560 
      return
18561 
    oprot.writeStructBegin('savePaymentSettlements_args')
18562 
    if self.settlementDate is not None:
18563 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
18564 
      oprot.writeI64(self.settlementDate)
18565 
      oprot.writeFieldEnd()
18566 
    if self.paymentGatewayId is not None:
18567 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
18568 
      oprot.writeI64(self.paymentGatewayId)
18569 
      oprot.writeFieldEnd()
4905 varun.gupt 18570 
    if self.referenceId is not None:
18571 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
18572 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 18573 
      oprot.writeFieldEnd()
18574 
    if self.serviceTax is not None:
18575 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
18576 
      oprot.writeDouble(self.serviceTax)
18577 
      oprot.writeFieldEnd()
18578 
    if self.otherCharges is not None:
18579 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
18580 
      oprot.writeDouble(self.otherCharges)
18581 
      oprot.writeFieldEnd()
18582 
    if self.netCollection is not None:
18583 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
18584 
      oprot.writeDouble(self.netCollection)
18585 
      oprot.writeFieldEnd()
18586 
    oprot.writeFieldStop()
18587 
    oprot.writeStructEnd()
18588 
 
18589 
  def validate(self):
18590 
    return
18591 
 
18592 
 
18593 
  def __repr__(self):
18594 
    L = ['%s=%r' % (key, value)
18595 
      for key, value in self.__dict__.iteritems()]
18596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18597 
 
18598 
  def __eq__(self, other):
18599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18600 
 
18601 
  def __ne__(self, other):
18602 
    return not (self == other)
18603 
 
18604 
class savePaymentSettlements_result:
18605 
  """
18606 
  Attributes:
18607 
   - ex
18608 
  """
18609 
 
18610 
  thrift_spec = (
18611 
    None, # 0
18612 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18613 
  )
18614 
 
18615 
  def __init__(self, ex=None,):
18616 
    self.ex = ex
18617 
 
18618 
  def read(self, iprot):
18619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18621 
      return
18622 
    iprot.readStructBegin()
18623 
    while True:
18624 
      (fname, ftype, fid) = iprot.readFieldBegin()
18625 
      if ftype == TType.STOP:
18626 
        break
18627 
      if fid == 1:
18628 
        if ftype == TType.STRUCT:
18629 
          self.ex = TransactionServiceException()
18630 
          self.ex.read(iprot)
18631 
        else:
18632 
          iprot.skip(ftype)
18633 
      else:
18634 
        iprot.skip(ftype)
18635 
      iprot.readFieldEnd()
18636 
    iprot.readStructEnd()
18637 
 
18638 
  def write(self, oprot):
18639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18641 
      return
18642 
    oprot.writeStructBegin('savePaymentSettlements_result')
18643 
    if self.ex is not None:
18644 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18645 
      self.ex.write(oprot)
18646 
      oprot.writeFieldEnd()
18647 
    oprot.writeFieldStop()
18648 
    oprot.writeStructEnd()
18649 
 
18650 
  def validate(self):
18651 
    return
18652 
 
18653 
 
18654 
  def __repr__(self):
18655 
    L = ['%s=%r' % (key, value)
18656 
      for key, value in self.__dict__.iteritems()]
18657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18658 
 
18659 
  def __eq__(self, other):
18660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18661 
 
18662 
  def __ne__(self, other):
18663 
    return not (self == other)
18664 
 
18665 
class saveEBSSettlementSummary_args:
18666 
  """
18667 
  Attributes:
18668 
   - settlementId
18669 
   - settlementDate
18670 
   - transactionDateFrom
18671 
   - transactionDateTo
18672 
   - amount
18673 
  """
18674 
 
18675 
  thrift_spec = (
18676 
    None, # 0
18677 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18678 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
18679 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
18680 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
18681 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
18682 
  )
18683 
 
18684 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
18685 
    self.settlementId = settlementId
18686 
    self.settlementDate = settlementDate
18687 
    self.transactionDateFrom = transactionDateFrom
18688 
    self.transactionDateTo = transactionDateTo
18689 
    self.amount = amount
18690 
 
18691 
  def read(self, iprot):
18692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18694 
      return
18695 
    iprot.readStructBegin()
18696 
    while True:
18697 
      (fname, ftype, fid) = iprot.readFieldBegin()
18698 
      if ftype == TType.STOP:
18699 
        break
18700 
      if fid == 1:
18701 
        if ftype == TType.I64:
18702 
          self.settlementId = iprot.readI64();
18703 
        else:
18704 
          iprot.skip(ftype)
18705 
      elif fid == 2:
18706 
        if ftype == TType.I64:
18707 
          self.settlementDate = iprot.readI64();
18708 
        else:
18709 
          iprot.skip(ftype)
18710 
      elif fid == 3:
18711 
        if ftype == TType.I64:
18712 
          self.transactionDateFrom = iprot.readI64();
18713 
        else:
18714 
          iprot.skip(ftype)
18715 
      elif fid == 4:
18716 
        if ftype == TType.I64:
18717 
          self.transactionDateTo = iprot.readI64();
18718 
        else:
18719 
          iprot.skip(ftype)
18720 
      elif fid == 5:
18721 
        if ftype == TType.DOUBLE:
18722 
          self.amount = iprot.readDouble();
18723 
        else:
18724 
          iprot.skip(ftype)
18725 
      else:
18726 
        iprot.skip(ftype)
18727 
      iprot.readFieldEnd()
18728 
    iprot.readStructEnd()
18729 
 
18730 
  def write(self, oprot):
18731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18733 
      return
18734 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
18735 
    if self.settlementId is not None:
18736 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18737 
      oprot.writeI64(self.settlementId)
18738 
      oprot.writeFieldEnd()
18739 
    if self.settlementDate is not None:
18740 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
18741 
      oprot.writeI64(self.settlementDate)
18742 
      oprot.writeFieldEnd()
18743 
    if self.transactionDateFrom is not None:
18744 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
18745 
      oprot.writeI64(self.transactionDateFrom)
18746 
      oprot.writeFieldEnd()
18747 
    if self.transactionDateTo is not None:
18748 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
18749 
      oprot.writeI64(self.transactionDateTo)
18750 
      oprot.writeFieldEnd()
18751 
    if self.amount is not None:
18752 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
18753 
      oprot.writeDouble(self.amount)
18754 
      oprot.writeFieldEnd()
18755 
    oprot.writeFieldStop()
18756 
    oprot.writeStructEnd()
18757 
 
18758 
  def validate(self):
18759 
    return
18760 
 
18761 
 
18762 
  def __repr__(self):
18763 
    L = ['%s=%r' % (key, value)
18764 
      for key, value in self.__dict__.iteritems()]
18765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18766 
 
18767 
  def __eq__(self, other):
18768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18769 
 
18770 
  def __ne__(self, other):
18771 
    return not (self == other)
18772 
 
18773 
class saveEBSSettlementSummary_result:
18774 
  """
18775 
  Attributes:
18776 
   - ex
18777 
  """
18778 
 
18779 
  thrift_spec = (
18780 
    None, # 0
18781 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18782 
  )
18783 
 
18784 
  def __init__(self, ex=None,):
18785 
    self.ex = ex
18786 
 
18787 
  def read(self, iprot):
18788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18790 
      return
18791 
    iprot.readStructBegin()
18792 
    while True:
18793 
      (fname, ftype, fid) = iprot.readFieldBegin()
18794 
      if ftype == TType.STOP:
18795 
        break
18796 
      if fid == 1:
18797 
        if ftype == TType.STRUCT:
18798 
          self.ex = TransactionServiceException()
18799 
          self.ex.read(iprot)
18800 
        else:
18801 
          iprot.skip(ftype)
18802 
      else:
18803 
        iprot.skip(ftype)
18804 
      iprot.readFieldEnd()
18805 
    iprot.readStructEnd()
18806 
 
18807 
  def write(self, oprot):
18808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18810 
      return
18811 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
18812 
    if self.ex is not None:
18813 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18814 
      self.ex.write(oprot)
18815 
      oprot.writeFieldEnd()
18816 
    oprot.writeFieldStop()
18817 
    oprot.writeStructEnd()
18818 
 
18819 
  def validate(self):
18820 
    return
18821 
 
18822 
 
18823 
  def __repr__(self):
18824 
    L = ['%s=%r' % (key, value)
18825 
      for key, value in self.__dict__.iteritems()]
18826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18827 
 
18828 
  def __eq__(self, other):
18829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18830 
 
18831 
  def __ne__(self, other):
18832 
    return not (self == other)
18833 
 
18834 
class getSettlementForPaymentId_args:
18835 
  """
18836 
  Attributes:
18837 
   - paymentId
18838 
  """
18839 
 
18840 
  thrift_spec = (
18841 
    None, # 0
18842 
    (1, TType.I64, 'paymentId', None, None, ), # 1
18843 
  )
18844 
 
18845 
  def __init__(self, paymentId=None,):
18846 
    self.paymentId = paymentId
18847 
 
18848 
  def read(self, iprot):
18849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18851 
      return
18852 
    iprot.readStructBegin()
18853 
    while True:
18854 
      (fname, ftype, fid) = iprot.readFieldBegin()
18855 
      if ftype == TType.STOP:
18856 
        break
18857 
      if fid == 1:
18858 
        if ftype == TType.I64:
18859 
          self.paymentId = iprot.readI64();
18860 
        else:
18861 
          iprot.skip(ftype)
18862 
      else:
18863 
        iprot.skip(ftype)
18864 
      iprot.readFieldEnd()
18865 
    iprot.readStructEnd()
18866 
 
18867 
  def write(self, oprot):
18868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18870 
      return
18871 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
18872 
    if self.paymentId is not None:
18873 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
18874 
      oprot.writeI64(self.paymentId)
18875 
      oprot.writeFieldEnd()
18876 
    oprot.writeFieldStop()
18877 
    oprot.writeStructEnd()
18878 
 
18879 
  def validate(self):
18880 
    return
18881 
 
18882 
 
18883 
  def __repr__(self):
18884 
    L = ['%s=%r' % (key, value)
18885 
      for key, value in self.__dict__.iteritems()]
18886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18887 
 
18888 
  def __eq__(self, other):
18889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18890 
 
18891 
  def __ne__(self, other):
18892 
    return not (self == other)
18893 
 
18894 
class getSettlementForPaymentId_result:
18895 
  """
18896 
  Attributes:
18897 
   - success
18898 
   - ex
18899 
  """
18900 
 
18901 
  thrift_spec = (
18902 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
18903 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18904 
  )
18905 
 
18906 
  def __init__(self, success=None, ex=None,):
18907 
    self.success = success
18908 
    self.ex = ex
18909 
 
18910 
  def read(self, iprot):
18911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18913 
      return
18914 
    iprot.readStructBegin()
18915 
    while True:
18916 
      (fname, ftype, fid) = iprot.readFieldBegin()
18917 
      if ftype == TType.STOP:
18918 
        break
18919 
      if fid == 0:
18920 
        if ftype == TType.STRUCT:
18921 
          self.success = PaymentSettlement()
18922 
          self.success.read(iprot)
18923 
        else:
18924 
          iprot.skip(ftype)
18925 
      elif fid == 1:
18926 
        if ftype == TType.STRUCT:
18927 
          self.ex = TransactionServiceException()
18928 
          self.ex.read(iprot)
18929 
        else:
18930 
          iprot.skip(ftype)
18931 
      else:
18932 
        iprot.skip(ftype)
18933 
      iprot.readFieldEnd()
18934 
    iprot.readStructEnd()
18935 
 
18936 
  def write(self, oprot):
18937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18939 
      return
18940 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
18941 
    if self.success is not None:
18942 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18943 
      self.success.write(oprot)
18944 
      oprot.writeFieldEnd()
18945 
    if self.ex is not None:
18946 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18947 
      self.ex.write(oprot)
18948 
      oprot.writeFieldEnd()
18949 
    oprot.writeFieldStop()
18950 
    oprot.writeStructEnd()
18951 
 
18952 
  def validate(self):
18953 
    return
18954 
 
18955 
 
18956 
  def __repr__(self):
18957 
    L = ['%s=%r' % (key, value)
18958 
      for key, value in self.__dict__.iteritems()]
18959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18960 
 
18961 
  def __eq__(self, other):
18962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18963 
 
18964 
  def __ne__(self, other):
18965 
    return not (self == other)
18966 
 
18967 
class getEBSSettlementSummaries_args:
18968 
 
18969 
  thrift_spec = (
18970 
  )
18971 
 
18972 
  def read(self, iprot):
18973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18975 
      return
18976 
    iprot.readStructBegin()
18977 
    while True:
18978 
      (fname, ftype, fid) = iprot.readFieldBegin()
18979 
      if ftype == TType.STOP:
18980 
        break
18981 
      else:
18982 
        iprot.skip(ftype)
18983 
      iprot.readFieldEnd()
18984 
    iprot.readStructEnd()
18985 
 
18986 
  def write(self, oprot):
18987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18989 
      return
18990 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
18991 
    oprot.writeFieldStop()
18992 
    oprot.writeStructEnd()
18993 
 
18994 
  def validate(self):
18995 
    return
18996 
 
18997 
 
18998 
  def __repr__(self):
18999 
    L = ['%s=%r' % (key, value)
19000 
      for key, value in self.__dict__.iteritems()]
19001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19002 
 
19003 
  def __eq__(self, other):
19004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19005 
 
19006 
  def __ne__(self, other):
19007 
    return not (self == other)
19008 
 
19009 
class getEBSSettlementSummaries_result:
19010 
  """
19011 
  Attributes:
19012 
   - success
19013 
   - ex
19014 
  """
19015 
 
19016 
  thrift_spec = (
19017 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
19018 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19019 
  )
19020 
 
19021 
  def __init__(self, success=None, ex=None,):
19022 
    self.success = success
19023 
    self.ex = ex
19024 
 
19025 
  def read(self, iprot):
19026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19028 
      return
19029 
    iprot.readStructBegin()
19030 
    while True:
19031 
      (fname, ftype, fid) = iprot.readFieldBegin()
19032 
      if ftype == TType.STOP:
19033 
        break
19034 
      if fid == 0:
19035 
        if ftype == TType.MAP:
19036 
          self.success = {}
4837 varun.gupt 19037 
          (_ktype380, _vtype381, _size379 ) = iprot.readMapBegin()
19038 
          for _i383 in xrange(_size379):
19039 
            _key384 = iprot.readI64();
19040 
            _val385 = iprot.readString();
19041 
            self.success[_key384] = _val385
4600 varun.gupt 19042 
          iprot.readMapEnd()
19043 
        else:
19044 
          iprot.skip(ftype)
19045 
      elif fid == 1:
19046 
        if ftype == TType.STRUCT:
19047 
          self.ex = TransactionServiceException()
19048 
          self.ex.read(iprot)
19049 
        else:
19050 
          iprot.skip(ftype)
19051 
      else:
19052 
        iprot.skip(ftype)
19053 
      iprot.readFieldEnd()
19054 
    iprot.readStructEnd()
19055 
 
19056 
  def write(self, oprot):
19057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19059 
      return
19060 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
19061 
    if self.success is not None:
19062 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19063 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
4837 varun.gupt 19064 
      for kiter386,viter387 in self.success.items():
19065 
        oprot.writeI64(kiter386)
19066 
        oprot.writeString(viter387)
4600 varun.gupt 19067 
      oprot.writeMapEnd()
19068 
      oprot.writeFieldEnd()
19069 
    if self.ex is not None:
19070 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19071 
      self.ex.write(oprot)
19072 
      oprot.writeFieldEnd()
19073 
    oprot.writeFieldStop()
19074 
    oprot.writeStructEnd()
19075 
 
19076 
  def validate(self):
19077 
    return
19078 
 
19079 
 
19080 
  def __repr__(self):
19081 
    L = ['%s=%r' % (key, value)
19082 
      for key, value in self.__dict__.iteritems()]
19083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19084 
 
19085 
  def __eq__(self, other):
19086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19087 
 
19088 
  def __ne__(self, other):
19089 
    return not (self == other)
19090 
 
19091 
class markEBSSettlementUploaded_args:
19092 
  """
19093 
  Attributes:
19094 
   - settlementId
19095 
  """
19096 
 
19097 
  thrift_spec = (
19098 
    None, # 0
19099 
    (1, TType.I64, 'settlementId', None, None, ), # 1
19100 
  )
19101 
 
19102 
  def __init__(self, settlementId=None,):
19103 
    self.settlementId = settlementId
19104 
 
19105 
  def read(self, iprot):
19106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19108 
      return
19109 
    iprot.readStructBegin()
19110 
    while True:
19111 
      (fname, ftype, fid) = iprot.readFieldBegin()
19112 
      if ftype == TType.STOP:
19113 
        break
19114 
      if fid == 1:
19115 
        if ftype == TType.I64:
19116 
          self.settlementId = iprot.readI64();
19117 
        else:
19118 
          iprot.skip(ftype)
19119 
      else:
19120 
        iprot.skip(ftype)
19121 
      iprot.readFieldEnd()
19122 
    iprot.readStructEnd()
19123 
 
19124 
  def write(self, oprot):
19125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19127 
      return
19128 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
19129 
    if self.settlementId is not None:
19130 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
19131 
      oprot.writeI64(self.settlementId)
19132 
      oprot.writeFieldEnd()
19133 
    oprot.writeFieldStop()
19134 
    oprot.writeStructEnd()
19135 
 
19136 
  def validate(self):
19137 
    return
19138 
 
19139 
 
19140 
  def __repr__(self):
19141 
    L = ['%s=%r' % (key, value)
19142 
      for key, value in self.__dict__.iteritems()]
19143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19144 
 
19145 
  def __eq__(self, other):
19146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19147 
 
19148 
  def __ne__(self, other):
19149 
    return not (self == other)
19150 
 
19151 
class markEBSSettlementUploaded_result:
19152 
  """
19153 
  Attributes:
19154 
   - ex
19155 
  """
19156 
 
19157 
  thrift_spec = (
19158 
    None, # 0
19159 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19160 
  )
19161 
 
19162 
  def __init__(self, ex=None,):
19163 
    self.ex = ex
19164 
 
19165 
  def read(self, iprot):
19166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19168 
      return
19169 
    iprot.readStructBegin()
19170 
    while True:
19171 
      (fname, ftype, fid) = iprot.readFieldBegin()
19172 
      if ftype == TType.STOP:
19173 
        break
19174 
      if fid == 1:
19175 
        if ftype == TType.STRUCT:
19176 
          self.ex = TransactionServiceException()
19177 
          self.ex.read(iprot)
19178 
        else:
19179 
          iprot.skip(ftype)
19180 
      else:
19181 
        iprot.skip(ftype)
19182 
      iprot.readFieldEnd()
19183 
    iprot.readStructEnd()
19184 
 
19185 
  def write(self, oprot):
19186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19188 
      return
19189 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
19190 
    if self.ex is not None:
19191 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19192 
      self.ex.write(oprot)
19193 
      oprot.writeFieldEnd()
19194 
    oprot.writeFieldStop()
19195 
    oprot.writeStructEnd()
19196 
 
19197 
  def validate(self):
19198 
    return
19199 
 
19200 
 
19201 
  def __repr__(self):
19202 
    L = ['%s=%r' % (key, value)
19203 
      for key, value in self.__dict__.iteritems()]
19204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19205 
 
19206 
  def __eq__(self, other):
19207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19208 
 
19209 
  def __ne__(self, other):
19210 
    return not (self == other)
19211 
 
19212 
class getEBSSettlementDate_args:
19213 
  """
19214 
  Attributes:
19215 
   - settlementId
19216 
  """
19217 
 
19218 
  thrift_spec = (
19219 
    None, # 0
19220 
    (1, TType.I64, 'settlementId', None, None, ), # 1
19221 
  )
19222 
 
19223 
  def __init__(self, settlementId=None,):
19224 
    self.settlementId = settlementId
19225 
 
19226 
  def read(self, iprot):
19227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19229 
      return
19230 
    iprot.readStructBegin()
19231 
    while True:
19232 
      (fname, ftype, fid) = iprot.readFieldBegin()
19233 
      if ftype == TType.STOP:
19234 
        break
19235 
      if fid == 1:
19236 
        if ftype == TType.I64:
19237 
          self.settlementId = iprot.readI64();
19238 
        else:
19239 
          iprot.skip(ftype)
19240 
      else:
19241 
        iprot.skip(ftype)
19242 
      iprot.readFieldEnd()
19243 
    iprot.readStructEnd()
19244 
 
19245 
  def write(self, oprot):
19246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19248 
      return
19249 
    oprot.writeStructBegin('getEBSSettlementDate_args')
19250 
    if self.settlementId is not None:
19251 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
19252 
      oprot.writeI64(self.settlementId)
19253 
      oprot.writeFieldEnd()
19254 
    oprot.writeFieldStop()
19255 
    oprot.writeStructEnd()
19256 
 
19257 
  def validate(self):
19258 
    return
19259 
 
19260 
 
19261 
  def __repr__(self):
19262 
    L = ['%s=%r' % (key, value)
19263 
      for key, value in self.__dict__.iteritems()]
19264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19265 
 
19266 
  def __eq__(self, other):
19267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19268 
 
19269 
  def __ne__(self, other):
19270 
    return not (self == other)
19271 
 
19272 
class getEBSSettlementDate_result:
19273 
  """
19274 
  Attributes:
19275 
   - success
19276 
   - ex
19277 
  """
19278 
 
19279 
  thrift_spec = (
19280 
    (0, TType.I64, 'success', None, None, ), # 0
19281 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19282 
  )
19283 
 
19284 
  def __init__(self, success=None, ex=None,):
19285 
    self.success = success
19286 
    self.ex = ex
19287 
 
19288 
  def read(self, iprot):
19289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19291 
      return
19292 
    iprot.readStructBegin()
19293 
    while True:
19294 
      (fname, ftype, fid) = iprot.readFieldBegin()
19295 
      if ftype == TType.STOP:
19296 
        break
19297 
      if fid == 0:
19298 
        if ftype == TType.I64:
19299 
          self.success = iprot.readI64();
19300 
        else:
19301 
          iprot.skip(ftype)
19302 
      elif fid == 1:
19303 
        if ftype == TType.STRUCT:
19304 
          self.ex = TransactionServiceException()
19305 
          self.ex.read(iprot)
19306 
        else:
19307 
          iprot.skip(ftype)
19308 
      else:
19309 
        iprot.skip(ftype)
19310 
      iprot.readFieldEnd()
19311 
    iprot.readStructEnd()
19312 
 
19313 
  def write(self, oprot):
19314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19316 
      return
19317 
    oprot.writeStructBegin('getEBSSettlementDate_result')
19318 
    if self.success is not None:
19319 
      oprot.writeFieldBegin('success', TType.I64, 0)
19320 
      oprot.writeI64(self.success)
19321 
      oprot.writeFieldEnd()
19322 
    if self.ex is not None:
19323 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19324 
      self.ex.write(oprot)
19325 
      oprot.writeFieldEnd()
19326 
    oprot.writeFieldStop()
19327 
    oprot.writeStructEnd()
19328 
 
19329 
  def validate(self):
19330 
    return
19331 
 
19332 
 
19333 
  def __repr__(self):
19334 
    L = ['%s=%r' % (key, value)
19335 
      for key, value in self.__dict__.iteritems()]
19336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19337 
 
19338 
  def __eq__(self, other):
19339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19340 
 
19341 
  def __ne__(self, other):
19342 
    return not (self == other)
4715 varun.gupt 19343 
 
19344 
class getSettlementsByDate_args:
19345 
  """
19346 
  Attributes:
19347 
   - settlementDateFrom
19348 
   - settlementDateTo
19349 
   - isRefund
19350 
  """
19351 
 
19352 
  thrift_spec = (
19353 
    None, # 0
19354 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
19355 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
19356 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
19357 
  )
19358 
 
19359 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
19360 
    self.settlementDateFrom = settlementDateFrom
19361 
    self.settlementDateTo = settlementDateTo
19362 
    self.isRefund = isRefund
19363 
 
19364 
  def read(self, iprot):
19365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19367 
      return
19368 
    iprot.readStructBegin()
19369 
    while True:
19370 
      (fname, ftype, fid) = iprot.readFieldBegin()
19371 
      if ftype == TType.STOP:
19372 
        break
19373 
      if fid == 1:
19374 
        if ftype == TType.I64:
19375 
          self.settlementDateFrom = iprot.readI64();
19376 
        else:
19377 
          iprot.skip(ftype)
19378 
      elif fid == 2:
19379 
        if ftype == TType.I64:
19380 
          self.settlementDateTo = iprot.readI64();
19381 
        else:
19382 
          iprot.skip(ftype)
19383 
      elif fid == 3:
19384 
        if ftype == TType.BOOL:
19385 
          self.isRefund = iprot.readBool();
19386 
        else:
19387 
          iprot.skip(ftype)
19388 
      else:
19389 
        iprot.skip(ftype)
19390 
      iprot.readFieldEnd()
19391 
    iprot.readStructEnd()
19392 
 
19393 
  def write(self, oprot):
19394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19396 
      return
19397 
    oprot.writeStructBegin('getSettlementsByDate_args')
19398 
    if self.settlementDateFrom is not None:
19399 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
19400 
      oprot.writeI64(self.settlementDateFrom)
19401 
      oprot.writeFieldEnd()
19402 
    if self.settlementDateTo is not None:
19403 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
19404 
      oprot.writeI64(self.settlementDateTo)
19405 
      oprot.writeFieldEnd()
19406 
    if self.isRefund is not None:
19407 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
19408 
      oprot.writeBool(self.isRefund)
19409 
      oprot.writeFieldEnd()
19410 
    oprot.writeFieldStop()
19411 
    oprot.writeStructEnd()
19412 
 
19413 
  def validate(self):
19414 
    return
19415 
 
19416 
 
19417 
  def __repr__(self):
19418 
    L = ['%s=%r' % (key, value)
19419 
      for key, value in self.__dict__.iteritems()]
19420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19421 
 
19422 
  def __eq__(self, other):
19423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19424 
 
19425 
  def __ne__(self, other):
19426 
    return not (self == other)
19427 
 
19428 
class getSettlementsByDate_result:
19429 
  """
19430 
  Attributes:
19431 
   - success
19432 
   - ex
19433 
  """
19434 
 
19435 
  thrift_spec = (
19436 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
19437 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19438 
  )
19439 
 
19440 
  def __init__(self, success=None, ex=None,):
19441 
    self.success = success
19442 
    self.ex = ex
19443 
 
19444 
  def read(self, iprot):
19445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19447 
      return
19448 
    iprot.readStructBegin()
19449 
    while True:
19450 
      (fname, ftype, fid) = iprot.readFieldBegin()
19451 
      if ftype == TType.STOP:
19452 
        break
19453 
      if fid == 0:
19454 
        if ftype == TType.LIST:
19455 
          self.success = []
4837 varun.gupt 19456 
          (_etype391, _size388) = iprot.readListBegin()
19457 
          for _i392 in xrange(_size388):
19458 
            _elem393 = PaymentSettlement()
19459 
            _elem393.read(iprot)
19460 
            self.success.append(_elem393)
4715 varun.gupt 19461 
          iprot.readListEnd()
19462 
        else:
19463 
          iprot.skip(ftype)
19464 
      elif fid == 1:
19465 
        if ftype == TType.STRUCT:
19466 
          self.ex = TransactionServiceException()
19467 
          self.ex.read(iprot)
19468 
        else:
19469 
          iprot.skip(ftype)
19470 
      else:
19471 
        iprot.skip(ftype)
19472 
      iprot.readFieldEnd()
19473 
    iprot.readStructEnd()
19474 
 
19475 
  def write(self, oprot):
19476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19478 
      return
19479 
    oprot.writeStructBegin('getSettlementsByDate_result')
19480 
    if self.success is not None:
19481 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19482 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4837 varun.gupt 19483 
      for iter394 in self.success:
19484 
        iter394.write(oprot)
4715 varun.gupt 19485 
      oprot.writeListEnd()
19486 
      oprot.writeFieldEnd()
19487 
    if self.ex is not None:
19488 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19489 
      self.ex.write(oprot)
19490 
      oprot.writeFieldEnd()
19491 
    oprot.writeFieldStop()
19492 
    oprot.writeStructEnd()
19493 
 
19494 
  def validate(self):
19495 
    return
19496 
 
19497 
 
19498 
  def __repr__(self):
19499 
    L = ['%s=%r' % (key, value)
19500 
      for key, value in self.__dict__.iteritems()]
19501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19502 
 
19503 
  def __eq__(self, other):
19504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19505 
 
19506 
  def __ne__(self, other):
19507 
    return not (self == other)
19508 
 
19509 
class getReshippedOrderIds_args:
19510 
  """
19511 
  Attributes:
19512 
   - orderIds
19513 
  """
19514 
 
19515 
  thrift_spec = (
19516 
    None, # 0
19517 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
19518 
  )
19519 
 
19520 
  def __init__(self, orderIds=None,):
19521 
    self.orderIds = orderIds
19522 
 
19523 
  def read(self, iprot):
19524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19526 
      return
19527 
    iprot.readStructBegin()
19528 
    while True:
19529 
      (fname, ftype, fid) = iprot.readFieldBegin()
19530 
      if ftype == TType.STOP:
19531 
        break
19532 
      if fid == 1:
19533 
        if ftype == TType.LIST:
19534 
          self.orderIds = []
4837 varun.gupt 19535 
          (_etype398, _size395) = iprot.readListBegin()
19536 
          for _i399 in xrange(_size395):
19537 
            _elem400 = iprot.readI64();
19538 
            self.orderIds.append(_elem400)
4715 varun.gupt 19539 
          iprot.readListEnd()
19540 
        else:
19541 
          iprot.skip(ftype)
19542 
      else:
19543 
        iprot.skip(ftype)
19544 
      iprot.readFieldEnd()
19545 
    iprot.readStructEnd()
19546 
 
19547 
  def write(self, oprot):
19548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19550 
      return
19551 
    oprot.writeStructBegin('getReshippedOrderIds_args')
19552 
    if self.orderIds is not None:
19553 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
19554 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
4837 varun.gupt 19555 
      for iter401 in self.orderIds:
19556 
        oprot.writeI64(iter401)
4715 varun.gupt 19557 
      oprot.writeListEnd()
19558 
      oprot.writeFieldEnd()
19559 
    oprot.writeFieldStop()
19560 
    oprot.writeStructEnd()
19561 
 
19562 
  def validate(self):
19563 
    return
19564 
 
19565 
 
19566 
  def __repr__(self):
19567 
    L = ['%s=%r' % (key, value)
19568 
      for key, value in self.__dict__.iteritems()]
19569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19570 
 
19571 
  def __eq__(self, other):
19572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19573 
 
19574 
  def __ne__(self, other):
19575 
    return not (self == other)
19576 
 
19577 
class getReshippedOrderIds_result:
19578 
  """
19579 
  Attributes:
19580 
   - success
19581 
   - ex
19582 
  """
19583 
 
19584 
  thrift_spec = (
19585 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19586 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19587 
  )
19588 
 
19589 
  def __init__(self, success=None, ex=None,):
19590 
    self.success = success
19591 
    self.ex = ex
19592 
 
19593 
  def read(self, iprot):
19594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19596 
      return
19597 
    iprot.readStructBegin()
19598 
    while True:
19599 
      (fname, ftype, fid) = iprot.readFieldBegin()
19600 
      if ftype == TType.STOP:
19601 
        break
19602 
      if fid == 0:
19603 
        if ftype == TType.LIST:
19604 
          self.success = []
4837 varun.gupt 19605 
          (_etype405, _size402) = iprot.readListBegin()
19606 
          for _i406 in xrange(_size402):
19607 
            _elem407 = iprot.readI64();
19608 
            self.success.append(_elem407)
4715 varun.gupt 19609 
          iprot.readListEnd()
19610 
        else:
19611 
          iprot.skip(ftype)
19612 
      elif fid == 1:
19613 
        if ftype == TType.STRUCT:
19614 
          self.ex = TransactionServiceException()
19615 
          self.ex.read(iprot)
19616 
        else:
19617 
          iprot.skip(ftype)
19618 
      else:
19619 
        iprot.skip(ftype)
19620 
      iprot.readFieldEnd()
19621 
    iprot.readStructEnd()
19622 
 
19623 
  def write(self, oprot):
19624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19626 
      return
19627 
    oprot.writeStructBegin('getReshippedOrderIds_result')
19628 
    if self.success is not None:
19629 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19630 
      oprot.writeListBegin(TType.I64, len(self.success))
4837 varun.gupt 19631 
      for iter408 in self.success:
19632 
        oprot.writeI64(iter408)
4715 varun.gupt 19633 
      oprot.writeListEnd()
19634 
      oprot.writeFieldEnd()
19635 
    if self.ex is not None:
19636 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19637 
      self.ex.write(oprot)
19638 
      oprot.writeFieldEnd()
19639 
    oprot.writeFieldStop()
19640 
    oprot.writeStructEnd()
19641 
 
19642 
  def validate(self):
19643 
    return
19644 
 
19645 
 
19646 
  def __repr__(self):
19647 
    L = ['%s=%r' % (key, value)
19648 
      for key, value in self.__dict__.iteritems()]
19649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19650 
 
19651 
  def __eq__(self, other):
19652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19653 
 
19654 
  def __ne__(self, other):
19655 
    return not (self == other)
4757 mandeep.dh 19656 
 
19657 
class updateOrdersAsPORaised_args:
19658 
  """
19659 
  Attributes:
19660 
   - itemIdQuantityMap
19661 
   - purchaseOrderId
19662 
   - warehouseId
19663 
  """
19664 
 
19665 
  thrift_spec = (
19666 
    None, # 0
19667 
    (1, TType.MAP, 'itemIdQuantityMap', (TType.I64,None,TType.I64,None), None, ), # 1
19668 
    (2, TType.I64, 'purchaseOrderId', None, None, ), # 2
19669 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
19670 
  )
19671 
 
19672 
  def __init__(self, itemIdQuantityMap=None, purchaseOrderId=None, warehouseId=None,):
19673 
    self.itemIdQuantityMap = itemIdQuantityMap
19674 
    self.purchaseOrderId = purchaseOrderId
19675 
    self.warehouseId = warehouseId
19676 
 
19677 
  def read(self, iprot):
19678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19680 
      return
19681 
    iprot.readStructBegin()
19682 
    while True:
19683 
      (fname, ftype, fid) = iprot.readFieldBegin()
19684 
      if ftype == TType.STOP:
19685 
        break
19686 
      if fid == 1:
19687 
        if ftype == TType.MAP:
19688 
          self.itemIdQuantityMap = {}
4837 varun.gupt 19689 
          (_ktype410, _vtype411, _size409 ) = iprot.readMapBegin()
19690 
          for _i413 in xrange(_size409):
19691 
            _key414 = iprot.readI64();
19692 
            _val415 = iprot.readI64();
19693 
            self.itemIdQuantityMap[_key414] = _val415
4757 mandeep.dh 19694 
          iprot.readMapEnd()
19695 
        else:
19696 
          iprot.skip(ftype)
19697 
      elif fid == 2:
19698 
        if ftype == TType.I64:
19699 
          self.purchaseOrderId = iprot.readI64();
19700 
        else:
19701 
          iprot.skip(ftype)
19702 
      elif fid == 3:
19703 
        if ftype == TType.I64:
19704 
          self.warehouseId = iprot.readI64();
19705 
        else:
19706 
          iprot.skip(ftype)
19707 
      else:
19708 
        iprot.skip(ftype)
19709 
      iprot.readFieldEnd()
19710 
    iprot.readStructEnd()
19711 
 
19712 
  def write(self, oprot):
19713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19715 
      return
19716 
    oprot.writeStructBegin('updateOrdersAsPORaised_args')
19717 
    if self.itemIdQuantityMap is not None:
19718 
      oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
19719 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
4837 varun.gupt 19720 
      for kiter416,viter417 in self.itemIdQuantityMap.items():
19721 
        oprot.writeI64(kiter416)
19722 
        oprot.writeI64(viter417)
4757 mandeep.dh 19723 
      oprot.writeMapEnd()
19724 
      oprot.writeFieldEnd()
19725 
    if self.purchaseOrderId is not None:
19726 
      oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
19727 
      oprot.writeI64(self.purchaseOrderId)
19728 
      oprot.writeFieldEnd()
19729 
    if self.warehouseId is not None:
19730 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
19731 
      oprot.writeI64(self.warehouseId)
19732 
      oprot.writeFieldEnd()
19733 
    oprot.writeFieldStop()
19734 
    oprot.writeStructEnd()
19735 
 
19736 
  def validate(self):
19737 
    return
19738 
 
19739 
 
19740 
  def __repr__(self):
19741 
    L = ['%s=%r' % (key, value)
19742 
      for key, value in self.__dict__.iteritems()]
19743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19744 
 
19745 
  def __eq__(self, other):
19746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19747 
 
19748 
  def __ne__(self, other):
19749 
    return not (self == other)
19750 
 
19751 
class updateOrdersAsPORaised_result:
19752 
  """
19753 
  Attributes:
19754 
   - ex
19755 
  """
19756 
 
19757 
  thrift_spec = (
19758 
    None, # 0
19759 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19760 
  )
19761 
 
19762 
  def __init__(self, ex=None,):
19763 
    self.ex = ex
19764 
 
19765 
  def read(self, iprot):
19766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19768 
      return
19769 
    iprot.readStructBegin()
19770 
    while True:
19771 
      (fname, ftype, fid) = iprot.readFieldBegin()
19772 
      if ftype == TType.STOP:
19773 
        break
19774 
      if fid == 1:
19775 
        if ftype == TType.STRUCT:
19776 
          self.ex = TransactionServiceException()
19777 
          self.ex.read(iprot)
19778 
        else:
19779 
          iprot.skip(ftype)
19780 
      else:
19781 
        iprot.skip(ftype)
19782 
      iprot.readFieldEnd()
19783 
    iprot.readStructEnd()
19784 
 
19785 
  def write(self, oprot):
19786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19788 
      return
19789 
    oprot.writeStructBegin('updateOrdersAsPORaised_result')
19790 
    if self.ex is not None:
19791 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19792 
      self.ex.write(oprot)
19793 
      oprot.writeFieldEnd()
19794 
    oprot.writeFieldStop()
19795 
    oprot.writeStructEnd()
19796 
 
19797 
  def validate(self):
19798 
    return
19799 
 
19800 
 
19801 
  def __repr__(self):
19802 
    L = ['%s=%r' % (key, value)
19803 
      for key, value in self.__dict__.iteritems()]
19804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19805 
 
19806 
  def __eq__(self, other):
19807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19808 
 
19809 
  def __ne__(self, other):
19810 
    return not (self == other)
4875 varun.gupt 19811 
 
19812 
class getOrdersWhereVendorNotPaid_args:
19813 
  """
19814 
  Attributes:
19815 
   - vendorId
19816 
  """
19817 
 
19818 
  thrift_spec = (
19819 
    None, # 0
19820 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19821 
  )
19822 
 
19823 
  def __init__(self, vendorId=None,):
19824 
    self.vendorId = vendorId
19825 
 
19826 
  def read(self, iprot):
19827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19829 
      return
19830 
    iprot.readStructBegin()
19831 
    while True:
19832 
      (fname, ftype, fid) = iprot.readFieldBegin()
19833 
      if ftype == TType.STOP:
19834 
        break
19835 
      if fid == 1:
19836 
        if ftype == TType.I64:
19837 
          self.vendorId = iprot.readI64();
19838 
        else:
19839 
          iprot.skip(ftype)
19840 
      else:
19841 
        iprot.skip(ftype)
19842 
      iprot.readFieldEnd()
19843 
    iprot.readStructEnd()
19844 
 
19845 
  def write(self, oprot):
19846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19848 
      return
19849 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_args')
19850 
    if self.vendorId is not None:
19851 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19852 
      oprot.writeI64(self.vendorId)
19853 
      oprot.writeFieldEnd()
19854 
    oprot.writeFieldStop()
19855 
    oprot.writeStructEnd()
19856 
 
19857 
  def validate(self):
19858 
    return
19859 
 
19860 
 
19861 
  def __repr__(self):
19862 
    L = ['%s=%r' % (key, value)
19863 
      for key, value in self.__dict__.iteritems()]
19864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19865 
 
19866 
  def __eq__(self, other):
19867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19868 
 
19869 
  def __ne__(self, other):
19870 
    return not (self == other)
19871 
 
19872 
class getOrdersWhereVendorNotPaid_result:
19873 
  """
19874 
  Attributes:
19875 
   - success
19876 
   - ex
19877 
  """
19878 
 
19879 
  thrift_spec = (
19880 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19881 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19882 
  )
19883 
 
19884 
  def __init__(self, success=None, ex=None,):
19885 
    self.success = success
19886 
    self.ex = ex
19887 
 
19888 
  def read(self, iprot):
19889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19891 
      return
19892 
    iprot.readStructBegin()
19893 
    while True:
19894 
      (fname, ftype, fid) = iprot.readFieldBegin()
19895 
      if ftype == TType.STOP:
19896 
        break
19897 
      if fid == 0:
19898 
        if ftype == TType.LIST:
19899 
          self.success = []
19900 
          (_etype421, _size418) = iprot.readListBegin()
19901 
          for _i422 in xrange(_size418):
19902 
            _elem423 = Order()
19903 
            _elem423.read(iprot)
19904 
            self.success.append(_elem423)
19905 
          iprot.readListEnd()
19906 
        else:
19907 
          iprot.skip(ftype)
19908 
      elif fid == 1:
19909 
        if ftype == TType.STRUCT:
19910 
          self.ex = TransactionServiceException()
19911 
          self.ex.read(iprot)
19912 
        else:
19913 
          iprot.skip(ftype)
19914 
      else:
19915 
        iprot.skip(ftype)
19916 
      iprot.readFieldEnd()
19917 
    iprot.readStructEnd()
19918 
 
19919 
  def write(self, oprot):
19920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19922 
      return
19923 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_result')
19924 
    if self.success is not None:
19925 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19926 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
19927 
      for iter424 in self.success:
19928 
        iter424.write(oprot)
19929 
      oprot.writeListEnd()
19930 
      oprot.writeFieldEnd()
19931 
    if self.ex is not None:
19932 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19933 
      self.ex.write(oprot)
19934 
      oprot.writeFieldEnd()
19935 
    oprot.writeFieldStop()
19936 
    oprot.writeStructEnd()
19937 
 
19938 
  def validate(self):
19939 
    return
19940 
 
19941 
 
19942 
  def __repr__(self):
19943 
    L = ['%s=%r' % (key, value)
19944 
      for key, value in self.__dict__.iteritems()]
19945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19946 
 
19947 
  def __eq__(self, other):
19948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19949 
 
19950 
  def __ne__(self, other):
19951 
    return not (self == other)