Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
483 rajveer 74 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
483 rajveer 77 
     - status
78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
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 
 
4658 mandeep.dh 318 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
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
3064 chandransh 336 
    """
337 
    pass
338 
 
4579 rajveer 339 
  def addInvoiceNumber(self, orderId, invoiceNumber):
340 
    """
341 
    Add the invoice number to the order.
342 
 
343 
    Parameters:
344 
     - orderId
345 
     - invoiceNumber
346 
    """
347 
    pass
348 
 
3064 chandransh 349 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
350 
    """
351 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 352 
    given warehouse and were picked up by the given provider as MANIFESTED.
353 
 
354 
    Parameters:
355 
     - warehouseId
356 
     - providerId
357 
     - cod
358 
    """
359 
    pass
360 
 
361 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
362 
    """
363 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
3064 chandransh 364 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 365 
 
3064 chandransh 366 
    Parameters:
759 chandransh 367 
     - warehouseId
368 
     - providerId
3064 chandransh 369 
     - cod
759 chandransh 370 
    """
371 
    pass
372 
 
1113 chandransh 373 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
374 
    """
375 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
376 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
377 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 378 
 
1113 chandransh 379 
    Parameters:
380 
     - providerId
381 
     - pickupDetails
382 
    """
383 
    pass
384 
 
1132 chandransh 385 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
386 
    """
387 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
388 
    the name of the receiver.
389 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 390 
 
1132 chandransh 391 
    Parameters:
392 
     - providerId
393 
     - deliveredOrders
394 
    """
395 
    pass
396 
 
1135 chandransh 397 
  def markOrdersAsFailed(self, providerId, returnedOrders):
398 
    """
399 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
400 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 401 
 
1135 chandransh 402 
    Parameters:
403 
     - providerId
404 
     - returnedOrders
405 
    """
406 
    pass
407 
 
1246 chandransh 408 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
409 
    """
410 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 411 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 412 
 
1246 chandransh 413 
    Parameters:
414 
     - providerId
415 
     - undeliveredOrders
416 
    """
417 
    pass
418 
 
1408 ankur.sing 419 
  def getUndeliveredOrders(self, providerId, warehouseId):
420 
    """
421 
    Returns the list of orders whose delivery time has passed but have not been
422 
    delivered yet for the given provider and warehouse. To get a complete list of
423 
    undelivered orders, pass them as -1.
424 
    Returns an empty list if no such orders exist.
3431 rajveer 425 
 
1408 ankur.sing 426 
    Parameters:
427 
     - providerId
428 
     - warehouseId
429 
    """
430 
    pass
431 
 
2536 chandransh 432 
  def toggleDOAFlag(self, orderId):
433 
    """
434 
    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.
435 
    Returns the final flag status.
436 
    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 437 
 
2536 chandransh 438 
    Parameters:
439 
     - orderId
440 
    """
441 
    pass
1886 ankur.sing 442 
 
4712 rajveer 443 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
444 
    """
445 
    Parameters:
446 
     - orderId
447 
     - deliveryTimestamp
448 
     - receiver
449 
    """
450 
    pass
451 
 
4454 rajveer 452 
  def markOrderDoaRequestReceived(self, orderId):
453 
    """
454 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
455 
 
456 
    Parameters:
457 
     - orderId
458 
    """
459 
    pass
460 
 
461 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
462 
    """
463 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
464 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
465 
 
466 
    Parameters:
467 
     - orderId
468 
     - isAuthorized
469 
    """
470 
    pass
471 
 
4488 rajveer 472 
  def markOrderReturnRequestReceived(self, orderId):
473 
    """
474 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
475 
 
476 
    Parameters:
477 
     - orderId
478 
    """
479 
    pass
480 
 
481 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
482 
    """
483 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
484 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
485 
 
486 
    Parameters:
487 
     - orderId
488 
     - isAuthorized
489 
    """
490 
    pass
491 
 
4579 rajveer 492 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 493 
    """
494 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 495 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
496 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 497 
    For any other status, it returns false.
498 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 499 
 
2536 chandransh 500 
    Parameters:
501 
     - orderId
4579 rajveer 502 
     - providerId
2536 chandransh 503 
    """
504 
    pass
505 
 
4602 rajveer 506 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 507 
    """
4452 rajveer 508 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 509 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
510 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
511 
    	3. Returns true
2591 chandransh 512 
    If the order is in any other status, it returns false.
2536 chandransh 513 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 514 
 
2536 chandransh 515 
    Parameters:
516 
     - orderId
517 
     - pickupNumber
4602 rajveer 518 
     - providerId
2536 chandransh 519 
    """
520 
    pass
521 
 
2764 chandransh 522 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
523 
    """
524 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
525 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 526 
 
2764 chandransh 527 
    Parameters:
528 
     - providerId
529 
     - pickupDetails
530 
    """
531 
    pass
532 
 
4741 phani.kuma 533 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
534 
    """
535 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
536 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
537 
 
538 
    Parameters:
539 
     - providerId
540 
     - pickupDetails
541 
    """
542 
    pass
543 
 
4479 rajveer 544 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 545 
    """
4452 rajveer 546 
    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 547 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 548 
    If the order is in any other state, it returns false.
549 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 550 
 
2591 chandransh 551 
    Parameters:
552 
     - orderId
4479 rajveer 553 
     - receiveCondition
2591 chandransh 554 
    """
555 
    pass
2536 chandransh 556 
 
2591 chandransh 557 
  def validateDoa(self, orderId, isValid):
558 
    """
4452 rajveer 559 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 560 
    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 561 
    If the order is in any other state, it returns false.
562 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 563 
 
2591 chandransh 564 
    Parameters:
565 
     - orderId
566 
     - isValid
567 
    """
568 
    pass
569 
 
4495 rajveer 570 
  def validateReturnProduct(self, orderId, isUsable):
571 
    """
572 
    Parameters:
573 
     - orderId
574 
     - isUsable
575 
    """
576 
    pass
577 
 
2616 chandransh 578 
  def reshipOrder(self, orderId):
579 
    """
4484 rajveer 580 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 581 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 582 
    	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 583 
 
584 
    If the order is in DOA_CERT_VALID state, it does the following:
585 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
586 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 587 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 588 
 
2616 chandransh 589 
    Returns the id of the newly created order.
3431 rajveer 590 
 
2616 chandransh 591 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 592 
 
2616 chandransh 593 
    Parameters:
594 
     - orderId
595 
    """
596 
    pass
2591 chandransh 597 
 
3226 chandransh 598 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 599 
    """
4484 rajveer 600 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 601 
    	1. Creates a refund request for batch processing.
602 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 603 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 604 
 
2616 chandransh 605 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
606 
    	1. Creates a refund request for batch processing.
3226 chandransh 607 
    	2. Cancels the reservation of the item in the warehouse.
608 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 609 
 
3226 chandransh 610 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
611 
    	1. Cancels the reservation of the item in the warehouse.
612 
    	2. Marks the current order as CANCELED.
613 
 
614 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
615 
 
2616 chandransh 616 
    Returns True if it is successful, False otherwise.
3431 rajveer 617 
 
2616 chandransh 618 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 619 
 
2616 chandransh 620 
    Parameters:
621 
     - orderId
3226 chandransh 622 
     - refundedBy
623 
     - reason
2616 chandransh 624 
    """
625 
    pass
626 
 
2690 chandransh 627 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
628 
    """
629 
    Get all return orders created between the from and to dates for the given warehouse.
630 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 631 
 
2690 chandransh 632 
    Parameters:
633 
     - warehouseId
634 
     - fromDate
635 
     - toDate
636 
    """
637 
    pass
2616 chandransh 638 
 
2700 chandransh 639 
  def getReturnOrder(self, id):
640 
    """
641 
    Returns the ReturnOrder corresponding to the given id.
642 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 643 
 
2700 chandransh 644 
    Parameters:
645 
     - id
646 
    """
647 
    pass
648 
 
2690 chandransh 649 
  def processReturn(self, returnOrderId):
650 
    """
651 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 652 
 
2690 chandransh 653 
    Parameters:
654 
     - returnOrderId
655 
    """
656 
    pass
657 
 
3451 chandransh 658 
  def updateWeight(self, orderId, weight):
659 
    """
660 
    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 661 
 
3451 chandransh 662 
    Parameters:
663 
     - orderId
664 
     - weight
665 
    """
666 
    pass
667 
 
3469 chandransh 668 
  def changeItem(self, orderId, itemId):
669 
    """
670 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
671 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 672 
 
3469 chandransh 673 
    Parameters:
674 
     - orderId
675 
     - itemId
676 
    """
677 
    pass
678 
 
679 
  def shiftToWarehouse(self, orderId, warehouseId):
680 
    """
681 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
682 
 
683 
    Parameters:
684 
     - orderId
685 
     - warehouseId
686 
    """
687 
    pass
688 
 
4647 rajveer 689 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 690 
    """
691 
    Adds the given delay reason to the given order.
3986 chandransh 692 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 693 
    Raises an exception if no order with the given id can be found.
3469 chandransh 694 
 
3553 chandransh 695 
    Parameters:
696 
     - orderId
697 
     - delayReason
3986 chandransh 698 
     - furtherDelay
4647 rajveer 699 
     - delayReasonText
3553 chandransh 700 
    """
701 
    pass
702 
 
3956 chandransh 703 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
704 
    """
705 
    Marks the COD orders with given AWB nos. as having been processed.
706 
    Updates the captured amount for the corresponding payment.
3553 chandransh 707 
 
3956 chandransh 708 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
709 
    1. There is no order corresponding to an AWB number.
710 
    2. The captured amount for a payment exceeds the total payment.
711 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
712 
 
713 
    Parameters:
714 
     - collectedAmountMap
715 
     - xferBy
716 
     - xferTxnId
717 
     - xferDate
718 
    """
719 
    pass
720 
 
4008 mandeep.dh 721 
  def getTransactionsRequiringExtraProcessing(self, category):
722 
    """
4065 mandeep.dh 723 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 724 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 725 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 726 
 
4008 mandeep.dh 727 
    Parameters:
728 
     - category
729 
    """
730 
    pass
731 
 
732 
  def markTransactionAsProcessed(self, transactionId, category):
733 
    """
734 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 735 
    It essentially deletes the transaction id record for a particular
736 
    processing type category (if present) from DB.
737 
    This is currently used by CRM application.
4008 mandeep.dh 738 
 
739 
    Parameters:
740 
     - transactionId
741 
     - category
742 
    """
743 
    pass
744 
 
4018 chandransh 745 
  def getItemWiseRiskyOrdersCount(self, ):
746 
    """
747 
    Returns a map containing the number of risky orders keyed by item id. A risky order
748 
    is defined as one whose shipping date is about to expire.
749 
    """
750 
    pass
4008 mandeep.dh 751 
 
4295 varun.gupt 752 
  def getOrdersForItemIds(self, itemIds):
753 
    """
754 
    Returns a list of all orders which have items with given id
755 
 
756 
    Parameters:
757 
     - itemIds
758 
    """
759 
    pass
760 
 
4247 rajveer 761 
  def markOrderCancellationRequestReceived(self, orderId):
762 
    """
763 
    Mark order as cancellation request received. If customer sends request of cancellation of
764 
    a particular order, this method will be called. It will just change status of the order
765 
    depending on its current status. It also records the previous status, so that we can move
766 
    back to that status if cancellation request is denied.
4018 chandransh 767 
 
4247 rajveer 768 
    Parameters:
769 
     - orderId
770 
    """
771 
    pass
772 
 
773 
  def markOrderCancellationRequestConfirmed(self, orderId):
774 
    """
775 
    If we decide to to cancel order, CRM will call this method to move the status of order to
776 
    cancellation request confirmed. After this OM will be able to cancel the order.
777 
 
778 
    Parameters:
779 
     - orderId
780 
    """
781 
    pass
782 
 
783 
  def markOrderCancellationRequestDenied(self, orderId):
784 
    """
785 
    If we decide to not to cancel order, we will move the order ro previous status.
786 
 
787 
    Parameters:
788 
     - orderId
789 
    """
790 
    pass
791 
 
4258 rajveer 792 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 793 
    """
4258 rajveer 794 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
795 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 796 
 
797 
    Parameters:
4258 rajveer 798 
     - transactionId
4247 rajveer 799 
    """
800 
    pass
801 
 
4259 anupam.sin 802 
  def refundTransaction(self, transactionId, refundedBy, reason):
803 
    """
804 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
805 
    need to be cancelled
4247 rajveer 806 
 
4259 anupam.sin 807 
    Parameters:
808 
     - transactionId
809 
     - refundedBy
810 
     - reason
811 
    """
812 
    pass
813 
 
4324 mandeep.dh 814 
  def updateShipmentAddress(self, orderId, addressId):
815 
    """
816 
    Updates shipment address of an order. Delivery and shipping date estimates
817 
    etc. are also updated here.
818 
 
819 
    Throws TransactionServiceException in case address change is not
820 
    possible due to certain reasons such as new pincode in address is
821 
    not serviceable etc.
822 
 
823 
    Parameters:
824 
     - orderId
825 
     - addressId
826 
    """
827 
    pass
828 
 
4285 rajveer 829 
  def acceptOrdersForItemId(self, itemId, inventory):
830 
    """
831 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
832 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 833 
 
4285 rajveer 834 
    Parameters:
835 
     - itemId
836 
     - inventory
837 
    """
838 
    pass
839 
 
4369 rajveer 840 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 841 
    """
842 
    Parameters:
843 
     - vendorId
844 
     - itemId
845 
     - quantity
846 
     - estimate
4369 rajveer 847 
     - isReminder
4303 rajveer 848 
    """
849 
    pass
4285 rajveer 850 
 
4369 rajveer 851 
  def markOrdersAsReversalInitiated(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
861 
 
4369 rajveer 862 
  def markOrdersAsNotAvailabke(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 markOrdersAsTimeout(self, vendorId):
874 
    """
875 
    Parameters:
876 
     - vendorId
877 
    """
878 
    pass
4303 rajveer 879 
 
4662 rajveer 880 
  def markOrderAsLostInTransit(self, orderId):
881 
    """
882 
    Mark order as LOST_IN_TRANSIT
883 
 
884 
    Parameters:
885 
     - orderId
886 
    """
887 
    pass
888 
 
4386 anupam.sin 889 
  def getOrderForAwb(self, awb):
890 
    """
891 
    Returns the order corresponding to an AWB number
4369 rajveer 892 
 
4386 anupam.sin 893 
    Parameters:
894 
     - awb
895 
    """
896 
    pass
897 
 
4506 phani.kuma 898 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
899 
    """
900 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 901 
 
4506 phani.kuma 902 
    Parameters:
903 
     - logistics_provider_id
904 
     - order_status
905 
    """
906 
    pass
907 
 
4600 varun.gupt 908 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
909 
    """
910 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 911 
 
4600 varun.gupt 912 
    Parameters:
913 
     - vendorId
914 
     - billingDateFrom
915 
     - billingDateTo
916 
    """
917 
    pass
918 
 
4607 rajveer 919 
  def getSlippedSippingDateOrders(self, ):
920 
    pass
921 
 
4709 rajveer 922 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
923 
    """
924 
    Parameters:
925 
     - cancelDateFrom
926 
     - cancelDateTo
927 
    """
928 
    pass
929 
 
4600 varun.gupt 930 
  def saveBluedartSettlements(self, mapAWBAndAmount):
931 
    """
932 
    Parameters:
933 
     - mapAWBAndAmount
934 
    """
935 
    pass
936 
 
937 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
938 
    """
939 
    Parameters:
940 
     - settlementDate
941 
     - paymentGatewayId
942 
     - paymentId
943 
     - serviceTax
944 
     - otherCharges
945 
     - netCollection
946 
    """
947 
    pass
948 
 
949 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
950 
    """
951 
    Parameters:
952 
     - settlementId
953 
     - settlementDate
954 
     - transactionDateFrom
955 
     - transactionDateTo
956 
     - amount
957 
    """
958 
    pass
959 
 
960 
  def getSettlementForPaymentId(self, paymentId):
961 
    """
962 
    Parameters:
963 
     - paymentId
964 
    """
965 
    pass
966 
 
967 
  def getEBSSettlementSummaries(self, ):
968 
    pass
969 
 
970 
  def markEBSSettlementUploaded(self, settlementId):
971 
    """
972 
    Parameters:
973 
     - settlementId
974 
    """
975 
    pass
976 
 
977 
  def getEBSSettlementDate(self, settlementId):
978 
    """
979 
    Parameters:
980 
     - settlementId
981 
    """
982 
    pass
983 
 
4715 varun.gupt 984 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
985 
    """
986 
    Parameters:
987 
     - settlementDateFrom
988 
     - settlementDateTo
989 
     - isRefund
990 
    """
991 
    pass
4600 varun.gupt 992 
 
4715 varun.gupt 993 
  def getReshippedOrderIds(self, orderIds):
994 
    """
995 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
996 
 
997 
    Parameters:
998 
     - orderIds
999 
    """
1000 
    pass
1001 
 
4757 mandeep.dh 1002 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
1003 
    """
1004 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
1005 
    the quantities for which the PO is raised.
4715 varun.gupt 1006 
 
4757 mandeep.dh 1007 
    Parameters:
1008 
     - itemIdQuantityMap
1009 
     - purchaseOrderId
1010 
     - warehouseId
1011 
    """
1012 
    pass
1013 
 
1014 
 
3376 rajveer 1015 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1016 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1017 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1018 
 
1019 
  def createTransaction(self, transaction):
1020 
    """
1021 
    Parameters:
1022 
     - transaction
1023 
    """
1024 
    self.send_createTransaction(transaction)
132 ashish 1025 
    return self.recv_createTransaction()
94 ashish 1026 
 
1027 
  def send_createTransaction(self, transaction):
1028 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1029 
    args = createTransaction_args()
1030 
    args.transaction = transaction
1031 
    args.write(self._oprot)
1032 
    self._oprot.writeMessageEnd()
1033 
    self._oprot.trans.flush()
1034 
 
1035 
  def recv_createTransaction(self, ):
1036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1037 
    if mtype == TMessageType.EXCEPTION:
1038 
      x = TApplicationException()
1039 
      x.read(self._iprot)
1040 
      self._iprot.readMessageEnd()
1041 
      raise x
1042 
    result = createTransaction_result()
1043 
    result.read(self._iprot)
1044 
    self._iprot.readMessageEnd()
3431 rajveer 1045 
    if result.success is not None:
132 ashish 1046 
      return result.success
3431 rajveer 1047 
    if result.ex is not None:
94 ashish 1048 
      raise result.ex
132 ashish 1049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1050 
 
1051 
  def getTransaction(self, id):
1052 
    """
1053 
    Parameters:
1054 
     - id
1055 
    """
1056 
    self.send_getTransaction(id)
1057 
    return self.recv_getTransaction()
1058 
 
1059 
  def send_getTransaction(self, id):
1060 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1061 
    args = getTransaction_args()
1062 
    args.id = id
1063 
    args.write(self._oprot)
1064 
    self._oprot.writeMessageEnd()
1065 
    self._oprot.trans.flush()
1066 
 
1067 
  def recv_getTransaction(self, ):
1068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1069 
    if mtype == TMessageType.EXCEPTION:
1070 
      x = TApplicationException()
1071 
      x.read(self._iprot)
1072 
      self._iprot.readMessageEnd()
1073 
      raise x
1074 
    result = getTransaction_result()
1075 
    result.read(self._iprot)
1076 
    self._iprot.readMessageEnd()
3431 rajveer 1077 
    if result.success is not None:
94 ashish 1078 
      return result.success
3431 rajveer 1079 
    if result.ex is not None:
94 ashish 1080 
      raise result.ex
1081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1082 
 
1083 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1084 
    """
1085 
    Parameters:
1086 
     - customerId
1087 
     - from_date
1088 
     - to_date
1089 
     - status
1090 
    """
1091 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1092 
    return self.recv_getTransactionsForCustomer()
1093 
 
1094 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1095 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1096 
    args = getTransactionsForCustomer_args()
1097 
    args.customerId = customerId
1098 
    args.from_date = from_date
1099 
    args.to_date = to_date
1100 
    args.status = status
1101 
    args.write(self._oprot)
1102 
    self._oprot.writeMessageEnd()
1103 
    self._oprot.trans.flush()
1104 
 
1105 
  def recv_getTransactionsForCustomer(self, ):
1106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1107 
    if mtype == TMessageType.EXCEPTION:
1108 
      x = TApplicationException()
1109 
      x.read(self._iprot)
1110 
      self._iprot.readMessageEnd()
1111 
      raise x
1112 
    result = getTransactionsForCustomer_result()
1113 
    result.read(self._iprot)
1114 
    self._iprot.readMessageEnd()
3431 rajveer 1115 
    if result.success is not None:
94 ashish 1116 
      return result.success
3431 rajveer 1117 
    if result.ex is not None:
94 ashish 1118 
      raise result.ex
1119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1120 
 
132 ashish 1121 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1122 
    """
1123 
    Parameters:
1124 
     - shoppingCartId
1125 
    """
1126 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1127 
    return self.recv_getTransactionsForShoppingCartId()
1128 
 
1129 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1130 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1131 
    args = getTransactionsForShoppingCartId_args()
1132 
    args.shoppingCartId = shoppingCartId
1133 
    args.write(self._oprot)
1134 
    self._oprot.writeMessageEnd()
1135 
    self._oprot.trans.flush()
1136 
 
1137 
  def recv_getTransactionsForShoppingCartId(self, ):
1138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1139 
    if mtype == TMessageType.EXCEPTION:
1140 
      x = TApplicationException()
1141 
      x.read(self._iprot)
1142 
      self._iprot.readMessageEnd()
1143 
      raise x
1144 
    result = getTransactionsForShoppingCartId_result()
1145 
    result.read(self._iprot)
1146 
    self._iprot.readMessageEnd()
3431 rajveer 1147 
    if result.success is not None:
132 ashish 1148 
      return result.success
3431 rajveer 1149 
    if result.ex is not None:
132 ashish 1150 
      raise result.ex
1151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1152 
 
94 ashish 1153 
  def getTransactionStatus(self, transactionId):
1154 
    """
1155 
    Parameters:
1156 
     - transactionId
1157 
    """
1158 
    self.send_getTransactionStatus(transactionId)
1159 
    return self.recv_getTransactionStatus()
1160 
 
1161 
  def send_getTransactionStatus(self, transactionId):
1162 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1163 
    args = getTransactionStatus_args()
1164 
    args.transactionId = transactionId
1165 
    args.write(self._oprot)
1166 
    self._oprot.writeMessageEnd()
1167 
    self._oprot.trans.flush()
1168 
 
1169 
  def recv_getTransactionStatus(self, ):
1170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1171 
    if mtype == TMessageType.EXCEPTION:
1172 
      x = TApplicationException()
1173 
      x.read(self._iprot)
1174 
      self._iprot.readMessageEnd()
1175 
      raise x
1176 
    result = getTransactionStatus_result()
1177 
    result.read(self._iprot)
1178 
    self._iprot.readMessageEnd()
3431 rajveer 1179 
    if result.success is not None:
94 ashish 1180 
      return result.success
3431 rajveer 1181 
    if result.ex is not None:
94 ashish 1182 
      raise result.ex
1183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1184 
 
1185 
  def changeTransactionStatus(self, transactionId, status, description):
1186 
    """
1187 
    Parameters:
1188 
     - transactionId
1189 
     - status
1190 
     - description
1191 
    """
1192 
    self.send_changeTransactionStatus(transactionId, status, description)
1193 
    return self.recv_changeTransactionStatus()
1194 
 
1195 
  def send_changeTransactionStatus(self, transactionId, status, description):
1196 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1197 
    args = changeTransactionStatus_args()
1198 
    args.transactionId = transactionId
1199 
    args.status = status
1200 
    args.description = description
1201 
    args.write(self._oprot)
1202 
    self._oprot.writeMessageEnd()
1203 
    self._oprot.trans.flush()
1204 
 
1205 
  def recv_changeTransactionStatus(self, ):
1206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1207 
    if mtype == TMessageType.EXCEPTION:
1208 
      x = TApplicationException()
1209 
      x.read(self._iprot)
1210 
      self._iprot.readMessageEnd()
1211 
      raise x
1212 
    result = changeTransactionStatus_result()
1213 
    result.read(self._iprot)
1214 
    self._iprot.readMessageEnd()
3431 rajveer 1215 
    if result.success is not None:
94 ashish 1216 
      return result.success
3431 rajveer 1217 
    if result.ex is not None:
94 ashish 1218 
      raise result.ex
1219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1220 
 
1398 varun.gupt 1221 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1222 
    """
1223 
    Parameters:
1224 
     - transactionId
1225 
    """
1398 varun.gupt 1226 
    self.send_enqueueTransactionInfoEmail(transactionId)
1227 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1228 
 
1398 varun.gupt 1229 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1230 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1231 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1232 
    args.transactionId = transactionId
1233 
    args.write(self._oprot)
1234 
    self._oprot.writeMessageEnd()
1235 
    self._oprot.trans.flush()
1236 
 
1398 varun.gupt 1237 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1239 
    if mtype == TMessageType.EXCEPTION:
1240 
      x = TApplicationException()
1241 
      x.read(self._iprot)
1242 
      self._iprot.readMessageEnd()
1243 
      raise x
1398 varun.gupt 1244 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1245 
    result.read(self._iprot)
1246 
    self._iprot.readMessageEnd()
3431 rajveer 1247 
    if result.success is not None:
1382 varun.gupt 1248 
      return result.success
3431 rajveer 1249 
    if result.ex is not None:
1382 varun.gupt 1250 
      raise result.ex
1398 varun.gupt 1251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1252 
 
483 rajveer 1253 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1254 
    """
1255 
    Parameters:
483 rajveer 1256 
     - status
1257 
     - from_date
1258 
     - to_date
1259 
     - warehouse_id
94 ashish 1260 
    """
483 rajveer 1261 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1262 
    return self.recv_getAllOrders()
94 ashish 1263 
 
483 rajveer 1264 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1265 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1266 
    args = getAllOrders_args()
1267 
    args.status = status
1268 
    args.from_date = from_date
1269 
    args.to_date = to_date
1270 
    args.warehouse_id = warehouse_id
94 ashish 1271 
    args.write(self._oprot)
1272 
    self._oprot.writeMessageEnd()
1273 
    self._oprot.trans.flush()
1274 
 
483 rajveer 1275 
  def recv_getAllOrders(self, ):
94 ashish 1276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1277 
    if mtype == TMessageType.EXCEPTION:
1278 
      x = TApplicationException()
1279 
      x.read(self._iprot)
1280 
      self._iprot.readMessageEnd()
1281 
      raise x
483 rajveer 1282 
    result = getAllOrders_result()
94 ashish 1283 
    result.read(self._iprot)
1284 
    self._iprot.readMessageEnd()
3431 rajveer 1285 
    if result.success is not None:
94 ashish 1286 
      return result.success
3431 rajveer 1287 
    if result.ex is not None:
94 ashish 1288 
      raise result.ex
483 rajveer 1289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1290 
 
4133 chandransh 1291 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1292 
    """
1293 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1294 
    Pass the status as null and the limit as 0 to ignore them.
1295 
 
1296 
    Parameters:
1297 
     - statuses
1298 
     - offset
1299 
     - limit
1300 
     - warehouse_id
1301 
    """
1302 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1303 
    return self.recv_getOrdersInBatch()
1304 
 
1305 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1306 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1307 
    args = getOrdersInBatch_args()
1308 
    args.statuses = statuses
1309 
    args.offset = offset
1310 
    args.limit = limit
1311 
    args.warehouse_id = warehouse_id
1312 
    args.write(self._oprot)
1313 
    self._oprot.writeMessageEnd()
1314 
    self._oprot.trans.flush()
1315 
 
1316 
  def recv_getOrdersInBatch(self, ):
1317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1318 
    if mtype == TMessageType.EXCEPTION:
1319 
      x = TApplicationException()
1320 
      x.read(self._iprot)
1321 
      self._iprot.readMessageEnd()
1322 
      raise x
1323 
    result = getOrdersInBatch_result()
1324 
    result.read(self._iprot)
1325 
    self._iprot.readMessageEnd()
1326 
    if result.success is not None:
1327 
      return result.success
1328 
    if result.ex is not None:
1329 
      raise result.ex
1330 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1331 
 
1332 
  def getOrderCount(self, statuses, warehouseId):
1333 
    """
1334 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1335 
 
1336 
    Parameters:
1337 
     - statuses
1338 
     - warehouseId
1339 
    """
1340 
    self.send_getOrderCount(statuses, warehouseId)
1341 
    return self.recv_getOrderCount()
1342 
 
1343 
  def send_getOrderCount(self, statuses, warehouseId):
1344 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1345 
    args = getOrderCount_args()
1346 
    args.statuses = statuses
1347 
    args.warehouseId = warehouseId
1348 
    args.write(self._oprot)
1349 
    self._oprot.writeMessageEnd()
1350 
    self._oprot.trans.flush()
1351 
 
1352 
  def recv_getOrderCount(self, ):
1353 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1354 
    if mtype == TMessageType.EXCEPTION:
1355 
      x = TApplicationException()
1356 
      x.read(self._iprot)
1357 
      self._iprot.readMessageEnd()
1358 
      raise x
1359 
    result = getOrderCount_result()
1360 
    result.read(self._iprot)
1361 
    self._iprot.readMessageEnd()
1362 
    if result.success is not None:
1363 
      return result.success
1364 
    if result.ex is not None:
1365 
      raise result.ex
1366 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1367 
 
999 varun.gupt 1368 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1369 
    """
1132 chandransh 1370 
    Returns orders within a range of their billing dates
3431 rajveer 1371 
 
999 varun.gupt 1372 
    Parameters:
1373 
     - status
1374 
     - start_billing_date
1375 
     - end_billing_date
1376 
     - warehouse_id
1377 
    """
1378 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1379 
    return self.recv_getOrdersByBillingDate()
1380 
 
1381 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1382 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1383 
    args = getOrdersByBillingDate_args()
1384 
    args.status = status
1385 
    args.start_billing_date = start_billing_date
1386 
    args.end_billing_date = end_billing_date
1387 
    args.warehouse_id = warehouse_id
1388 
    args.write(self._oprot)
1389 
    self._oprot.writeMessageEnd()
1390 
    self._oprot.trans.flush()
1391 
 
1392 
  def recv_getOrdersByBillingDate(self, ):
1393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1394 
    if mtype == TMessageType.EXCEPTION:
1395 
      x = TApplicationException()
1396 
      x.read(self._iprot)
1397 
      self._iprot.readMessageEnd()
1398 
      raise x
1399 
    result = getOrdersByBillingDate_result()
1400 
    result.read(self._iprot)
1401 
    self._iprot.readMessageEnd()
3431 rajveer 1402 
    if result.success is not None:
999 varun.gupt 1403 
      return result.success
3431 rajveer 1404 
    if result.ex is not None:
999 varun.gupt 1405 
      raise result.ex
1406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1407 
 
3451 chandransh 1408 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1409 
    """
1410 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1411 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1412 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1413 
 
3427 chandransh 1414 
    Parameters:
1415 
     - fromShippingDate
1416 
     - toShippingDate
1417 
     - providerId
1418 
     - warehouseId
3451 chandransh 1419 
     - cod
3427 chandransh 1420 
    """
3451 chandransh 1421 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1422 
    return self.recv_getOrdersByShippingDate()
1423 
 
3451 chandransh 1424 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1425 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1426 
    args = getOrdersByShippingDate_args()
1427 
    args.fromShippingDate = fromShippingDate
1428 
    args.toShippingDate = toShippingDate
1429 
    args.providerId = providerId
1430 
    args.warehouseId = warehouseId
3451 chandransh 1431 
    args.cod = cod
3427 chandransh 1432 
    args.write(self._oprot)
1433 
    self._oprot.writeMessageEnd()
1434 
    self._oprot.trans.flush()
1435 
 
1436 
  def recv_getOrdersByShippingDate(self, ):
1437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1438 
    if mtype == TMessageType.EXCEPTION:
1439 
      x = TApplicationException()
1440 
      x.read(self._iprot)
1441 
      self._iprot.readMessageEnd()
1442 
      raise x
1443 
    result = getOrdersByShippingDate_result()
1444 
    result.read(self._iprot)
1445 
    self._iprot.readMessageEnd()
3431 rajveer 1446 
    if result.success is not None:
3427 chandransh 1447 
      return result.success
3431 rajveer 1448 
    if result.ex is not None:
3427 chandransh 1449 
      raise result.ex
1450 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1451 
 
1382 varun.gupt 1452 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1453 
    """
1454 
    Returns order ids for orders which can be returned
3431 rajveer 1455 
 
1382 varun.gupt 1456 
    Parameters:
1457 
     - customer_id
1458 
     - limit
1459 
    """
1460 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1461 
    return self.recv_getReturnableOrdersForCustomer()
1462 
 
1463 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1464 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1465 
    args = getReturnableOrdersForCustomer_args()
1466 
    args.customer_id = customer_id
1467 
    args.limit = limit
1468 
    args.write(self._oprot)
1469 
    self._oprot.writeMessageEnd()
1470 
    self._oprot.trans.flush()
1471 
 
1472 
  def recv_getReturnableOrdersForCustomer(self, ):
1473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1474 
    if mtype == TMessageType.EXCEPTION:
1475 
      x = TApplicationException()
1476 
      x.read(self._iprot)
1477 
      self._iprot.readMessageEnd()
1478 
      raise x
1479 
    result = getReturnableOrdersForCustomer_result()
1480 
    result.read(self._iprot)
1481 
    self._iprot.readMessageEnd()
3431 rajveer 1482 
    if result.success is not None:
1382 varun.gupt 1483 
      return result.success
3431 rajveer 1484 
    if result.ex is not None:
1382 varun.gupt 1485 
      raise result.ex
1486 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1487 
 
1488 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1489 
    """
1490 
    Returns order ids for orders which can be cancelled
3431 rajveer 1491 
 
1382 varun.gupt 1492 
    Parameters:
1493 
     - customer_id
1494 
     - limit
1495 
    """
1496 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1497 
    return self.recv_getCancellableOrdersForCustomer()
1498 
 
1499 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1500 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1501 
    args = getCancellableOrdersForCustomer_args()
1502 
    args.customer_id = customer_id
1503 
    args.limit = limit
1504 
    args.write(self._oprot)
1505 
    self._oprot.writeMessageEnd()
1506 
    self._oprot.trans.flush()
1507 
 
1508 
  def recv_getCancellableOrdersForCustomer(self, ):
1509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1510 
    if mtype == TMessageType.EXCEPTION:
1511 
      x = TApplicationException()
1512 
      x.read(self._iprot)
1513 
      self._iprot.readMessageEnd()
1514 
      raise x
1515 
    result = getCancellableOrdersForCustomer_result()
1516 
    result.read(self._iprot)
1517 
    self._iprot.readMessageEnd()
3431 rajveer 1518 
    if result.success is not None:
1382 varun.gupt 1519 
      return result.success
3431 rajveer 1520 
    if result.ex is not None:
1382 varun.gupt 1521 
      raise result.ex
1522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1523 
 
483 rajveer 1524 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1525 
    """
1526 
    Parameters:
483 rajveer 1527 
     - orderId
1528 
     - status
1529 
     - description
94 ashish 1530 
    """
483 rajveer 1531 
    self.send_changeOrderStatus(orderId, status, description)
1532 
    return self.recv_changeOrderStatus()
94 ashish 1533 
 
483 rajveer 1534 
  def send_changeOrderStatus(self, orderId, status, description):
1535 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1536 
    args = changeOrderStatus_args()
1537 
    args.orderId = orderId
1538 
    args.status = status
1539 
    args.description = description
94 ashish 1540 
    args.write(self._oprot)
1541 
    self._oprot.writeMessageEnd()
1542 
    self._oprot.trans.flush()
1543 
 
483 rajveer 1544 
  def recv_changeOrderStatus(self, ):
94 ashish 1545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1546 
    if mtype == TMessageType.EXCEPTION:
1547 
      x = TApplicationException()
1548 
      x.read(self._iprot)
1549 
      self._iprot.readMessageEnd()
1550 
      raise x
483 rajveer 1551 
    result = changeOrderStatus_result()
94 ashish 1552 
    result.read(self._iprot)
1553 
    self._iprot.readMessageEnd()
3431 rajveer 1554 
    if result.success is not None:
94 ashish 1555 
      return result.success
3431 rajveer 1556 
    if result.ex is not None:
94 ashish 1557 
      raise result.ex
483 rajveer 1558 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1559 
 
1528 ankur.sing 1560 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1561 
    """
1528 ankur.sing 1562 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1563 
    only user who owns the transaction can view its order details.
3431 rajveer 1564 
 
94 ashish 1565 
    Parameters:
1566 
     - transactionId
1528 ankur.sing 1567 
     - customerId
94 ashish 1568 
    """
1528 ankur.sing 1569 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1570 
    return self.recv_getOrdersForTransaction()
94 ashish 1571 
 
1528 ankur.sing 1572 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1573 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1574 
    args = getOrdersForTransaction_args()
94 ashish 1575 
    args.transactionId = transactionId
1528 ankur.sing 1576 
    args.customerId = customerId
94 ashish 1577 
    args.write(self._oprot)
1578 
    self._oprot.writeMessageEnd()
1579 
    self._oprot.trans.flush()
1580 
 
483 rajveer 1581 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1583 
    if mtype == TMessageType.EXCEPTION:
1584 
      x = TApplicationException()
1585 
      x.read(self._iprot)
1586 
      self._iprot.readMessageEnd()
1587 
      raise x
483 rajveer 1588 
    result = getOrdersForTransaction_result()
94 ashish 1589 
    result.read(self._iprot)
1590 
    self._iprot.readMessageEnd()
3431 rajveer 1591 
    if result.success is not None:
94 ashish 1592 
      return result.success
3431 rajveer 1593 
    if result.ex is not None:
94 ashish 1594 
      raise result.ex
483 rajveer 1595 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1596 
 
3014 chandransh 1597 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1598 
    """
3014 chandransh 1599 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1600 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1601 
 
94 ashish 1602 
    Parameters:
483 rajveer 1603 
     - customerId
1604 
     - from_date
1605 
     - to_date
3014 chandransh 1606 
     - statuses
94 ashish 1607 
    """
3014 chandransh 1608 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1609 
    return self.recv_getOrdersForCustomer()
94 ashish 1610 
 
3014 chandransh 1611 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1612 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1613 
    args = getOrdersForCustomer_args()
1614 
    args.customerId = customerId
1615 
    args.from_date = from_date
1616 
    args.to_date = to_date
3014 chandransh 1617 
    args.statuses = statuses
94 ashish 1618 
    args.write(self._oprot)
1619 
    self._oprot.writeMessageEnd()
1620 
    self._oprot.trans.flush()
1621 
 
483 rajveer 1622 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1623 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1624 
    if mtype == TMessageType.EXCEPTION:
1625 
      x = TApplicationException()
1626 
      x.read(self._iprot)
1627 
      self._iprot.readMessageEnd()
1628 
      raise x
483 rajveer 1629 
    result = getOrdersForCustomer_result()
94 ashish 1630 
    result.read(self._iprot)
1631 
    self._iprot.readMessageEnd()
3431 rajveer 1632 
    if result.success is not None:
94 ashish 1633 
      return result.success
3431 rajveer 1634 
    if result.ex is not None:
94 ashish 1635 
      raise result.ex
483 rajveer 1636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1637 
 
483 rajveer 1638 
  def createOrder(self, order):
94 ashish 1639 
    """
1640 
    Parameters:
483 rajveer 1641 
     - order
94 ashish 1642 
    """
483 rajveer 1643 
    self.send_createOrder(order)
1644 
    return self.recv_createOrder()
94 ashish 1645 
 
483 rajveer 1646 
  def send_createOrder(self, order):
1647 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1648 
    args = createOrder_args()
1649 
    args.order = order
94 ashish 1650 
    args.write(self._oprot)
1651 
    self._oprot.writeMessageEnd()
1652 
    self._oprot.trans.flush()
1653 
 
483 rajveer 1654 
  def recv_createOrder(self, ):
94 ashish 1655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1656 
    if mtype == TMessageType.EXCEPTION:
1657 
      x = TApplicationException()
1658 
      x.read(self._iprot)
1659 
      self._iprot.readMessageEnd()
1660 
      raise x
483 rajveer 1661 
    result = createOrder_result()
94 ashish 1662 
    result.read(self._iprot)
1663 
    self._iprot.readMessageEnd()
3431 rajveer 1664 
    if result.success is not None:
94 ashish 1665 
      return result.success
3431 rajveer 1666 
    if result.ex is not None:
94 ashish 1667 
      raise result.ex
483 rajveer 1668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1669 
 
483 rajveer 1670 
  def getOrder(self, id):
94 ashish 1671 
    """
1672 
    Parameters:
483 rajveer 1673 
     - id
94 ashish 1674 
    """
483 rajveer 1675 
    self.send_getOrder(id)
1676 
    return self.recv_getOrder()
94 ashish 1677 
 
483 rajveer 1678 
  def send_getOrder(self, id):
1679 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1680 
    args = getOrder_args()
1681 
    args.id = id
94 ashish 1682 
    args.write(self._oprot)
1683 
    self._oprot.writeMessageEnd()
1684 
    self._oprot.trans.flush()
1685 
 
483 rajveer 1686 
  def recv_getOrder(self, ):
94 ashish 1687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1688 
    if mtype == TMessageType.EXCEPTION:
1689 
      x = TApplicationException()
1690 
      x.read(self._iprot)
1691 
      self._iprot.readMessageEnd()
1692 
      raise x
483 rajveer 1693 
    result = getOrder_result()
94 ashish 1694 
    result.read(self._iprot)
1695 
    self._iprot.readMessageEnd()
3431 rajveer 1696 
    if result.success is not None:
94 ashish 1697 
      return result.success
3431 rajveer 1698 
    if result.ex is not None:
94 ashish 1699 
      raise result.ex
483 rajveer 1700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1701 
 
483 rajveer 1702 
  def getLineItemsForOrder(self, orderId):
94 ashish 1703 
    """
1704 
    Parameters:
483 rajveer 1705 
     - orderId
94 ashish 1706 
    """
483 rajveer 1707 
    self.send_getLineItemsForOrder(orderId)
1708 
    return self.recv_getLineItemsForOrder()
94 ashish 1709 
 
483 rajveer 1710 
  def send_getLineItemsForOrder(self, orderId):
1711 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1712 
    args = getLineItemsForOrder_args()
1713 
    args.orderId = orderId
94 ashish 1714 
    args.write(self._oprot)
1715 
    self._oprot.writeMessageEnd()
1716 
    self._oprot.trans.flush()
1717 
 
483 rajveer 1718 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1720 
    if mtype == TMessageType.EXCEPTION:
1721 
      x = TApplicationException()
1722 
      x.read(self._iprot)
1723 
      self._iprot.readMessageEnd()
1724 
      raise x
483 rajveer 1725 
    result = getLineItemsForOrder_result()
94 ashish 1726 
    result.read(self._iprot)
1727 
    self._iprot.readMessageEnd()
3431 rajveer 1728 
    if result.success is not None:
94 ashish 1729 
      return result.success
3431 rajveer 1730 
    if result.ex is not None:
94 ashish 1731 
      raise result.ex
483 rajveer 1732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1733 
 
1528 ankur.sing 1734 
  def getOrderForCustomer(self, orderId, customerId):
1735 
    """
1736 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1737 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1738 
 
1528 ankur.sing 1739 
    Parameters:
1740 
     - orderId
1741 
     - customerId
1742 
    """
1743 
    self.send_getOrderForCustomer(orderId, customerId)
1744 
    return self.recv_getOrderForCustomer()
1745 
 
1746 
  def send_getOrderForCustomer(self, orderId, customerId):
1747 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1748 
    args = getOrderForCustomer_args()
1749 
    args.orderId = orderId
1750 
    args.customerId = customerId
1751 
    args.write(self._oprot)
1752 
    self._oprot.writeMessageEnd()
1753 
    self._oprot.trans.flush()
1754 
 
1755 
  def recv_getOrderForCustomer(self, ):
1756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1757 
    if mtype == TMessageType.EXCEPTION:
1758 
      x = TApplicationException()
1759 
      x.read(self._iprot)
1760 
      self._iprot.readMessageEnd()
1761 
      raise x
1762 
    result = getOrderForCustomer_result()
1763 
    result.read(self._iprot)
1764 
    self._iprot.readMessageEnd()
3431 rajveer 1765 
    if result.success is not None:
1528 ankur.sing 1766 
      return result.success
3431 rajveer 1767 
    if result.ex is not None:
1528 ankur.sing 1768 
      raise result.ex
1769 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1770 
 
4444 rajveer 1771 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1772 
    """
1773 
    Parameters:
4394 rajveer 1774 
     - type
4444 rajveer 1775 
     - warehouseId
4394 rajveer 1776 
     - status
1777 
     - timestamp
3064 chandransh 1778 
    """
4444 rajveer 1779 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1780 
    return self.recv_getAlerts()
1781 
 
4444 rajveer 1782 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1783 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1784 
    args = getAlerts_args()
4394 rajveer 1785 
    args.type = type
4444 rajveer 1786 
    args.warehouseId = warehouseId
4394 rajveer 1787 
    args.status = status
1788 
    args.timestamp = timestamp
3064 chandransh 1789 
    args.write(self._oprot)
1790 
    self._oprot.writeMessageEnd()
1791 
    self._oprot.trans.flush()
1792 
 
1793 
  def recv_getAlerts(self, ):
1794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1795 
    if mtype == TMessageType.EXCEPTION:
1796 
      x = TApplicationException()
1797 
      x.read(self._iprot)
1798 
      self._iprot.readMessageEnd()
1799 
      raise x
1800 
    result = getAlerts_result()
1801 
    result.read(self._iprot)
1802 
    self._iprot.readMessageEnd()
3431 rajveer 1803 
    if result.success is not None:
3064 chandransh 1804 
      return result.success
1805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1806 
 
4444 rajveer 1807 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1808 
    """
1809 
    Parameters:
1810 
     - type
4444 rajveer 1811 
     - warehouseId
4394 rajveer 1812 
     - description
3064 chandransh 1813 
    """
4444 rajveer 1814 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1815 
    self.recv_addAlert()
3064 chandransh 1816 
 
4444 rajveer 1817 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1818 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1819 
    args = addAlert_args()
3064 chandransh 1820 
    args.type = type
4444 rajveer 1821 
    args.warehouseId = warehouseId
4394 rajveer 1822 
    args.description = description
3064 chandransh 1823 
    args.write(self._oprot)
1824 
    self._oprot.writeMessageEnd()
1825 
    self._oprot.trans.flush()
1826 
 
4394 rajveer 1827 
  def recv_addAlert(self, ):
3064 chandransh 1828 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1829 
    if mtype == TMessageType.EXCEPTION:
1830 
      x = TApplicationException()
1831 
      x.read(self._iprot)
1832 
      self._iprot.readMessageEnd()
1833 
      raise x
4394 rajveer 1834 
    result = addAlert_result()
3064 chandransh 1835 
    result.read(self._iprot)
1836 
    self._iprot.readMessageEnd()
1837 
    return
1838 
 
4444 rajveer 1839 
  def markAlertsAsSeen(self, warehouseId):
1840 
    """
1841 
    Parameters:
1842 
     - warehouseId
1843 
    """
1844 
    self.send_markAlertsAsSeen(warehouseId)
1845 
    self.recv_markAlertsAsSeen()
1846 
 
1847 
  def send_markAlertsAsSeen(self, warehouseId):
1848 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1849 
    args = markAlertsAsSeen_args()
1850 
    args.warehouseId = warehouseId
1851 
    args.write(self._oprot)
1852 
    self._oprot.writeMessageEnd()
1853 
    self._oprot.trans.flush()
1854 
 
1855 
  def recv_markAlertsAsSeen(self, ):
1856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1857 
    if mtype == TMessageType.EXCEPTION:
1858 
      x = TApplicationException()
1859 
      x.read(self._iprot)
1860 
      self._iprot.readMessageEnd()
1861 
      raise x
1862 
    result = markAlertsAsSeen_result()
1863 
    result.read(self._iprot)
1864 
    self._iprot.readMessageEnd()
1865 
    return
1866 
 
3064 chandransh 1867 
  def getValidOrderCount(self, ):
1868 
    """
1869 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1870 
    """
1871 
    self.send_getValidOrderCount()
1872 
    return self.recv_getValidOrderCount()
1873 
 
1874 
  def send_getValidOrderCount(self, ):
1875 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1876 
    args = getValidOrderCount_args()
1877 
    args.write(self._oprot)
1878 
    self._oprot.writeMessageEnd()
1879 
    self._oprot.trans.flush()
1880 
 
1881 
  def recv_getValidOrderCount(self, ):
1882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1883 
    if mtype == TMessageType.EXCEPTION:
1884 
      x = TApplicationException()
1885 
      x.read(self._iprot)
1886 
      self._iprot.readMessageEnd()
1887 
      raise x
1888 
    result = getValidOrderCount_result()
1889 
    result.read(self._iprot)
1890 
    self._iprot.readMessageEnd()
3431 rajveer 1891 
    if result.success is not None:
3064 chandransh 1892 
      return result.success
1893 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1894 
 
1895 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1896 
    """
1897 
    Returns the number of distinct customers who have done successful transactions
1898 
    """
1899 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1900 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1901 
 
1902 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1903 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1904 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1905 
    args.write(self._oprot)
1906 
    self._oprot.writeMessageEnd()
1907 
    self._oprot.trans.flush()
1908 
 
1909 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1911 
    if mtype == TMessageType.EXCEPTION:
1912 
      x = TApplicationException()
1913 
      x.read(self._iprot)
1914 
      self._iprot.readMessageEnd()
1915 
      raise x
1916 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1917 
    result.read(self._iprot)
1918 
    self._iprot.readMessageEnd()
3431 rajveer 1919 
    if result.success is not None:
3064 chandransh 1920 
      return result.success
1921 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1922 
 
1923 
  def getValidOrdersAmountRange(self, ):
1924 
    """
1925 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1926 
    List contains two values, first minimum amount and second maximum amount.
1927 
    """
1928 
    self.send_getValidOrdersAmountRange()
1929 
    return self.recv_getValidOrdersAmountRange()
1930 
 
1931 
  def send_getValidOrdersAmountRange(self, ):
1932 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1933 
    args = getValidOrdersAmountRange_args()
1934 
    args.write(self._oprot)
1935 
    self._oprot.writeMessageEnd()
1936 
    self._oprot.trans.flush()
1937 
 
1938 
  def recv_getValidOrdersAmountRange(self, ):
1939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1940 
    if mtype == TMessageType.EXCEPTION:
1941 
      x = TApplicationException()
1942 
      x.read(self._iprot)
1943 
      self._iprot.readMessageEnd()
1944 
      raise x
1945 
    result = getValidOrdersAmountRange_result()
1946 
    result.read(self._iprot)
1947 
    self._iprot.readMessageEnd()
3431 rajveer 1948 
    if result.success is not None:
3064 chandransh 1949 
      return result.success
1950 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1951 
 
1952 
  def getValidOrders(self, limit):
1953 
    """
1954 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1955 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1956 
 
3064 chandransh 1957 
    Parameters:
1958 
     - limit
1959 
    """
1960 
    self.send_getValidOrders(limit)
1961 
    return self.recv_getValidOrders()
1962 
 
1963 
  def send_getValidOrders(self, limit):
1964 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1965 
    args = getValidOrders_args()
1966 
    args.limit = limit
1967 
    args.write(self._oprot)
1968 
    self._oprot.writeMessageEnd()
1969 
    self._oprot.trans.flush()
1970 
 
1971 
  def recv_getValidOrders(self, ):
1972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1973 
    if mtype == TMessageType.EXCEPTION:
1974 
      x = TApplicationException()
1975 
      x.read(self._iprot)
1976 
      self._iprot.readMessageEnd()
1977 
      raise x
1978 
    result = getValidOrders_result()
1979 
    result.read(self._iprot)
1980 
    self._iprot.readMessageEnd()
3431 rajveer 1981 
    if result.success is not None:
3064 chandransh 1982 
      return result.success
1983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1984 
 
1220 chandransh 1985 
  def batchOrders(self, warehouseId):
1986 
    """
1987 
    Create a batch of all the pending orders for the given warehouse.
1988 
    The returned list is orderd by created_timestamp.
1989 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1990 
 
1220 chandransh 1991 
    Parameters:
1992 
     - warehouseId
1993 
    """
1994 
    self.send_batchOrders(warehouseId)
1995 
    return self.recv_batchOrders()
1996 
 
1997 
  def send_batchOrders(self, warehouseId):
1998 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1999 
    args = batchOrders_args()
2000 
    args.warehouseId = warehouseId
2001 
    args.write(self._oprot)
2002 
    self._oprot.writeMessageEnd()
2003 
    self._oprot.trans.flush()
2004 
 
2005 
  def recv_batchOrders(self, ):
2006 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2007 
    if mtype == TMessageType.EXCEPTION:
2008 
      x = TApplicationException()
2009 
      x.read(self._iprot)
2010 
      self._iprot.readMessageEnd()
2011 
      raise x
2012 
    result = batchOrders_result()
2013 
    result.read(self._iprot)
2014 
    self._iprot.readMessageEnd()
3431 rajveer 2015 
    if result.success is not None:
1220 chandransh 2016 
      return result.success
3431 rajveer 2017 
    if result.ex is not None:
1220 chandransh 2018 
      raise result.ex
2019 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2020 
 
1208 chandransh 2021 
  def markOrderAsOutOfStock(self, orderId):
2022 
    """
2023 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2024 
 
1208 chandransh 2025 
    Parameters:
2026 
     - orderId
2027 
    """
2028 
    self.send_markOrderAsOutOfStock(orderId)
2029 
    return self.recv_markOrderAsOutOfStock()
2030 
 
2031 
  def send_markOrderAsOutOfStock(self, orderId):
2032 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2033 
    args = markOrderAsOutOfStock_args()
2034 
    args.orderId = orderId
2035 
    args.write(self._oprot)
2036 
    self._oprot.writeMessageEnd()
2037 
    self._oprot.trans.flush()
2038 
 
2039 
  def recv_markOrderAsOutOfStock(self, ):
2040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2041 
    if mtype == TMessageType.EXCEPTION:
2042 
      x = TApplicationException()
2043 
      x.read(self._iprot)
2044 
      self._iprot.readMessageEnd()
2045 
      raise x
2046 
    result = markOrderAsOutOfStock_result()
2047 
    result.read(self._iprot)
2048 
    self._iprot.readMessageEnd()
3431 rajveer 2049 
    if result.success is not None:
1208 chandransh 2050 
      return result.success
3431 rajveer 2051 
    if result.ex is not None:
1208 chandransh 2052 
      raise result.ex
2053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2054 
 
3064 chandransh 2055 
  def verifyOrder(self, orderId):
759 chandransh 2056 
    """
3064 chandransh 2057 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2058 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2059 
    used for all other orders as well.
2060 
    Throws an exception if no such order exists.
3431 rajveer 2061 
 
759 chandransh 2062 
    Parameters:
3064 chandransh 2063 
     - orderId
759 chandransh 2064 
    """
3064 chandransh 2065 
    self.send_verifyOrder(orderId)
2066 
    return self.recv_verifyOrder()
759 chandransh 2067 
 
3064 chandransh 2068 
  def send_verifyOrder(self, orderId):
2069 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2070 
    args = verifyOrder_args()
2071 
    args.orderId = orderId
759 chandransh 2072 
    args.write(self._oprot)
2073 
    self._oprot.writeMessageEnd()
2074 
    self._oprot.trans.flush()
2075 
 
3064 chandransh 2076 
  def recv_verifyOrder(self, ):
759 chandransh 2077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2078 
    if mtype == TMessageType.EXCEPTION:
2079 
      x = TApplicationException()
2080 
      x.read(self._iprot)
2081 
      self._iprot.readMessageEnd()
2082 
      raise x
3064 chandransh 2083 
    result = verifyOrder_result()
759 chandransh 2084 
    result.read(self._iprot)
2085 
    self._iprot.readMessageEnd()
3431 rajveer 2086 
    if result.success is not None:
759 chandransh 2087 
      return result.success
3431 rajveer 2088 
    if result.ex is not None:
759 chandransh 2089 
      raise result.ex
3064 chandransh 2090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2091 
 
3064 chandransh 2092 
  def acceptOrder(self, orderId):
1113 chandransh 2093 
    """
3064 chandransh 2094 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2095 
    given order is not a COD order, it also captures the payment if the same has
2096 
    not been captured.
2097 
    Throws an exception if no such order exists.
3431 rajveer 2098 
 
1113 chandransh 2099 
    Parameters:
3064 chandransh 2100 
     - orderId
1113 chandransh 2101 
    """
3064 chandransh 2102 
    self.send_acceptOrder(orderId)
2103 
    return self.recv_acceptOrder()
1113 chandransh 2104 
 
3064 chandransh 2105 
  def send_acceptOrder(self, orderId):
2106 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2107 
    args = acceptOrder_args()
2108 
    args.orderId = orderId
1113 chandransh 2109 
    args.write(self._oprot)
2110 
    self._oprot.writeMessageEnd()
2111 
    self._oprot.trans.flush()
2112 
 
3064 chandransh 2113 
  def recv_acceptOrder(self, ):
1113 chandransh 2114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2115 
    if mtype == TMessageType.EXCEPTION:
2116 
      x = TApplicationException()
2117 
      x.read(self._iprot)
2118 
      self._iprot.readMessageEnd()
2119 
      raise x
3064 chandransh 2120 
    result = acceptOrder_result()
1113 chandransh 2121 
    result.read(self._iprot)
2122 
    self._iprot.readMessageEnd()
3431 rajveer 2123 
    if result.success is not None:
1113 chandransh 2124 
      return result.success
3431 rajveer 2125 
    if result.ex is not None:
1113 chandransh 2126 
      raise result.ex
3064 chandransh 2127 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2128 
 
4658 mandeep.dh 2129 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 2130 
    """
3064 chandransh 2131 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2132 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2133 
    the IMEI no. if a -1 is supplied.
2134 
    Also, it generates an invoice number for the order, marks the order as
2135 
    BILLED and sets the billing timestamp.
2136 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2137 
 
1135 chandransh 2138 
    Parameters:
3064 chandransh 2139 
     - orderId
2140 
     - invoice_number
4658 mandeep.dh 2141 
     - serialNumber
4283 anupam.sin 2142 
     - itemNumber
3064 chandransh 2143 
     - billed_by
4264 rajveer 2144 
     - jacketNumber
4283 anupam.sin 2145 
     - billingType
2146 
     - vendorId
1135 chandransh 2147 
    """
4658 mandeep.dh 2148 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 2149 
    return self.recv_addBillingDetails()
1135 chandransh 2150 
 
4658 mandeep.dh 2151 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 2152 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2153 
    args = addBillingDetails_args()
2154 
    args.orderId = orderId
2155 
    args.invoice_number = invoice_number
4658 mandeep.dh 2156 
    args.serialNumber = serialNumber
4283 anupam.sin 2157 
    args.itemNumber = itemNumber
3064 chandransh 2158 
    args.billed_by = billed_by
4264 rajveer 2159 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2160 
    args.billingType = billingType
2161 
    args.vendorId = vendorId
1135 chandransh 2162 
    args.write(self._oprot)
2163 
    self._oprot.writeMessageEnd()
2164 
    self._oprot.trans.flush()
2165 
 
3064 chandransh 2166 
  def recv_addBillingDetails(self, ):
1135 chandransh 2167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2168 
    if mtype == TMessageType.EXCEPTION:
2169 
      x = TApplicationException()
2170 
      x.read(self._iprot)
2171 
      self._iprot.readMessageEnd()
2172 
      raise x
3064 chandransh 2173 
    result = addBillingDetails_result()
1135 chandransh 2174 
    result.read(self._iprot)
2175 
    self._iprot.readMessageEnd()
3431 rajveer 2176 
    if result.success is not None:
3064 chandransh 2177 
      return result.success
3431 rajveer 2178 
    if result.ex is not None:
1135 chandransh 2179 
      raise result.ex
3064 chandransh 2180 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2181 
 
4579 rajveer 2182 
  def addInvoiceNumber(self, orderId, invoiceNumber):
2183 
    """
2184 
    Add the invoice number to the order.
2185 
 
2186 
    Parameters:
2187 
     - orderId
2188 
     - invoiceNumber
2189 
    """
2190 
    self.send_addInvoiceNumber(orderId, invoiceNumber)
2191 
    self.recv_addInvoiceNumber()
2192 
 
2193 
  def send_addInvoiceNumber(self, orderId, invoiceNumber):
2194 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2195 
    args = addInvoiceNumber_args()
2196 
    args.orderId = orderId
2197 
    args.invoiceNumber = invoiceNumber
2198 
    args.write(self._oprot)
2199 
    self._oprot.writeMessageEnd()
2200 
    self._oprot.trans.flush()
2201 
 
2202 
  def recv_addInvoiceNumber(self, ):
2203 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2204 
    if mtype == TMessageType.EXCEPTION:
2205 
      x = TApplicationException()
2206 
      x.read(self._iprot)
2207 
      self._iprot.readMessageEnd()
2208 
      raise x
2209 
    result = addInvoiceNumber_result()
2210 
    result.read(self._iprot)
2211 
    self._iprot.readMessageEnd()
2212 
    if result.ex is not None:
2213 
      raise result.ex
2214 
    return
2215 
 
3064 chandransh 2216 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2217 
    """
3064 chandransh 2218 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2219 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2220 
 
1408 ankur.sing 2221 
    Parameters:
3064 chandransh 2222 
     - warehouseId
1408 ankur.sing 2223 
     - providerId
3064 chandransh 2224 
     - cod
1408 ankur.sing 2225 
    """
3064 chandransh 2226 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2227 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2228 
 
3064 chandransh 2229 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2230 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2231 
    args = markOrdersAsManifested_args()
2232 
    args.warehouseId = warehouseId
1408 ankur.sing 2233 
    args.providerId = providerId
3064 chandransh 2234 
    args.cod = cod
1408 ankur.sing 2235 
    args.write(self._oprot)
2236 
    self._oprot.writeMessageEnd()
2237 
    self._oprot.trans.flush()
2238 
 
3064 chandransh 2239 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2241 
    if mtype == TMessageType.EXCEPTION:
2242 
      x = TApplicationException()
2243 
      x.read(self._iprot)
2244 
      self._iprot.readMessageEnd()
2245 
      raise x
3064 chandransh 2246 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2247 
    result.read(self._iprot)
2248 
    self._iprot.readMessageEnd()
3431 rajveer 2249 
    if result.success is not None:
1408 ankur.sing 2250 
      return result.success
3431 rajveer 2251 
    if result.ex is not None:
3064 chandransh 2252 
      raise result.ex
2253 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2254 
 
4410 rajveer 2255 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2256 
    """
2257 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2258 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2259 
 
2260 
    Parameters:
2261 
     - warehouseId
2262 
     - providerId
2263 
     - cod
2264 
    """
2265 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2266 
    return self.recv_markOrdersAsShippedFromWarehouse()
2267 
 
2268 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2269 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2270 
    args = markOrdersAsShippedFromWarehouse_args()
2271 
    args.warehouseId = warehouseId
2272 
    args.providerId = providerId
2273 
    args.cod = cod
2274 
    args.write(self._oprot)
2275 
    self._oprot.writeMessageEnd()
2276 
    self._oprot.trans.flush()
2277 
 
2278 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2279 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2280 
    if mtype == TMessageType.EXCEPTION:
2281 
      x = TApplicationException()
2282 
      x.read(self._iprot)
2283 
      self._iprot.readMessageEnd()
2284 
      raise x
2285 
    result = markOrdersAsShippedFromWarehouse_result()
2286 
    result.read(self._iprot)
2287 
    self._iprot.readMessageEnd()
2288 
    if result.success is not None:
2289 
      return result.success
2290 
    if result.ex is not None:
2291 
      raise result.ex
2292 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2293 
 
3064 chandransh 2294 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2295 
    """
3064 chandransh 2296 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2297 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2298 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2299 
 
94 ashish 2300 
    Parameters:
3064 chandransh 2301 
     - providerId
2302 
     - pickupDetails
304 ashish 2303 
    """
3064 chandransh 2304 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2305 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2306 
 
3064 chandransh 2307 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2308 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2309 
    args = markOrdersAsPickedUp_args()
2310 
    args.providerId = providerId
2311 
    args.pickupDetails = pickupDetails
304 ashish 2312 
    args.write(self._oprot)
2313 
    self._oprot.writeMessageEnd()
2314 
    self._oprot.trans.flush()
2315 
 
3064 chandransh 2316 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2318 
    if mtype == TMessageType.EXCEPTION:
2319 
      x = TApplicationException()
2320 
      x.read(self._iprot)
2321 
      self._iprot.readMessageEnd()
2322 
      raise x
3064 chandransh 2323 
    result = markOrdersAsPickedUp_result()
304 ashish 2324 
    result.read(self._iprot)
2325 
    self._iprot.readMessageEnd()
3431 rajveer 2326 
    if result.success is not None:
304 ashish 2327 
      return result.success
3431 rajveer 2328 
    if result.ex is not None:
3064 chandransh 2329 
      raise result.ex
2330 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2331 
 
3064 chandransh 2332 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2333 
    """
3064 chandransh 2334 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2335 
    the name of the receiver.
2336 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2337 
 
304 ashish 2338 
    Parameters:
3064 chandransh 2339 
     - providerId
2340 
     - deliveredOrders
304 ashish 2341 
    """
3064 chandransh 2342 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2343 
    self.recv_markOrdersAsDelivered()
304 ashish 2344 
 
3064 chandransh 2345 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2346 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2347 
    args = markOrdersAsDelivered_args()
2348 
    args.providerId = providerId
2349 
    args.deliveredOrders = deliveredOrders
304 ashish 2350 
    args.write(self._oprot)
2351 
    self._oprot.writeMessageEnd()
2352 
    self._oprot.trans.flush()
2353 
 
3064 chandransh 2354 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2356 
    if mtype == TMessageType.EXCEPTION:
2357 
      x = TApplicationException()
2358 
      x.read(self._iprot)
2359 
      self._iprot.readMessageEnd()
2360 
      raise x
3064 chandransh 2361 
    result = markOrdersAsDelivered_result()
304 ashish 2362 
    result.read(self._iprot)
2363 
    self._iprot.readMessageEnd()
3431 rajveer 2364 
    if result.ex is not None:
3064 chandransh 2365 
      raise result.ex
304 ashish 2366 
    return
2367 
 
3064 chandransh 2368 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2369 
    """
3064 chandransh 2370 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2371 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2372 
 
3064 chandransh 2373 
    Parameters:
2374 
     - providerId
2375 
     - returnedOrders
1596 ankur.sing 2376 
    """
3064 chandransh 2377 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2378 
    self.recv_markOrdersAsFailed()
304 ashish 2379 
 
3064 chandransh 2380 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2381 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2382 
    args = markOrdersAsFailed_args()
2383 
    args.providerId = providerId
2384 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2385 
    args.write(self._oprot)
2386 
    self._oprot.writeMessageEnd()
2387 
    self._oprot.trans.flush()
2388 
 
3064 chandransh 2389 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2391 
    if mtype == TMessageType.EXCEPTION:
2392 
      x = TApplicationException()
2393 
      x.read(self._iprot)
2394 
      self._iprot.readMessageEnd()
2395 
      raise x
3064 chandransh 2396 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2397 
    result.read(self._iprot)
2398 
    self._iprot.readMessageEnd()
3431 rajveer 2399 
    if result.ex is not None:
3064 chandransh 2400 
      raise result.ex
2401 
    return
1596 ankur.sing 2402 
 
3064 chandransh 2403 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2404 
    """
3064 chandransh 2405 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2406 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2407 
 
3064 chandransh 2408 
    Parameters:
2409 
     - providerId
2410 
     - undeliveredOrders
1627 ankur.sing 2411 
    """
3064 chandransh 2412 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2413 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2414 
 
3064 chandransh 2415 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2416 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2417 
    args = updateNonDeliveryReason_args()
2418 
    args.providerId = providerId
2419 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2420 
    args.write(self._oprot)
2421 
    self._oprot.writeMessageEnd()
2422 
    self._oprot.trans.flush()
2423 
 
3064 chandransh 2424 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2426 
    if mtype == TMessageType.EXCEPTION:
2427 
      x = TApplicationException()
2428 
      x.read(self._iprot)
2429 
      self._iprot.readMessageEnd()
2430 
      raise x
3064 chandransh 2431 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2432 
    result.read(self._iprot)
2433 
    self._iprot.readMessageEnd()
4581 phani.kuma 2434 
    if result.success is not None:
2435 
      return result.success
3431 rajveer 2436 
    if result.ex is not None:
3064 chandransh 2437 
      raise result.ex
4581 phani.kuma 2438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2439 
 
3064 chandransh 2440 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2441 
    """
3064 chandransh 2442 
    Returns the list of orders whose delivery time has passed but have not been
2443 
    delivered yet for the given provider and warehouse. To get a complete list of
2444 
    undelivered orders, pass them as -1.
2445 
    Returns an empty list if no such orders exist.
3431 rajveer 2446 
 
1886 ankur.sing 2447 
    Parameters:
3064 chandransh 2448 
     - providerId
2449 
     - warehouseId
1886 ankur.sing 2450 
    """
3064 chandransh 2451 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2452 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2453 
 
3064 chandransh 2454 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2455 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2456 
    args = getUndeliveredOrders_args()
2457 
    args.providerId = providerId
2458 
    args.warehouseId = warehouseId
1886 ankur.sing 2459 
    args.write(self._oprot)
2460 
    self._oprot.writeMessageEnd()
2461 
    self._oprot.trans.flush()
2462 
 
3064 chandransh 2463 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2465 
    if mtype == TMessageType.EXCEPTION:
2466 
      x = TApplicationException()
2467 
      x.read(self._iprot)
2468 
      self._iprot.readMessageEnd()
2469 
      raise x
3064 chandransh 2470 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2471 
    result.read(self._iprot)
2472 
    self._iprot.readMessageEnd()
3431 rajveer 2473 
    if result.success is not None:
1886 ankur.sing 2474 
      return result.success
3064 chandransh 2475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2476 
 
2536 chandransh 2477 
  def toggleDOAFlag(self, orderId):
2478 
    """
2479 
    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.
2480 
    Returns the final flag status.
2481 
    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 2482 
 
2536 chandransh 2483 
    Parameters:
2484 
     - orderId
2485 
    """
2486 
    self.send_toggleDOAFlag(orderId)
2487 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2488 
 
2536 chandransh 2489 
  def send_toggleDOAFlag(self, orderId):
2490 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2491 
    args = toggleDOAFlag_args()
2492 
    args.orderId = orderId
2493 
    args.write(self._oprot)
2494 
    self._oprot.writeMessageEnd()
2495 
    self._oprot.trans.flush()
2496 
 
2497 
  def recv_toggleDOAFlag(self, ):
2498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2499 
    if mtype == TMessageType.EXCEPTION:
2500 
      x = TApplicationException()
2501 
      x.read(self._iprot)
2502 
      self._iprot.readMessageEnd()
2503 
      raise x
2504 
    result = toggleDOAFlag_result()
2505 
    result.read(self._iprot)
2506 
    self._iprot.readMessageEnd()
3431 rajveer 2507 
    if result.success is not None:
2536 chandransh 2508 
      return result.success
3431 rajveer 2509 
    if result.ex is not None:
2536 chandransh 2510 
      raise result.ex
2511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2512 
 
4712 rajveer 2513 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2514 
    """
2515 
    Parameters:
2516 
     - orderId
2517 
     - deliveryTimestamp
2518 
     - receiver
2519 
    """
2520 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2521 
    self.recv_markOrderAsDelivered()
2522 
 
2523 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2524 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2525 
    args = markOrderAsDelivered_args()
2526 
    args.orderId = orderId
2527 
    args.deliveryTimestamp = deliveryTimestamp
2528 
    args.receiver = receiver
2529 
    args.write(self._oprot)
2530 
    self._oprot.writeMessageEnd()
2531 
    self._oprot.trans.flush()
2532 
 
2533 
  def recv_markOrderAsDelivered(self, ):
2534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2535 
    if mtype == TMessageType.EXCEPTION:
2536 
      x = TApplicationException()
2537 
      x.read(self._iprot)
2538 
      self._iprot.readMessageEnd()
2539 
      raise x
2540 
    result = markOrderAsDelivered_result()
2541 
    result.read(self._iprot)
2542 
    self._iprot.readMessageEnd()
2543 
    if result.ex is not None:
2544 
      raise result.ex
2545 
    return
2546 
 
4454 rajveer 2547 
  def markOrderDoaRequestReceived(self, orderId):
2548 
    """
2549 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2550 
 
2551 
    Parameters:
2552 
     - orderId
2553 
    """
2554 
    self.send_markOrderDoaRequestReceived(orderId)
2555 
    return self.recv_markOrderDoaRequestReceived()
2556 
 
2557 
  def send_markOrderDoaRequestReceived(self, orderId):
2558 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2559 
    args = markOrderDoaRequestReceived_args()
2560 
    args.orderId = orderId
2561 
    args.write(self._oprot)
2562 
    self._oprot.writeMessageEnd()
2563 
    self._oprot.trans.flush()
2564 
 
2565 
  def recv_markOrderDoaRequestReceived(self, ):
2566 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2567 
    if mtype == TMessageType.EXCEPTION:
2568 
      x = TApplicationException()
2569 
      x.read(self._iprot)
2570 
      self._iprot.readMessageEnd()
2571 
      raise x
2572 
    result = markOrderDoaRequestReceived_result()
2573 
    result.read(self._iprot)
2574 
    self._iprot.readMessageEnd()
2575 
    if result.success is not None:
2576 
      return result.success
2577 
    if result.ex is not None:
2578 
      raise result.ex
2579 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2580 
 
2581 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2582 
    """
2583 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2584 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2585 
 
2586 
    Parameters:
2587 
     - orderId
2588 
     - isAuthorized
2589 
    """
2590 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2591 
    return self.recv_markOrderDoaRequestAuthorized()
2592 
 
2593 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2594 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2595 
    args = markOrderDoaRequestAuthorized_args()
2596 
    args.orderId = orderId
2597 
    args.isAuthorized = isAuthorized
2598 
    args.write(self._oprot)
2599 
    self._oprot.writeMessageEnd()
2600 
    self._oprot.trans.flush()
2601 
 
2602 
  def recv_markOrderDoaRequestAuthorized(self, ):
2603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2604 
    if mtype == TMessageType.EXCEPTION:
2605 
      x = TApplicationException()
2606 
      x.read(self._iprot)
2607 
      self._iprot.readMessageEnd()
2608 
      raise x
2609 
    result = markOrderDoaRequestAuthorized_result()
2610 
    result.read(self._iprot)
2611 
    self._iprot.readMessageEnd()
2612 
    if result.success is not None:
2613 
      return result.success
2614 
    if result.ex is not None:
2615 
      raise result.ex
2616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2617 
 
4488 rajveer 2618 
  def markOrderReturnRequestReceived(self, orderId):
2619 
    """
2620 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2621 
 
2622 
    Parameters:
2623 
     - orderId
2624 
    """
2625 
    self.send_markOrderReturnRequestReceived(orderId)
2626 
    return self.recv_markOrderReturnRequestReceived()
2627 
 
2628 
  def send_markOrderReturnRequestReceived(self, orderId):
2629 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2630 
    args = markOrderReturnRequestReceived_args()
2631 
    args.orderId = orderId
2632 
    args.write(self._oprot)
2633 
    self._oprot.writeMessageEnd()
2634 
    self._oprot.trans.flush()
2635 
 
2636 
  def recv_markOrderReturnRequestReceived(self, ):
2637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2638 
    if mtype == TMessageType.EXCEPTION:
2639 
      x = TApplicationException()
2640 
      x.read(self._iprot)
2641 
      self._iprot.readMessageEnd()
2642 
      raise x
2643 
    result = markOrderReturnRequestReceived_result()
2644 
    result.read(self._iprot)
2645 
    self._iprot.readMessageEnd()
2646 
    if result.success is not None:
2647 
      return result.success
2648 
    if result.ex is not None:
2649 
      raise result.ex
2650 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2651 
 
2652 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2653 
    """
2654 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2655 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2656 
 
2657 
    Parameters:
2658 
     - orderId
2659 
     - isAuthorized
2660 
    """
2661 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2662 
    return self.recv_markOrderReturnRequestAuthorized()
2663 
 
2664 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2665 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2666 
    args = markOrderReturnRequestAuthorized_args()
2667 
    args.orderId = orderId
2668 
    args.isAuthorized = isAuthorized
2669 
    args.write(self._oprot)
2670 
    self._oprot.writeMessageEnd()
2671 
    self._oprot.trans.flush()
2672 
 
2673 
  def recv_markOrderReturnRequestAuthorized(self, ):
2674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2675 
    if mtype == TMessageType.EXCEPTION:
2676 
      x = TApplicationException()
2677 
      x.read(self._iprot)
2678 
      self._iprot.readMessageEnd()
2679 
      raise x
2680 
    result = markOrderReturnRequestAuthorized_result()
2681 
    result.read(self._iprot)
2682 
    self._iprot.readMessageEnd()
2683 
    if result.success is not None:
2684 
      return result.success
2685 
    if result.ex is not None:
2686 
      raise result.ex
2687 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2688 
 
4579 rajveer 2689 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2690 
    """
2691 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2692 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2693 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2694 
    For any other status, it returns false.
2695 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2696 
 
2536 chandransh 2697 
    Parameters:
2698 
     - orderId
4579 rajveer 2699 
     - providerId
2536 chandransh 2700 
    """
4579 rajveer 2701 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2702 
    return self.recv_requestPickupNumber()
2703 
 
4579 rajveer 2704 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2705 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2706 
    args = requestPickupNumber_args()
2707 
    args.orderId = orderId
4579 rajveer 2708 
    args.providerId = providerId
2536 chandransh 2709 
    args.write(self._oprot)
2710 
    self._oprot.writeMessageEnd()
2711 
    self._oprot.trans.flush()
2712 
 
2713 
  def recv_requestPickupNumber(self, ):
2714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2715 
    if mtype == TMessageType.EXCEPTION:
2716 
      x = TApplicationException()
2717 
      x.read(self._iprot)
2718 
      self._iprot.readMessageEnd()
2719 
      raise x
2720 
    result = requestPickupNumber_result()
2721 
    result.read(self._iprot)
2722 
    self._iprot.readMessageEnd()
3431 rajveer 2723 
    if result.success is not None:
2536 chandransh 2724 
      return result.success
3431 rajveer 2725 
    if result.ex is not None:
2536 chandransh 2726 
      raise result.ex
2727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2728 
 
4602 rajveer 2729 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2730 
    """
4452 rajveer 2731 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2732 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2733 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2734 
    	3. Returns true
2591 chandransh 2735 
    If the order is in any other status, it returns false.
2536 chandransh 2736 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2737 
 
2536 chandransh 2738 
    Parameters:
2739 
     - orderId
2740 
     - pickupNumber
4602 rajveer 2741 
     - providerId
2536 chandransh 2742 
    """
4602 rajveer 2743 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 2744 
    return self.recv_authorizePickup()
2745 
 
4602 rajveer 2746 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2747 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2748 
    args = authorizePickup_args()
2749 
    args.orderId = orderId
2750 
    args.pickupNumber = pickupNumber
4602 rajveer 2751 
    args.providerId = providerId
2536 chandransh 2752 
    args.write(self._oprot)
2753 
    self._oprot.writeMessageEnd()
2754 
    self._oprot.trans.flush()
2755 
 
2756 
  def recv_authorizePickup(self, ):
2757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2758 
    if mtype == TMessageType.EXCEPTION:
2759 
      x = TApplicationException()
2760 
      x.read(self._iprot)
2761 
      self._iprot.readMessageEnd()
2762 
      raise x
2763 
    result = authorizePickup_result()
2764 
    result.read(self._iprot)
2765 
    self._iprot.readMessageEnd()
3431 rajveer 2766 
    if result.success is not None:
2536 chandransh 2767 
      return result.success
3431 rajveer 2768 
    if result.ex is not None:
2536 chandransh 2769 
      raise result.ex
2770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2771 
 
2764 chandransh 2772 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2773 
    """
2774 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2775 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2776 
 
2764 chandransh 2777 
    Parameters:
2778 
     - providerId
2779 
     - pickupDetails
2780 
    """
2781 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2782 
    return self.recv_markDoasAsPickedUp()
2783 
 
2784 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2785 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2786 
    args = markDoasAsPickedUp_args()
2787 
    args.providerId = providerId
2788 
    args.pickupDetails = pickupDetails
2789 
    args.write(self._oprot)
2790 
    self._oprot.writeMessageEnd()
2791 
    self._oprot.trans.flush()
2792 
 
2793 
  def recv_markDoasAsPickedUp(self, ):
2794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2795 
    if mtype == TMessageType.EXCEPTION:
2796 
      x = TApplicationException()
2797 
      x.read(self._iprot)
2798 
      self._iprot.readMessageEnd()
2799 
      raise x
2800 
    result = markDoasAsPickedUp_result()
2801 
    result.read(self._iprot)
2802 
    self._iprot.readMessageEnd()
3431 rajveer 2803 
    if result.success is not None:
2764 chandransh 2804 
      return result.success
2805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2806 
 
4741 phani.kuma 2807 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
2808 
    """
2809 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
2810 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
2811 
 
2812 
    Parameters:
2813 
     - providerId
2814 
     - pickupDetails
2815 
    """
2816 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
2817 
    return self.recv_markReturnOrdersAsPickedUp()
2818 
 
2819 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
2820 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2821 
    args = markReturnOrdersAsPickedUp_args()
2822 
    args.providerId = providerId
2823 
    args.pickupDetails = pickupDetails
2824 
    args.write(self._oprot)
2825 
    self._oprot.writeMessageEnd()
2826 
    self._oprot.trans.flush()
2827 
 
2828 
  def recv_markReturnOrdersAsPickedUp(self, ):
2829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2830 
    if mtype == TMessageType.EXCEPTION:
2831 
      x = TApplicationException()
2832 
      x.read(self._iprot)
2833 
      self._iprot.readMessageEnd()
2834 
      raise x
2835 
    result = markReturnOrdersAsPickedUp_result()
2836 
    result.read(self._iprot)
2837 
    self._iprot.readMessageEnd()
2838 
    if result.success is not None:
2839 
      return result.success
2840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markReturnOrdersAsPickedUp failed: unknown result");
2841 
 
4479 rajveer 2842 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2843 
    """
4452 rajveer 2844 
    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 2845 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2846 
    If the order is in any other state, it returns false.
2847 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2848 
 
2591 chandransh 2849 
    Parameters:
2850 
     - orderId
4479 rajveer 2851 
     - receiveCondition
2591 chandransh 2852 
    """
4479 rajveer 2853 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2854 
    return self.recv_receiveReturn()
2536 chandransh 2855 
 
4479 rajveer 2856 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2857 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2858 
    args = receiveReturn_args()
2591 chandransh 2859 
    args.orderId = orderId
4479 rajveer 2860 
    args.receiveCondition = receiveCondition
2591 chandransh 2861 
    args.write(self._oprot)
2862 
    self._oprot.writeMessageEnd()
2863 
    self._oprot.trans.flush()
2864 
 
2616 chandransh 2865 
  def recv_receiveReturn(self, ):
2591 chandransh 2866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2867 
    if mtype == TMessageType.EXCEPTION:
2868 
      x = TApplicationException()
2869 
      x.read(self._iprot)
2870 
      self._iprot.readMessageEnd()
2871 
      raise x
2616 chandransh 2872 
    result = receiveReturn_result()
2591 chandransh 2873 
    result.read(self._iprot)
2874 
    self._iprot.readMessageEnd()
3431 rajveer 2875 
    if result.success is not None:
2591 chandransh 2876 
      return result.success
3431 rajveer 2877 
    if result.ex is not None:
2591 chandransh 2878 
      raise result.ex
2616 chandransh 2879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2880 
 
2881 
  def validateDoa(self, orderId, isValid):
2882 
    """
4452 rajveer 2883 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2884 
    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 2885 
    If the order is in any other state, it returns false.
2886 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2887 
 
2591 chandransh 2888 
    Parameters:
2889 
     - orderId
2890 
     - isValid
2891 
    """
2892 
    self.send_validateDoa(orderId, isValid)
2893 
    return self.recv_validateDoa()
2894 
 
2895 
  def send_validateDoa(self, orderId, isValid):
2896 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2897 
    args = validateDoa_args()
2898 
    args.orderId = orderId
2899 
    args.isValid = isValid
2900 
    args.write(self._oprot)
2901 
    self._oprot.writeMessageEnd()
2902 
    self._oprot.trans.flush()
2903 
 
2904 
  def recv_validateDoa(self, ):
2905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2906 
    if mtype == TMessageType.EXCEPTION:
2907 
      x = TApplicationException()
2908 
      x.read(self._iprot)
2909 
      self._iprot.readMessageEnd()
2910 
      raise x
2911 
    result = validateDoa_result()
2912 
    result.read(self._iprot)
2913 
    self._iprot.readMessageEnd()
3431 rajveer 2914 
    if result.success is not None:
2591 chandransh 2915 
      return result.success
3431 rajveer 2916 
    if result.ex is not None:
2591 chandransh 2917 
      raise result.ex
2918 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2919 
 
4495 rajveer 2920 
  def validateReturnProduct(self, orderId, isUsable):
2921 
    """
2922 
    Parameters:
2923 
     - orderId
2924 
     - isUsable
2925 
    """
2926 
    self.send_validateReturnProduct(orderId, isUsable)
2927 
    return self.recv_validateReturnProduct()
2928 
 
2929 
  def send_validateReturnProduct(self, orderId, isUsable):
2930 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2931 
    args = validateReturnProduct_args()
2932 
    args.orderId = orderId
2933 
    args.isUsable = isUsable
2934 
    args.write(self._oprot)
2935 
    self._oprot.writeMessageEnd()
2936 
    self._oprot.trans.flush()
2937 
 
2938 
  def recv_validateReturnProduct(self, ):
2939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2940 
    if mtype == TMessageType.EXCEPTION:
2941 
      x = TApplicationException()
2942 
      x.read(self._iprot)
2943 
      self._iprot.readMessageEnd()
2944 
      raise x
2945 
    result = validateReturnProduct_result()
2946 
    result.read(self._iprot)
2947 
    self._iprot.readMessageEnd()
2948 
    if result.success is not None:
2949 
      return result.success
2950 
    if result.ex is not None:
2951 
      raise result.ex
2952 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2953 
 
2616 chandransh 2954 
  def reshipOrder(self, orderId):
2955 
    """
4484 rajveer 2956 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2957 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2958 
    	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 2959 
 
2960 
    If the order is in DOA_CERT_VALID state, it does the following:
2961 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2962 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2963 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2964 
 
2616 chandransh 2965 
    Returns the id of the newly created order.
3431 rajveer 2966 
 
2616 chandransh 2967 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2968 
 
2616 chandransh 2969 
    Parameters:
2970 
     - orderId
2971 
    """
2972 
    self.send_reshipOrder(orderId)
2973 
    return self.recv_reshipOrder()
2591 chandransh 2974 
 
2616 chandransh 2975 
  def send_reshipOrder(self, orderId):
2976 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2977 
    args = reshipOrder_args()
2978 
    args.orderId = orderId
2979 
    args.write(self._oprot)
2980 
    self._oprot.writeMessageEnd()
2981 
    self._oprot.trans.flush()
2982 
 
2983 
  def recv_reshipOrder(self, ):
2984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2985 
    if mtype == TMessageType.EXCEPTION:
2986 
      x = TApplicationException()
2987 
      x.read(self._iprot)
2988 
      self._iprot.readMessageEnd()
2989 
      raise x
2990 
    result = reshipOrder_result()
2991 
    result.read(self._iprot)
2992 
    self._iprot.readMessageEnd()
3431 rajveer 2993 
    if result.success is not None:
2616 chandransh 2994 
      return result.success
3431 rajveer 2995 
    if result.ex is not None:
2616 chandransh 2996 
      raise result.ex
2997 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2998 
 
3226 chandransh 2999 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3000 
    """
4484 rajveer 3001 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3002 
    	1. Creates a refund request for batch processing.
3003 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3004 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3005 
 
2616 chandransh 3006 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3007 
    	1. Creates a refund request for batch processing.
3226 chandransh 3008 
    	2. Cancels the reservation of the item in the warehouse.
3009 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3010 
 
3226 chandransh 3011 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3012 
    	1. Cancels the reservation of the item in the warehouse.
3013 
    	2. Marks the current order as CANCELED.
3014 
 
3015 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3016 
 
2616 chandransh 3017 
    Returns True if it is successful, False otherwise.
3431 rajveer 3018 
 
2616 chandransh 3019 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3020 
 
2616 chandransh 3021 
    Parameters:
3022 
     - orderId
3226 chandransh 3023 
     - refundedBy
3024 
     - reason
2616 chandransh 3025 
    """
3226 chandransh 3026 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3027 
    return self.recv_refundOrder()
3028 
 
3226 chandransh 3029 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3030 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3031 
    args = refundOrder_args()
3032 
    args.orderId = orderId
3226 chandransh 3033 
    args.refundedBy = refundedBy
3034 
    args.reason = reason
2616 chandransh 3035 
    args.write(self._oprot)
3036 
    self._oprot.writeMessageEnd()
3037 
    self._oprot.trans.flush()
3038 
 
3039 
  def recv_refundOrder(self, ):
3040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3041 
    if mtype == TMessageType.EXCEPTION:
3042 
      x = TApplicationException()
3043 
      x.read(self._iprot)
3044 
      self._iprot.readMessageEnd()
3045 
      raise x
3046 
    result = refundOrder_result()
3047 
    result.read(self._iprot)
3048 
    self._iprot.readMessageEnd()
3431 rajveer 3049 
    if result.success is not None:
2616 chandransh 3050 
      return result.success
3431 rajveer 3051 
    if result.ex is not None:
2616 chandransh 3052 
      raise result.ex
3053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3054 
 
2690 chandransh 3055 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3056 
    """
3057 
    Get all return orders created between the from and to dates for the given warehouse.
3058 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3059 
 
2690 chandransh 3060 
    Parameters:
3061 
     - warehouseId
3062 
     - fromDate
3063 
     - toDate
3064 
    """
3065 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3066 
    return self.recv_getReturnOrders()
2616 chandransh 3067 
 
2690 chandransh 3068 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3069 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3070 
    args = getReturnOrders_args()
3071 
    args.warehouseId = warehouseId
3072 
    args.fromDate = fromDate
3073 
    args.toDate = toDate
3074 
    args.write(self._oprot)
3075 
    self._oprot.writeMessageEnd()
3076 
    self._oprot.trans.flush()
3077 
 
3078 
  def recv_getReturnOrders(self, ):
3079 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3080 
    if mtype == TMessageType.EXCEPTION:
3081 
      x = TApplicationException()
3082 
      x.read(self._iprot)
3083 
      self._iprot.readMessageEnd()
3084 
      raise x
3085 
    result = getReturnOrders_result()
3086 
    result.read(self._iprot)
3087 
    self._iprot.readMessageEnd()
3431 rajveer 3088 
    if result.success is not None:
2690 chandransh 3089 
      return result.success
3090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3091 
 
2700 chandransh 3092 
  def getReturnOrder(self, id):
3093 
    """
3094 
    Returns the ReturnOrder corresponding to the given id.
3095 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3096 
 
2700 chandransh 3097 
    Parameters:
3098 
     - id
3099 
    """
3100 
    self.send_getReturnOrder(id)
3101 
    return self.recv_getReturnOrder()
3102 
 
3103 
  def send_getReturnOrder(self, id):
3104 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3105 
    args = getReturnOrder_args()
3106 
    args.id = id
3107 
    args.write(self._oprot)
3108 
    self._oprot.writeMessageEnd()
3109 
    self._oprot.trans.flush()
3110 
 
3111 
  def recv_getReturnOrder(self, ):
3112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3113 
    if mtype == TMessageType.EXCEPTION:
3114 
      x = TApplicationException()
3115 
      x.read(self._iprot)
3116 
      self._iprot.readMessageEnd()
3117 
      raise x
3118 
    result = getReturnOrder_result()
3119 
    result.read(self._iprot)
3120 
    self._iprot.readMessageEnd()
3431 rajveer 3121 
    if result.success is not None:
2700 chandransh 3122 
      return result.success
3431 rajveer 3123 
    if result.ex is not None:
2700 chandransh 3124 
      raise result.ex
3125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3126 
 
2690 chandransh 3127 
  def processReturn(self, returnOrderId):
3128 
    """
3129 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3130 
 
2690 chandransh 3131 
    Parameters:
3132 
     - returnOrderId
3133 
    """
3134 
    self.send_processReturn(returnOrderId)
3135 
    self.recv_processReturn()
3136 
 
3137 
  def send_processReturn(self, returnOrderId):
3138 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3139 
    args = processReturn_args()
3140 
    args.returnOrderId = returnOrderId
3141 
    args.write(self._oprot)
3142 
    self._oprot.writeMessageEnd()
3143 
    self._oprot.trans.flush()
3144 
 
3145 
  def recv_processReturn(self, ):
3146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3147 
    if mtype == TMessageType.EXCEPTION:
3148 
      x = TApplicationException()
3149 
      x.read(self._iprot)
3150 
      self._iprot.readMessageEnd()
3151 
      raise x
3152 
    result = processReturn_result()
3153 
    result.read(self._iprot)
3154 
    self._iprot.readMessageEnd()
3431 rajveer 3155 
    if result.ex is not None:
2690 chandransh 3156 
      raise result.ex
3157 
    return
3158 
 
3451 chandransh 3159 
  def updateWeight(self, orderId, weight):
3160 
    """
3161 
    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 3162 
 
3451 chandransh 3163 
    Parameters:
3164 
     - orderId
3165 
     - weight
3166 
    """
3167 
    self.send_updateWeight(orderId, weight)
3168 
    return self.recv_updateWeight()
3169 
 
3170 
  def send_updateWeight(self, orderId, weight):
3171 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3172 
    args = updateWeight_args()
3173 
    args.orderId = orderId
3174 
    args.weight = weight
3175 
    args.write(self._oprot)
3176 
    self._oprot.writeMessageEnd()
3177 
    self._oprot.trans.flush()
3178 
 
3179 
  def recv_updateWeight(self, ):
3180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3181 
    if mtype == TMessageType.EXCEPTION:
3182 
      x = TApplicationException()
3183 
      x.read(self._iprot)
3184 
      self._iprot.readMessageEnd()
3185 
      raise x
3186 
    result = updateWeight_result()
3187 
    result.read(self._iprot)
3188 
    self._iprot.readMessageEnd()
3189 
    if result.success is not None:
3190 
      return result.success
3191 
    if result.ex is not None:
3192 
      raise result.ex
3193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3194 
 
3469 chandransh 3195 
  def changeItem(self, orderId, itemId):
3196 
    """
3197 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3198 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3199 
 
3469 chandransh 3200 
    Parameters:
3201 
     - orderId
3202 
     - itemId
3203 
    """
3204 
    self.send_changeItem(orderId, itemId)
3205 
    return self.recv_changeItem()
3206 
 
3207 
  def send_changeItem(self, orderId, itemId):
3208 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3209 
    args = changeItem_args()
3210 
    args.orderId = orderId
3211 
    args.itemId = itemId
3212 
    args.write(self._oprot)
3213 
    self._oprot.writeMessageEnd()
3214 
    self._oprot.trans.flush()
3215 
 
3216 
  def recv_changeItem(self, ):
3217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3218 
    if mtype == TMessageType.EXCEPTION:
3219 
      x = TApplicationException()
3220 
      x.read(self._iprot)
3221 
      self._iprot.readMessageEnd()
3222 
      raise x
3223 
    result = changeItem_result()
3224 
    result.read(self._iprot)
3225 
    self._iprot.readMessageEnd()
3226 
    if result.success is not None:
3227 
      return result.success
3228 
    if result.ex is not None:
3229 
      raise result.ex
3230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3231 
 
3232 
  def shiftToWarehouse(self, orderId, warehouseId):
3233 
    """
3234 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3235 
 
3236 
    Parameters:
3237 
     - orderId
3238 
     - warehouseId
3239 
    """
3240 
    self.send_shiftToWarehouse(orderId, warehouseId)
3241 
    return self.recv_shiftToWarehouse()
3242 
 
3243 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3244 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3245 
    args = shiftToWarehouse_args()
3246 
    args.orderId = orderId
3247 
    args.warehouseId = warehouseId
3248 
    args.write(self._oprot)
3249 
    self._oprot.writeMessageEnd()
3250 
    self._oprot.trans.flush()
3251 
 
3252 
  def recv_shiftToWarehouse(self, ):
3253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3254 
    if mtype == TMessageType.EXCEPTION:
3255 
      x = TApplicationException()
3256 
      x.read(self._iprot)
3257 
      self._iprot.readMessageEnd()
3258 
      raise x
3259 
    result = shiftToWarehouse_result()
3260 
    result.read(self._iprot)
3261 
    self._iprot.readMessageEnd()
3262 
    if result.success is not None:
3263 
      return result.success
3264 
    if result.ex is not None:
3265 
      raise result.ex
3266 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3267 
 
4647 rajveer 3268 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3269 
    """
3270 
    Adds the given delay reason to the given order.
3986 chandransh 3271 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3272 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3273 
 
3553 chandransh 3274 
    Parameters:
3275 
     - orderId
3276 
     - delayReason
3986 chandransh 3277 
     - furtherDelay
4647 rajveer 3278 
     - delayReasonText
3553 chandransh 3279 
    """
4647 rajveer 3280 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3281 
    return self.recv_addDelayReason()
3282 
 
4647 rajveer 3283 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3284 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3285 
    args = addDelayReason_args()
3286 
    args.orderId = orderId
3287 
    args.delayReason = delayReason
3986 chandransh 3288 
    args.furtherDelay = furtherDelay
4647 rajveer 3289 
    args.delayReasonText = delayReasonText
3553 chandransh 3290 
    args.write(self._oprot)
3291 
    self._oprot.writeMessageEnd()
3292 
    self._oprot.trans.flush()
3293 
 
3294 
  def recv_addDelayReason(self, ):
3295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3296 
    if mtype == TMessageType.EXCEPTION:
3297 
      x = TApplicationException()
3298 
      x.read(self._iprot)
3299 
      self._iprot.readMessageEnd()
3300 
      raise x
3301 
    result = addDelayReason_result()
3302 
    result.read(self._iprot)
3303 
    self._iprot.readMessageEnd()
3304 
    if result.success is not None:
3305 
      return result.success
3306 
    if result.ex is not None:
3307 
      raise result.ex
3308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3309 
 
3956 chandransh 3310 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3311 
    """
3312 
    Marks the COD orders with given AWB nos. as having been processed.
3313 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3314 
 
3956 chandransh 3315 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3316 
    1. There is no order corresponding to an AWB number.
3317 
    2. The captured amount for a payment exceeds the total payment.
3318 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3319 
 
3320 
    Parameters:
3321 
     - collectedAmountMap
3322 
     - xferBy
3323 
     - xferTxnId
3324 
     - xferDate
3325 
    """
3326 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3327 
    return self.recv_reconcileCodCollection()
3328 
 
3329 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3330 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3331 
    args = reconcileCodCollection_args()
3332 
    args.collectedAmountMap = collectedAmountMap
3333 
    args.xferBy = xferBy
3334 
    args.xferTxnId = xferTxnId
3335 
    args.xferDate = xferDate
3336 
    args.write(self._oprot)
3337 
    self._oprot.writeMessageEnd()
3338 
    self._oprot.trans.flush()
3339 
 
3340 
  def recv_reconcileCodCollection(self, ):
3341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3342 
    if mtype == TMessageType.EXCEPTION:
3343 
      x = TApplicationException()
3344 
      x.read(self._iprot)
3345 
      self._iprot.readMessageEnd()
3346 
      raise x
3347 
    result = reconcileCodCollection_result()
3348 
    result.read(self._iprot)
3349 
    self._iprot.readMessageEnd()
3350 
    if result.success is not None:
3351 
      return result.success
3352 
    if result.ex is not None:
3353 
      raise result.ex
3354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3355 
 
4008 mandeep.dh 3356 
  def getTransactionsRequiringExtraProcessing(self, category):
3357 
    """
4065 mandeep.dh 3358 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3359 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3360 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3361 
 
4008 mandeep.dh 3362 
    Parameters:
3363 
     - category
3364 
    """
3365 
    self.send_getTransactionsRequiringExtraProcessing(category)
3366 
    return self.recv_getTransactionsRequiringExtraProcessing()
3367 
 
3368 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3369 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3370 
    args = getTransactionsRequiringExtraProcessing_args()
3371 
    args.category = category
3372 
    args.write(self._oprot)
3373 
    self._oprot.writeMessageEnd()
3374 
    self._oprot.trans.flush()
3375 
 
3376 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3378 
    if mtype == TMessageType.EXCEPTION:
3379 
      x = TApplicationException()
3380 
      x.read(self._iprot)
3381 
      self._iprot.readMessageEnd()
3382 
      raise x
3383 
    result = getTransactionsRequiringExtraProcessing_result()
3384 
    result.read(self._iprot)
3385 
    self._iprot.readMessageEnd()
3386 
    if result.success is not None:
3387 
      return result.success
3388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3389 
 
3390 
  def markTransactionAsProcessed(self, transactionId, category):
3391 
    """
3392 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3393 
    It essentially deletes the transaction id record for a particular
3394 
    processing type category (if present) from DB.
3395 
    This is currently used by CRM application.
4008 mandeep.dh 3396 
 
3397 
    Parameters:
3398 
     - transactionId
3399 
     - category
3400 
    """
3401 
    self.send_markTransactionAsProcessed(transactionId, category)
3402 
    self.recv_markTransactionAsProcessed()
3403 
 
3404 
  def send_markTransactionAsProcessed(self, transactionId, category):
3405 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3406 
    args = markTransactionAsProcessed_args()
3407 
    args.transactionId = transactionId
3408 
    args.category = category
3409 
    args.write(self._oprot)
3410 
    self._oprot.writeMessageEnd()
3411 
    self._oprot.trans.flush()
3412 
 
3413 
  def recv_markTransactionAsProcessed(self, ):
3414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3415 
    if mtype == TMessageType.EXCEPTION:
3416 
      x = TApplicationException()
3417 
      x.read(self._iprot)
3418 
      self._iprot.readMessageEnd()
3419 
      raise x
3420 
    result = markTransactionAsProcessed_result()
3421 
    result.read(self._iprot)
3422 
    self._iprot.readMessageEnd()
3423 
    return
3424 
 
4018 chandransh 3425 
  def getItemWiseRiskyOrdersCount(self, ):
3426 
    """
3427 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3428 
    is defined as one whose shipping date is about to expire.
3429 
    """
3430 
    self.send_getItemWiseRiskyOrdersCount()
3431 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3432 
 
4018 chandransh 3433 
  def send_getItemWiseRiskyOrdersCount(self, ):
3434 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3435 
    args = getItemWiseRiskyOrdersCount_args()
3436 
    args.write(self._oprot)
3437 
    self._oprot.writeMessageEnd()
3438 
    self._oprot.trans.flush()
3439 
 
3440 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3442 
    if mtype == TMessageType.EXCEPTION:
3443 
      x = TApplicationException()
3444 
      x.read(self._iprot)
3445 
      self._iprot.readMessageEnd()
3446 
      raise x
3447 
    result = getItemWiseRiskyOrdersCount_result()
3448 
    result.read(self._iprot)
3449 
    self._iprot.readMessageEnd()
3450 
    if result.success is not None:
3451 
      return result.success
3452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3453 
 
4295 varun.gupt 3454 
  def getOrdersForItemIds(self, itemIds):
3455 
    """
3456 
    Returns a list of all orders which have items with given id
3457 
 
3458 
    Parameters:
3459 
     - itemIds
3460 
    """
3461 
    self.send_getOrdersForItemIds(itemIds)
3462 
    return self.recv_getOrdersForItemIds()
3463 
 
3464 
  def send_getOrdersForItemIds(self, itemIds):
3465 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3466 
    args = getOrdersForItemIds_args()
3467 
    args.itemIds = itemIds
3468 
    args.write(self._oprot)
3469 
    self._oprot.writeMessageEnd()
3470 
    self._oprot.trans.flush()
3471 
 
3472 
  def recv_getOrdersForItemIds(self, ):
3473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3474 
    if mtype == TMessageType.EXCEPTION:
3475 
      x = TApplicationException()
3476 
      x.read(self._iprot)
3477 
      self._iprot.readMessageEnd()
3478 
      raise x
3479 
    result = getOrdersForItemIds_result()
3480 
    result.read(self._iprot)
3481 
    self._iprot.readMessageEnd()
3482 
    if result.success is not None:
3483 
      return result.success
3484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3485 
 
4247 rajveer 3486 
  def markOrderCancellationRequestReceived(self, orderId):
3487 
    """
3488 
    Mark order as cancellation request received. If customer sends request of cancellation of
3489 
    a particular order, this method will be called. It will just change status of the order
3490 
    depending on its current status. It also records the previous status, so that we can move
3491 
    back to that status if cancellation request is denied.
4018 chandransh 3492 
 
4247 rajveer 3493 
    Parameters:
3494 
     - orderId
3495 
    """
3496 
    self.send_markOrderCancellationRequestReceived(orderId)
3497 
    self.recv_markOrderCancellationRequestReceived()
3498 
 
3499 
  def send_markOrderCancellationRequestReceived(self, orderId):
3500 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3501 
    args = markOrderCancellationRequestReceived_args()
3502 
    args.orderId = orderId
3503 
    args.write(self._oprot)
3504 
    self._oprot.writeMessageEnd()
3505 
    self._oprot.trans.flush()
3506 
 
3507 
  def recv_markOrderCancellationRequestReceived(self, ):
3508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3509 
    if mtype == TMessageType.EXCEPTION:
3510 
      x = TApplicationException()
3511 
      x.read(self._iprot)
3512 
      self._iprot.readMessageEnd()
3513 
      raise x
3514 
    result = markOrderCancellationRequestReceived_result()
3515 
    result.read(self._iprot)
3516 
    self._iprot.readMessageEnd()
3517 
    if result.ex is not None:
3518 
      raise result.ex
3519 
    return
3520 
 
3521 
  def markOrderCancellationRequestConfirmed(self, orderId):
3522 
    """
3523 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3524 
    cancellation request confirmed. After this OM will be able to cancel the order.
3525 
 
3526 
    Parameters:
3527 
     - orderId
3528 
    """
3529 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3530 
    self.recv_markOrderCancellationRequestConfirmed()
3531 
 
3532 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3533 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3534 
    args = markOrderCancellationRequestConfirmed_args()
3535 
    args.orderId = orderId
3536 
    args.write(self._oprot)
3537 
    self._oprot.writeMessageEnd()
3538 
    self._oprot.trans.flush()
3539 
 
3540 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3542 
    if mtype == TMessageType.EXCEPTION:
3543 
      x = TApplicationException()
3544 
      x.read(self._iprot)
3545 
      self._iprot.readMessageEnd()
3546 
      raise x
3547 
    result = markOrderCancellationRequestConfirmed_result()
3548 
    result.read(self._iprot)
3549 
    self._iprot.readMessageEnd()
3550 
    if result.ex is not None:
3551 
      raise result.ex
3552 
    return
3553 
 
3554 
  def markOrderCancellationRequestDenied(self, orderId):
3555 
    """
3556 
    If we decide to not to cancel order, we will move the order ro previous status.
3557 
 
3558 
    Parameters:
3559 
     - orderId
3560 
    """
3561 
    self.send_markOrderCancellationRequestDenied(orderId)
3562 
    self.recv_markOrderCancellationRequestDenied()
3563 
 
3564 
  def send_markOrderCancellationRequestDenied(self, orderId):
3565 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3566 
    args = markOrderCancellationRequestDenied_args()
3567 
    args.orderId = orderId
3568 
    args.write(self._oprot)
3569 
    self._oprot.writeMessageEnd()
3570 
    self._oprot.trans.flush()
3571 
 
3572 
  def recv_markOrderCancellationRequestDenied(self, ):
3573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3574 
    if mtype == TMessageType.EXCEPTION:
3575 
      x = TApplicationException()
3576 
      x.read(self._iprot)
3577 
      self._iprot.readMessageEnd()
3578 
      raise x
3579 
    result = markOrderCancellationRequestDenied_result()
3580 
    result.read(self._iprot)
3581 
    self._iprot.readMessageEnd()
3582 
    if result.ex is not None:
3583 
      raise result.ex
3584 
    return
3585 
 
4258 rajveer 3586 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3587 
    """
4258 rajveer 3588 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3589 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3590 
 
3591 
    Parameters:
4258 rajveer 3592 
     - transactionId
4247 rajveer 3593 
    """
4258 rajveer 3594 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3595 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3596 
 
4258 rajveer 3597 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3598 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3599 
    args = markTransactionAsPaymentFlagRemoved_args()
3600 
    args.transactionId = transactionId
4247 rajveer 3601 
    args.write(self._oprot)
3602 
    self._oprot.writeMessageEnd()
3603 
    self._oprot.trans.flush()
3604 
 
4258 rajveer 3605 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3607 
    if mtype == TMessageType.EXCEPTION:
3608 
      x = TApplicationException()
3609 
      x.read(self._iprot)
3610 
      self._iprot.readMessageEnd()
3611 
      raise x
4258 rajveer 3612 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3613 
    result.read(self._iprot)
3614 
    self._iprot.readMessageEnd()
3615 
    if result.ex is not None:
3616 
      raise result.ex
3617 
    return
3618 
 
4259 anupam.sin 3619 
  def refundTransaction(self, transactionId, refundedBy, reason):
3620 
    """
3621 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3622 
    need to be cancelled
4247 rajveer 3623 
 
4259 anupam.sin 3624 
    Parameters:
3625 
     - transactionId
3626 
     - refundedBy
3627 
     - reason
3628 
    """
3629 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3630 
    self.recv_refundTransaction()
3631 
 
3632 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3633 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3634 
    args = refundTransaction_args()
3635 
    args.transactionId = transactionId
3636 
    args.refundedBy = refundedBy
3637 
    args.reason = reason
3638 
    args.write(self._oprot)
3639 
    self._oprot.writeMessageEnd()
3640 
    self._oprot.trans.flush()
3641 
 
3642 
  def recv_refundTransaction(self, ):
3643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3644 
    if mtype == TMessageType.EXCEPTION:
3645 
      x = TApplicationException()
3646 
      x.read(self._iprot)
3647 
      self._iprot.readMessageEnd()
3648 
      raise x
3649 
    result = refundTransaction_result()
3650 
    result.read(self._iprot)
3651 
    self._iprot.readMessageEnd()
3652 
    if result.ex is not None:
3653 
      raise result.ex
3654 
    return
3655 
 
4324 mandeep.dh 3656 
  def updateShipmentAddress(self, orderId, addressId):
3657 
    """
3658 
    Updates shipment address of an order. Delivery and shipping date estimates
3659 
    etc. are also updated here.
3660 
 
3661 
    Throws TransactionServiceException in case address change is not
3662 
    possible due to certain reasons such as new pincode in address is
3663 
    not serviceable etc.
3664 
 
3665 
    Parameters:
3666 
     - orderId
3667 
     - addressId
3668 
    """
3669 
    self.send_updateShipmentAddress(orderId, addressId)
3670 
    self.recv_updateShipmentAddress()
3671 
 
3672 
  def send_updateShipmentAddress(self, orderId, addressId):
3673 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3674 
    args = updateShipmentAddress_args()
3675 
    args.orderId = orderId
3676 
    args.addressId = addressId
3677 
    args.write(self._oprot)
3678 
    self._oprot.writeMessageEnd()
3679 
    self._oprot.trans.flush()
3680 
 
3681 
  def recv_updateShipmentAddress(self, ):
3682 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3683 
    if mtype == TMessageType.EXCEPTION:
3684 
      x = TApplicationException()
3685 
      x.read(self._iprot)
3686 
      self._iprot.readMessageEnd()
3687 
      raise x
3688 
    result = updateShipmentAddress_result()
3689 
    result.read(self._iprot)
3690 
    self._iprot.readMessageEnd()
3691 
    if result.ex is not None:
3692 
      raise result.ex
3693 
    return
3694 
 
4285 rajveer 3695 
  def acceptOrdersForItemId(self, itemId, inventory):
3696 
    """
3697 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3698 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3699 
 
4285 rajveer 3700 
    Parameters:
3701 
     - itemId
3702 
     - inventory
3703 
    """
3704 
    self.send_acceptOrdersForItemId(itemId, inventory)
3705 
    return self.recv_acceptOrdersForItemId()
3706 
 
3707 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3708 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3709 
    args = acceptOrdersForItemId_args()
3710 
    args.itemId = itemId
3711 
    args.inventory = inventory
3712 
    args.write(self._oprot)
3713 
    self._oprot.writeMessageEnd()
3714 
    self._oprot.trans.flush()
3715 
 
3716 
  def recv_acceptOrdersForItemId(self, ):
3717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3718 
    if mtype == TMessageType.EXCEPTION:
3719 
      x = TApplicationException()
3720 
      x.read(self._iprot)
3721 
      self._iprot.readMessageEnd()
3722 
      raise x
3723 
    result = acceptOrdersForItemId_result()
3724 
    result.read(self._iprot)
3725 
    self._iprot.readMessageEnd()
3726 
    if result.success is not None:
3727 
      return result.success
3728 
    if result.ex is not None:
3729 
      raise result.ex
3730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3731 
 
4369 rajveer 3732 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3733 
    """
3734 
    Parameters:
3735 
     - vendorId
3736 
     - itemId
3737 
     - quantity
3738 
     - estimate
4369 rajveer 3739 
     - isReminder
4303 rajveer 3740 
    """
4369 rajveer 3741 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3742 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3743 
 
4369 rajveer 3744 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3745 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3746 
    args = markOrdersAsPORaised_args()
3747 
    args.vendorId = vendorId
3748 
    args.itemId = itemId
3749 
    args.quantity = quantity
3750 
    args.estimate = estimate
4369 rajveer 3751 
    args.isReminder = isReminder
4303 rajveer 3752 
    args.write(self._oprot)
3753 
    self._oprot.writeMessageEnd()
3754 
    self._oprot.trans.flush()
3755 
 
3756 
  def recv_markOrdersAsPORaised(self, ):
3757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3758 
    if mtype == TMessageType.EXCEPTION:
3759 
      x = TApplicationException()
3760 
      x.read(self._iprot)
3761 
      self._iprot.readMessageEnd()
3762 
      raise x
3763 
    result = markOrdersAsPORaised_result()
3764 
    result.read(self._iprot)
3765 
    self._iprot.readMessageEnd()
3766 
    if result.ex is not None:
3767 
      raise result.ex
3768 
    return
3769 
 
4369 rajveer 3770 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3771 
    """
3772 
    Parameters:
3773 
     - vendorId
3774 
     - itemId
3775 
     - quantity
3776 
     - estimate
4369 rajveer 3777 
     - isReminder
4303 rajveer 3778 
    """
4369 rajveer 3779 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3780 
    self.recv_markOrdersAsReversalInitiated()
3781 
 
4369 rajveer 3782 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3783 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3784 
    args = markOrdersAsReversalInitiated_args()
3785 
    args.vendorId = vendorId
3786 
    args.itemId = itemId
3787 
    args.quantity = quantity
3788 
    args.estimate = estimate
4369 rajveer 3789 
    args.isReminder = isReminder
4303 rajveer 3790 
    args.write(self._oprot)
3791 
    self._oprot.writeMessageEnd()
3792 
    self._oprot.trans.flush()
3793 
 
3794 
  def recv_markOrdersAsReversalInitiated(self, ):
3795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3796 
    if mtype == TMessageType.EXCEPTION:
3797 
      x = TApplicationException()
3798 
      x.read(self._iprot)
3799 
      self._iprot.readMessageEnd()
3800 
      raise x
3801 
    result = markOrdersAsReversalInitiated_result()
3802 
    result.read(self._iprot)
3803 
    self._iprot.readMessageEnd()
3804 
    if result.ex is not None:
3805 
      raise result.ex
3806 
    return
3807 
 
4369 rajveer 3808 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3809 
    """
3810 
    Parameters:
3811 
     - vendorId
3812 
     - itemId
3813 
     - quantity
3814 
     - estimate
4369 rajveer 3815 
     - isReminder
4303 rajveer 3816 
    """
4369 rajveer 3817 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3818 
    self.recv_markOrdersAsNotAvailabke()
3819 
 
4369 rajveer 3820 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3821 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3822 
    args = markOrdersAsNotAvailabke_args()
3823 
    args.vendorId = vendorId
3824 
    args.itemId = itemId
3825 
    args.quantity = quantity
3826 
    args.estimate = estimate
4369 rajveer 3827 
    args.isReminder = isReminder
4303 rajveer 3828 
    args.write(self._oprot)
3829 
    self._oprot.writeMessageEnd()
3830 
    self._oprot.trans.flush()
3831 
 
3832 
  def recv_markOrdersAsNotAvailabke(self, ):
3833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3834 
    if mtype == TMessageType.EXCEPTION:
3835 
      x = TApplicationException()
3836 
      x.read(self._iprot)
3837 
      self._iprot.readMessageEnd()
3838 
      raise x
3839 
    result = markOrdersAsNotAvailabke_result()
3840 
    result.read(self._iprot)
3841 
    self._iprot.readMessageEnd()
3842 
    if result.ex is not None:
3843 
      raise result.ex
3844 
    return
3845 
 
4369 rajveer 3846 
  def markOrdersAsTimeout(self, vendorId):
3847 
    """
3848 
    Parameters:
3849 
     - vendorId
3850 
    """
3851 
    self.send_markOrdersAsTimeout(vendorId)
3852 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3853 
 
4369 rajveer 3854 
  def send_markOrdersAsTimeout(self, vendorId):
3855 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3856 
    args = markOrdersAsTimeout_args()
3857 
    args.vendorId = vendorId
3858 
    args.write(self._oprot)
3859 
    self._oprot.writeMessageEnd()
3860 
    self._oprot.trans.flush()
3861 
 
3862 
  def recv_markOrdersAsTimeout(self, ):
3863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3864 
    if mtype == TMessageType.EXCEPTION:
3865 
      x = TApplicationException()
3866 
      x.read(self._iprot)
3867 
      self._iprot.readMessageEnd()
3868 
      raise x
3869 
    result = markOrdersAsTimeout_result()
3870 
    result.read(self._iprot)
3871 
    self._iprot.readMessageEnd()
3872 
    if result.success is not None:
3873 
      return result.success
3874 
    if result.ex is not None:
3875 
      raise result.ex
3876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3877 
 
4662 rajveer 3878 
  def markOrderAsLostInTransit(self, orderId):
3879 
    """
3880 
    Mark order as LOST_IN_TRANSIT
3881 
 
3882 
    Parameters:
3883 
     - orderId
3884 
    """
3885 
    self.send_markOrderAsLostInTransit(orderId)
3886 
    return self.recv_markOrderAsLostInTransit()
3887 
 
3888 
  def send_markOrderAsLostInTransit(self, orderId):
3889 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
3890 
    args = markOrderAsLostInTransit_args()
3891 
    args.orderId = orderId
3892 
    args.write(self._oprot)
3893 
    self._oprot.writeMessageEnd()
3894 
    self._oprot.trans.flush()
3895 
 
3896 
  def recv_markOrderAsLostInTransit(self, ):
3897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3898 
    if mtype == TMessageType.EXCEPTION:
3899 
      x = TApplicationException()
3900 
      x.read(self._iprot)
3901 
      self._iprot.readMessageEnd()
3902 
      raise x
3903 
    result = markOrderAsLostInTransit_result()
3904 
    result.read(self._iprot)
3905 
    self._iprot.readMessageEnd()
3906 
    if result.success is not None:
3907 
      return result.success
3908 
    if result.ex is not None:
3909 
      raise result.ex
3910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
3911 
 
4386 anupam.sin 3912 
  def getOrderForAwb(self, awb):
3913 
    """
3914 
    Returns the order corresponding to an AWB number
4369 rajveer 3915 
 
4386 anupam.sin 3916 
    Parameters:
3917 
     - awb
3918 
    """
3919 
    self.send_getOrderForAwb(awb)
3920 
    return self.recv_getOrderForAwb()
3921 
 
3922 
  def send_getOrderForAwb(self, awb):
3923 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3924 
    args = getOrderForAwb_args()
3925 
    args.awb = awb
3926 
    args.write(self._oprot)
3927 
    self._oprot.writeMessageEnd()
3928 
    self._oprot.trans.flush()
3929 
 
3930 
  def recv_getOrderForAwb(self, ):
3931 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3932 
    if mtype == TMessageType.EXCEPTION:
3933 
      x = TApplicationException()
3934 
      x.read(self._iprot)
3935 
      self._iprot.readMessageEnd()
3936 
      raise x
3937 
    result = getOrderForAwb_result()
3938 
    result.read(self._iprot)
3939 
    self._iprot.readMessageEnd()
3940 
    if result.success is not None:
3941 
      return result.success
3942 
    if result.ex is not None:
3943 
      raise result.ex
3944 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3945 
 
4506 phani.kuma 3946 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3947 
    """
3948 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3949 
 
4506 phani.kuma 3950 
    Parameters:
3951 
     - logistics_provider_id
3952 
     - order_status
3953 
    """
3954 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
3955 
    return self.recv_getOrdersForProviderForStatus()
3956 
 
3957 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3958 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
3959 
    args = getOrdersForProviderForStatus_args()
3960 
    args.logistics_provider_id = logistics_provider_id
3961 
    args.order_status = order_status
3962 
    args.write(self._oprot)
3963 
    self._oprot.writeMessageEnd()
3964 
    self._oprot.trans.flush()
3965 
 
3966 
  def recv_getOrdersForProviderForStatus(self, ):
3967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3968 
    if mtype == TMessageType.EXCEPTION:
3969 
      x = TApplicationException()
3970 
      x.read(self._iprot)
3971 
      self._iprot.readMessageEnd()
3972 
      raise x
3973 
    result = getOrdersForProviderForStatus_result()
3974 
    result.read(self._iprot)
3975 
    self._iprot.readMessageEnd()
3976 
    if result.success is not None:
3977 
      return result.success
3978 
    if result.ex is not None:
3979 
      raise result.ex
3980 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
3981 
 
4600 varun.gupt 3982 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3983 
    """
3984 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 3985 
 
4600 varun.gupt 3986 
    Parameters:
3987 
     - vendorId
3988 
     - billingDateFrom
3989 
     - billingDateTo
3990 
    """
3991 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
3992 
    return self.recv_getBilledOrdersForVendor()
3993 
 
3994 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3995 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
3996 
    args = getBilledOrdersForVendor_args()
3997 
    args.vendorId = vendorId
3998 
    args.billingDateFrom = billingDateFrom
3999 
    args.billingDateTo = billingDateTo
4000 
    args.write(self._oprot)
4001 
    self._oprot.writeMessageEnd()
4002 
    self._oprot.trans.flush()
4003 
 
4004 
  def recv_getBilledOrdersForVendor(self, ):
4005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4006 
    if mtype == TMessageType.EXCEPTION:
4007 
      x = TApplicationException()
4008 
      x.read(self._iprot)
4009 
      self._iprot.readMessageEnd()
4010 
      raise x
4011 
    result = getBilledOrdersForVendor_result()
4012 
    result.read(self._iprot)
4013 
    self._iprot.readMessageEnd()
4014 
    if result.success is not None:
4015 
      return result.success
4016 
    if result.ex is not None:
4017 
      raise result.ex
4018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4019 
 
4607 rajveer 4020 
  def getSlippedSippingDateOrders(self, ):
4021 
    self.send_getSlippedSippingDateOrders()
4022 
    return self.recv_getSlippedSippingDateOrders()
4023 
 
4024 
  def send_getSlippedSippingDateOrders(self, ):
4025 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4026 
    args = getSlippedSippingDateOrders_args()
4027 
    args.write(self._oprot)
4028 
    self._oprot.writeMessageEnd()
4029 
    self._oprot.trans.flush()
4030 
 
4031 
  def recv_getSlippedSippingDateOrders(self, ):
4032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4033 
    if mtype == TMessageType.EXCEPTION:
4034 
      x = TApplicationException()
4035 
      x.read(self._iprot)
4036 
      self._iprot.readMessageEnd()
4037 
      raise x
4038 
    result = getSlippedSippingDateOrders_result()
4039 
    result.read(self._iprot)
4040 
    self._iprot.readMessageEnd()
4041 
    if result.success is not None:
4042 
      return result.success
4043 
    if result.ex is not None:
4044 
      raise result.ex
4045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4046 
 
4709 rajveer 4047 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4048 
    """
4049 
    Parameters:
4050 
     - cancelDateFrom
4051 
     - cancelDateTo
4052 
    """
4053 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4054 
    return self.recv_getCancelledOrders()
4055 
 
4056 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4057 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4058 
    args = getCancelledOrders_args()
4059 
    args.cancelDateFrom = cancelDateFrom
4060 
    args.cancelDateTo = cancelDateTo
4061 
    args.write(self._oprot)
4062 
    self._oprot.writeMessageEnd()
4063 
    self._oprot.trans.flush()
4064 
 
4065 
  def recv_getCancelledOrders(self, ):
4066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4067 
    if mtype == TMessageType.EXCEPTION:
4068 
      x = TApplicationException()
4069 
      x.read(self._iprot)
4070 
      self._iprot.readMessageEnd()
4071 
      raise x
4072 
    result = getCancelledOrders_result()
4073 
    result.read(self._iprot)
4074 
    self._iprot.readMessageEnd()
4075 
    if result.success is not None:
4076 
      return result.success
4077 
    if result.ex is not None:
4078 
      raise result.ex
4079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4080 
 
4600 varun.gupt 4081 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4082 
    """
4083 
    Parameters:
4084 
     - mapAWBAndAmount
4085 
    """
4086 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4087 
    self.recv_saveBluedartSettlements()
4088 
 
4089 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4090 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4091 
    args = saveBluedartSettlements_args()
4092 
    args.mapAWBAndAmount = mapAWBAndAmount
4093 
    args.write(self._oprot)
4094 
    self._oprot.writeMessageEnd()
4095 
    self._oprot.trans.flush()
4096 
 
4097 
  def recv_saveBluedartSettlements(self, ):
4098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4099 
    if mtype == TMessageType.EXCEPTION:
4100 
      x = TApplicationException()
4101 
      x.read(self._iprot)
4102 
      self._iprot.readMessageEnd()
4103 
      raise x
4104 
    result = saveBluedartSettlements_result()
4105 
    result.read(self._iprot)
4106 
    self._iprot.readMessageEnd()
4107 
    if result.ex is not None:
4108 
      raise result.ex
4109 
    return
4110 
 
4111 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4112 
    """
4113 
    Parameters:
4114 
     - settlementDate
4115 
     - paymentGatewayId
4116 
     - paymentId
4117 
     - serviceTax
4118 
     - otherCharges
4119 
     - netCollection
4120 
    """
4121 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection)
4122 
    self.recv_savePaymentSettlements()
4123 
 
4124 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4125 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4126 
    args = savePaymentSettlements_args()
4127 
    args.settlementDate = settlementDate
4128 
    args.paymentGatewayId = paymentGatewayId
4129 
    args.paymentId = paymentId
4130 
    args.serviceTax = serviceTax
4131 
    args.otherCharges = otherCharges
4132 
    args.netCollection = netCollection
4133 
    args.write(self._oprot)
4134 
    self._oprot.writeMessageEnd()
4135 
    self._oprot.trans.flush()
4136 
 
4137 
  def recv_savePaymentSettlements(self, ):
4138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4139 
    if mtype == TMessageType.EXCEPTION:
4140 
      x = TApplicationException()
4141 
      x.read(self._iprot)
4142 
      self._iprot.readMessageEnd()
4143 
      raise x
4144 
    result = savePaymentSettlements_result()
4145 
    result.read(self._iprot)
4146 
    self._iprot.readMessageEnd()
4147 
    if result.ex is not None:
4148 
      raise result.ex
4149 
    return
4150 
 
4151 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4152 
    """
4153 
    Parameters:
4154 
     - settlementId
4155 
     - settlementDate
4156 
     - transactionDateFrom
4157 
     - transactionDateTo
4158 
     - amount
4159 
    """
4160 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4161 
    self.recv_saveEBSSettlementSummary()
4162 
 
4163 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4164 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4165 
    args = saveEBSSettlementSummary_args()
4166 
    args.settlementId = settlementId
4167 
    args.settlementDate = settlementDate
4168 
    args.transactionDateFrom = transactionDateFrom
4169 
    args.transactionDateTo = transactionDateTo
4170 
    args.amount = amount
4171 
    args.write(self._oprot)
4172 
    self._oprot.writeMessageEnd()
4173 
    self._oprot.trans.flush()
4174 
 
4175 
  def recv_saveEBSSettlementSummary(self, ):
4176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4177 
    if mtype == TMessageType.EXCEPTION:
4178 
      x = TApplicationException()
4179 
      x.read(self._iprot)
4180 
      self._iprot.readMessageEnd()
4181 
      raise x
4182 
    result = saveEBSSettlementSummary_result()
4183 
    result.read(self._iprot)
4184 
    self._iprot.readMessageEnd()
4185 
    if result.ex is not None:
4186 
      raise result.ex
4187 
    return
4188 
 
4189 
  def getSettlementForPaymentId(self, paymentId):
4190 
    """
4191 
    Parameters:
4192 
     - paymentId
4193 
    """
4194 
    self.send_getSettlementForPaymentId(paymentId)
4195 
    return self.recv_getSettlementForPaymentId()
4196 
 
4197 
  def send_getSettlementForPaymentId(self, paymentId):
4198 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4199 
    args = getSettlementForPaymentId_args()
4200 
    args.paymentId = paymentId
4201 
    args.write(self._oprot)
4202 
    self._oprot.writeMessageEnd()
4203 
    self._oprot.trans.flush()
4204 
 
4205 
  def recv_getSettlementForPaymentId(self, ):
4206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4207 
    if mtype == TMessageType.EXCEPTION:
4208 
      x = TApplicationException()
4209 
      x.read(self._iprot)
4210 
      self._iprot.readMessageEnd()
4211 
      raise x
4212 
    result = getSettlementForPaymentId_result()
4213 
    result.read(self._iprot)
4214 
    self._iprot.readMessageEnd()
4215 
    if result.success is not None:
4216 
      return result.success
4217 
    if result.ex is not None:
4218 
      raise result.ex
4219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4220 
 
4221 
  def getEBSSettlementSummaries(self, ):
4222 
    self.send_getEBSSettlementSummaries()
4223 
    return self.recv_getEBSSettlementSummaries()
4224 
 
4225 
  def send_getEBSSettlementSummaries(self, ):
4226 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4227 
    args = getEBSSettlementSummaries_args()
4228 
    args.write(self._oprot)
4229 
    self._oprot.writeMessageEnd()
4230 
    self._oprot.trans.flush()
4231 
 
4232 
  def recv_getEBSSettlementSummaries(self, ):
4233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4234 
    if mtype == TMessageType.EXCEPTION:
4235 
      x = TApplicationException()
4236 
      x.read(self._iprot)
4237 
      self._iprot.readMessageEnd()
4238 
      raise x
4239 
    result = getEBSSettlementSummaries_result()
4240 
    result.read(self._iprot)
4241 
    self._iprot.readMessageEnd()
4242 
    if result.success is not None:
4243 
      return result.success
4244 
    if result.ex is not None:
4245 
      raise result.ex
4246 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4247 
 
4248 
  def markEBSSettlementUploaded(self, settlementId):
4249 
    """
4250 
    Parameters:
4251 
     - settlementId
4252 
    """
4253 
    self.send_markEBSSettlementUploaded(settlementId)
4254 
    self.recv_markEBSSettlementUploaded()
4255 
 
4256 
  def send_markEBSSettlementUploaded(self, settlementId):
4257 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4258 
    args = markEBSSettlementUploaded_args()
4259 
    args.settlementId = settlementId
4260 
    args.write(self._oprot)
4261 
    self._oprot.writeMessageEnd()
4262 
    self._oprot.trans.flush()
4263 
 
4264 
  def recv_markEBSSettlementUploaded(self, ):
4265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4266 
    if mtype == TMessageType.EXCEPTION:
4267 
      x = TApplicationException()
4268 
      x.read(self._iprot)
4269 
      self._iprot.readMessageEnd()
4270 
      raise x
4271 
    result = markEBSSettlementUploaded_result()
4272 
    result.read(self._iprot)
4273 
    self._iprot.readMessageEnd()
4274 
    if result.ex is not None:
4275 
      raise result.ex
4276 
    return
4277 
 
4278 
  def getEBSSettlementDate(self, settlementId):
4279 
    """
4280 
    Parameters:
4281 
     - settlementId
4282 
    """
4283 
    self.send_getEBSSettlementDate(settlementId)
4284 
    return self.recv_getEBSSettlementDate()
4285 
 
4286 
  def send_getEBSSettlementDate(self, settlementId):
4287 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4288 
    args = getEBSSettlementDate_args()
4289 
    args.settlementId = settlementId
4290 
    args.write(self._oprot)
4291 
    self._oprot.writeMessageEnd()
4292 
    self._oprot.trans.flush()
4293 
 
4294 
  def recv_getEBSSettlementDate(self, ):
4295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4296 
    if mtype == TMessageType.EXCEPTION:
4297 
      x = TApplicationException()
4298 
      x.read(self._iprot)
4299 
      self._iprot.readMessageEnd()
4300 
      raise x
4301 
    result = getEBSSettlementDate_result()
4302 
    result.read(self._iprot)
4303 
    self._iprot.readMessageEnd()
4304 
    if result.success is not None:
4305 
      return result.success
4306 
    if result.ex is not None:
4307 
      raise result.ex
4308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4309 
 
4715 varun.gupt 4310 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4311 
    """
4312 
    Parameters:
4313 
     - settlementDateFrom
4314 
     - settlementDateTo
4315 
     - isRefund
4316 
    """
4317 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4318 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4319 
 
4715 varun.gupt 4320 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4321 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4322 
    args = getSettlementsByDate_args()
4323 
    args.settlementDateFrom = settlementDateFrom
4324 
    args.settlementDateTo = settlementDateTo
4325 
    args.isRefund = isRefund
4326 
    args.write(self._oprot)
4327 
    self._oprot.writeMessageEnd()
4328 
    self._oprot.trans.flush()
4329 
 
4330 
  def recv_getSettlementsByDate(self, ):
4331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4332 
    if mtype == TMessageType.EXCEPTION:
4333 
      x = TApplicationException()
4334 
      x.read(self._iprot)
4335 
      self._iprot.readMessageEnd()
4336 
      raise x
4337 
    result = getSettlementsByDate_result()
4338 
    result.read(self._iprot)
4339 
    self._iprot.readMessageEnd()
4340 
    if result.success is not None:
4341 
      return result.success
4342 
    if result.ex is not None:
4343 
      raise result.ex
4344 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4345 
 
4346 
  def getReshippedOrderIds(self, orderIds):
4347 
    """
4348 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4349 
 
4350 
    Parameters:
4351 
     - orderIds
4352 
    """
4353 
    self.send_getReshippedOrderIds(orderIds)
4354 
    return self.recv_getReshippedOrderIds()
4355 
 
4356 
  def send_getReshippedOrderIds(self, orderIds):
4357 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4358 
    args = getReshippedOrderIds_args()
4359 
    args.orderIds = orderIds
4360 
    args.write(self._oprot)
4361 
    self._oprot.writeMessageEnd()
4362 
    self._oprot.trans.flush()
4363 
 
4364 
  def recv_getReshippedOrderIds(self, ):
4365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4366 
    if mtype == TMessageType.EXCEPTION:
4367 
      x = TApplicationException()
4368 
      x.read(self._iprot)
4369 
      self._iprot.readMessageEnd()
4370 
      raise x
4371 
    result = getReshippedOrderIds_result()
4372 
    result.read(self._iprot)
4373 
    self._iprot.readMessageEnd()
4374 
    if result.success is not None:
4375 
      return result.success
4376 
    if result.ex is not None:
4377 
      raise result.ex
4378 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4379 
 
4757 mandeep.dh 4380 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4381 
    """
4382 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
4383 
    the quantities for which the PO is raised.
4715 varun.gupt 4384 
 
4757 mandeep.dh 4385 
    Parameters:
4386 
     - itemIdQuantityMap
4387 
     - purchaseOrderId
4388 
     - warehouseId
4389 
    """
4390 
    self.send_updateOrdersAsPORaised(itemIdQuantityMap, purchaseOrderId, warehouseId)
4391 
    self.recv_updateOrdersAsPORaised()
4392 
 
4393 
  def send_updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4394 
    self._oprot.writeMessageBegin('updateOrdersAsPORaised', TMessageType.CALL, self._seqid)
4395 
    args = updateOrdersAsPORaised_args()
4396 
    args.itemIdQuantityMap = itemIdQuantityMap
4397 
    args.purchaseOrderId = purchaseOrderId
4398 
    args.warehouseId = warehouseId
4399 
    args.write(self._oprot)
4400 
    self._oprot.writeMessageEnd()
4401 
    self._oprot.trans.flush()
4402 
 
4403 
  def recv_updateOrdersAsPORaised(self, ):
4404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4405 
    if mtype == TMessageType.EXCEPTION:
4406 
      x = TApplicationException()
4407 
      x.read(self._iprot)
4408 
      self._iprot.readMessageEnd()
4409 
      raise x
4410 
    result = updateOrdersAsPORaised_result()
4411 
    result.read(self._iprot)
4412 
    self._iprot.readMessageEnd()
4413 
    if result.ex is not None:
4414 
      raise result.ex
4415 
    return
4416 
 
4417 
 
3376 rajveer 4418 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4419 
  def __init__(self, handler):
3376 rajveer 4420 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4421 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4422 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4423 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4424 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4425 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4426 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4427 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4428 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4429 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4430 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4431 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4432 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4433 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4434 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4435 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4436 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4437 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4438 
    self._processMap["createOrder"] = Processor.process_createOrder
4439 
    self._processMap["getOrder"] = Processor.process_getOrder
4440 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4441 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4442 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4443 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4444 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4445 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4446 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4447 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4448 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4449 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4450 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4451 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4452 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4453 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4454 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 4455 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 4456 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4457 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 4458 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 4459 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 4460 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 4461 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 4462 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 4463 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 4464 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4465 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4466 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4467 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4468 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4469 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4470 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4741 phani.kuma 4471 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
2616 chandransh 4472 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4473 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4474 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4475 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4476 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4477 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4478 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4479 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 4480 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4481 
    self._processMap["changeItem"] = Processor.process_changeItem
4482 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4483 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4484 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4485 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4486 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4487 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4488 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4489 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4490 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4491 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4492 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4493 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4494 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4495 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4496 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4497 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4498 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4499 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 4500 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 4501 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4502 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4503 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4504 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 4505 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 4506 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4507 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4508 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4509 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4510 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4511 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4512 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 4513 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
4514 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4757 mandeep.dh 4515 
    self._processMap["updateOrdersAsPORaised"] = Processor.process_updateOrdersAsPORaised
94 ashish 4516 
 
4517 
  def process(self, iprot, oprot):
4518 
    (name, type, seqid) = iprot.readMessageBegin()
4519 
    if name not in self._processMap:
4520 
      iprot.skip(TType.STRUCT)
4521 
      iprot.readMessageEnd()
4522 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4523 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4524 
      x.write(oprot)
4525 
      oprot.writeMessageEnd()
4526 
      oprot.trans.flush()
4527 
      return
4528 
    else:
4529 
      self._processMap[name](self, seqid, iprot, oprot)
4530 
    return True
4531 
 
4532 
  def process_createTransaction(self, seqid, iprot, oprot):
4533 
    args = createTransaction_args()
4534 
    args.read(iprot)
4535 
    iprot.readMessageEnd()
4536 
    result = createTransaction_result()
4537 
    try:
132 ashish 4538 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4539 
    except TransactionServiceException, ex:
4540 
      result.ex = ex
4541 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4542 
    result.write(oprot)
4543 
    oprot.writeMessageEnd()
4544 
    oprot.trans.flush()
4545 
 
4546 
  def process_getTransaction(self, seqid, iprot, oprot):
4547 
    args = getTransaction_args()
4548 
    args.read(iprot)
4549 
    iprot.readMessageEnd()
4550 
    result = getTransaction_result()
4551 
    try:
4552 
      result.success = self._handler.getTransaction(args.id)
4553 
    except TransactionServiceException, ex:
4554 
      result.ex = ex
4555 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4556 
    result.write(oprot)
4557 
    oprot.writeMessageEnd()
4558 
    oprot.trans.flush()
4559 
 
4560 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4561 
    args = getTransactionsForCustomer_args()
4562 
    args.read(iprot)
4563 
    iprot.readMessageEnd()
4564 
    result = getTransactionsForCustomer_result()
4565 
    try:
4566 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4567 
    except TransactionServiceException, ex:
4568 
      result.ex = ex
4569 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4570 
    result.write(oprot)
4571 
    oprot.writeMessageEnd()
4572 
    oprot.trans.flush()
4573 
 
132 ashish 4574 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4575 
    args = getTransactionsForShoppingCartId_args()
4576 
    args.read(iprot)
4577 
    iprot.readMessageEnd()
4578 
    result = getTransactionsForShoppingCartId_result()
4579 
    try:
4580 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4581 
    except TransactionServiceException, ex:
4582 
      result.ex = ex
4583 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4584 
    result.write(oprot)
4585 
    oprot.writeMessageEnd()
4586 
    oprot.trans.flush()
4587 
 
94 ashish 4588 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4589 
    args = getTransactionStatus_args()
4590 
    args.read(iprot)
4591 
    iprot.readMessageEnd()
4592 
    result = getTransactionStatus_result()
4593 
    try:
4594 
      result.success = self._handler.getTransactionStatus(args.transactionId)
4595 
    except TransactionServiceException, ex:
4596 
      result.ex = ex
4597 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
4598 
    result.write(oprot)
4599 
    oprot.writeMessageEnd()
4600 
    oprot.trans.flush()
4601 
 
4602 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
4603 
    args = changeTransactionStatus_args()
4604 
    args.read(iprot)
4605 
    iprot.readMessageEnd()
4606 
    result = changeTransactionStatus_result()
4607 
    try:
4608 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
4609 
    except TransactionServiceException, ex:
4610 
      result.ex = ex
4611 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
4612 
    result.write(oprot)
4613 
    oprot.writeMessageEnd()
4614 
    oprot.trans.flush()
4615 
 
1398 varun.gupt 4616 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
4617 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 4618 
    args.read(iprot)
4619 
    iprot.readMessageEnd()
1398 varun.gupt 4620 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 4621 
    try:
1398 varun.gupt 4622 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 4623 
    except TransactionServiceException, ex:
4624 
      result.ex = ex
1398 varun.gupt 4625 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 4626 
    result.write(oprot)
4627 
    oprot.writeMessageEnd()
4628 
    oprot.trans.flush()
4629 
 
483 rajveer 4630 
  def process_getAllOrders(self, seqid, iprot, oprot):
4631 
    args = getAllOrders_args()
94 ashish 4632 
    args.read(iprot)
4633 
    iprot.readMessageEnd()
483 rajveer 4634 
    result = getAllOrders_result()
94 ashish 4635 
    try:
483 rajveer 4636 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 4637 
    except TransactionServiceException, ex:
4638 
      result.ex = ex
483 rajveer 4639 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 4640 
    result.write(oprot)
4641 
    oprot.writeMessageEnd()
4642 
    oprot.trans.flush()
4643 
 
4133 chandransh 4644 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
4645 
    args = getOrdersInBatch_args()
4646 
    args.read(iprot)
4647 
    iprot.readMessageEnd()
4648 
    result = getOrdersInBatch_result()
4649 
    try:
4650 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4651 
    except TransactionServiceException, ex:
4652 
      result.ex = ex
4653 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4654 
    result.write(oprot)
4655 
    oprot.writeMessageEnd()
4656 
    oprot.trans.flush()
4657 
 
4658 
  def process_getOrderCount(self, seqid, iprot, oprot):
4659 
    args = getOrderCount_args()
4660 
    args.read(iprot)
4661 
    iprot.readMessageEnd()
4662 
    result = getOrderCount_result()
4663 
    try:
4664 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4665 
    except TransactionServiceException, ex:
4666 
      result.ex = ex
4667 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4668 
    result.write(oprot)
4669 
    oprot.writeMessageEnd()
4670 
    oprot.trans.flush()
4671 
 
999 varun.gupt 4672 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4673 
    args = getOrdersByBillingDate_args()
4674 
    args.read(iprot)
4675 
    iprot.readMessageEnd()
4676 
    result = getOrdersByBillingDate_result()
4677 
    try:
4678 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4679 
    except TransactionServiceException, ex:
4680 
      result.ex = ex
4681 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4682 
    result.write(oprot)
4683 
    oprot.writeMessageEnd()
4684 
    oprot.trans.flush()
4685 
 
3427 chandransh 4686 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4687 
    args = getOrdersByShippingDate_args()
4688 
    args.read(iprot)
4689 
    iprot.readMessageEnd()
4690 
    result = getOrdersByShippingDate_result()
4691 
    try:
3451 chandransh 4692 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4693 
    except TransactionServiceException, ex:
4694 
      result.ex = ex
4695 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4696 
    result.write(oprot)
4697 
    oprot.writeMessageEnd()
4698 
    oprot.trans.flush()
4699 
 
1382 varun.gupt 4700 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4701 
    args = getReturnableOrdersForCustomer_args()
4702 
    args.read(iprot)
4703 
    iprot.readMessageEnd()
4704 
    result = getReturnableOrdersForCustomer_result()
4705 
    try:
4706 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4707 
    except TransactionServiceException, ex:
4708 
      result.ex = ex
4709 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4710 
    result.write(oprot)
4711 
    oprot.writeMessageEnd()
4712 
    oprot.trans.flush()
4713 
 
4714 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4715 
    args = getCancellableOrdersForCustomer_args()
4716 
    args.read(iprot)
4717 
    iprot.readMessageEnd()
4718 
    result = getCancellableOrdersForCustomer_result()
4719 
    try:
4720 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4721 
    except TransactionServiceException, ex:
4722 
      result.ex = ex
4723 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4724 
    result.write(oprot)
4725 
    oprot.writeMessageEnd()
4726 
    oprot.trans.flush()
4727 
 
483 rajveer 4728 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4729 
    args = changeOrderStatus_args()
94 ashish 4730 
    args.read(iprot)
4731 
    iprot.readMessageEnd()
483 rajveer 4732 
    result = changeOrderStatus_result()
94 ashish 4733 
    try:
483 rajveer 4734 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4735 
    except TransactionServiceException, ex:
4736 
      result.ex = ex
483 rajveer 4737 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4738 
    result.write(oprot)
4739 
    oprot.writeMessageEnd()
4740 
    oprot.trans.flush()
4741 
 
483 rajveer 4742 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4743 
    args = getOrdersForTransaction_args()
94 ashish 4744 
    args.read(iprot)
4745 
    iprot.readMessageEnd()
483 rajveer 4746 
    result = getOrdersForTransaction_result()
94 ashish 4747 
    try:
1528 ankur.sing 4748 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4749 
    except TransactionServiceException, ex:
4750 
      result.ex = ex
483 rajveer 4751 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4752 
    result.write(oprot)
4753 
    oprot.writeMessageEnd()
4754 
    oprot.trans.flush()
4755 
 
483 rajveer 4756 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4757 
    args = getOrdersForCustomer_args()
94 ashish 4758 
    args.read(iprot)
4759 
    iprot.readMessageEnd()
483 rajveer 4760 
    result = getOrdersForCustomer_result()
94 ashish 4761 
    try:
3014 chandransh 4762 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4763 
    except TransactionServiceException, ex:
4764 
      result.ex = ex
483 rajveer 4765 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4766 
    result.write(oprot)
4767 
    oprot.writeMessageEnd()
4768 
    oprot.trans.flush()
4769 
 
483 rajveer 4770 
  def process_createOrder(self, seqid, iprot, oprot):
4771 
    args = createOrder_args()
94 ashish 4772 
    args.read(iprot)
4773 
    iprot.readMessageEnd()
483 rajveer 4774 
    result = createOrder_result()
94 ashish 4775 
    try:
483 rajveer 4776 
      result.success = self._handler.createOrder(args.order)
94 ashish 4777 
    except TransactionServiceException, ex:
4778 
      result.ex = ex
483 rajveer 4779 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4780 
    result.write(oprot)
4781 
    oprot.writeMessageEnd()
4782 
    oprot.trans.flush()
4783 
 
483 rajveer 4784 
  def process_getOrder(self, seqid, iprot, oprot):
4785 
    args = getOrder_args()
94 ashish 4786 
    args.read(iprot)
4787 
    iprot.readMessageEnd()
483 rajveer 4788 
    result = getOrder_result()
94 ashish 4789 
    try:
483 rajveer 4790 
      result.success = self._handler.getOrder(args.id)
94 ashish 4791 
    except TransactionServiceException, ex:
4792 
      result.ex = ex
483 rajveer 4793 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4794 
    result.write(oprot)
4795 
    oprot.writeMessageEnd()
4796 
    oprot.trans.flush()
4797 
 
483 rajveer 4798 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4799 
    args = getLineItemsForOrder_args()
94 ashish 4800 
    args.read(iprot)
4801 
    iprot.readMessageEnd()
483 rajveer 4802 
    result = getLineItemsForOrder_result()
94 ashish 4803 
    try:
483 rajveer 4804 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4805 
    except TransactionServiceException, ex:
4806 
      result.ex = ex
483 rajveer 4807 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4808 
    result.write(oprot)
4809 
    oprot.writeMessageEnd()
4810 
    oprot.trans.flush()
4811 
 
1528 ankur.sing 4812 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4813 
    args = getOrderForCustomer_args()
4814 
    args.read(iprot)
4815 
    iprot.readMessageEnd()
4816 
    result = getOrderForCustomer_result()
4817 
    try:
4818 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4819 
    except TransactionServiceException, ex:
4820 
      result.ex = ex
4821 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4822 
    result.write(oprot)
4823 
    oprot.writeMessageEnd()
4824 
    oprot.trans.flush()
4825 
 
3064 chandransh 4826 
  def process_getAlerts(self, seqid, iprot, oprot):
4827 
    args = getAlerts_args()
4828 
    args.read(iprot)
4829 
    iprot.readMessageEnd()
4830 
    result = getAlerts_result()
4444 rajveer 4831 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4832 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4833 
    result.write(oprot)
4834 
    oprot.writeMessageEnd()
4835 
    oprot.trans.flush()
4836 
 
4394 rajveer 4837 
  def process_addAlert(self, seqid, iprot, oprot):
4838 
    args = addAlert_args()
3064 chandransh 4839 
    args.read(iprot)
4840 
    iprot.readMessageEnd()
4394 rajveer 4841 
    result = addAlert_result()
4444 rajveer 4842 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4843 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4844 
    result.write(oprot)
4845 
    oprot.writeMessageEnd()
4846 
    oprot.trans.flush()
4847 
 
4444 rajveer 4848 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4849 
    args = markAlertsAsSeen_args()
4850 
    args.read(iprot)
4851 
    iprot.readMessageEnd()
4852 
    result = markAlertsAsSeen_result()
4853 
    self._handler.markAlertsAsSeen(args.warehouseId)
4854 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4855 
    result.write(oprot)
4856 
    oprot.writeMessageEnd()
4857 
    oprot.trans.flush()
4858 
 
3064 chandransh 4859 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4860 
    args = getValidOrderCount_args()
4861 
    args.read(iprot)
4862 
    iprot.readMessageEnd()
4863 
    result = getValidOrderCount_result()
4864 
    result.success = self._handler.getValidOrderCount()
4865 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4866 
    result.write(oprot)
4867 
    oprot.writeMessageEnd()
4868 
    oprot.trans.flush()
4869 
 
4870 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4871 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4872 
    args.read(iprot)
4873 
    iprot.readMessageEnd()
4874 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4875 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4876 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4877 
    result.write(oprot)
4878 
    oprot.writeMessageEnd()
4879 
    oprot.trans.flush()
4880 
 
4881 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4882 
    args = getValidOrdersAmountRange_args()
4883 
    args.read(iprot)
4884 
    iprot.readMessageEnd()
4885 
    result = getValidOrdersAmountRange_result()
4886 
    result.success = self._handler.getValidOrdersAmountRange()
4887 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4888 
    result.write(oprot)
4889 
    oprot.writeMessageEnd()
4890 
    oprot.trans.flush()
4891 
 
4892 
  def process_getValidOrders(self, seqid, iprot, oprot):
4893 
    args = getValidOrders_args()
4894 
    args.read(iprot)
4895 
    iprot.readMessageEnd()
4896 
    result = getValidOrders_result()
4897 
    result.success = self._handler.getValidOrders(args.limit)
4898 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4899 
    result.write(oprot)
4900 
    oprot.writeMessageEnd()
4901 
    oprot.trans.flush()
4902 
 
1220 chandransh 4903 
  def process_batchOrders(self, seqid, iprot, oprot):
4904 
    args = batchOrders_args()
4905 
    args.read(iprot)
4906 
    iprot.readMessageEnd()
4907 
    result = batchOrders_result()
4908 
    try:
4909 
      result.success = self._handler.batchOrders(args.warehouseId)
4910 
    except TransactionServiceException, ex:
4911 
      result.ex = ex
4912 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4913 
    result.write(oprot)
4914 
    oprot.writeMessageEnd()
4915 
    oprot.trans.flush()
4916 
 
1208 chandransh 4917 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4918 
    args = markOrderAsOutOfStock_args()
4919 
    args.read(iprot)
4920 
    iprot.readMessageEnd()
4921 
    result = markOrderAsOutOfStock_result()
4922 
    try:
4923 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4924 
    except TransactionServiceException, ex:
4925 
      result.ex = ex
4926 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4927 
    result.write(oprot)
4928 
    oprot.writeMessageEnd()
4929 
    oprot.trans.flush()
4930 
 
3064 chandransh 4931 
  def process_verifyOrder(self, seqid, iprot, oprot):
4932 
    args = verifyOrder_args()
759 chandransh 4933 
    args.read(iprot)
4934 
    iprot.readMessageEnd()
3064 chandransh 4935 
    result = verifyOrder_result()
759 chandransh 4936 
    try:
3064 chandransh 4937 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4938 
    except TransactionServiceException, ex:
4939 
      result.ex = ex
3064 chandransh 4940 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4941 
    result.write(oprot)
4942 
    oprot.writeMessageEnd()
4943 
    oprot.trans.flush()
4944 
 
3064 chandransh 4945 
  def process_acceptOrder(self, seqid, iprot, oprot):
4946 
    args = acceptOrder_args()
1113 chandransh 4947 
    args.read(iprot)
4948 
    iprot.readMessageEnd()
3064 chandransh 4949 
    result = acceptOrder_result()
1113 chandransh 4950 
    try:
3064 chandransh 4951 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4952 
    except TransactionServiceException, ex:
4953 
      result.ex = ex
3064 chandransh 4954 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4955 
    result.write(oprot)
4956 
    oprot.writeMessageEnd()
4957 
    oprot.trans.flush()
4958 
 
3064 chandransh 4959 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4960 
    args = addBillingDetails_args()
1135 chandransh 4961 
    args.read(iprot)
4962 
    iprot.readMessageEnd()
3064 chandransh 4963 
    result = addBillingDetails_result()
1135 chandransh 4964 
    try:
4658 mandeep.dh 4965 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.serialNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.vendorId)
1135 chandransh 4966 
    except TransactionServiceException, ex:
4967 
      result.ex = ex
3064 chandransh 4968 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4969 
    result.write(oprot)
4970 
    oprot.writeMessageEnd()
4971 
    oprot.trans.flush()
4972 
 
4579 rajveer 4973 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
4974 
    args = addInvoiceNumber_args()
4975 
    args.read(iprot)
4976 
    iprot.readMessageEnd()
4977 
    result = addInvoiceNumber_result()
4978 
    try:
4979 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber)
4980 
    except TransactionServiceException, ex:
4981 
      result.ex = ex
4982 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
4983 
    result.write(oprot)
4984 
    oprot.writeMessageEnd()
4985 
    oprot.trans.flush()
4986 
 
3064 chandransh 4987 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4988 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4989 
    args.read(iprot)
4990 
    iprot.readMessageEnd()
3064 chandransh 4991 
    result = markOrdersAsManifested_result()
4992 
    try:
4993 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4994 
    except TransactionServiceException, ex:
4995 
      result.ex = ex
4996 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4997 
    result.write(oprot)
4998 
    oprot.writeMessageEnd()
4999 
    oprot.trans.flush()
5000 
 
4410 rajveer 5001 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5002 
    args = markOrdersAsShippedFromWarehouse_args()
5003 
    args.read(iprot)
5004 
    iprot.readMessageEnd()
5005 
    result = markOrdersAsShippedFromWarehouse_result()
5006 
    try:
5007 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
5008 
    except TransactionServiceException, ex:
5009 
      result.ex = ex
5010 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5011 
    result.write(oprot)
5012 
    oprot.writeMessageEnd()
5013 
    oprot.trans.flush()
5014 
 
3064 chandransh 5015 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5016 
    args = markOrdersAsPickedUp_args()
304 ashish 5017 
    args.read(iprot)
5018 
    iprot.readMessageEnd()
3064 chandransh 5019 
    result = markOrdersAsPickedUp_result()
5020 
    try:
5021 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
5022 
    except TransactionServiceException, ex:
5023 
      result.ex = ex
5024 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5025 
    result.write(oprot)
5026 
    oprot.writeMessageEnd()
5027 
    oprot.trans.flush()
94 ashish 5028 
 
3064 chandransh 5029 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5030 
    args = markOrdersAsDelivered_args()
304 ashish 5031 
    args.read(iprot)
5032 
    iprot.readMessageEnd()
3064 chandransh 5033 
    result = markOrdersAsDelivered_result()
5034 
    try:
5035 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5036 
    except TransactionServiceException, ex:
5037 
      result.ex = ex
5038 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5039 
    result.write(oprot)
5040 
    oprot.writeMessageEnd()
5041 
    oprot.trans.flush()
5042 
 
3064 chandransh 5043 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
5044 
    args = markOrdersAsFailed_args()
1596 ankur.sing 5045 
    args.read(iprot)
5046 
    iprot.readMessageEnd()
3064 chandransh 5047 
    result = markOrdersAsFailed_result()
5048 
    try:
5049 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
5050 
    except TransactionServiceException, ex:
5051 
      result.ex = ex
5052 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 5053 
    result.write(oprot)
5054 
    oprot.writeMessageEnd()
5055 
    oprot.trans.flush()
304 ashish 5056 
 
3064 chandransh 5057 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5058 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5059 
    args.read(iprot)
5060 
    iprot.readMessageEnd()
3064 chandransh 5061 
    result = updateNonDeliveryReason_result()
5062 
    try:
4581 phani.kuma 5063 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5064 
    except TransactionServiceException, ex:
5065 
      result.ex = ex
5066 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5067 
    result.write(oprot)
5068 
    oprot.writeMessageEnd()
5069 
    oprot.trans.flush()
1596 ankur.sing 5070 
 
3064 chandransh 5071 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5072 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5073 
    args.read(iprot)
5074 
    iprot.readMessageEnd()
3064 chandransh 5075 
    result = getUndeliveredOrders_result()
5076 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5077 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5078 
    result.write(oprot)
5079 
    oprot.writeMessageEnd()
5080 
    oprot.trans.flush()
5081 
 
2536 chandransh 5082 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5083 
    args = toggleDOAFlag_args()
5084 
    args.read(iprot)
5085 
    iprot.readMessageEnd()
5086 
    result = toggleDOAFlag_result()
5087 
    try:
5088 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5089 
    except TransactionServiceException, ex:
5090 
      result.ex = ex
5091 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5092 
    result.write(oprot)
5093 
    oprot.writeMessageEnd()
5094 
    oprot.trans.flush()
1886 ankur.sing 5095 
 
4712 rajveer 5096 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5097 
    args = markOrderAsDelivered_args()
5098 
    args.read(iprot)
5099 
    iprot.readMessageEnd()
5100 
    result = markOrderAsDelivered_result()
5101 
    try:
5102 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5103 
    except TransactionServiceException, ex:
5104 
      result.ex = ex
5105 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5106 
    result.write(oprot)
5107 
    oprot.writeMessageEnd()
5108 
    oprot.trans.flush()
5109 
 
4454 rajveer 5110 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5111 
    args = markOrderDoaRequestReceived_args()
5112 
    args.read(iprot)
5113 
    iprot.readMessageEnd()
5114 
    result = markOrderDoaRequestReceived_result()
5115 
    try:
5116 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5117 
    except TransactionServiceException, ex:
5118 
      result.ex = ex
5119 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5120 
    result.write(oprot)
5121 
    oprot.writeMessageEnd()
5122 
    oprot.trans.flush()
5123 
 
5124 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5125 
    args = markOrderDoaRequestAuthorized_args()
5126 
    args.read(iprot)
5127 
    iprot.readMessageEnd()
5128 
    result = markOrderDoaRequestAuthorized_result()
5129 
    try:
5130 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5131 
    except TransactionServiceException, ex:
5132 
      result.ex = ex
5133 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5134 
    result.write(oprot)
5135 
    oprot.writeMessageEnd()
5136 
    oprot.trans.flush()
5137 
 
4488 rajveer 5138 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5139 
    args = markOrderReturnRequestReceived_args()
5140 
    args.read(iprot)
5141 
    iprot.readMessageEnd()
5142 
    result = markOrderReturnRequestReceived_result()
5143 
    try:
5144 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5145 
    except TransactionServiceException, ex:
5146 
      result.ex = ex
5147 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5148 
    result.write(oprot)
5149 
    oprot.writeMessageEnd()
5150 
    oprot.trans.flush()
5151 
 
5152 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5153 
    args = markOrderReturnRequestAuthorized_args()
5154 
    args.read(iprot)
5155 
    iprot.readMessageEnd()
5156 
    result = markOrderReturnRequestAuthorized_result()
5157 
    try:
5158 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5159 
    except TransactionServiceException, ex:
5160 
      result.ex = ex
5161 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5162 
    result.write(oprot)
5163 
    oprot.writeMessageEnd()
5164 
    oprot.trans.flush()
5165 
 
2536 chandransh 5166 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5167 
    args = requestPickupNumber_args()
5168 
    args.read(iprot)
5169 
    iprot.readMessageEnd()
5170 
    result = requestPickupNumber_result()
5171 
    try:
4579 rajveer 5172 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5173 
    except TransactionServiceException, ex:
5174 
      result.ex = ex
5175 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5176 
    result.write(oprot)
5177 
    oprot.writeMessageEnd()
5178 
    oprot.trans.flush()
5179 
 
5180 
  def process_authorizePickup(self, seqid, iprot, oprot):
5181 
    args = authorizePickup_args()
5182 
    args.read(iprot)
5183 
    iprot.readMessageEnd()
5184 
    result = authorizePickup_result()
5185 
    try:
4602 rajveer 5186 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5187 
    except TransactionServiceException, ex:
5188 
      result.ex = ex
5189 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5190 
    result.write(oprot)
5191 
    oprot.writeMessageEnd()
5192 
    oprot.trans.flush()
5193 
 
2764 chandransh 5194 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5195 
    args = markDoasAsPickedUp_args()
5196 
    args.read(iprot)
5197 
    iprot.readMessageEnd()
5198 
    result = markDoasAsPickedUp_result()
5199 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
5200 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5201 
    result.write(oprot)
5202 
    oprot.writeMessageEnd()
5203 
    oprot.trans.flush()
5204 
 
4741 phani.kuma 5205 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5206 
    args = markReturnOrdersAsPickedUp_args()
5207 
    args.read(iprot)
5208 
    iprot.readMessageEnd()
5209 
    result = markReturnOrdersAsPickedUp_result()
5210 
    result.success = self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
5211 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5212 
    result.write(oprot)
5213 
    oprot.writeMessageEnd()
5214 
    oprot.trans.flush()
5215 
 
2616 chandransh 5216 
  def process_receiveReturn(self, seqid, iprot, oprot):
5217 
    args = receiveReturn_args()
2591 chandransh 5218 
    args.read(iprot)
5219 
    iprot.readMessageEnd()
2616 chandransh 5220 
    result = receiveReturn_result()
2591 chandransh 5221 
    try:
4479 rajveer 5222 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5223 
    except TransactionServiceException, ex:
5224 
      result.ex = ex
2616 chandransh 5225 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5226 
    result.write(oprot)
5227 
    oprot.writeMessageEnd()
5228 
    oprot.trans.flush()
2536 chandransh 5229 
 
2591 chandransh 5230 
  def process_validateDoa(self, seqid, iprot, oprot):
5231 
    args = validateDoa_args()
5232 
    args.read(iprot)
5233 
    iprot.readMessageEnd()
5234 
    result = validateDoa_result()
5235 
    try:
5236 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5237 
    except TransactionServiceException, ex:
5238 
      result.ex = ex
5239 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5240 
    result.write(oprot)
5241 
    oprot.writeMessageEnd()
5242 
    oprot.trans.flush()
5243 
 
4495 rajveer 5244 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5245 
    args = validateReturnProduct_args()
5246 
    args.read(iprot)
5247 
    iprot.readMessageEnd()
5248 
    result = validateReturnProduct_result()
5249 
    try:
5250 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5251 
    except TransactionServiceException, ex:
5252 
      result.ex = ex
5253 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5254 
    result.write(oprot)
5255 
    oprot.writeMessageEnd()
5256 
    oprot.trans.flush()
5257 
 
2616 chandransh 5258 
  def process_reshipOrder(self, seqid, iprot, oprot):
5259 
    args = reshipOrder_args()
5260 
    args.read(iprot)
5261 
    iprot.readMessageEnd()
5262 
    result = reshipOrder_result()
5263 
    try:
5264 
      result.success = self._handler.reshipOrder(args.orderId)
5265 
    except TransactionServiceException, ex:
5266 
      result.ex = ex
5267 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5268 
    result.write(oprot)
5269 
    oprot.writeMessageEnd()
5270 
    oprot.trans.flush()
2591 chandransh 5271 
 
2616 chandransh 5272 
  def process_refundOrder(self, seqid, iprot, oprot):
5273 
    args = refundOrder_args()
5274 
    args.read(iprot)
5275 
    iprot.readMessageEnd()
5276 
    result = refundOrder_result()
5277 
    try:
3226 chandransh 5278 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5279 
    except TransactionServiceException, ex:
5280 
      result.ex = ex
5281 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5282 
    result.write(oprot)
5283 
    oprot.writeMessageEnd()
5284 
    oprot.trans.flush()
5285 
 
2690 chandransh 5286 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5287 
    args = getReturnOrders_args()
5288 
    args.read(iprot)
5289 
    iprot.readMessageEnd()
5290 
    result = getReturnOrders_result()
5291 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5292 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5293 
    result.write(oprot)
5294 
    oprot.writeMessageEnd()
5295 
    oprot.trans.flush()
2616 chandransh 5296 
 
2700 chandransh 5297 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5298 
    args = getReturnOrder_args()
5299 
    args.read(iprot)
5300 
    iprot.readMessageEnd()
5301 
    result = getReturnOrder_result()
5302 
    try:
5303 
      result.success = self._handler.getReturnOrder(args.id)
5304 
    except TransactionServiceException, ex:
5305 
      result.ex = ex
5306 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5307 
    result.write(oprot)
5308 
    oprot.writeMessageEnd()
5309 
    oprot.trans.flush()
5310 
 
2690 chandransh 5311 
  def process_processReturn(self, seqid, iprot, oprot):
5312 
    args = processReturn_args()
5313 
    args.read(iprot)
5314 
    iprot.readMessageEnd()
5315 
    result = processReturn_result()
5316 
    try:
5317 
      self._handler.processReturn(args.returnOrderId)
5318 
    except TransactionServiceException, ex:
5319 
      result.ex = ex
5320 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5321 
    result.write(oprot)
5322 
    oprot.writeMessageEnd()
5323 
    oprot.trans.flush()
5324 
 
3451 chandransh 5325 
  def process_updateWeight(self, seqid, iprot, oprot):
5326 
    args = updateWeight_args()
5327 
    args.read(iprot)
5328 
    iprot.readMessageEnd()
5329 
    result = updateWeight_result()
5330 
    try:
5331 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5332 
    except TransactionServiceException, ex:
5333 
      result.ex = ex
5334 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5335 
    result.write(oprot)
5336 
    oprot.writeMessageEnd()
5337 
    oprot.trans.flush()
2819 chandransh 5338 
 
3469 chandransh 5339 
  def process_changeItem(self, seqid, iprot, oprot):
5340 
    args = changeItem_args()
5341 
    args.read(iprot)
5342 
    iprot.readMessageEnd()
5343 
    result = changeItem_result()
5344 
    try:
5345 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5346 
    except TransactionServiceException, ex:
5347 
      result.ex = ex
5348 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5349 
    result.write(oprot)
5350 
    oprot.writeMessageEnd()
5351 
    oprot.trans.flush()
3451 chandransh 5352 
 
3469 chandransh 5353 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5354 
    args = shiftToWarehouse_args()
5355 
    args.read(iprot)
5356 
    iprot.readMessageEnd()
5357 
    result = shiftToWarehouse_result()
5358 
    try:
5359 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5360 
    except TransactionServiceException, ex:
5361 
      result.ex = ex
5362 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5363 
    result.write(oprot)
5364 
    oprot.writeMessageEnd()
5365 
    oprot.trans.flush()
5366 
 
3553 chandransh 5367 
  def process_addDelayReason(self, seqid, iprot, oprot):
5368 
    args = addDelayReason_args()
5369 
    args.read(iprot)
5370 
    iprot.readMessageEnd()
5371 
    result = addDelayReason_result()
5372 
    try:
4647 rajveer 5373 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 5374 
    except TransactionServiceException, ex:
5375 
      result.ex = ex
5376 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5377 
    result.write(oprot)
5378 
    oprot.writeMessageEnd()
5379 
    oprot.trans.flush()
3469 chandransh 5380 
 
3956 chandransh 5381 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5382 
    args = reconcileCodCollection_args()
5383 
    args.read(iprot)
5384 
    iprot.readMessageEnd()
5385 
    result = reconcileCodCollection_result()
5386 
    try:
5387 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5388 
    except TransactionServiceException, ex:
5389 
      result.ex = ex
5390 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5391 
    result.write(oprot)
5392 
    oprot.writeMessageEnd()
5393 
    oprot.trans.flush()
3553 chandransh 5394 
 
4008 mandeep.dh 5395 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5396 
    args = getTransactionsRequiringExtraProcessing_args()
5397 
    args.read(iprot)
5398 
    iprot.readMessageEnd()
5399 
    result = getTransactionsRequiringExtraProcessing_result()
5400 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5401 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5402 
    result.write(oprot)
5403 
    oprot.writeMessageEnd()
5404 
    oprot.trans.flush()
3956 chandransh 5405 
 
4008 mandeep.dh 5406 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5407 
    args = markTransactionAsProcessed_args()
5408 
    args.read(iprot)
5409 
    iprot.readMessageEnd()
5410 
    result = markTransactionAsProcessed_result()
5411 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5412 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5413 
    result.write(oprot)
5414 
    oprot.writeMessageEnd()
5415 
    oprot.trans.flush()
5416 
 
4018 chandransh 5417 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5418 
    args = getItemWiseRiskyOrdersCount_args()
5419 
    args.read(iprot)
5420 
    iprot.readMessageEnd()
5421 
    result = getItemWiseRiskyOrdersCount_result()
5422 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5423 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5424 
    result.write(oprot)
5425 
    oprot.writeMessageEnd()
5426 
    oprot.trans.flush()
4008 mandeep.dh 5427 
 
4295 varun.gupt 5428 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5429 
    args = getOrdersForItemIds_args()
5430 
    args.read(iprot)
5431 
    iprot.readMessageEnd()
5432 
    result = getOrdersForItemIds_result()
5433 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5434 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5435 
    result.write(oprot)
5436 
    oprot.writeMessageEnd()
5437 
    oprot.trans.flush()
5438 
 
4247 rajveer 5439 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5440 
    args = markOrderCancellationRequestReceived_args()
5441 
    args.read(iprot)
5442 
    iprot.readMessageEnd()
5443 
    result = markOrderCancellationRequestReceived_result()
5444 
    try:
5445 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5446 
    except TransactionServiceException, ex:
5447 
      result.ex = ex
5448 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5449 
    result.write(oprot)
5450 
    oprot.writeMessageEnd()
5451 
    oprot.trans.flush()
4018 chandransh 5452 
 
4247 rajveer 5453 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5454 
    args = markOrderCancellationRequestConfirmed_args()
5455 
    args.read(iprot)
5456 
    iprot.readMessageEnd()
5457 
    result = markOrderCancellationRequestConfirmed_result()
5458 
    try:
5459 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5460 
    except TransactionServiceException, ex:
5461 
      result.ex = ex
5462 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5463 
    result.write(oprot)
5464 
    oprot.writeMessageEnd()
5465 
    oprot.trans.flush()
5466 
 
5467 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5468 
    args = markOrderCancellationRequestDenied_args()
5469 
    args.read(iprot)
5470 
    iprot.readMessageEnd()
5471 
    result = markOrderCancellationRequestDenied_result()
5472 
    try:
5473 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5474 
    except TransactionServiceException, ex:
5475 
      result.ex = ex
5476 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5477 
    result.write(oprot)
5478 
    oprot.writeMessageEnd()
5479 
    oprot.trans.flush()
5480 
 
4258 rajveer 5481 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5482 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5483 
    args.read(iprot)
5484 
    iprot.readMessageEnd()
4258 rajveer 5485 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5486 
    try:
4258 rajveer 5487 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 5488 
    except TransactionServiceException, ex:
5489 
      result.ex = ex
4258 rajveer 5490 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 5491 
    result.write(oprot)
5492 
    oprot.writeMessageEnd()
5493 
    oprot.trans.flush()
5494 
 
4259 anupam.sin 5495 
  def process_refundTransaction(self, seqid, iprot, oprot):
5496 
    args = refundTransaction_args()
5497 
    args.read(iprot)
5498 
    iprot.readMessageEnd()
5499 
    result = refundTransaction_result()
5500 
    try:
5501 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
5502 
    except TransactionServiceException, ex:
5503 
      result.ex = ex
5504 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
5505 
    result.write(oprot)
5506 
    oprot.writeMessageEnd()
5507 
    oprot.trans.flush()
4247 rajveer 5508 
 
4324 mandeep.dh 5509 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
5510 
    args = updateShipmentAddress_args()
5511 
    args.read(iprot)
5512 
    iprot.readMessageEnd()
5513 
    result = updateShipmentAddress_result()
5514 
    try:
5515 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
5516 
    except TransactionServiceException, ex:
5517 
      result.ex = ex
5518 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
5519 
    result.write(oprot)
5520 
    oprot.writeMessageEnd()
5521 
    oprot.trans.flush()
5522 
 
4285 rajveer 5523 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
5524 
    args = acceptOrdersForItemId_args()
5525 
    args.read(iprot)
5526 
    iprot.readMessageEnd()
5527 
    result = acceptOrdersForItemId_result()
5528 
    try:
5529 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
5530 
    except TransactionServiceException, ex:
5531 
      result.ex = ex
5532 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
5533 
    result.write(oprot)
5534 
    oprot.writeMessageEnd()
5535 
    oprot.trans.flush()
4259 anupam.sin 5536 
 
4303 rajveer 5537 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
5538 
    args = markOrdersAsPORaised_args()
5539 
    args.read(iprot)
5540 
    iprot.readMessageEnd()
5541 
    result = markOrdersAsPORaised_result()
5542 
    try:
4369 rajveer 5543 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5544 
    except TransactionServiceException, ex:
5545 
      result.ex = ex
5546 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
5547 
    result.write(oprot)
5548 
    oprot.writeMessageEnd()
5549 
    oprot.trans.flush()
4285 rajveer 5550 
 
4303 rajveer 5551 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
5552 
    args = markOrdersAsReversalInitiated_args()
5553 
    args.read(iprot)
5554 
    iprot.readMessageEnd()
5555 
    result = markOrdersAsReversalInitiated_result()
5556 
    try:
4369 rajveer 5557 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5558 
    except TransactionServiceException, ex:
5559 
      result.ex = ex
5560 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
5561 
    result.write(oprot)
5562 
    oprot.writeMessageEnd()
5563 
    oprot.trans.flush()
5564 
 
5565 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
5566 
    args = markOrdersAsNotAvailabke_args()
5567 
    args.read(iprot)
5568 
    iprot.readMessageEnd()
5569 
    result = markOrdersAsNotAvailabke_result()
5570 
    try:
4369 rajveer 5571 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5572 
    except TransactionServiceException, ex:
5573 
      result.ex = ex
5574 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
5575 
    result.write(oprot)
5576 
    oprot.writeMessageEnd()
5577 
    oprot.trans.flush()
5578 
 
4369 rajveer 5579 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
5580 
    args = markOrdersAsTimeout_args()
5581 
    args.read(iprot)
5582 
    iprot.readMessageEnd()
5583 
    result = markOrdersAsTimeout_result()
5584 
    try:
5585 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
5586 
    except TransactionServiceException, ex:
5587 
      result.ex = ex
5588 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
5589 
    result.write(oprot)
5590 
    oprot.writeMessageEnd()
5591 
    oprot.trans.flush()
4303 rajveer 5592 
 
4662 rajveer 5593 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
5594 
    args = markOrderAsLostInTransit_args()
5595 
    args.read(iprot)
5596 
    iprot.readMessageEnd()
5597 
    result = markOrderAsLostInTransit_result()
5598 
    try:
5599 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
5600 
    except TransactionServiceException, ex:
5601 
      result.ex = ex
5602 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
5603 
    result.write(oprot)
5604 
    oprot.writeMessageEnd()
5605 
    oprot.trans.flush()
5606 
 
4386 anupam.sin 5607 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
5608 
    args = getOrderForAwb_args()
5609 
    args.read(iprot)
5610 
    iprot.readMessageEnd()
5611 
    result = getOrderForAwb_result()
5612 
    try:
5613 
      result.success = self._handler.getOrderForAwb(args.awb)
5614 
    except TransactionServiceException, ex:
5615 
      result.ex = ex
5616 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
5617 
    result.write(oprot)
5618 
    oprot.writeMessageEnd()
5619 
    oprot.trans.flush()
4369 rajveer 5620 
 
4506 phani.kuma 5621 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
5622 
    args = getOrdersForProviderForStatus_args()
5623 
    args.read(iprot)
5624 
    iprot.readMessageEnd()
5625 
    result = getOrdersForProviderForStatus_result()
5626 
    try:
5627 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
5628 
    except TransactionServiceException, ex:
5629 
      result.ex = ex
5630 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
5631 
    result.write(oprot)
5632 
    oprot.writeMessageEnd()
5633 
    oprot.trans.flush()
4386 anupam.sin 5634 
 
4600 varun.gupt 5635 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
5636 
    args = getBilledOrdersForVendor_args()
5637 
    args.read(iprot)
5638 
    iprot.readMessageEnd()
5639 
    result = getBilledOrdersForVendor_result()
5640 
    try:
5641 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
5642 
    except TransactionServiceException, ex:
5643 
      result.ex = ex
5644 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
5645 
    result.write(oprot)
5646 
    oprot.writeMessageEnd()
5647 
    oprot.trans.flush()
4506 phani.kuma 5648 
 
4607 rajveer 5649 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
5650 
    args = getSlippedSippingDateOrders_args()
5651 
    args.read(iprot)
5652 
    iprot.readMessageEnd()
5653 
    result = getSlippedSippingDateOrders_result()
5654 
    try:
5655 
      result.success = self._handler.getSlippedSippingDateOrders()
5656 
    except TransactionServiceException, ex:
5657 
      result.ex = ex
5658 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
5659 
    result.write(oprot)
5660 
    oprot.writeMessageEnd()
5661 
    oprot.trans.flush()
5662 
 
4709 rajveer 5663 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
5664 
    args = getCancelledOrders_args()
5665 
    args.read(iprot)
5666 
    iprot.readMessageEnd()
5667 
    result = getCancelledOrders_result()
5668 
    try:
5669 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
5670 
    except TransactionServiceException, ex:
5671 
      result.ex = ex
5672 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
5673 
    result.write(oprot)
5674 
    oprot.writeMessageEnd()
5675 
    oprot.trans.flush()
5676 
 
4600 varun.gupt 5677 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
5678 
    args = saveBluedartSettlements_args()
5679 
    args.read(iprot)
5680 
    iprot.readMessageEnd()
5681 
    result = saveBluedartSettlements_result()
5682 
    try:
5683 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
5684 
    except TransactionServiceException, ex:
5685 
      result.ex = ex
5686 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
5687 
    result.write(oprot)
5688 
    oprot.writeMessageEnd()
5689 
    oprot.trans.flush()
5690 
 
5691 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
5692 
    args = savePaymentSettlements_args()
5693 
    args.read(iprot)
5694 
    iprot.readMessageEnd()
5695 
    result = savePaymentSettlements_result()
5696 
    try:
5697 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.paymentId, args.serviceTax, args.otherCharges, args.netCollection)
5698 
    except TransactionServiceException, ex:
5699 
      result.ex = ex
5700 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
5701 
    result.write(oprot)
5702 
    oprot.writeMessageEnd()
5703 
    oprot.trans.flush()
5704 
 
5705 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
5706 
    args = saveEBSSettlementSummary_args()
5707 
    args.read(iprot)
5708 
    iprot.readMessageEnd()
5709 
    result = saveEBSSettlementSummary_result()
5710 
    try:
5711 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
5712 
    except TransactionServiceException, ex:
5713 
      result.ex = ex
5714 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
5715 
    result.write(oprot)
5716 
    oprot.writeMessageEnd()
5717 
    oprot.trans.flush()
5718 
 
5719 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
5720 
    args = getSettlementForPaymentId_args()
5721 
    args.read(iprot)
5722 
    iprot.readMessageEnd()
5723 
    result = getSettlementForPaymentId_result()
5724 
    try:
5725 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
5726 
    except TransactionServiceException, ex:
5727 
      result.ex = ex
5728 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
5729 
    result.write(oprot)
5730 
    oprot.writeMessageEnd()
5731 
    oprot.trans.flush()
5732 
 
5733 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
5734 
    args = getEBSSettlementSummaries_args()
5735 
    args.read(iprot)
5736 
    iprot.readMessageEnd()
5737 
    result = getEBSSettlementSummaries_result()
5738 
    try:
5739 
      result.success = self._handler.getEBSSettlementSummaries()
5740 
    except TransactionServiceException, ex:
5741 
      result.ex = ex
5742 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
5743 
    result.write(oprot)
5744 
    oprot.writeMessageEnd()
5745 
    oprot.trans.flush()
5746 
 
5747 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
5748 
    args = markEBSSettlementUploaded_args()
5749 
    args.read(iprot)
5750 
    iprot.readMessageEnd()
5751 
    result = markEBSSettlementUploaded_result()
5752 
    try:
5753 
      self._handler.markEBSSettlementUploaded(args.settlementId)
5754 
    except TransactionServiceException, ex:
5755 
      result.ex = ex
5756 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
5757 
    result.write(oprot)
5758 
    oprot.writeMessageEnd()
5759 
    oprot.trans.flush()
5760 
 
5761 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
5762 
    args = getEBSSettlementDate_args()
5763 
    args.read(iprot)
5764 
    iprot.readMessageEnd()
5765 
    result = getEBSSettlementDate_result()
5766 
    try:
5767 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
5768 
    except TransactionServiceException, ex:
5769 
      result.ex = ex
5770 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
5771 
    result.write(oprot)
5772 
    oprot.writeMessageEnd()
5773 
    oprot.trans.flush()
5774 
 
4715 varun.gupt 5775 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
5776 
    args = getSettlementsByDate_args()
5777 
    args.read(iprot)
5778 
    iprot.readMessageEnd()
5779 
    result = getSettlementsByDate_result()
5780 
    try:
5781 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
5782 
    except TransactionServiceException, ex:
5783 
      result.ex = ex
5784 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
5785 
    result.write(oprot)
5786 
    oprot.writeMessageEnd()
5787 
    oprot.trans.flush()
4600 varun.gupt 5788 
 
4715 varun.gupt 5789 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
5790 
    args = getReshippedOrderIds_args()
5791 
    args.read(iprot)
5792 
    iprot.readMessageEnd()
5793 
    result = getReshippedOrderIds_result()
5794 
    try:
5795 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
5796 
    except TransactionServiceException, ex:
5797 
      result.ex = ex
5798 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
5799 
    result.write(oprot)
5800 
    oprot.writeMessageEnd()
5801 
    oprot.trans.flush()
5802 
 
4757 mandeep.dh 5803 
  def process_updateOrdersAsPORaised(self, seqid, iprot, oprot):
5804 
    args = updateOrdersAsPORaised_args()
5805 
    args.read(iprot)
5806 
    iprot.readMessageEnd()
5807 
    result = updateOrdersAsPORaised_result()
5808 
    try:
5809 
      self._handler.updateOrdersAsPORaised(args.itemIdQuantityMap, args.purchaseOrderId, args.warehouseId)
5810 
    except TransactionServiceException, ex:
5811 
      result.ex = ex
5812 
    oprot.writeMessageBegin("updateOrdersAsPORaised", TMessageType.REPLY, seqid)
5813 
    result.write(oprot)
5814 
    oprot.writeMessageEnd()
5815 
    oprot.trans.flush()
4715 varun.gupt 5816 
 
4757 mandeep.dh 5817 
 
94 ashish 5818 
# HELPER FUNCTIONS AND STRUCTURES
5819 
 
5820 
class createTransaction_args:
5821 
  """
5822 
  Attributes:
5823 
   - transaction
5824 
  """
5825 
 
5826 
  thrift_spec = (
5827 
    None, # 0
5828 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
5829 
  )
5830 
 
5831 
  def __init__(self, transaction=None,):
5832 
    self.transaction = transaction
5833 
 
5834 
  def read(self, iprot):
5835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5837 
      return
5838 
    iprot.readStructBegin()
5839 
    while True:
5840 
      (fname, ftype, fid) = iprot.readFieldBegin()
5841 
      if ftype == TType.STOP:
5842 
        break
5843 
      if fid == 1:
5844 
        if ftype == TType.STRUCT:
5845 
          self.transaction = Transaction()
5846 
          self.transaction.read(iprot)
5847 
        else:
5848 
          iprot.skip(ftype)
5849 
      else:
5850 
        iprot.skip(ftype)
5851 
      iprot.readFieldEnd()
5852 
    iprot.readStructEnd()
5853 
 
5854 
  def write(self, oprot):
5855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5857 
      return
5858 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 5859 
    if self.transaction is not None:
94 ashish 5860 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5861 
      self.transaction.write(oprot)
5862 
      oprot.writeFieldEnd()
5863 
    oprot.writeFieldStop()
5864 
    oprot.writeStructEnd()
5865 
 
3431 rajveer 5866 
  def validate(self):
5867 
    return
5868 
 
5869 
 
94 ashish 5870 
  def __repr__(self):
5871 
    L = ['%s=%r' % (key, value)
5872 
      for key, value in self.__dict__.iteritems()]
5873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5874 
 
5875 
  def __eq__(self, other):
5876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5877 
 
5878 
  def __ne__(self, other):
5879 
    return not (self == other)
5880 
 
5881 
class createTransaction_result:
5882 
  """
5883 
  Attributes:
132 ashish 5884 
   - success
94 ashish 5885 
   - ex
5886 
  """
5887 
 
5888 
  thrift_spec = (
132 ashish 5889 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5890 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5891 
  )
5892 
 
132 ashish 5893 
  def __init__(self, success=None, ex=None,):
5894 
    self.success = success
94 ashish 5895 
    self.ex = ex
5896 
 
5897 
  def read(self, iprot):
5898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5900 
      return
5901 
    iprot.readStructBegin()
5902 
    while True:
5903 
      (fname, ftype, fid) = iprot.readFieldBegin()
5904 
      if ftype == TType.STOP:
5905 
        break
132 ashish 5906 
      if fid == 0:
5907 
        if ftype == TType.I64:
5908 
          self.success = iprot.readI64();
5909 
        else:
5910 
          iprot.skip(ftype)
5911 
      elif fid == 1:
94 ashish 5912 
        if ftype == TType.STRUCT:
5913 
          self.ex = TransactionServiceException()
5914 
          self.ex.read(iprot)
5915 
        else:
5916 
          iprot.skip(ftype)
5917 
      else:
5918 
        iprot.skip(ftype)
5919 
      iprot.readFieldEnd()
5920 
    iprot.readStructEnd()
5921 
 
5922 
  def write(self, oprot):
5923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5925 
      return
5926 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5927 
    if self.success is not None:
132 ashish 5928 
      oprot.writeFieldBegin('success', TType.I64, 0)
5929 
      oprot.writeI64(self.success)
5930 
      oprot.writeFieldEnd()
3431 rajveer 5931 
    if self.ex is not None:
94 ashish 5932 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5933 
      self.ex.write(oprot)
5934 
      oprot.writeFieldEnd()
5935 
    oprot.writeFieldStop()
5936 
    oprot.writeStructEnd()
5937 
 
3431 rajveer 5938 
  def validate(self):
5939 
    return
5940 
 
5941 
 
94 ashish 5942 
  def __repr__(self):
5943 
    L = ['%s=%r' % (key, value)
5944 
      for key, value in self.__dict__.iteritems()]
5945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5946 
 
5947 
  def __eq__(self, other):
5948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5949 
 
5950 
  def __ne__(self, other):
5951 
    return not (self == other)
5952 
 
5953 
class getTransaction_args:
5954 
  """
5955 
  Attributes:
5956 
   - id
5957 
  """
5958 
 
5959 
  thrift_spec = (
5960 
    None, # 0
5961 
    (1, TType.I64, 'id', None, None, ), # 1
5962 
  )
5963 
 
5964 
  def __init__(self, id=None,):
5965 
    self.id = id
5966 
 
5967 
  def read(self, iprot):
5968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5970 
      return
5971 
    iprot.readStructBegin()
5972 
    while True:
5973 
      (fname, ftype, fid) = iprot.readFieldBegin()
5974 
      if ftype == TType.STOP:
5975 
        break
5976 
      if fid == 1:
5977 
        if ftype == TType.I64:
5978 
          self.id = iprot.readI64();
5979 
        else:
5980 
          iprot.skip(ftype)
5981 
      else:
5982 
        iprot.skip(ftype)
5983 
      iprot.readFieldEnd()
5984 
    iprot.readStructEnd()
5985 
 
5986 
  def write(self, oprot):
5987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5989 
      return
5990 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 5991 
    if self.id is not None:
94 ashish 5992 
      oprot.writeFieldBegin('id', TType.I64, 1)
5993 
      oprot.writeI64(self.id)
5994 
      oprot.writeFieldEnd()
5995 
    oprot.writeFieldStop()
5996 
    oprot.writeStructEnd()
5997 
 
3431 rajveer 5998 
  def validate(self):
5999 
    return
6000 
 
6001 
 
94 ashish 6002 
  def __repr__(self):
6003 
    L = ['%s=%r' % (key, value)
6004 
      for key, value in self.__dict__.iteritems()]
6005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6006 
 
6007 
  def __eq__(self, other):
6008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6009 
 
6010 
  def __ne__(self, other):
6011 
    return not (self == other)
6012 
 
6013 
class getTransaction_result:
6014 
  """
6015 
  Attributes:
6016 
   - success
6017 
   - ex
6018 
  """
6019 
 
6020 
  thrift_spec = (
6021 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6022 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6023 
  )
6024 
 
6025 
  def __init__(self, success=None, ex=None,):
6026 
    self.success = success
6027 
    self.ex = ex
6028 
 
6029 
  def read(self, iprot):
6030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6032 
      return
6033 
    iprot.readStructBegin()
6034 
    while True:
6035 
      (fname, ftype, fid) = iprot.readFieldBegin()
6036 
      if ftype == TType.STOP:
6037 
        break
6038 
      if fid == 0:
6039 
        if ftype == TType.STRUCT:
6040 
          self.success = Transaction()
6041 
          self.success.read(iprot)
6042 
        else:
6043 
          iprot.skip(ftype)
6044 
      elif fid == 1:
6045 
        if ftype == TType.STRUCT:
6046 
          self.ex = TransactionServiceException()
6047 
          self.ex.read(iprot)
6048 
        else:
6049 
          iprot.skip(ftype)
6050 
      else:
6051 
        iprot.skip(ftype)
6052 
      iprot.readFieldEnd()
6053 
    iprot.readStructEnd()
6054 
 
6055 
  def write(self, oprot):
6056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6058 
      return
6059 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6060 
    if self.success is not None:
94 ashish 6061 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6062 
      self.success.write(oprot)
6063 
      oprot.writeFieldEnd()
3431 rajveer 6064 
    if self.ex is not None:
94 ashish 6065 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6066 
      self.ex.write(oprot)
6067 
      oprot.writeFieldEnd()
6068 
    oprot.writeFieldStop()
6069 
    oprot.writeStructEnd()
6070 
 
3431 rajveer 6071 
  def validate(self):
6072 
    return
6073 
 
6074 
 
94 ashish 6075 
  def __repr__(self):
6076 
    L = ['%s=%r' % (key, value)
6077 
      for key, value in self.__dict__.iteritems()]
6078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6079 
 
6080 
  def __eq__(self, other):
6081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6082 
 
6083 
  def __ne__(self, other):
6084 
    return not (self == other)
6085 
 
6086 
class getTransactionsForCustomer_args:
6087 
  """
6088 
  Attributes:
6089 
   - customerId
6090 
   - from_date
6091 
   - to_date
6092 
   - status
6093 
  """
6094 
 
6095 
  thrift_spec = (
6096 
    None, # 0
6097 
    (1, TType.I64, 'customerId', None, None, ), # 1
6098 
    (2, TType.I64, 'from_date', None, None, ), # 2
6099 
    (3, TType.I64, 'to_date', None, None, ), # 3
6100 
    (4, TType.I32, 'status', None, None, ), # 4
6101 
  )
6102 
 
6103 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6104 
    self.customerId = customerId
6105 
    self.from_date = from_date
6106 
    self.to_date = to_date
6107 
    self.status = status
6108 
 
6109 
  def read(self, iprot):
6110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6112 
      return
6113 
    iprot.readStructBegin()
6114 
    while True:
6115 
      (fname, ftype, fid) = iprot.readFieldBegin()
6116 
      if ftype == TType.STOP:
6117 
        break
6118 
      if fid == 1:
6119 
        if ftype == TType.I64:
6120 
          self.customerId = iprot.readI64();
6121 
        else:
6122 
          iprot.skip(ftype)
6123 
      elif fid == 2:
6124 
        if ftype == TType.I64:
6125 
          self.from_date = iprot.readI64();
6126 
        else:
6127 
          iprot.skip(ftype)
6128 
      elif fid == 3:
6129 
        if ftype == TType.I64:
6130 
          self.to_date = iprot.readI64();
6131 
        else:
6132 
          iprot.skip(ftype)
6133 
      elif fid == 4:
6134 
        if ftype == TType.I32:
6135 
          self.status = iprot.readI32();
6136 
        else:
6137 
          iprot.skip(ftype)
6138 
      else:
6139 
        iprot.skip(ftype)
6140 
      iprot.readFieldEnd()
6141 
    iprot.readStructEnd()
6142 
 
6143 
  def write(self, oprot):
6144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6146 
      return
6147 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6148 
    if self.customerId is not None:
94 ashish 6149 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6150 
      oprot.writeI64(self.customerId)
6151 
      oprot.writeFieldEnd()
3431 rajveer 6152 
    if self.from_date is not None:
94 ashish 6153 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6154 
      oprot.writeI64(self.from_date)
6155 
      oprot.writeFieldEnd()
3431 rajveer 6156 
    if self.to_date is not None:
94 ashish 6157 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6158 
      oprot.writeI64(self.to_date)
6159 
      oprot.writeFieldEnd()
3431 rajveer 6160 
    if self.status is not None:
94 ashish 6161 
      oprot.writeFieldBegin('status', TType.I32, 4)
6162 
      oprot.writeI32(self.status)
6163 
      oprot.writeFieldEnd()
6164 
    oprot.writeFieldStop()
6165 
    oprot.writeStructEnd()
6166 
 
3431 rajveer 6167 
  def validate(self):
6168 
    return
6169 
 
6170 
 
94 ashish 6171 
  def __repr__(self):
6172 
    L = ['%s=%r' % (key, value)
6173 
      for key, value in self.__dict__.iteritems()]
6174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6175 
 
6176 
  def __eq__(self, other):
6177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6178 
 
6179 
  def __ne__(self, other):
6180 
    return not (self == other)
6181 
 
6182 
class getTransactionsForCustomer_result:
6183 
  """
6184 
  Attributes:
6185 
   - success
6186 
   - ex
6187 
  """
6188 
 
6189 
  thrift_spec = (
6190 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6191 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6192 
  )
6193 
 
6194 
  def __init__(self, success=None, ex=None,):
6195 
    self.success = success
6196 
    self.ex = ex
6197 
 
6198 
  def read(self, iprot):
6199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6201 
      return
6202 
    iprot.readStructBegin()
6203 
    while True:
6204 
      (fname, ftype, fid) = iprot.readFieldBegin()
6205 
      if ftype == TType.STOP:
6206 
        break
6207 
      if fid == 0:
6208 
        if ftype == TType.LIST:
6209 
          self.success = []
685 chandransh 6210 
          (_etype17, _size14) = iprot.readListBegin()
6211 
          for _i18 in xrange(_size14):
6212 
            _elem19 = Transaction()
6213 
            _elem19.read(iprot)
6214 
            self.success.append(_elem19)
94 ashish 6215 
          iprot.readListEnd()
6216 
        else:
6217 
          iprot.skip(ftype)
6218 
      elif fid == 1:
6219 
        if ftype == TType.STRUCT:
6220 
          self.ex = TransactionServiceException()
6221 
          self.ex.read(iprot)
6222 
        else:
6223 
          iprot.skip(ftype)
6224 
      else:
6225 
        iprot.skip(ftype)
6226 
      iprot.readFieldEnd()
6227 
    iprot.readStructEnd()
6228 
 
6229 
  def write(self, oprot):
6230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6232 
      return
6233 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6234 
    if self.success is not None:
94 ashish 6235 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6236 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6237 
      for iter20 in self.success:
6238 
        iter20.write(oprot)
94 ashish 6239 
      oprot.writeListEnd()
6240 
      oprot.writeFieldEnd()
3431 rajveer 6241 
    if self.ex is not None:
94 ashish 6242 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6243 
      self.ex.write(oprot)
6244 
      oprot.writeFieldEnd()
6245 
    oprot.writeFieldStop()
6246 
    oprot.writeStructEnd()
6247 
 
3431 rajveer 6248 
  def validate(self):
6249 
    return
6250 
 
6251 
 
94 ashish 6252 
  def __repr__(self):
6253 
    L = ['%s=%r' % (key, value)
6254 
      for key, value in self.__dict__.iteritems()]
6255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6256 
 
6257 
  def __eq__(self, other):
6258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6259 
 
6260 
  def __ne__(self, other):
6261 
    return not (self == other)
6262 
 
132 ashish 6263 
class getTransactionsForShoppingCartId_args:
6264 
  """
6265 
  Attributes:
6266 
   - shoppingCartId
6267 
  """
6268 
 
6269 
  thrift_spec = (
6270 
    None, # 0
6271 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
6272 
  )
6273 
 
6274 
  def __init__(self, shoppingCartId=None,):
6275 
    self.shoppingCartId = shoppingCartId
6276 
 
6277 
  def read(self, iprot):
6278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6280 
      return
6281 
    iprot.readStructBegin()
6282 
    while True:
6283 
      (fname, ftype, fid) = iprot.readFieldBegin()
6284 
      if ftype == TType.STOP:
6285 
        break
6286 
      if fid == 1:
6287 
        if ftype == TType.I64:
6288 
          self.shoppingCartId = iprot.readI64();
6289 
        else:
6290 
          iprot.skip(ftype)
6291 
      else:
6292 
        iprot.skip(ftype)
6293 
      iprot.readFieldEnd()
6294 
    iprot.readStructEnd()
6295 
 
6296 
  def write(self, oprot):
6297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6299 
      return
6300 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 6301 
    if self.shoppingCartId is not None:
132 ashish 6302 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
6303 
      oprot.writeI64(self.shoppingCartId)
6304 
      oprot.writeFieldEnd()
6305 
    oprot.writeFieldStop()
6306 
    oprot.writeStructEnd()
6307 
 
3431 rajveer 6308 
  def validate(self):
6309 
    return
6310 
 
6311 
 
132 ashish 6312 
  def __repr__(self):
6313 
    L = ['%s=%r' % (key, value)
6314 
      for key, value in self.__dict__.iteritems()]
6315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6316 
 
6317 
  def __eq__(self, other):
6318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6319 
 
6320 
  def __ne__(self, other):
6321 
    return not (self == other)
6322 
 
6323 
class getTransactionsForShoppingCartId_result:
6324 
  """
6325 
  Attributes:
6326 
   - success
6327 
   - ex
6328 
  """
6329 
 
6330 
  thrift_spec = (
6331 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6332 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6333 
  )
6334 
 
6335 
  def __init__(self, success=None, ex=None,):
6336 
    self.success = success
6337 
    self.ex = ex
6338 
 
6339 
  def read(self, iprot):
6340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6342 
      return
6343 
    iprot.readStructBegin()
6344 
    while True:
6345 
      (fname, ftype, fid) = iprot.readFieldBegin()
6346 
      if ftype == TType.STOP:
6347 
        break
6348 
      if fid == 0:
6349 
        if ftype == TType.LIST:
6350 
          self.success = []
685 chandransh 6351 
          (_etype24, _size21) = iprot.readListBegin()
6352 
          for _i25 in xrange(_size21):
6353 
            _elem26 = Transaction()
6354 
            _elem26.read(iprot)
6355 
            self.success.append(_elem26)
132 ashish 6356 
          iprot.readListEnd()
6357 
        else:
6358 
          iprot.skip(ftype)
6359 
      elif fid == 1:
6360 
        if ftype == TType.STRUCT:
6361 
          self.ex = TransactionServiceException()
6362 
          self.ex.read(iprot)
6363 
        else:
6364 
          iprot.skip(ftype)
6365 
      else:
6366 
        iprot.skip(ftype)
6367 
      iprot.readFieldEnd()
6368 
    iprot.readStructEnd()
6369 
 
6370 
  def write(self, oprot):
6371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6373 
      return
6374 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 6375 
    if self.success is not None:
132 ashish 6376 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6377 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6378 
      for iter27 in self.success:
6379 
        iter27.write(oprot)
132 ashish 6380 
      oprot.writeListEnd()
6381 
      oprot.writeFieldEnd()
3431 rajveer 6382 
    if self.ex is not None:
132 ashish 6383 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6384 
      self.ex.write(oprot)
6385 
      oprot.writeFieldEnd()
6386 
    oprot.writeFieldStop()
6387 
    oprot.writeStructEnd()
6388 
 
3431 rajveer 6389 
  def validate(self):
6390 
    return
6391 
 
6392 
 
132 ashish 6393 
  def __repr__(self):
6394 
    L = ['%s=%r' % (key, value)
6395 
      for key, value in self.__dict__.iteritems()]
6396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6397 
 
6398 
  def __eq__(self, other):
6399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6400 
 
6401 
  def __ne__(self, other):
6402 
    return not (self == other)
6403 
 
94 ashish 6404 
class getTransactionStatus_args:
6405 
  """
6406 
  Attributes:
6407 
   - transactionId
6408 
  """
6409 
 
6410 
  thrift_spec = (
6411 
    None, # 0
6412 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6413 
  )
6414 
 
6415 
  def __init__(self, transactionId=None,):
6416 
    self.transactionId = transactionId
6417 
 
6418 
  def read(self, iprot):
6419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6421 
      return
6422 
    iprot.readStructBegin()
6423 
    while True:
6424 
      (fname, ftype, fid) = iprot.readFieldBegin()
6425 
      if ftype == TType.STOP:
6426 
        break
6427 
      if fid == 1:
6428 
        if ftype == TType.I64:
6429 
          self.transactionId = iprot.readI64();
6430 
        else:
6431 
          iprot.skip(ftype)
6432 
      else:
6433 
        iprot.skip(ftype)
6434 
      iprot.readFieldEnd()
6435 
    iprot.readStructEnd()
6436 
 
6437 
  def write(self, oprot):
6438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6440 
      return
6441 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6442 
    if self.transactionId is not None:
94 ashish 6443 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6444 
      oprot.writeI64(self.transactionId)
6445 
      oprot.writeFieldEnd()
6446 
    oprot.writeFieldStop()
6447 
    oprot.writeStructEnd()
6448 
 
3431 rajveer 6449 
  def validate(self):
6450 
    return
6451 
 
6452 
 
94 ashish 6453 
  def __repr__(self):
6454 
    L = ['%s=%r' % (key, value)
6455 
      for key, value in self.__dict__.iteritems()]
6456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6457 
 
6458 
  def __eq__(self, other):
6459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6460 
 
6461 
  def __ne__(self, other):
6462 
    return not (self == other)
6463 
 
6464 
class getTransactionStatus_result:
6465 
  """
6466 
  Attributes:
6467 
   - success
6468 
   - ex
6469 
  """
6470 
 
6471 
  thrift_spec = (
6472 
    (0, TType.I32, 'success', None, None, ), # 0
6473 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6474 
  )
6475 
 
6476 
  def __init__(self, success=None, ex=None,):
6477 
    self.success = success
6478 
    self.ex = ex
6479 
 
6480 
  def read(self, iprot):
6481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6483 
      return
6484 
    iprot.readStructBegin()
6485 
    while True:
6486 
      (fname, ftype, fid) = iprot.readFieldBegin()
6487 
      if ftype == TType.STOP:
6488 
        break
6489 
      if fid == 0:
6490 
        if ftype == TType.I32:
6491 
          self.success = iprot.readI32();
6492 
        else:
6493 
          iprot.skip(ftype)
6494 
      elif fid == 1:
6495 
        if ftype == TType.STRUCT:
6496 
          self.ex = TransactionServiceException()
6497 
          self.ex.read(iprot)
6498 
        else:
6499 
          iprot.skip(ftype)
6500 
      else:
6501 
        iprot.skip(ftype)
6502 
      iprot.readFieldEnd()
6503 
    iprot.readStructEnd()
6504 
 
6505 
  def write(self, oprot):
6506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6508 
      return
6509 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 6510 
    if self.success is not None:
94 ashish 6511 
      oprot.writeFieldBegin('success', TType.I32, 0)
6512 
      oprot.writeI32(self.success)
6513 
      oprot.writeFieldEnd()
3431 rajveer 6514 
    if self.ex is not None:
94 ashish 6515 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6516 
      self.ex.write(oprot)
6517 
      oprot.writeFieldEnd()
6518 
    oprot.writeFieldStop()
6519 
    oprot.writeStructEnd()
6520 
 
3431 rajveer 6521 
  def validate(self):
6522 
    return
6523 
 
6524 
 
94 ashish 6525 
  def __repr__(self):
6526 
    L = ['%s=%r' % (key, value)
6527 
      for key, value in self.__dict__.iteritems()]
6528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6529 
 
6530 
  def __eq__(self, other):
6531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6532 
 
6533 
  def __ne__(self, other):
6534 
    return not (self == other)
6535 
 
6536 
class changeTransactionStatus_args:
6537 
  """
6538 
  Attributes:
6539 
   - transactionId
6540 
   - status
6541 
   - description
6542 
  """
6543 
 
6544 
  thrift_spec = (
6545 
    None, # 0
6546 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6547 
    (2, TType.I32, 'status', None, None, ), # 2
6548 
    (3, TType.STRING, 'description', None, None, ), # 3
6549 
  )
6550 
 
6551 
  def __init__(self, transactionId=None, status=None, description=None,):
6552 
    self.transactionId = transactionId
6553 
    self.status = status
6554 
    self.description = description
6555 
 
6556 
  def read(self, iprot):
6557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6559 
      return
6560 
    iprot.readStructBegin()
6561 
    while True:
6562 
      (fname, ftype, fid) = iprot.readFieldBegin()
6563 
      if ftype == TType.STOP:
6564 
        break
6565 
      if fid == 1:
6566 
        if ftype == TType.I64:
6567 
          self.transactionId = iprot.readI64();
6568 
        else:
6569 
          iprot.skip(ftype)
6570 
      elif fid == 2:
6571 
        if ftype == TType.I32:
6572 
          self.status = iprot.readI32();
6573 
        else:
6574 
          iprot.skip(ftype)
6575 
      elif fid == 3:
6576 
        if ftype == TType.STRING:
6577 
          self.description = iprot.readString();
6578 
        else:
6579 
          iprot.skip(ftype)
6580 
      else:
6581 
        iprot.skip(ftype)
6582 
      iprot.readFieldEnd()
6583 
    iprot.readStructEnd()
6584 
 
6585 
  def write(self, oprot):
6586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6588 
      return
6589 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 6590 
    if self.transactionId is not None:
94 ashish 6591 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6592 
      oprot.writeI64(self.transactionId)
6593 
      oprot.writeFieldEnd()
3431 rajveer 6594 
    if self.status is not None:
94 ashish 6595 
      oprot.writeFieldBegin('status', TType.I32, 2)
6596 
      oprot.writeI32(self.status)
6597 
      oprot.writeFieldEnd()
3431 rajveer 6598 
    if self.description is not None:
94 ashish 6599 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6600 
      oprot.writeString(self.description)
6601 
      oprot.writeFieldEnd()
6602 
    oprot.writeFieldStop()
6603 
    oprot.writeStructEnd()
6604 
 
3431 rajveer 6605 
  def validate(self):
6606 
    return
6607 
 
6608 
 
94 ashish 6609 
  def __repr__(self):
6610 
    L = ['%s=%r' % (key, value)
6611 
      for key, value in self.__dict__.iteritems()]
6612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6613 
 
6614 
  def __eq__(self, other):
6615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6616 
 
6617 
  def __ne__(self, other):
6618 
    return not (self == other)
6619 
 
6620 
class changeTransactionStatus_result:
6621 
  """
6622 
  Attributes:
6623 
   - success
6624 
   - ex
6625 
  """
6626 
 
6627 
  thrift_spec = (
6628 
    (0, TType.BOOL, 'success', None, None, ), # 0
6629 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6630 
  )
6631 
 
6632 
  def __init__(self, success=None, ex=None,):
6633 
    self.success = success
6634 
    self.ex = ex
6635 
 
6636 
  def read(self, iprot):
6637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6639 
      return
6640 
    iprot.readStructBegin()
6641 
    while True:
6642 
      (fname, ftype, fid) = iprot.readFieldBegin()
6643 
      if ftype == TType.STOP:
6644 
        break
6645 
      if fid == 0:
6646 
        if ftype == TType.BOOL:
6647 
          self.success = iprot.readBool();
6648 
        else:
6649 
          iprot.skip(ftype)
6650 
      elif fid == 1:
6651 
        if ftype == TType.STRUCT:
6652 
          self.ex = TransactionServiceException()
6653 
          self.ex.read(iprot)
6654 
        else:
6655 
          iprot.skip(ftype)
6656 
      else:
6657 
        iprot.skip(ftype)
6658 
      iprot.readFieldEnd()
6659 
    iprot.readStructEnd()
6660 
 
6661 
  def write(self, oprot):
6662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6664 
      return
6665 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 6666 
    if self.success is not None:
94 ashish 6667 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6668 
      oprot.writeBool(self.success)
6669 
      oprot.writeFieldEnd()
3431 rajveer 6670 
    if self.ex is not None:
94 ashish 6671 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6672 
      self.ex.write(oprot)
6673 
      oprot.writeFieldEnd()
6674 
    oprot.writeFieldStop()
6675 
    oprot.writeStructEnd()
6676 
 
3431 rajveer 6677 
  def validate(self):
6678 
    return
6679 
 
6680 
 
94 ashish 6681 
  def __repr__(self):
6682 
    L = ['%s=%r' % (key, value)
6683 
      for key, value in self.__dict__.iteritems()]
6684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6685 
 
6686 
  def __eq__(self, other):
6687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6688 
 
6689 
  def __ne__(self, other):
6690 
    return not (self == other)
6691 
 
1398 varun.gupt 6692 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 6693 
  """
6694 
  Attributes:
6695 
   - transactionId
6696 
  """
6697 
 
6698 
  thrift_spec = (
6699 
    None, # 0
6700 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6701 
  )
6702 
 
6703 
  def __init__(self, transactionId=None,):
6704 
    self.transactionId = transactionId
6705 
 
6706 
  def read(self, iprot):
6707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6709 
      return
6710 
    iprot.readStructBegin()
6711 
    while True:
6712 
      (fname, ftype, fid) = iprot.readFieldBegin()
6713 
      if ftype == TType.STOP:
6714 
        break
6715 
      if fid == 1:
6716 
        if ftype == TType.I64:
6717 
          self.transactionId = iprot.readI64();
6718 
        else:
6719 
          iprot.skip(ftype)
6720 
      else:
6721 
        iprot.skip(ftype)
6722 
      iprot.readFieldEnd()
6723 
    iprot.readStructEnd()
6724 
 
6725 
  def write(self, oprot):
6726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6728 
      return
1398 varun.gupt 6729 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 6730 
    if self.transactionId is not None:
1382 varun.gupt 6731 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6732 
      oprot.writeI64(self.transactionId)
6733 
      oprot.writeFieldEnd()
6734 
    oprot.writeFieldStop()
6735 
    oprot.writeStructEnd()
6736 
 
3431 rajveer 6737 
  def validate(self):
6738 
    return
6739 
 
6740 
 
1382 varun.gupt 6741 
  def __repr__(self):
6742 
    L = ['%s=%r' % (key, value)
6743 
      for key, value in self.__dict__.iteritems()]
6744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6745 
 
6746 
  def __eq__(self, other):
6747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6748 
 
6749 
  def __ne__(self, other):
6750 
    return not (self == other)
6751 
 
1398 varun.gupt 6752 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 6753 
  """
6754 
  Attributes:
6755 
   - success
6756 
   - ex
6757 
  """
6758 
 
6759 
  thrift_spec = (
6760 
    (0, TType.BOOL, 'success', None, None, ), # 0
6761 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6762 
  )
6763 
 
6764 
  def __init__(self, success=None, ex=None,):
6765 
    self.success = success
6766 
    self.ex = ex
6767 
 
6768 
  def read(self, iprot):
6769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6771 
      return
6772 
    iprot.readStructBegin()
6773 
    while True:
6774 
      (fname, ftype, fid) = iprot.readFieldBegin()
6775 
      if ftype == TType.STOP:
6776 
        break
6777 
      if fid == 0:
6778 
        if ftype == TType.BOOL:
6779 
          self.success = iprot.readBool();
6780 
        else:
6781 
          iprot.skip(ftype)
6782 
      elif fid == 1:
6783 
        if ftype == TType.STRUCT:
6784 
          self.ex = TransactionServiceException()
6785 
          self.ex.read(iprot)
6786 
        else:
6787 
          iprot.skip(ftype)
6788 
      else:
6789 
        iprot.skip(ftype)
6790 
      iprot.readFieldEnd()
6791 
    iprot.readStructEnd()
6792 
 
6793 
  def write(self, oprot):
6794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6796 
      return
1398 varun.gupt 6797 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 6798 
    if self.success is not None:
1382 varun.gupt 6799 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6800 
      oprot.writeBool(self.success)
6801 
      oprot.writeFieldEnd()
3431 rajveer 6802 
    if self.ex is not None:
1382 varun.gupt 6803 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6804 
      self.ex.write(oprot)
6805 
      oprot.writeFieldEnd()
6806 
    oprot.writeFieldStop()
6807 
    oprot.writeStructEnd()
6808 
 
3431 rajveer 6809 
  def validate(self):
6810 
    return
6811 
 
6812 
 
1382 varun.gupt 6813 
  def __repr__(self):
6814 
    L = ['%s=%r' % (key, value)
6815 
      for key, value in self.__dict__.iteritems()]
6816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6817 
 
6818 
  def __eq__(self, other):
6819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6820 
 
6821 
  def __ne__(self, other):
6822 
    return not (self == other)
6823 
 
483 rajveer 6824 
class getAllOrders_args:
94 ashish 6825 
  """
6826 
  Attributes:
483 rajveer 6827 
   - status
6828 
   - from_date
6829 
   - to_date
6830 
   - warehouse_id
94 ashish 6831 
  """
6832 
 
6833 
  thrift_spec = (
6834 
    None, # 0
483 rajveer 6835 
    (1, TType.I32, 'status', None, None, ), # 1
6836 
    (2, TType.I64, 'from_date', None, None, ), # 2
6837 
    (3, TType.I64, 'to_date', None, None, ), # 3
6838 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 6839 
  )
6840 
 
483 rajveer 6841 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
6842 
    self.status = status
6843 
    self.from_date = from_date
6844 
    self.to_date = to_date
6845 
    self.warehouse_id = warehouse_id
94 ashish 6846 
 
6847 
  def read(self, iprot):
6848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6850 
      return
6851 
    iprot.readStructBegin()
6852 
    while True:
6853 
      (fname, ftype, fid) = iprot.readFieldBegin()
6854 
      if ftype == TType.STOP:
6855 
        break
6856 
      if fid == 1:
483 rajveer 6857 
        if ftype == TType.I32:
6858 
          self.status = iprot.readI32();
94 ashish 6859 
        else:
6860 
          iprot.skip(ftype)
483 rajveer 6861 
      elif fid == 2:
6862 
        if ftype == TType.I64:
6863 
          self.from_date = iprot.readI64();
94 ashish 6864 
        else:
6865 
          iprot.skip(ftype)
483 rajveer 6866 
      elif fid == 3:
6867 
        if ftype == TType.I64:
6868 
          self.to_date = iprot.readI64();
94 ashish 6869 
        else:
6870 
          iprot.skip(ftype)
483 rajveer 6871 
      elif fid == 4:
94 ashish 6872 
        if ftype == TType.I64:
483 rajveer 6873 
          self.warehouse_id = iprot.readI64();
94 ashish 6874 
        else:
6875 
          iprot.skip(ftype)
6876 
      else:
6877 
        iprot.skip(ftype)
6878 
      iprot.readFieldEnd()
6879 
    iprot.readStructEnd()
6880 
 
6881 
  def write(self, oprot):
6882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6884 
      return
483 rajveer 6885 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 6886 
    if self.status is not None:
483 rajveer 6887 
      oprot.writeFieldBegin('status', TType.I32, 1)
6888 
      oprot.writeI32(self.status)
94 ashish 6889 
      oprot.writeFieldEnd()
3431 rajveer 6890 
    if self.from_date is not None:
483 rajveer 6891 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6892 
      oprot.writeI64(self.from_date)
94 ashish 6893 
      oprot.writeFieldEnd()
3431 rajveer 6894 
    if self.to_date is not None:
483 rajveer 6895 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6896 
      oprot.writeI64(self.to_date)
94 ashish 6897 
      oprot.writeFieldEnd()
3431 rajveer 6898 
    if self.warehouse_id is not None:
483 rajveer 6899 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6900 
      oprot.writeI64(self.warehouse_id)
94 ashish 6901 
      oprot.writeFieldEnd()
6902 
    oprot.writeFieldStop()
6903 
    oprot.writeStructEnd()
6904 
 
3431 rajveer 6905 
  def validate(self):
6906 
    return
6907 
 
6908 
 
94 ashish 6909 
  def __repr__(self):
6910 
    L = ['%s=%r' % (key, value)
6911 
      for key, value in self.__dict__.iteritems()]
6912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6913 
 
6914 
  def __eq__(self, other):
6915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6916 
 
6917 
  def __ne__(self, other):
6918 
    return not (self == other)
6919 
 
483 rajveer 6920 
class getAllOrders_result:
94 ashish 6921 
  """
6922 
  Attributes:
6923 
   - success
6924 
   - ex
6925 
  """
6926 
 
6927 
  thrift_spec = (
483 rajveer 6928 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6929 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6930 
  )
6931 
 
6932 
  def __init__(self, success=None, ex=None,):
6933 
    self.success = success
6934 
    self.ex = ex
6935 
 
6936 
  def read(self, iprot):
6937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6939 
      return
6940 
    iprot.readStructBegin()
6941 
    while True:
6942 
      (fname, ftype, fid) = iprot.readFieldBegin()
6943 
      if ftype == TType.STOP:
6944 
        break
6945 
      if fid == 0:
483 rajveer 6946 
        if ftype == TType.LIST:
6947 
          self.success = []
685 chandransh 6948 
          (_etype31, _size28) = iprot.readListBegin()
6949 
          for _i32 in xrange(_size28):
6950 
            _elem33 = Order()
6951 
            _elem33.read(iprot)
6952 
            self.success.append(_elem33)
483 rajveer 6953 
          iprot.readListEnd()
94 ashish 6954 
        else:
6955 
          iprot.skip(ftype)
6956 
      elif fid == 1:
6957 
        if ftype == TType.STRUCT:
6958 
          self.ex = TransactionServiceException()
6959 
          self.ex.read(iprot)
6960 
        else:
6961 
          iprot.skip(ftype)
6962 
      else:
6963 
        iprot.skip(ftype)
6964 
      iprot.readFieldEnd()
6965 
    iprot.readStructEnd()
6966 
 
6967 
  def write(self, oprot):
6968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6970 
      return
483 rajveer 6971 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 6972 
    if self.success is not None:
483 rajveer 6973 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6974 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6975 
      for iter34 in self.success:
6976 
        iter34.write(oprot)
483 rajveer 6977 
      oprot.writeListEnd()
94 ashish 6978 
      oprot.writeFieldEnd()
3431 rajveer 6979 
    if self.ex is not None:
94 ashish 6980 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6981 
      self.ex.write(oprot)
6982 
      oprot.writeFieldEnd()
6983 
    oprot.writeFieldStop()
6984 
    oprot.writeStructEnd()
6985 
 
3431 rajveer 6986 
  def validate(self):
6987 
    return
6988 
 
6989 
 
94 ashish 6990 
  def __repr__(self):
6991 
    L = ['%s=%r' % (key, value)
6992 
      for key, value in self.__dict__.iteritems()]
6993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6994 
 
6995 
  def __eq__(self, other):
6996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6997 
 
6998 
  def __ne__(self, other):
6999 
    return not (self == other)
7000 
 
4133 chandransh 7001 
class getOrdersInBatch_args:
7002 
  """
7003 
  Attributes:
7004 
   - statuses
7005 
   - offset
7006 
   - limit
7007 
   - warehouse_id
7008 
  """
7009 
 
7010 
  thrift_spec = (
7011 
    None, # 0
7012 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7013 
    (2, TType.I64, 'offset', None, None, ), # 2
7014 
    (3, TType.I64, 'limit', None, None, ), # 3
7015 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7016 
  )
7017 
 
7018 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7019 
    self.statuses = statuses
7020 
    self.offset = offset
7021 
    self.limit = limit
7022 
    self.warehouse_id = warehouse_id
7023 
 
7024 
  def read(self, iprot):
7025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7027 
      return
7028 
    iprot.readStructBegin()
7029 
    while True:
7030 
      (fname, ftype, fid) = iprot.readFieldBegin()
7031 
      if ftype == TType.STOP:
7032 
        break
7033 
      if fid == 1:
7034 
        if ftype == TType.LIST:
7035 
          self.statuses = []
7036 
          (_etype38, _size35) = iprot.readListBegin()
7037 
          for _i39 in xrange(_size35):
7038 
            _elem40 = iprot.readI32();
7039 
            self.statuses.append(_elem40)
7040 
          iprot.readListEnd()
7041 
        else:
7042 
          iprot.skip(ftype)
7043 
      elif fid == 2:
7044 
        if ftype == TType.I64:
7045 
          self.offset = iprot.readI64();
7046 
        else:
7047 
          iprot.skip(ftype)
7048 
      elif fid == 3:
7049 
        if ftype == TType.I64:
7050 
          self.limit = iprot.readI64();
7051 
        else:
7052 
          iprot.skip(ftype)
7053 
      elif fid == 4:
7054 
        if ftype == TType.I64:
7055 
          self.warehouse_id = iprot.readI64();
7056 
        else:
7057 
          iprot.skip(ftype)
7058 
      else:
7059 
        iprot.skip(ftype)
7060 
      iprot.readFieldEnd()
7061 
    iprot.readStructEnd()
7062 
 
7063 
  def write(self, oprot):
7064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7066 
      return
7067 
    oprot.writeStructBegin('getOrdersInBatch_args')
7068 
    if self.statuses is not None:
7069 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7070 
      oprot.writeListBegin(TType.I32, len(self.statuses))
7071 
      for iter41 in self.statuses:
7072 
        oprot.writeI32(iter41)
7073 
      oprot.writeListEnd()
7074 
      oprot.writeFieldEnd()
7075 
    if self.offset is not None:
7076 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7077 
      oprot.writeI64(self.offset)
7078 
      oprot.writeFieldEnd()
7079 
    if self.limit is not None:
7080 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7081 
      oprot.writeI64(self.limit)
7082 
      oprot.writeFieldEnd()
7083 
    if self.warehouse_id is not None:
7084 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7085 
      oprot.writeI64(self.warehouse_id)
7086 
      oprot.writeFieldEnd()
7087 
    oprot.writeFieldStop()
7088 
    oprot.writeStructEnd()
7089 
 
7090 
  def validate(self):
7091 
    return
7092 
 
7093 
 
7094 
  def __repr__(self):
7095 
    L = ['%s=%r' % (key, value)
7096 
      for key, value in self.__dict__.iteritems()]
7097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7098 
 
7099 
  def __eq__(self, other):
7100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7101 
 
7102 
  def __ne__(self, other):
7103 
    return not (self == other)
7104 
 
7105 
class getOrdersInBatch_result:
7106 
  """
7107 
  Attributes:
7108 
   - success
7109 
   - ex
7110 
  """
7111 
 
7112 
  thrift_spec = (
7113 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7114 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7115 
  )
7116 
 
7117 
  def __init__(self, success=None, ex=None,):
7118 
    self.success = success
7119 
    self.ex = ex
7120 
 
7121 
  def read(self, iprot):
7122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7124 
      return
7125 
    iprot.readStructBegin()
7126 
    while True:
7127 
      (fname, ftype, fid) = iprot.readFieldBegin()
7128 
      if ftype == TType.STOP:
7129 
        break
7130 
      if fid == 0:
7131 
        if ftype == TType.LIST:
7132 
          self.success = []
7133 
          (_etype45, _size42) = iprot.readListBegin()
7134 
          for _i46 in xrange(_size42):
7135 
            _elem47 = Order()
7136 
            _elem47.read(iprot)
7137 
            self.success.append(_elem47)
7138 
          iprot.readListEnd()
7139 
        else:
7140 
          iprot.skip(ftype)
7141 
      elif fid == 1:
7142 
        if ftype == TType.STRUCT:
7143 
          self.ex = TransactionServiceException()
7144 
          self.ex.read(iprot)
7145 
        else:
7146 
          iprot.skip(ftype)
7147 
      else:
7148 
        iprot.skip(ftype)
7149 
      iprot.readFieldEnd()
7150 
    iprot.readStructEnd()
7151 
 
7152 
  def write(self, oprot):
7153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7155 
      return
7156 
    oprot.writeStructBegin('getOrdersInBatch_result')
7157 
    if self.success is not None:
7158 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7159 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7160 
      for iter48 in self.success:
7161 
        iter48.write(oprot)
7162 
      oprot.writeListEnd()
7163 
      oprot.writeFieldEnd()
7164 
    if self.ex is not None:
7165 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7166 
      self.ex.write(oprot)
7167 
      oprot.writeFieldEnd()
7168 
    oprot.writeFieldStop()
7169 
    oprot.writeStructEnd()
7170 
 
7171 
  def validate(self):
7172 
    return
7173 
 
7174 
 
7175 
  def __repr__(self):
7176 
    L = ['%s=%r' % (key, value)
7177 
      for key, value in self.__dict__.iteritems()]
7178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7179 
 
7180 
  def __eq__(self, other):
7181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7182 
 
7183 
  def __ne__(self, other):
7184 
    return not (self == other)
7185 
 
7186 
class getOrderCount_args:
7187 
  """
7188 
  Attributes:
7189 
   - statuses
7190 
   - warehouseId
7191 
  """
7192 
 
7193 
  thrift_spec = (
7194 
    None, # 0
7195 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7196 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7197 
  )
7198 
 
7199 
  def __init__(self, statuses=None, warehouseId=None,):
7200 
    self.statuses = statuses
7201 
    self.warehouseId = warehouseId
7202 
 
7203 
  def read(self, iprot):
7204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7206 
      return
7207 
    iprot.readStructBegin()
7208 
    while True:
7209 
      (fname, ftype, fid) = iprot.readFieldBegin()
7210 
      if ftype == TType.STOP:
7211 
        break
7212 
      if fid == 1:
7213 
        if ftype == TType.LIST:
7214 
          self.statuses = []
7215 
          (_etype52, _size49) = iprot.readListBegin()
7216 
          for _i53 in xrange(_size49):
7217 
            _elem54 = iprot.readI32();
7218 
            self.statuses.append(_elem54)
7219 
          iprot.readListEnd()
7220 
        else:
7221 
          iprot.skip(ftype)
7222 
      elif fid == 2:
7223 
        if ftype == TType.I64:
7224 
          self.warehouseId = iprot.readI64();
7225 
        else:
7226 
          iprot.skip(ftype)
7227 
      else:
7228 
        iprot.skip(ftype)
7229 
      iprot.readFieldEnd()
7230 
    iprot.readStructEnd()
7231 
 
7232 
  def write(self, oprot):
7233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7235 
      return
7236 
    oprot.writeStructBegin('getOrderCount_args')
7237 
    if self.statuses is not None:
7238 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7239 
      oprot.writeListBegin(TType.I32, len(self.statuses))
7240 
      for iter55 in self.statuses:
7241 
        oprot.writeI32(iter55)
7242 
      oprot.writeListEnd()
7243 
      oprot.writeFieldEnd()
7244 
    if self.warehouseId is not None:
7245 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7246 
      oprot.writeI64(self.warehouseId)
7247 
      oprot.writeFieldEnd()
7248 
    oprot.writeFieldStop()
7249 
    oprot.writeStructEnd()
7250 
 
7251 
  def validate(self):
7252 
    return
7253 
 
7254 
 
7255 
  def __repr__(self):
7256 
    L = ['%s=%r' % (key, value)
7257 
      for key, value in self.__dict__.iteritems()]
7258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7259 
 
7260 
  def __eq__(self, other):
7261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7262 
 
7263 
  def __ne__(self, other):
7264 
    return not (self == other)
7265 
 
7266 
class getOrderCount_result:
7267 
  """
7268 
  Attributes:
7269 
   - success
7270 
   - ex
7271 
  """
7272 
 
7273 
  thrift_spec = (
7274 
    (0, TType.I32, 'success', None, None, ), # 0
7275 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7276 
  )
7277 
 
7278 
  def __init__(self, success=None, ex=None,):
7279 
    self.success = success
7280 
    self.ex = ex
7281 
 
7282 
  def read(self, iprot):
7283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7285 
      return
7286 
    iprot.readStructBegin()
7287 
    while True:
7288 
      (fname, ftype, fid) = iprot.readFieldBegin()
7289 
      if ftype == TType.STOP:
7290 
        break
7291 
      if fid == 0:
7292 
        if ftype == TType.I32:
7293 
          self.success = iprot.readI32();
7294 
        else:
7295 
          iprot.skip(ftype)
7296 
      elif fid == 1:
7297 
        if ftype == TType.STRUCT:
7298 
          self.ex = TransactionServiceException()
7299 
          self.ex.read(iprot)
7300 
        else:
7301 
          iprot.skip(ftype)
7302 
      else:
7303 
        iprot.skip(ftype)
7304 
      iprot.readFieldEnd()
7305 
    iprot.readStructEnd()
7306 
 
7307 
  def write(self, oprot):
7308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7310 
      return
7311 
    oprot.writeStructBegin('getOrderCount_result')
7312 
    if self.success is not None:
7313 
      oprot.writeFieldBegin('success', TType.I32, 0)
7314 
      oprot.writeI32(self.success)
7315 
      oprot.writeFieldEnd()
7316 
    if self.ex is not None:
7317 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7318 
      self.ex.write(oprot)
7319 
      oprot.writeFieldEnd()
7320 
    oprot.writeFieldStop()
7321 
    oprot.writeStructEnd()
7322 
 
7323 
  def validate(self):
7324 
    return
7325 
 
7326 
 
7327 
  def __repr__(self):
7328 
    L = ['%s=%r' % (key, value)
7329 
      for key, value in self.__dict__.iteritems()]
7330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7331 
 
7332 
  def __eq__(self, other):
7333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7334 
 
7335 
  def __ne__(self, other):
7336 
    return not (self == other)
7337 
 
999 varun.gupt 7338 
class getOrdersByBillingDate_args:
7339 
  """
7340 
  Attributes:
7341 
   - status
7342 
   - start_billing_date
7343 
   - end_billing_date
7344 
   - warehouse_id
7345 
  """
7346 
 
7347 
  thrift_spec = (
7348 
    None, # 0
7349 
    (1, TType.I32, 'status', None, None, ), # 1
7350 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
7351 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
7352 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7353 
  )
7354 
 
7355 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7356 
    self.status = status
7357 
    self.start_billing_date = start_billing_date
7358 
    self.end_billing_date = end_billing_date
7359 
    self.warehouse_id = warehouse_id
7360 
 
7361 
  def read(self, iprot):
7362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7364 
      return
7365 
    iprot.readStructBegin()
7366 
    while True:
7367 
      (fname, ftype, fid) = iprot.readFieldBegin()
7368 
      if ftype == TType.STOP:
7369 
        break
7370 
      if fid == 1:
7371 
        if ftype == TType.I32:
7372 
          self.status = iprot.readI32();
7373 
        else:
7374 
          iprot.skip(ftype)
7375 
      elif fid == 2:
7376 
        if ftype == TType.I64:
7377 
          self.start_billing_date = iprot.readI64();
7378 
        else:
7379 
          iprot.skip(ftype)
7380 
      elif fid == 3:
7381 
        if ftype == TType.I64:
7382 
          self.end_billing_date = iprot.readI64();
7383 
        else:
7384 
          iprot.skip(ftype)
7385 
      elif fid == 4:
7386 
        if ftype == TType.I64:
7387 
          self.warehouse_id = iprot.readI64();
7388 
        else:
7389 
          iprot.skip(ftype)
7390 
      else:
7391 
        iprot.skip(ftype)
7392 
      iprot.readFieldEnd()
7393 
    iprot.readStructEnd()
7394 
 
7395 
  def write(self, oprot):
7396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7398 
      return
7399 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7400 
    if self.status is not None:
999 varun.gupt 7401 
      oprot.writeFieldBegin('status', TType.I32, 1)
7402 
      oprot.writeI32(self.status)
7403 
      oprot.writeFieldEnd()
3431 rajveer 7404 
    if self.start_billing_date is not None:
999 varun.gupt 7405 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7406 
      oprot.writeI64(self.start_billing_date)
7407 
      oprot.writeFieldEnd()
3431 rajveer 7408 
    if self.end_billing_date is not None:
999 varun.gupt 7409 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7410 
      oprot.writeI64(self.end_billing_date)
7411 
      oprot.writeFieldEnd()
3431 rajveer 7412 
    if self.warehouse_id is not None:
999 varun.gupt 7413 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7414 
      oprot.writeI64(self.warehouse_id)
7415 
      oprot.writeFieldEnd()
7416 
    oprot.writeFieldStop()
7417 
    oprot.writeStructEnd()
7418 
 
3431 rajveer 7419 
  def validate(self):
7420 
    return
7421 
 
7422 
 
999 varun.gupt 7423 
  def __repr__(self):
7424 
    L = ['%s=%r' % (key, value)
7425 
      for key, value in self.__dict__.iteritems()]
7426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7427 
 
7428 
  def __eq__(self, other):
7429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7430 
 
7431 
  def __ne__(self, other):
7432 
    return not (self == other)
7433 
 
7434 
class getOrdersByBillingDate_result:
7435 
  """
7436 
  Attributes:
7437 
   - success
7438 
   - ex
7439 
  """
7440 
 
7441 
  thrift_spec = (
7442 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7443 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7444 
  )
7445 
 
7446 
  def __init__(self, success=None, ex=None,):
7447 
    self.success = success
7448 
    self.ex = ex
7449 
 
7450 
  def read(self, iprot):
7451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7453 
      return
7454 
    iprot.readStructBegin()
7455 
    while True:
7456 
      (fname, ftype, fid) = iprot.readFieldBegin()
7457 
      if ftype == TType.STOP:
7458 
        break
7459 
      if fid == 0:
7460 
        if ftype == TType.LIST:
7461 
          self.success = []
4133 chandransh 7462 
          (_etype59, _size56) = iprot.readListBegin()
7463 
          for _i60 in xrange(_size56):
7464 
            _elem61 = Order()
7465 
            _elem61.read(iprot)
7466 
            self.success.append(_elem61)
999 varun.gupt 7467 
          iprot.readListEnd()
7468 
        else:
7469 
          iprot.skip(ftype)
7470 
      elif fid == 1:
7471 
        if ftype == TType.STRUCT:
7472 
          self.ex = TransactionServiceException()
7473 
          self.ex.read(iprot)
7474 
        else:
7475 
          iprot.skip(ftype)
7476 
      else:
7477 
        iprot.skip(ftype)
7478 
      iprot.readFieldEnd()
7479 
    iprot.readStructEnd()
7480 
 
7481 
  def write(self, oprot):
7482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7484 
      return
7485 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 7486 
    if self.success is not None:
999 varun.gupt 7487 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7488 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7489 
      for iter62 in self.success:
7490 
        iter62.write(oprot)
999 varun.gupt 7491 
      oprot.writeListEnd()
7492 
      oprot.writeFieldEnd()
3431 rajveer 7493 
    if self.ex is not None:
999 varun.gupt 7494 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7495 
      self.ex.write(oprot)
7496 
      oprot.writeFieldEnd()
7497 
    oprot.writeFieldStop()
7498 
    oprot.writeStructEnd()
7499 
 
3431 rajveer 7500 
  def validate(self):
7501 
    return
7502 
 
7503 
 
999 varun.gupt 7504 
  def __repr__(self):
7505 
    L = ['%s=%r' % (key, value)
7506 
      for key, value in self.__dict__.iteritems()]
7507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7508 
 
7509 
  def __eq__(self, other):
7510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7511 
 
7512 
  def __ne__(self, other):
7513 
    return not (self == other)
7514 
 
3427 chandransh 7515 
class getOrdersByShippingDate_args:
7516 
  """
7517 
  Attributes:
7518 
   - fromShippingDate
7519 
   - toShippingDate
7520 
   - providerId
7521 
   - warehouseId
3451 chandransh 7522 
   - cod
3427 chandransh 7523 
  """
7524 
 
7525 
  thrift_spec = (
7526 
    None, # 0
7527 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
7528 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
7529 
    (3, TType.I64, 'providerId', None, None, ), # 3
7530 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 7531 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 7532 
  )
7533 
 
3451 chandransh 7534 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 7535 
    self.fromShippingDate = fromShippingDate
7536 
    self.toShippingDate = toShippingDate
7537 
    self.providerId = providerId
7538 
    self.warehouseId = warehouseId
3451 chandransh 7539 
    self.cod = cod
3427 chandransh 7540 
 
7541 
  def read(self, iprot):
7542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7544 
      return
7545 
    iprot.readStructBegin()
7546 
    while True:
7547 
      (fname, ftype, fid) = iprot.readFieldBegin()
7548 
      if ftype == TType.STOP:
7549 
        break
7550 
      if fid == 1:
7551 
        if ftype == TType.I64:
7552 
          self.fromShippingDate = iprot.readI64();
7553 
        else:
7554 
          iprot.skip(ftype)
7555 
      elif fid == 2:
7556 
        if ftype == TType.I64:
7557 
          self.toShippingDate = iprot.readI64();
7558 
        else:
7559 
          iprot.skip(ftype)
7560 
      elif fid == 3:
7561 
        if ftype == TType.I64:
7562 
          self.providerId = iprot.readI64();
7563 
        else:
7564 
          iprot.skip(ftype)
7565 
      elif fid == 4:
7566 
        if ftype == TType.I64:
7567 
          self.warehouseId = iprot.readI64();
7568 
        else:
7569 
          iprot.skip(ftype)
3451 chandransh 7570 
      elif fid == 5:
7571 
        if ftype == TType.BOOL:
7572 
          self.cod = iprot.readBool();
7573 
        else:
7574 
          iprot.skip(ftype)
3427 chandransh 7575 
      else:
7576 
        iprot.skip(ftype)
7577 
      iprot.readFieldEnd()
7578 
    iprot.readStructEnd()
7579 
 
7580 
  def write(self, oprot):
7581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7583 
      return
7584 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 7585 
    if self.fromShippingDate is not None:
3427 chandransh 7586 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
7587 
      oprot.writeI64(self.fromShippingDate)
7588 
      oprot.writeFieldEnd()
3431 rajveer 7589 
    if self.toShippingDate is not None:
3427 chandransh 7590 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
7591 
      oprot.writeI64(self.toShippingDate)
7592 
      oprot.writeFieldEnd()
3431 rajveer 7593 
    if self.providerId is not None:
3427 chandransh 7594 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
7595 
      oprot.writeI64(self.providerId)
7596 
      oprot.writeFieldEnd()
3431 rajveer 7597 
    if self.warehouseId is not None:
3427 chandransh 7598 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
7599 
      oprot.writeI64(self.warehouseId)
7600 
      oprot.writeFieldEnd()
3451 chandransh 7601 
    if self.cod is not None:
7602 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
7603 
      oprot.writeBool(self.cod)
7604 
      oprot.writeFieldEnd()
3427 chandransh 7605 
    oprot.writeFieldStop()
7606 
    oprot.writeStructEnd()
7607 
 
3431 rajveer 7608 
  def validate(self):
7609 
    return
7610 
 
7611 
 
3427 chandransh 7612 
  def __repr__(self):
7613 
    L = ['%s=%r' % (key, value)
7614 
      for key, value in self.__dict__.iteritems()]
7615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7616 
 
7617 
  def __eq__(self, other):
7618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7619 
 
7620 
  def __ne__(self, other):
7621 
    return not (self == other)
7622 
 
7623 
class getOrdersByShippingDate_result:
7624 
  """
7625 
  Attributes:
7626 
   - success
7627 
   - ex
7628 
  """
7629 
 
7630 
  thrift_spec = (
7631 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7632 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7633 
  )
7634 
 
7635 
  def __init__(self, success=None, ex=None,):
7636 
    self.success = success
7637 
    self.ex = ex
7638 
 
7639 
  def read(self, iprot):
7640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7642 
      return
7643 
    iprot.readStructBegin()
7644 
    while True:
7645 
      (fname, ftype, fid) = iprot.readFieldBegin()
7646 
      if ftype == TType.STOP:
7647 
        break
7648 
      if fid == 0:
7649 
        if ftype == TType.LIST:
7650 
          self.success = []
4133 chandransh 7651 
          (_etype66, _size63) = iprot.readListBegin()
7652 
          for _i67 in xrange(_size63):
7653 
            _elem68 = Order()
7654 
            _elem68.read(iprot)
7655 
            self.success.append(_elem68)
3427 chandransh 7656 
          iprot.readListEnd()
7657 
        else:
7658 
          iprot.skip(ftype)
7659 
      elif fid == 1:
7660 
        if ftype == TType.STRUCT:
7661 
          self.ex = TransactionServiceException()
7662 
          self.ex.read(iprot)
7663 
        else:
7664 
          iprot.skip(ftype)
7665 
      else:
7666 
        iprot.skip(ftype)
7667 
      iprot.readFieldEnd()
7668 
    iprot.readStructEnd()
7669 
 
7670 
  def write(self, oprot):
7671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7673 
      return
7674 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 7675 
    if self.success is not None:
3427 chandransh 7676 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7677 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7678 
      for iter69 in self.success:
7679 
        iter69.write(oprot)
3427 chandransh 7680 
      oprot.writeListEnd()
7681 
      oprot.writeFieldEnd()
3431 rajveer 7682 
    if self.ex is not None:
3427 chandransh 7683 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7684 
      self.ex.write(oprot)
7685 
      oprot.writeFieldEnd()
7686 
    oprot.writeFieldStop()
7687 
    oprot.writeStructEnd()
7688 
 
3431 rajveer 7689 
  def validate(self):
7690 
    return
7691 
 
7692 
 
3427 chandransh 7693 
  def __repr__(self):
7694 
    L = ['%s=%r' % (key, value)
7695 
      for key, value in self.__dict__.iteritems()]
7696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7697 
 
7698 
  def __eq__(self, other):
7699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7700 
 
7701 
  def __ne__(self, other):
7702 
    return not (self == other)
7703 
 
1382 varun.gupt 7704 
class getReturnableOrdersForCustomer_args:
7705 
  """
7706 
  Attributes:
7707 
   - customer_id
7708 
   - limit
7709 
  """
7710 
 
7711 
  thrift_spec = (
7712 
    None, # 0
7713 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7714 
    (2, TType.I64, 'limit', None, None, ), # 2
7715 
  )
7716 
 
7717 
  def __init__(self, customer_id=None, limit=None,):
7718 
    self.customer_id = customer_id
7719 
    self.limit = limit
7720 
 
7721 
  def read(self, iprot):
7722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7724 
      return
7725 
    iprot.readStructBegin()
7726 
    while True:
7727 
      (fname, ftype, fid) = iprot.readFieldBegin()
7728 
      if ftype == TType.STOP:
7729 
        break
7730 
      if fid == 1:
7731 
        if ftype == TType.I64:
7732 
          self.customer_id = iprot.readI64();
7733 
        else:
7734 
          iprot.skip(ftype)
7735 
      elif fid == 2:
7736 
        if ftype == TType.I64:
7737 
          self.limit = iprot.readI64();
7738 
        else:
7739 
          iprot.skip(ftype)
7740 
      else:
7741 
        iprot.skip(ftype)
7742 
      iprot.readFieldEnd()
7743 
    iprot.readStructEnd()
7744 
 
7745 
  def write(self, oprot):
7746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7748 
      return
7749 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 7750 
    if self.customer_id is not None:
1382 varun.gupt 7751 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7752 
      oprot.writeI64(self.customer_id)
7753 
      oprot.writeFieldEnd()
3431 rajveer 7754 
    if self.limit is not None:
1382 varun.gupt 7755 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7756 
      oprot.writeI64(self.limit)
7757 
      oprot.writeFieldEnd()
7758 
    oprot.writeFieldStop()
7759 
    oprot.writeStructEnd()
7760 
 
3431 rajveer 7761 
  def validate(self):
7762 
    return
7763 
 
7764 
 
1382 varun.gupt 7765 
  def __repr__(self):
7766 
    L = ['%s=%r' % (key, value)
7767 
      for key, value in self.__dict__.iteritems()]
7768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7769 
 
7770 
  def __eq__(self, other):
7771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7772 
 
7773 
  def __ne__(self, other):
7774 
    return not (self == other)
7775 
 
7776 
class getReturnableOrdersForCustomer_result:
7777 
  """
7778 
  Attributes:
7779 
   - success
7780 
   - ex
7781 
  """
7782 
 
7783 
  thrift_spec = (
7784 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7785 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7786 
  )
7787 
 
7788 
  def __init__(self, success=None, ex=None,):
7789 
    self.success = success
7790 
    self.ex = ex
7791 
 
7792 
  def read(self, iprot):
7793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7795 
      return
7796 
    iprot.readStructBegin()
7797 
    while True:
7798 
      (fname, ftype, fid) = iprot.readFieldBegin()
7799 
      if ftype == TType.STOP:
7800 
        break
7801 
      if fid == 0:
7802 
        if ftype == TType.LIST:
7803 
          self.success = []
4133 chandransh 7804 
          (_etype73, _size70) = iprot.readListBegin()
7805 
          for _i74 in xrange(_size70):
7806 
            _elem75 = iprot.readI64();
7807 
            self.success.append(_elem75)
1382 varun.gupt 7808 
          iprot.readListEnd()
7809 
        else:
7810 
          iprot.skip(ftype)
7811 
      elif fid == 1:
7812 
        if ftype == TType.STRUCT:
7813 
          self.ex = TransactionServiceException()
7814 
          self.ex.read(iprot)
7815 
        else:
7816 
          iprot.skip(ftype)
7817 
      else:
7818 
        iprot.skip(ftype)
7819 
      iprot.readFieldEnd()
7820 
    iprot.readStructEnd()
7821 
 
7822 
  def write(self, oprot):
7823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7825 
      return
7826 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 7827 
    if self.success is not None:
1382 varun.gupt 7828 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7829 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7830 
      for iter76 in self.success:
7831 
        oprot.writeI64(iter76)
1382 varun.gupt 7832 
      oprot.writeListEnd()
7833 
      oprot.writeFieldEnd()
3431 rajveer 7834 
    if self.ex is not None:
1382 varun.gupt 7835 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7836 
      self.ex.write(oprot)
7837 
      oprot.writeFieldEnd()
7838 
    oprot.writeFieldStop()
7839 
    oprot.writeStructEnd()
7840 
 
3431 rajveer 7841 
  def validate(self):
7842 
    return
7843 
 
7844 
 
1382 varun.gupt 7845 
  def __repr__(self):
7846 
    L = ['%s=%r' % (key, value)
7847 
      for key, value in self.__dict__.iteritems()]
7848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7849 
 
7850 
  def __eq__(self, other):
7851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7852 
 
7853 
  def __ne__(self, other):
7854 
    return not (self == other)
7855 
 
7856 
class getCancellableOrdersForCustomer_args:
7857 
  """
7858 
  Attributes:
7859 
   - customer_id
7860 
   - limit
7861 
  """
7862 
 
7863 
  thrift_spec = (
7864 
    None, # 0
7865 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7866 
    (2, TType.I64, 'limit', None, None, ), # 2
7867 
  )
7868 
 
7869 
  def __init__(self, customer_id=None, limit=None,):
7870 
    self.customer_id = customer_id
7871 
    self.limit = limit
7872 
 
7873 
  def read(self, iprot):
7874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7876 
      return
7877 
    iprot.readStructBegin()
7878 
    while True:
7879 
      (fname, ftype, fid) = iprot.readFieldBegin()
7880 
      if ftype == TType.STOP:
7881 
        break
7882 
      if fid == 1:
7883 
        if ftype == TType.I64:
7884 
          self.customer_id = iprot.readI64();
7885 
        else:
7886 
          iprot.skip(ftype)
7887 
      elif fid == 2:
7888 
        if ftype == TType.I64:
7889 
          self.limit = iprot.readI64();
7890 
        else:
7891 
          iprot.skip(ftype)
7892 
      else:
7893 
        iprot.skip(ftype)
7894 
      iprot.readFieldEnd()
7895 
    iprot.readStructEnd()
7896 
 
7897 
  def write(self, oprot):
7898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7900 
      return
7901 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7902 
    if self.customer_id is not None:
1382 varun.gupt 7903 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7904 
      oprot.writeI64(self.customer_id)
7905 
      oprot.writeFieldEnd()
3431 rajveer 7906 
    if self.limit is not None:
1382 varun.gupt 7907 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7908 
      oprot.writeI64(self.limit)
7909 
      oprot.writeFieldEnd()
7910 
    oprot.writeFieldStop()
7911 
    oprot.writeStructEnd()
7912 
 
3431 rajveer 7913 
  def validate(self):
7914 
    return
7915 
 
7916 
 
1382 varun.gupt 7917 
  def __repr__(self):
7918 
    L = ['%s=%r' % (key, value)
7919 
      for key, value in self.__dict__.iteritems()]
7920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7921 
 
7922 
  def __eq__(self, other):
7923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7924 
 
7925 
  def __ne__(self, other):
7926 
    return not (self == other)
7927 
 
7928 
class getCancellableOrdersForCustomer_result:
7929 
  """
7930 
  Attributes:
7931 
   - success
7932 
   - ex
7933 
  """
7934 
 
7935 
  thrift_spec = (
7936 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7937 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7938 
  )
7939 
 
7940 
  def __init__(self, success=None, ex=None,):
7941 
    self.success = success
7942 
    self.ex = ex
7943 
 
7944 
  def read(self, iprot):
7945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7947 
      return
7948 
    iprot.readStructBegin()
7949 
    while True:
7950 
      (fname, ftype, fid) = iprot.readFieldBegin()
7951 
      if ftype == TType.STOP:
7952 
        break
7953 
      if fid == 0:
7954 
        if ftype == TType.LIST:
7955 
          self.success = []
4133 chandransh 7956 
          (_etype80, _size77) = iprot.readListBegin()
7957 
          for _i81 in xrange(_size77):
7958 
            _elem82 = iprot.readI64();
7959 
            self.success.append(_elem82)
1382 varun.gupt 7960 
          iprot.readListEnd()
7961 
        else:
7962 
          iprot.skip(ftype)
7963 
      elif fid == 1:
7964 
        if ftype == TType.STRUCT:
7965 
          self.ex = TransactionServiceException()
7966 
          self.ex.read(iprot)
7967 
        else:
7968 
          iprot.skip(ftype)
7969 
      else:
7970 
        iprot.skip(ftype)
7971 
      iprot.readFieldEnd()
7972 
    iprot.readStructEnd()
7973 
 
7974 
  def write(self, oprot):
7975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7977 
      return
7978 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 7979 
    if self.success is not None:
1382 varun.gupt 7980 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7981 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7982 
      for iter83 in self.success:
7983 
        oprot.writeI64(iter83)
1382 varun.gupt 7984 
      oprot.writeListEnd()
7985 
      oprot.writeFieldEnd()
3431 rajveer 7986 
    if self.ex is not None:
1382 varun.gupt 7987 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7988 
      self.ex.write(oprot)
7989 
      oprot.writeFieldEnd()
7990 
    oprot.writeFieldStop()
7991 
    oprot.writeStructEnd()
7992 
 
3431 rajveer 7993 
  def validate(self):
7994 
    return
7995 
 
7996 
 
1382 varun.gupt 7997 
  def __repr__(self):
7998 
    L = ['%s=%r' % (key, value)
7999 
      for key, value in self.__dict__.iteritems()]
8000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8001 
 
8002 
  def __eq__(self, other):
8003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8004 
 
8005 
  def __ne__(self, other):
8006 
    return not (self == other)
8007 
 
483 rajveer 8008 
class changeOrderStatus_args:
94 ashish 8009 
  """
8010 
  Attributes:
483 rajveer 8011 
   - orderId
8012 
   - status
8013 
   - description
94 ashish 8014 
  """
8015 
 
8016 
  thrift_spec = (
8017 
    None, # 0
483 rajveer 8018 
    (1, TType.I64, 'orderId', None, None, ), # 1
8019 
    (2, TType.I32, 'status', None, None, ), # 2
8020 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8021 
  )
8022 
 
483 rajveer 8023 
  def __init__(self, orderId=None, status=None, description=None,):
8024 
    self.orderId = orderId
8025 
    self.status = status
8026 
    self.description = description
94 ashish 8027 
 
8028 
  def read(self, iprot):
8029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8031 
      return
8032 
    iprot.readStructBegin()
8033 
    while True:
8034 
      (fname, ftype, fid) = iprot.readFieldBegin()
8035 
      if ftype == TType.STOP:
8036 
        break
8037 
      if fid == 1:
8038 
        if ftype == TType.I64:
483 rajveer 8039 
          self.orderId = iprot.readI64();
94 ashish 8040 
        else:
8041 
          iprot.skip(ftype)
8042 
      elif fid == 2:
483 rajveer 8043 
        if ftype == TType.I32:
8044 
          self.status = iprot.readI32();
94 ashish 8045 
        else:
8046 
          iprot.skip(ftype)
483 rajveer 8047 
      elif fid == 3:
8048 
        if ftype == TType.STRING:
8049 
          self.description = iprot.readString();
8050 
        else:
8051 
          iprot.skip(ftype)
94 ashish 8052 
      else:
8053 
        iprot.skip(ftype)
8054 
      iprot.readFieldEnd()
8055 
    iprot.readStructEnd()
8056 
 
8057 
  def write(self, oprot):
8058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8060 
      return
483 rajveer 8061 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8062 
    if self.orderId is not None:
483 rajveer 8063 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8064 
      oprot.writeI64(self.orderId)
94 ashish 8065 
      oprot.writeFieldEnd()
3431 rajveer 8066 
    if self.status is not None:
483 rajveer 8067 
      oprot.writeFieldBegin('status', TType.I32, 2)
8068 
      oprot.writeI32(self.status)
94 ashish 8069 
      oprot.writeFieldEnd()
3431 rajveer 8070 
    if self.description is not None:
483 rajveer 8071 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8072 
      oprot.writeString(self.description)
8073 
      oprot.writeFieldEnd()
94 ashish 8074 
    oprot.writeFieldStop()
8075 
    oprot.writeStructEnd()
8076 
 
3431 rajveer 8077 
  def validate(self):
8078 
    return
8079 
 
8080 
 
94 ashish 8081 
  def __repr__(self):
8082 
    L = ['%s=%r' % (key, value)
8083 
      for key, value in self.__dict__.iteritems()]
8084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8085 
 
8086 
  def __eq__(self, other):
8087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8088 
 
8089 
  def __ne__(self, other):
8090 
    return not (self == other)
8091 
 
483 rajveer 8092 
class changeOrderStatus_result:
94 ashish 8093 
  """
8094 
  Attributes:
8095 
   - success
8096 
   - ex
8097 
  """
8098 
 
8099 
  thrift_spec = (
8100 
    (0, TType.BOOL, 'success', None, None, ), # 0
8101 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8102 
  )
8103 
 
8104 
  def __init__(self, success=None, ex=None,):
8105 
    self.success = success
8106 
    self.ex = ex
8107 
 
8108 
  def read(self, iprot):
8109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8111 
      return
8112 
    iprot.readStructBegin()
8113 
    while True:
8114 
      (fname, ftype, fid) = iprot.readFieldBegin()
8115 
      if ftype == TType.STOP:
8116 
        break
8117 
      if fid == 0:
8118 
        if ftype == TType.BOOL:
8119 
          self.success = iprot.readBool();
8120 
        else:
8121 
          iprot.skip(ftype)
8122 
      elif fid == 1:
8123 
        if ftype == TType.STRUCT:
8124 
          self.ex = TransactionServiceException()
8125 
          self.ex.read(iprot)
8126 
        else:
8127 
          iprot.skip(ftype)
8128 
      else:
8129 
        iprot.skip(ftype)
8130 
      iprot.readFieldEnd()
8131 
    iprot.readStructEnd()
8132 
 
8133 
  def write(self, oprot):
8134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8136 
      return
483 rajveer 8137 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8138 
    if self.success is not None:
94 ashish 8139 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8140 
      oprot.writeBool(self.success)
8141 
      oprot.writeFieldEnd()
3431 rajveer 8142 
    if self.ex is not None:
94 ashish 8143 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8144 
      self.ex.write(oprot)
8145 
      oprot.writeFieldEnd()
8146 
    oprot.writeFieldStop()
8147 
    oprot.writeStructEnd()
8148 
 
3431 rajveer 8149 
  def validate(self):
8150 
    return
8151 
 
8152 
 
94 ashish 8153 
  def __repr__(self):
8154 
    L = ['%s=%r' % (key, value)
8155 
      for key, value in self.__dict__.iteritems()]
8156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8157 
 
8158 
  def __eq__(self, other):
8159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8160 
 
8161 
  def __ne__(self, other):
8162 
    return not (self == other)
8163 
 
3064 chandransh 8164 
class getOrdersForTransaction_args:
494 rajveer 8165 
  """
8166 
  Attributes:
3064 chandransh 8167 
   - transactionId
8168 
   - customerId
494 rajveer 8169 
  """
8170 
 
8171 
  thrift_spec = (
8172 
    None, # 0
3064 chandransh 8173 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8174 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8175 
  )
8176 
 
3064 chandransh 8177 
  def __init__(self, transactionId=None, customerId=None,):
8178 
    self.transactionId = transactionId
8179 
    self.customerId = customerId
494 rajveer 8180 
 
8181 
  def read(self, iprot):
8182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8184 
      return
8185 
    iprot.readStructBegin()
8186 
    while True:
8187 
      (fname, ftype, fid) = iprot.readFieldBegin()
8188 
      if ftype == TType.STOP:
8189 
        break
8190 
      if fid == 1:
8191 
        if ftype == TType.I64:
3064 chandransh 8192 
          self.transactionId = iprot.readI64();
494 rajveer 8193 
        else:
8194 
          iprot.skip(ftype)
8195 
      elif fid == 2:
3064 chandransh 8196 
        if ftype == TType.I64:
8197 
          self.customerId = iprot.readI64();
494 rajveer 8198 
        else:
8199 
          iprot.skip(ftype)
8200 
      else:
8201 
        iprot.skip(ftype)
8202 
      iprot.readFieldEnd()
8203 
    iprot.readStructEnd()
8204 
 
8205 
  def write(self, oprot):
8206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8208 
      return
3064 chandransh 8209 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8210 
    if self.transactionId is not None:
3064 chandransh 8211 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8212 
      oprot.writeI64(self.transactionId)
494 rajveer 8213 
      oprot.writeFieldEnd()
3431 rajveer 8214 
    if self.customerId is not None:
3064 chandransh 8215 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8216 
      oprot.writeI64(self.customerId)
494 rajveer 8217 
      oprot.writeFieldEnd()
8218 
    oprot.writeFieldStop()
8219 
    oprot.writeStructEnd()
8220 
 
3431 rajveer 8221 
  def validate(self):
8222 
    return
8223 
 
8224 
 
494 rajveer 8225 
  def __repr__(self):
8226 
    L = ['%s=%r' % (key, value)
8227 
      for key, value in self.__dict__.iteritems()]
8228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8229 
 
8230 
  def __eq__(self, other):
8231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8232 
 
8233 
  def __ne__(self, other):
8234 
    return not (self == other)
8235 
 
3064 chandransh 8236 
class getOrdersForTransaction_result:
494 rajveer 8237 
  """
8238 
  Attributes:
8239 
   - success
8240 
   - ex
8241 
  """
8242 
 
8243 
  thrift_spec = (
3064 chandransh 8244 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8245 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8246 
  )
8247 
 
8248 
  def __init__(self, success=None, ex=None,):
8249 
    self.success = success
8250 
    self.ex = ex
8251 
 
8252 
  def read(self, iprot):
8253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8255 
      return
8256 
    iprot.readStructBegin()
8257 
    while True:
8258 
      (fname, ftype, fid) = iprot.readFieldBegin()
8259 
      if ftype == TType.STOP:
8260 
        break
8261 
      if fid == 0:
3064 chandransh 8262 
        if ftype == TType.LIST:
8263 
          self.success = []
4133 chandransh 8264 
          (_etype87, _size84) = iprot.readListBegin()
8265 
          for _i88 in xrange(_size84):
8266 
            _elem89 = Order()
8267 
            _elem89.read(iprot)
8268 
            self.success.append(_elem89)
3064 chandransh 8269 
          iprot.readListEnd()
494 rajveer 8270 
        else:
8271 
          iprot.skip(ftype)
8272 
      elif fid == 1:
8273 
        if ftype == TType.STRUCT:
8274 
          self.ex = TransactionServiceException()
8275 
          self.ex.read(iprot)
8276 
        else:
8277 
          iprot.skip(ftype)
8278 
      else:
8279 
        iprot.skip(ftype)
8280 
      iprot.readFieldEnd()
8281 
    iprot.readStructEnd()
8282 
 
8283 
  def write(self, oprot):
8284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8286 
      return
3064 chandransh 8287 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 8288 
    if self.success is not None:
3064 chandransh 8289 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8290 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8291 
      for iter90 in self.success:
8292 
        iter90.write(oprot)
3064 chandransh 8293 
      oprot.writeListEnd()
494 rajveer 8294 
      oprot.writeFieldEnd()
3431 rajveer 8295 
    if self.ex is not None:
494 rajveer 8296 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8297 
      self.ex.write(oprot)
8298 
      oprot.writeFieldEnd()
8299 
    oprot.writeFieldStop()
8300 
    oprot.writeStructEnd()
8301 
 
3431 rajveer 8302 
  def validate(self):
8303 
    return
8304 
 
8305 
 
494 rajveer 8306 
  def __repr__(self):
8307 
    L = ['%s=%r' % (key, value)
8308 
      for key, value in self.__dict__.iteritems()]
8309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8310 
 
8311 
  def __eq__(self, other):
8312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8313 
 
8314 
  def __ne__(self, other):
8315 
    return not (self == other)
8316 
 
3064 chandransh 8317 
class getOrdersForCustomer_args:
1149 chandransh 8318 
  """
8319 
  Attributes:
3064 chandransh 8320 
   - customerId
8321 
   - from_date
8322 
   - to_date
8323 
   - statuses
1149 chandransh 8324 
  """
8325 
 
8326 
  thrift_spec = (
8327 
    None, # 0
3064 chandransh 8328 
    (1, TType.I64, 'customerId', None, None, ), # 1
8329 
    (2, TType.I64, 'from_date', None, None, ), # 2
8330 
    (3, TType.I64, 'to_date', None, None, ), # 3
8331 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 8332 
  )
8333 
 
3064 chandransh 8334 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
8335 
    self.customerId = customerId
8336 
    self.from_date = from_date
8337 
    self.to_date = to_date
8338 
    self.statuses = statuses
1149 chandransh 8339 
 
8340 
  def read(self, iprot):
8341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8343 
      return
8344 
    iprot.readStructBegin()
8345 
    while True:
8346 
      (fname, ftype, fid) = iprot.readFieldBegin()
8347 
      if ftype == TType.STOP:
8348 
        break
8349 
      if fid == 1:
8350 
        if ftype == TType.I64:
3064 chandransh 8351 
          self.customerId = iprot.readI64();
1149 chandransh 8352 
        else:
8353 
          iprot.skip(ftype)
8354 
      elif fid == 2:
8355 
        if ftype == TType.I64:
3064 chandransh 8356 
          self.from_date = iprot.readI64();
1149 chandransh 8357 
        else:
8358 
          iprot.skip(ftype)
2783 chandransh 8359 
      elif fid == 3:
8360 
        if ftype == TType.I64:
3064 chandransh 8361 
          self.to_date = iprot.readI64();
2783 chandransh 8362 
        else:
8363 
          iprot.skip(ftype)
8364 
      elif fid == 4:
3064 chandransh 8365 
        if ftype == TType.LIST:
8366 
          self.statuses = []
4133 chandransh 8367 
          (_etype94, _size91) = iprot.readListBegin()
8368 
          for _i95 in xrange(_size91):
8369 
            _elem96 = iprot.readI32();
8370 
            self.statuses.append(_elem96)
3064 chandransh 8371 
          iprot.readListEnd()
2783 chandransh 8372 
        else:
8373 
          iprot.skip(ftype)
1149 chandransh 8374 
      else:
8375 
        iprot.skip(ftype)
8376 
      iprot.readFieldEnd()
8377 
    iprot.readStructEnd()
8378 
 
8379 
  def write(self, oprot):
8380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8382 
      return
3064 chandransh 8383 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 8384 
    if self.customerId is not None:
3064 chandransh 8385 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8386 
      oprot.writeI64(self.customerId)
1149 chandransh 8387 
      oprot.writeFieldEnd()
3431 rajveer 8388 
    if self.from_date is not None:
3064 chandransh 8389 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8390 
      oprot.writeI64(self.from_date)
1149 chandransh 8391 
      oprot.writeFieldEnd()
3431 rajveer 8392 
    if self.to_date is not None:
3064 chandransh 8393 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8394 
      oprot.writeI64(self.to_date)
2783 chandransh 8395 
      oprot.writeFieldEnd()
3431 rajveer 8396 
    if self.statuses is not None:
3064 chandransh 8397 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
8398 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 8399 
      for iter97 in self.statuses:
8400 
        oprot.writeI32(iter97)
3064 chandransh 8401 
      oprot.writeListEnd()
2783 chandransh 8402 
      oprot.writeFieldEnd()
1149 chandransh 8403 
    oprot.writeFieldStop()
8404 
    oprot.writeStructEnd()
8405 
 
3431 rajveer 8406 
  def validate(self):
8407 
    return
8408 
 
8409 
 
1149 chandransh 8410 
  def __repr__(self):
8411 
    L = ['%s=%r' % (key, value)
8412 
      for key, value in self.__dict__.iteritems()]
8413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8414 
 
8415 
  def __eq__(self, other):
8416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8417 
 
8418 
  def __ne__(self, other):
8419 
    return not (self == other)
8420 
 
3064 chandransh 8421 
class getOrdersForCustomer_result:
1149 chandransh 8422 
  """
8423 
  Attributes:
8424 
   - success
8425 
   - ex
8426 
  """
8427 
 
8428 
  thrift_spec = (
3064 chandransh 8429 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8430 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8431 
  )
8432 
 
8433 
  def __init__(self, success=None, ex=None,):
8434 
    self.success = success
8435 
    self.ex = ex
8436 
 
8437 
  def read(self, iprot):
8438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8440 
      return
8441 
    iprot.readStructBegin()
8442 
    while True:
8443 
      (fname, ftype, fid) = iprot.readFieldBegin()
8444 
      if ftype == TType.STOP:
8445 
        break
8446 
      if fid == 0:
3064 chandransh 8447 
        if ftype == TType.LIST:
8448 
          self.success = []
4133 chandransh 8449 
          (_etype101, _size98) = iprot.readListBegin()
8450 
          for _i102 in xrange(_size98):
8451 
            _elem103 = Order()
8452 
            _elem103.read(iprot)
8453 
            self.success.append(_elem103)
3064 chandransh 8454 
          iprot.readListEnd()
1149 chandransh 8455 
        else:
8456 
          iprot.skip(ftype)
8457 
      elif fid == 1:
8458 
        if ftype == TType.STRUCT:
8459 
          self.ex = TransactionServiceException()
8460 
          self.ex.read(iprot)
8461 
        else:
8462 
          iprot.skip(ftype)
8463 
      else:
8464 
        iprot.skip(ftype)
8465 
      iprot.readFieldEnd()
8466 
    iprot.readStructEnd()
8467 
 
8468 
  def write(self, oprot):
8469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8471 
      return
3064 chandransh 8472 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 8473 
    if self.success is not None:
3064 chandransh 8474 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8475 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8476 
      for iter104 in self.success:
8477 
        iter104.write(oprot)
3064 chandransh 8478 
      oprot.writeListEnd()
1149 chandransh 8479 
      oprot.writeFieldEnd()
3431 rajveer 8480 
    if self.ex is not None:
1149 chandransh 8481 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8482 
      self.ex.write(oprot)
8483 
      oprot.writeFieldEnd()
8484 
    oprot.writeFieldStop()
8485 
    oprot.writeStructEnd()
8486 
 
3431 rajveer 8487 
  def validate(self):
8488 
    return
8489 
 
8490 
 
1149 chandransh 8491 
  def __repr__(self):
8492 
    L = ['%s=%r' % (key, value)
8493 
      for key, value in self.__dict__.iteritems()]
8494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8495 
 
8496 
  def __eq__(self, other):
8497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8498 
 
8499 
  def __ne__(self, other):
8500 
    return not (self == other)
8501 
 
3064 chandransh 8502 
class createOrder_args:
921 rajveer 8503 
  """
8504 
  Attributes:
3064 chandransh 8505 
   - order
921 rajveer 8506 
  """
8507 
 
8508 
  thrift_spec = (
8509 
    None, # 0
3064 chandransh 8510 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 8511 
  )
8512 
 
3064 chandransh 8513 
  def __init__(self, order=None,):
8514 
    self.order = order
921 rajveer 8515 
 
8516 
  def read(self, iprot):
8517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8519 
      return
8520 
    iprot.readStructBegin()
8521 
    while True:
8522 
      (fname, ftype, fid) = iprot.readFieldBegin()
8523 
      if ftype == TType.STOP:
8524 
        break
8525 
      if fid == 1:
3064 chandransh 8526 
        if ftype == TType.STRUCT:
8527 
          self.order = Order()
8528 
          self.order.read(iprot)
921 rajveer 8529 
        else:
8530 
          iprot.skip(ftype)
8531 
      else:
8532 
        iprot.skip(ftype)
8533 
      iprot.readFieldEnd()
8534 
    iprot.readStructEnd()
8535 
 
8536 
  def write(self, oprot):
8537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8539 
      return
3064 chandransh 8540 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 8541 
    if self.order is not None:
3064 chandransh 8542 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
8543 
      self.order.write(oprot)
921 rajveer 8544 
      oprot.writeFieldEnd()
8545 
    oprot.writeFieldStop()
8546 
    oprot.writeStructEnd()
8547 
 
3431 rajveer 8548 
  def validate(self):
8549 
    return
8550 
 
8551 
 
921 rajveer 8552 
  def __repr__(self):
8553 
    L = ['%s=%r' % (key, value)
8554 
      for key, value in self.__dict__.iteritems()]
8555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8556 
 
8557 
  def __eq__(self, other):
8558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8559 
 
8560 
  def __ne__(self, other):
8561 
    return not (self == other)
8562 
 
3064 chandransh 8563 
class createOrder_result:
921 rajveer 8564 
  """
8565 
  Attributes:
8566 
   - success
8567 
   - ex
8568 
  """
8569 
 
8570 
  thrift_spec = (
3064 chandransh 8571 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 8572 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8573 
  )
8574 
 
8575 
  def __init__(self, success=None, ex=None,):
8576 
    self.success = success
8577 
    self.ex = ex
8578 
 
8579 
  def read(self, iprot):
8580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8582 
      return
8583 
    iprot.readStructBegin()
8584 
    while True:
8585 
      (fname, ftype, fid) = iprot.readFieldBegin()
8586 
      if ftype == TType.STOP:
8587 
        break
8588 
      if fid == 0:
3064 chandransh 8589 
        if ftype == TType.I64:
8590 
          self.success = iprot.readI64();
921 rajveer 8591 
        else:
8592 
          iprot.skip(ftype)
8593 
      elif fid == 1:
8594 
        if ftype == TType.STRUCT:
8595 
          self.ex = TransactionServiceException()
8596 
          self.ex.read(iprot)
8597 
        else:
8598 
          iprot.skip(ftype)
8599 
      else:
8600 
        iprot.skip(ftype)
8601 
      iprot.readFieldEnd()
8602 
    iprot.readStructEnd()
8603 
 
8604 
  def write(self, oprot):
8605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8607 
      return
3064 chandransh 8608 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 8609 
    if self.success is not None:
3064 chandransh 8610 
      oprot.writeFieldBegin('success', TType.I64, 0)
8611 
      oprot.writeI64(self.success)
921 rajveer 8612 
      oprot.writeFieldEnd()
3431 rajveer 8613 
    if self.ex is not None:
921 rajveer 8614 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8615 
      self.ex.write(oprot)
8616 
      oprot.writeFieldEnd()
8617 
    oprot.writeFieldStop()
8618 
    oprot.writeStructEnd()
8619 
 
3431 rajveer 8620 
  def validate(self):
8621 
    return
8622 
 
8623 
 
921 rajveer 8624 
  def __repr__(self):
8625 
    L = ['%s=%r' % (key, value)
8626 
      for key, value in self.__dict__.iteritems()]
8627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8628 
 
8629 
  def __eq__(self, other):
8630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8631 
 
8632 
  def __ne__(self, other):
8633 
    return not (self == other)
8634 
 
3064 chandransh 8635 
class getOrder_args:
921 rajveer 8636 
  """
8637 
  Attributes:
3064 chandransh 8638 
   - id
921 rajveer 8639 
  """
8640 
 
8641 
  thrift_spec = (
8642 
    None, # 0
3064 chandransh 8643 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 8644 
  )
8645 
 
3064 chandransh 8646 
  def __init__(self, id=None,):
8647 
    self.id = id
921 rajveer 8648 
 
8649 
  def read(self, iprot):
8650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8652 
      return
8653 
    iprot.readStructBegin()
8654 
    while True:
8655 
      (fname, ftype, fid) = iprot.readFieldBegin()
8656 
      if ftype == TType.STOP:
8657 
        break
8658 
      if fid == 1:
8659 
        if ftype == TType.I64:
3064 chandransh 8660 
          self.id = iprot.readI64();
921 rajveer 8661 
        else:
8662 
          iprot.skip(ftype)
8663 
      else:
8664 
        iprot.skip(ftype)
8665 
      iprot.readFieldEnd()
8666 
    iprot.readStructEnd()
8667 
 
8668 
  def write(self, oprot):
8669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8671 
      return
3064 chandransh 8672 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 8673 
    if self.id is not None:
3064 chandransh 8674 
      oprot.writeFieldBegin('id', TType.I64, 1)
8675 
      oprot.writeI64(self.id)
921 rajveer 8676 
      oprot.writeFieldEnd()
8677 
    oprot.writeFieldStop()
8678 
    oprot.writeStructEnd()
8679 
 
3431 rajveer 8680 
  def validate(self):
8681 
    return
8682 
 
8683 
 
921 rajveer 8684 
  def __repr__(self):
8685 
    L = ['%s=%r' % (key, value)
8686 
      for key, value in self.__dict__.iteritems()]
8687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8688 
 
8689 
  def __eq__(self, other):
8690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8691 
 
8692 
  def __ne__(self, other):
8693 
    return not (self == other)
8694 
 
3064 chandransh 8695 
class getOrder_result:
921 rajveer 8696 
  """
8697 
  Attributes:
8698 
   - success
8699 
   - ex
8700 
  """
8701 
 
8702 
  thrift_spec = (
3064 chandransh 8703 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 8704 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8705 
  )
8706 
 
8707 
  def __init__(self, success=None, ex=None,):
8708 
    self.success = success
8709 
    self.ex = ex
8710 
 
8711 
  def read(self, iprot):
8712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8714 
      return
8715 
    iprot.readStructBegin()
8716 
    while True:
8717 
      (fname, ftype, fid) = iprot.readFieldBegin()
8718 
      if ftype == TType.STOP:
8719 
        break
8720 
      if fid == 0:
3064 chandransh 8721 
        if ftype == TType.STRUCT:
8722 
          self.success = Order()
8723 
          self.success.read(iprot)
921 rajveer 8724 
        else:
8725 
          iprot.skip(ftype)
8726 
      elif fid == 1:
8727 
        if ftype == TType.STRUCT:
8728 
          self.ex = TransactionServiceException()
8729 
          self.ex.read(iprot)
8730 
        else:
8731 
          iprot.skip(ftype)
8732 
      else:
8733 
        iprot.skip(ftype)
8734 
      iprot.readFieldEnd()
8735 
    iprot.readStructEnd()
8736 
 
8737 
  def write(self, oprot):
8738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8740 
      return
3064 chandransh 8741 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 8742 
    if self.success is not None:
3064 chandransh 8743 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8744 
      self.success.write(oprot)
921 rajveer 8745 
      oprot.writeFieldEnd()
3431 rajveer 8746 
    if self.ex is not None:
921 rajveer 8747 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8748 
      self.ex.write(oprot)
8749 
      oprot.writeFieldEnd()
8750 
    oprot.writeFieldStop()
8751 
    oprot.writeStructEnd()
8752 
 
3431 rajveer 8753 
  def validate(self):
8754 
    return
8755 
 
8756 
 
921 rajveer 8757 
  def __repr__(self):
8758 
    L = ['%s=%r' % (key, value)
8759 
      for key, value in self.__dict__.iteritems()]
8760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8761 
 
8762 
  def __eq__(self, other):
8763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8764 
 
8765 
  def __ne__(self, other):
8766 
    return not (self == other)
8767 
 
3064 chandransh 8768 
class getLineItemsForOrder_args:
94 ashish 8769 
  """
8770 
  Attributes:
3064 chandransh 8771 
   - orderId
94 ashish 8772 
  """
8773 
 
8774 
  thrift_spec = (
8775 
    None, # 0
3064 chandransh 8776 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 8777 
  )
8778 
 
3064 chandransh 8779 
  def __init__(self, orderId=None,):
8780 
    self.orderId = orderId
94 ashish 8781 
 
8782 
  def read(self, iprot):
8783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8785 
      return
8786 
    iprot.readStructBegin()
8787 
    while True:
8788 
      (fname, ftype, fid) = iprot.readFieldBegin()
8789 
      if ftype == TType.STOP:
8790 
        break
8791 
      if fid == 1:
8792 
        if ftype == TType.I64:
3064 chandransh 8793 
          self.orderId = iprot.readI64();
94 ashish 8794 
        else:
8795 
          iprot.skip(ftype)
8796 
      else:
8797 
        iprot.skip(ftype)
8798 
      iprot.readFieldEnd()
8799 
    iprot.readStructEnd()
8800 
 
8801 
  def write(self, oprot):
8802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8804 
      return
3064 chandransh 8805 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 8806 
    if self.orderId is not None:
3064 chandransh 8807 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8808 
      oprot.writeI64(self.orderId)
94 ashish 8809 
      oprot.writeFieldEnd()
8810 
    oprot.writeFieldStop()
8811 
    oprot.writeStructEnd()
8812 
 
3431 rajveer 8813 
  def validate(self):
8814 
    return
8815 
 
8816 
 
94 ashish 8817 
  def __repr__(self):
8818 
    L = ['%s=%r' % (key, value)
8819 
      for key, value in self.__dict__.iteritems()]
8820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8821 
 
8822 
  def __eq__(self, other):
8823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8824 
 
8825 
  def __ne__(self, other):
8826 
    return not (self == other)
8827 
 
3064 chandransh 8828 
class getLineItemsForOrder_result:
94 ashish 8829 
  """
8830 
  Attributes:
8831 
   - success
8832 
   - ex
8833 
  """
8834 
 
8835 
  thrift_spec = (
3064 chandransh 8836 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 8837 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8838 
  )
8839 
 
8840 
  def __init__(self, success=None, ex=None,):
8841 
    self.success = success
8842 
    self.ex = ex
8843 
 
8844 
  def read(self, iprot):
8845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8847 
      return
8848 
    iprot.readStructBegin()
8849 
    while True:
8850 
      (fname, ftype, fid) = iprot.readFieldBegin()
8851 
      if ftype == TType.STOP:
8852 
        break
8853 
      if fid == 0:
483 rajveer 8854 
        if ftype == TType.LIST:
8855 
          self.success = []
4133 chandransh 8856 
          (_etype108, _size105) = iprot.readListBegin()
8857 
          for _i109 in xrange(_size105):
8858 
            _elem110 = LineItem()
8859 
            _elem110.read(iprot)
8860 
            self.success.append(_elem110)
483 rajveer 8861 
          iprot.readListEnd()
94 ashish 8862 
        else:
8863 
          iprot.skip(ftype)
8864 
      elif fid == 1:
8865 
        if ftype == TType.STRUCT:
8866 
          self.ex = TransactionServiceException()
8867 
          self.ex.read(iprot)
8868 
        else:
8869 
          iprot.skip(ftype)
8870 
      else:
8871 
        iprot.skip(ftype)
8872 
      iprot.readFieldEnd()
8873 
    iprot.readStructEnd()
8874 
 
8875 
  def write(self, oprot):
8876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8878 
      return
3064 chandransh 8879 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8880 
    if self.success is not None:
483 rajveer 8881 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8882 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8883 
      for iter111 in self.success:
8884 
        iter111.write(oprot)
483 rajveer 8885 
      oprot.writeListEnd()
94 ashish 8886 
      oprot.writeFieldEnd()
3431 rajveer 8887 
    if self.ex is not None:
94 ashish 8888 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8889 
      self.ex.write(oprot)
8890 
      oprot.writeFieldEnd()
8891 
    oprot.writeFieldStop()
8892 
    oprot.writeStructEnd()
8893 
 
3431 rajveer 8894 
  def validate(self):
8895 
    return
8896 
 
8897 
 
94 ashish 8898 
  def __repr__(self):
8899 
    L = ['%s=%r' % (key, value)
8900 
      for key, value in self.__dict__.iteritems()]
8901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8902 
 
8903 
  def __eq__(self, other):
8904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8905 
 
8906 
  def __ne__(self, other):
8907 
    return not (self == other)
8908 
 
3064 chandransh 8909 
class getOrderForCustomer_args:
94 ashish 8910 
  """
8911 
  Attributes:
3064 chandransh 8912 
   - orderId
483 rajveer 8913 
   - customerId
94 ashish 8914 
  """
8915 
 
8916 
  thrift_spec = (
8917 
    None, # 0
3064 chandransh 8918 
    (1, TType.I64, 'orderId', None, None, ), # 1
8919 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8920 
  )
8921 
 
3064 chandransh 8922 
  def __init__(self, orderId=None, customerId=None,):
8923 
    self.orderId = orderId
483 rajveer 8924 
    self.customerId = customerId
94 ashish 8925 
 
8926 
  def read(self, iprot):
8927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8929 
      return
8930 
    iprot.readStructBegin()
8931 
    while True:
8932 
      (fname, ftype, fid) = iprot.readFieldBegin()
8933 
      if ftype == TType.STOP:
8934 
        break
8935 
      if fid == 1:
8936 
        if ftype == TType.I64:
3064 chandransh 8937 
          self.orderId = iprot.readI64();
94 ashish 8938 
        else:
8939 
          iprot.skip(ftype)
8940 
      elif fid == 2:
8941 
        if ftype == TType.I64:
3064 chandransh 8942 
          self.customerId = iprot.readI64();
94 ashish 8943 
        else:
8944 
          iprot.skip(ftype)
8945 
      else:
8946 
        iprot.skip(ftype)
8947 
      iprot.readFieldEnd()
8948 
    iprot.readStructEnd()
8949 
 
8950 
  def write(self, oprot):
8951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8953 
      return
3064 chandransh 8954 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 8955 
    if self.orderId is not None:
3064 chandransh 8956 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8957 
      oprot.writeI64(self.orderId)
8958 
      oprot.writeFieldEnd()
3431 rajveer 8959 
    if self.customerId is not None:
3064 chandransh 8960 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 8961 
      oprot.writeI64(self.customerId)
94 ashish 8962 
      oprot.writeFieldEnd()
8963 
    oprot.writeFieldStop()
8964 
    oprot.writeStructEnd()
8965 
 
3431 rajveer 8966 
  def validate(self):
8967 
    return
8968 
 
8969 
 
94 ashish 8970 
  def __repr__(self):
8971 
    L = ['%s=%r' % (key, value)
8972 
      for key, value in self.__dict__.iteritems()]
8973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8974 
 
8975 
  def __eq__(self, other):
8976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8977 
 
8978 
  def __ne__(self, other):
8979 
    return not (self == other)
8980 
 
3064 chandransh 8981 
class getOrderForCustomer_result:
94 ashish 8982 
  """
8983 
  Attributes:
8984 
   - success
8985 
   - ex
8986 
  """
8987 
 
8988 
  thrift_spec = (
3064 chandransh 8989 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 8990 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8991 
  )
8992 
 
8993 
  def __init__(self, success=None, ex=None,):
8994 
    self.success = success
8995 
    self.ex = ex
8996 
 
8997 
  def read(self, iprot):
8998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9000 
      return
9001 
    iprot.readStructBegin()
9002 
    while True:
9003 
      (fname, ftype, fid) = iprot.readFieldBegin()
9004 
      if ftype == TType.STOP:
9005 
        break
9006 
      if fid == 0:
3064 chandransh 9007 
        if ftype == TType.STRUCT:
9008 
          self.success = Order()
9009 
          self.success.read(iprot)
94 ashish 9010 
        else:
9011 
          iprot.skip(ftype)
9012 
      elif fid == 1:
9013 
        if ftype == TType.STRUCT:
9014 
          self.ex = TransactionServiceException()
9015 
          self.ex.read(iprot)
9016 
        else:
9017 
          iprot.skip(ftype)
9018 
      else:
9019 
        iprot.skip(ftype)
9020 
      iprot.readFieldEnd()
9021 
    iprot.readStructEnd()
9022 
 
9023 
  def write(self, oprot):
9024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9026 
      return
3064 chandransh 9027 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 9028 
    if self.success is not None:
3064 chandransh 9029 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9030 
      self.success.write(oprot)
94 ashish 9031 
      oprot.writeFieldEnd()
3431 rajveer 9032 
    if self.ex is not None:
94 ashish 9033 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9034 
      self.ex.write(oprot)
9035 
      oprot.writeFieldEnd()
9036 
    oprot.writeFieldStop()
9037 
    oprot.writeStructEnd()
9038 
 
3431 rajveer 9039 
  def validate(self):
9040 
    return
9041 
 
9042 
 
94 ashish 9043 
  def __repr__(self):
9044 
    L = ['%s=%r' % (key, value)
9045 
      for key, value in self.__dict__.iteritems()]
9046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9047 
 
9048 
  def __eq__(self, other):
9049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9050 
 
9051 
  def __ne__(self, other):
9052 
    return not (self == other)
9053 
 
3064 chandransh 9054 
class getAlerts_args:
94 ashish 9055 
  """
9056 
  Attributes:
4394 rajveer 9057 
   - type
4444 rajveer 9058 
   - warehouseId
4394 rajveer 9059 
   - status
9060 
   - timestamp
94 ashish 9061 
  """
9062 
 
9063 
  thrift_spec = (
9064 
    None, # 0
4394 rajveer 9065 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9066 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9067 
    (3, TType.I64, 'status', None, None, ), # 3
9068 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 9069 
  )
9070 
 
4444 rajveer 9071 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 9072 
    self.type = type
4444 rajveer 9073 
    self.warehouseId = warehouseId
4394 rajveer 9074 
    self.status = status
9075 
    self.timestamp = timestamp
94 ashish 9076 
 
9077 
  def read(self, iprot):
9078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9080 
      return
9081 
    iprot.readStructBegin()
9082 
    while True:
9083 
      (fname, ftype, fid) = iprot.readFieldBegin()
9084 
      if ftype == TType.STOP:
9085 
        break
9086 
      if fid == 1:
3064 chandransh 9087 
        if ftype == TType.I64:
4394 rajveer 9088 
          self.type = iprot.readI64();
94 ashish 9089 
        else:
9090 
          iprot.skip(ftype)
3064 chandransh 9091 
      elif fid == 2:
4394 rajveer 9092 
        if ftype == TType.I64:
4444 rajveer 9093 
          self.warehouseId = iprot.readI64();
3064 chandransh 9094 
        else:
9095 
          iprot.skip(ftype)
4394 rajveer 9096 
      elif fid == 3:
9097 
        if ftype == TType.I64:
4444 rajveer 9098 
          self.status = iprot.readI64();
9099 
        else:
9100 
          iprot.skip(ftype)
9101 
      elif fid == 4:
9102 
        if ftype == TType.I64:
4394 rajveer 9103 
          self.timestamp = iprot.readI64();
9104 
        else:
9105 
          iprot.skip(ftype)
94 ashish 9106 
      else:
9107 
        iprot.skip(ftype)
9108 
      iprot.readFieldEnd()
9109 
    iprot.readStructEnd()
9110 
 
9111 
  def write(self, oprot):
9112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9114 
      return
3064 chandransh 9115 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 9116 
    if self.type is not None:
9117 
      oprot.writeFieldBegin('type', TType.I64, 1)
9118 
      oprot.writeI64(self.type)
94 ashish 9119 
      oprot.writeFieldEnd()
4444 rajveer 9120 
    if self.warehouseId is not None:
9121 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9122 
      oprot.writeI64(self.warehouseId)
9123 
      oprot.writeFieldEnd()
4394 rajveer 9124 
    if self.status is not None:
4444 rajveer 9125 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 9126 
      oprot.writeI64(self.status)
3064 chandransh 9127 
      oprot.writeFieldEnd()
4394 rajveer 9128 
    if self.timestamp is not None:
4444 rajveer 9129 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 9130 
      oprot.writeI64(self.timestamp)
9131 
      oprot.writeFieldEnd()
94 ashish 9132 
    oprot.writeFieldStop()
9133 
    oprot.writeStructEnd()
9134 
 
3431 rajveer 9135 
  def validate(self):
9136 
    return
9137 
 
9138 
 
94 ashish 9139 
  def __repr__(self):
9140 
    L = ['%s=%r' % (key, value)
9141 
      for key, value in self.__dict__.iteritems()]
9142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9143 
 
9144 
  def __eq__(self, other):
9145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9146 
 
9147 
  def __ne__(self, other):
9148 
    return not (self == other)
9149 
 
3064 chandransh 9150 
class getAlerts_result:
94 ashish 9151 
  """
9152 
  Attributes:
9153 
   - success
9154 
  """
9155 
 
9156 
  thrift_spec = (
3064 chandransh 9157 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 9158 
  )
9159 
 
3064 chandransh 9160 
  def __init__(self, success=None,):
94 ashish 9161 
    self.success = success
9162 
 
9163 
  def read(self, iprot):
9164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9166 
      return
9167 
    iprot.readStructBegin()
9168 
    while True:
9169 
      (fname, ftype, fid) = iprot.readFieldBegin()
9170 
      if ftype == TType.STOP:
9171 
        break
9172 
      if fid == 0:
3064 chandransh 9173 
        if ftype == TType.LIST:
9174 
          self.success = []
4133 chandransh 9175 
          (_etype115, _size112) = iprot.readListBegin()
9176 
          for _i116 in xrange(_size112):
9177 
            _elem117 = Alert()
9178 
            _elem117.read(iprot)
9179 
            self.success.append(_elem117)
3064 chandransh 9180 
          iprot.readListEnd()
94 ashish 9181 
        else:
9182 
          iprot.skip(ftype)
9183 
      else:
9184 
        iprot.skip(ftype)
9185 
      iprot.readFieldEnd()
9186 
    iprot.readStructEnd()
9187 
 
9188 
  def write(self, oprot):
9189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9191 
      return
3064 chandransh 9192 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 9193 
    if self.success is not None:
3064 chandransh 9194 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9195 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9196 
      for iter118 in self.success:
9197 
        iter118.write(oprot)
3064 chandransh 9198 
      oprot.writeListEnd()
94 ashish 9199 
      oprot.writeFieldEnd()
9200 
    oprot.writeFieldStop()
9201 
    oprot.writeStructEnd()
9202 
 
3431 rajveer 9203 
  def validate(self):
9204 
    return
9205 
 
9206 
 
94 ashish 9207 
  def __repr__(self):
9208 
    L = ['%s=%r' % (key, value)
9209 
      for key, value in self.__dict__.iteritems()]
9210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9211 
 
9212 
  def __eq__(self, other):
9213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9214 
 
9215 
  def __ne__(self, other):
9216 
    return not (self == other)
9217 
 
4394 rajveer 9218 
class addAlert_args:
94 ashish 9219 
  """
9220 
  Attributes:
3064 chandransh 9221 
   - type
4444 rajveer 9222 
   - warehouseId
4394 rajveer 9223 
   - description
94 ashish 9224 
  """
9225 
 
9226 
  thrift_spec = (
9227 
    None, # 0
4394 rajveer 9228 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9229 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9230 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9231 
  )
9232 
 
4444 rajveer 9233 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 9234 
    self.type = type
4444 rajveer 9235 
    self.warehouseId = warehouseId
4394 rajveer 9236 
    self.description = description
94 ashish 9237 
 
9238 
  def read(self, iprot):
9239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9241 
      return
9242 
    iprot.readStructBegin()
9243 
    while True:
9244 
      (fname, ftype, fid) = iprot.readFieldBegin()
9245 
      if ftype == TType.STOP:
9246 
        break
9247 
      if fid == 1:
9248 
        if ftype == TType.I64:
4394 rajveer 9249 
          self.type = iprot.readI64();
94 ashish 9250 
        else:
9251 
          iprot.skip(ftype)
3064 chandransh 9252 
      elif fid == 2:
4444 rajveer 9253 
        if ftype == TType.I64:
9254 
          self.warehouseId = iprot.readI64();
9255 
        else:
9256 
          iprot.skip(ftype)
9257 
      elif fid == 3:
3064 chandransh 9258 
        if ftype == TType.STRING:
4394 rajveer 9259 
          self.description = iprot.readString();
3064 chandransh 9260 
        else:
9261 
          iprot.skip(ftype)
94 ashish 9262 
      else:
9263 
        iprot.skip(ftype)
9264 
      iprot.readFieldEnd()
9265 
    iprot.readStructEnd()
9266 
 
9267 
  def write(self, oprot):
9268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9270 
      return
4394 rajveer 9271 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 9272 
    if self.type is not None:
4394 rajveer 9273 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 9274 
      oprot.writeI64(self.type)
9275 
      oprot.writeFieldEnd()
4444 rajveer 9276 
    if self.warehouseId is not None:
9277 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9278 
      oprot.writeI64(self.warehouseId)
9279 
      oprot.writeFieldEnd()
4394 rajveer 9280 
    if self.description is not None:
4444 rajveer 9281 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 9282 
      oprot.writeString(self.description)
3064 chandransh 9283 
      oprot.writeFieldEnd()
94 ashish 9284 
    oprot.writeFieldStop()
9285 
    oprot.writeStructEnd()
9286 
 
3431 rajveer 9287 
  def validate(self):
9288 
    return
9289 
 
9290 
 
94 ashish 9291 
  def __repr__(self):
9292 
    L = ['%s=%r' % (key, value)
9293 
      for key, value in self.__dict__.iteritems()]
9294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9295 
 
9296 
  def __eq__(self, other):
9297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9298 
 
9299 
  def __ne__(self, other):
9300 
    return not (self == other)
9301 
 
4394 rajveer 9302 
class addAlert_result:
3064 chandransh 9303 
 
9304 
  thrift_spec = (
9305 
  )
9306 
 
9307 
  def read(self, iprot):
9308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9310 
      return
9311 
    iprot.readStructBegin()
9312 
    while True:
9313 
      (fname, ftype, fid) = iprot.readFieldBegin()
9314 
      if ftype == TType.STOP:
9315 
        break
9316 
      else:
9317 
        iprot.skip(ftype)
9318 
      iprot.readFieldEnd()
9319 
    iprot.readStructEnd()
9320 
 
9321 
  def write(self, oprot):
9322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9324 
      return
4394 rajveer 9325 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 9326 
    oprot.writeFieldStop()
9327 
    oprot.writeStructEnd()
9328 
 
3431 rajveer 9329 
  def validate(self):
9330 
    return
9331 
 
9332 
 
3064 chandransh 9333 
  def __repr__(self):
9334 
    L = ['%s=%r' % (key, value)
9335 
      for key, value in self.__dict__.iteritems()]
9336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9337 
 
9338 
  def __eq__(self, other):
9339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9340 
 
9341 
  def __ne__(self, other):
9342 
    return not (self == other)
9343 
 
4444 rajveer 9344 
class markAlertsAsSeen_args:
9345 
  """
9346 
  Attributes:
9347 
   - warehouseId
9348 
  """
9349 
 
9350 
  thrift_spec = (
9351 
    None, # 0
9352 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9353 
  )
9354 
 
9355 
  def __init__(self, warehouseId=None,):
9356 
    self.warehouseId = warehouseId
9357 
 
9358 
  def read(self, iprot):
9359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9361 
      return
9362 
    iprot.readStructBegin()
9363 
    while True:
9364 
      (fname, ftype, fid) = iprot.readFieldBegin()
9365 
      if ftype == TType.STOP:
9366 
        break
9367 
      if fid == 1:
9368 
        if ftype == TType.I64:
9369 
          self.warehouseId = iprot.readI64();
9370 
        else:
9371 
          iprot.skip(ftype)
9372 
      else:
9373 
        iprot.skip(ftype)
9374 
      iprot.readFieldEnd()
9375 
    iprot.readStructEnd()
9376 
 
9377 
  def write(self, oprot):
9378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9380 
      return
9381 
    oprot.writeStructBegin('markAlertsAsSeen_args')
9382 
    if self.warehouseId is not None:
9383 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9384 
      oprot.writeI64(self.warehouseId)
9385 
      oprot.writeFieldEnd()
9386 
    oprot.writeFieldStop()
9387 
    oprot.writeStructEnd()
9388 
 
9389 
  def validate(self):
9390 
    return
9391 
 
9392 
 
9393 
  def __repr__(self):
9394 
    L = ['%s=%r' % (key, value)
9395 
      for key, value in self.__dict__.iteritems()]
9396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9397 
 
9398 
  def __eq__(self, other):
9399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9400 
 
9401 
  def __ne__(self, other):
9402 
    return not (self == other)
9403 
 
9404 
class markAlertsAsSeen_result:
9405 
 
9406 
  thrift_spec = (
9407 
  )
9408 
 
9409 
  def read(self, iprot):
9410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9412 
      return
9413 
    iprot.readStructBegin()
9414 
    while True:
9415 
      (fname, ftype, fid) = iprot.readFieldBegin()
9416 
      if ftype == TType.STOP:
9417 
        break
9418 
      else:
9419 
        iprot.skip(ftype)
9420 
      iprot.readFieldEnd()
9421 
    iprot.readStructEnd()
9422 
 
9423 
  def write(self, oprot):
9424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9426 
      return
9427 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9428 
    oprot.writeFieldStop()
9429 
    oprot.writeStructEnd()
9430 
 
9431 
  def validate(self):
9432 
    return
9433 
 
9434 
 
9435 
  def __repr__(self):
9436 
    L = ['%s=%r' % (key, value)
9437 
      for key, value in self.__dict__.iteritems()]
9438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9439 
 
9440 
  def __eq__(self, other):
9441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9442 
 
9443 
  def __ne__(self, other):
9444 
    return not (self == other)
9445 
 
3064 chandransh 9446 
class getValidOrderCount_args:
9447 
 
9448 
  thrift_spec = (
9449 
  )
9450 
 
9451 
  def read(self, iprot):
9452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9454 
      return
9455 
    iprot.readStructBegin()
9456 
    while True:
9457 
      (fname, ftype, fid) = iprot.readFieldBegin()
9458 
      if ftype == TType.STOP:
9459 
        break
9460 
      else:
9461 
        iprot.skip(ftype)
9462 
      iprot.readFieldEnd()
9463 
    iprot.readStructEnd()
9464 
 
9465 
  def write(self, oprot):
9466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9468 
      return
9469 
    oprot.writeStructBegin('getValidOrderCount_args')
9470 
    oprot.writeFieldStop()
9471 
    oprot.writeStructEnd()
9472 
 
3431 rajveer 9473 
  def validate(self):
9474 
    return
9475 
 
9476 
 
3064 chandransh 9477 
  def __repr__(self):
9478 
    L = ['%s=%r' % (key, value)
9479 
      for key, value in self.__dict__.iteritems()]
9480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9481 
 
9482 
  def __eq__(self, other):
9483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9484 
 
9485 
  def __ne__(self, other):
9486 
    return not (self == other)
9487 
 
9488 
class getValidOrderCount_result:
94 ashish 9489 
  """
9490 
  Attributes:
9491 
   - success
9492 
  """
9493 
 
9494 
  thrift_spec = (
3064 chandransh 9495 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9496 
  )
9497 
 
3064 chandransh 9498 
  def __init__(self, success=None,):
94 ashish 9499 
    self.success = success
9500 
 
9501 
  def read(self, iprot):
9502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9504 
      return
9505 
    iprot.readStructBegin()
9506 
    while True:
9507 
      (fname, ftype, fid) = iprot.readFieldBegin()
9508 
      if ftype == TType.STOP:
9509 
        break
9510 
      if fid == 0:
3064 chandransh 9511 
        if ftype == TType.I64:
9512 
          self.success = iprot.readI64();
94 ashish 9513 
        else:
9514 
          iprot.skip(ftype)
9515 
      else:
9516 
        iprot.skip(ftype)
9517 
      iprot.readFieldEnd()
9518 
    iprot.readStructEnd()
9519 
 
9520 
  def write(self, oprot):
9521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9523 
      return
3064 chandransh 9524 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 9525 
    if self.success is not None:
3064 chandransh 9526 
      oprot.writeFieldBegin('success', TType.I64, 0)
9527 
      oprot.writeI64(self.success)
94 ashish 9528 
      oprot.writeFieldEnd()
9529 
    oprot.writeFieldStop()
9530 
    oprot.writeStructEnd()
9531 
 
3431 rajveer 9532 
  def validate(self):
9533 
    return
9534 
 
9535 
 
94 ashish 9536 
  def __repr__(self):
9537 
    L = ['%s=%r' % (key, value)
9538 
      for key, value in self.__dict__.iteritems()]
9539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9540 
 
9541 
  def __eq__(self, other):
9542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9543 
 
9544 
  def __ne__(self, other):
9545 
    return not (self == other)
9546 
 
3064 chandransh 9547 
class getNoOfCustomersWithSuccessfulTransaction_args:
9548 
 
9549 
  thrift_spec = (
9550 
  )
9551 
 
9552 
  def read(self, iprot):
9553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9555 
      return
9556 
    iprot.readStructBegin()
9557 
    while True:
9558 
      (fname, ftype, fid) = iprot.readFieldBegin()
9559 
      if ftype == TType.STOP:
9560 
        break
9561 
      else:
9562 
        iprot.skip(ftype)
9563 
      iprot.readFieldEnd()
9564 
    iprot.readStructEnd()
9565 
 
9566 
  def write(self, oprot):
9567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9569 
      return
9570 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
9571 
    oprot.writeFieldStop()
9572 
    oprot.writeStructEnd()
9573 
 
3431 rajveer 9574 
  def validate(self):
9575 
    return
9576 
 
9577 
 
3064 chandransh 9578 
  def __repr__(self):
9579 
    L = ['%s=%r' % (key, value)
9580 
      for key, value in self.__dict__.iteritems()]
9581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9582 
 
9583 
  def __eq__(self, other):
9584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9585 
 
9586 
  def __ne__(self, other):
9587 
    return not (self == other)
9588 
 
9589 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 9590 
  """
9591 
  Attributes:
3064 chandransh 9592 
   - success
94 ashish 9593 
  """
9594 
 
9595 
  thrift_spec = (
3064 chandransh 9596 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9597 
  )
9598 
 
3064 chandransh 9599 
  def __init__(self, success=None,):
9600 
    self.success = success
94 ashish 9601 
 
9602 
  def read(self, iprot):
9603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9605 
      return
9606 
    iprot.readStructBegin()
9607 
    while True:
9608 
      (fname, ftype, fid) = iprot.readFieldBegin()
9609 
      if ftype == TType.STOP:
9610 
        break
3064 chandransh 9611 
      if fid == 0:
94 ashish 9612 
        if ftype == TType.I64:
3064 chandransh 9613 
          self.success = iprot.readI64();
94 ashish 9614 
        else:
9615 
          iprot.skip(ftype)
9616 
      else:
9617 
        iprot.skip(ftype)
9618 
      iprot.readFieldEnd()
9619 
    iprot.readStructEnd()
9620 
 
9621 
  def write(self, oprot):
9622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9624 
      return
3064 chandransh 9625 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 9626 
    if self.success is not None:
3064 chandransh 9627 
      oprot.writeFieldBegin('success', TType.I64, 0)
9628 
      oprot.writeI64(self.success)
94 ashish 9629 
      oprot.writeFieldEnd()
9630 
    oprot.writeFieldStop()
9631 
    oprot.writeStructEnd()
9632 
 
3431 rajveer 9633 
  def validate(self):
9634 
    return
9635 
 
9636 
 
94 ashish 9637 
  def __repr__(self):
9638 
    L = ['%s=%r' % (key, value)
9639 
      for key, value in self.__dict__.iteritems()]
9640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9641 
 
9642 
  def __eq__(self, other):
9643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9644 
 
9645 
  def __ne__(self, other):
9646 
    return not (self == other)
9647 
 
3064 chandransh 9648 
class getValidOrdersAmountRange_args:
9649 
 
9650 
  thrift_spec = (
9651 
  )
9652 
 
9653 
  def read(self, iprot):
9654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9656 
      return
9657 
    iprot.readStructBegin()
9658 
    while True:
9659 
      (fname, ftype, fid) = iprot.readFieldBegin()
9660 
      if ftype == TType.STOP:
9661 
        break
9662 
      else:
9663 
        iprot.skip(ftype)
9664 
      iprot.readFieldEnd()
9665 
    iprot.readStructEnd()
9666 
 
9667 
  def write(self, oprot):
9668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9670 
      return
9671 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
9672 
    oprot.writeFieldStop()
9673 
    oprot.writeStructEnd()
9674 
 
3431 rajveer 9675 
  def validate(self):
9676 
    return
9677 
 
9678 
 
3064 chandransh 9679 
  def __repr__(self):
9680 
    L = ['%s=%r' % (key, value)
9681 
      for key, value in self.__dict__.iteritems()]
9682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9683 
 
9684 
  def __eq__(self, other):
9685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9686 
 
9687 
  def __ne__(self, other):
9688 
    return not (self == other)
9689 
 
9690 
class getValidOrdersAmountRange_result:
94 ashish 9691 
  """
9692 
  Attributes:
9693 
   - success
9694 
  """
9695 
 
9696 
  thrift_spec = (
3064 chandransh 9697 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 9698 
  )
9699 
 
3064 chandransh 9700 
  def __init__(self, success=None,):
94 ashish 9701 
    self.success = success
9702 
 
9703 
  def read(self, iprot):
9704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9706 
      return
9707 
    iprot.readStructBegin()
9708 
    while True:
9709 
      (fname, ftype, fid) = iprot.readFieldBegin()
9710 
      if ftype == TType.STOP:
9711 
        break
9712 
      if fid == 0:
483 rajveer 9713 
        if ftype == TType.LIST:
9714 
          self.success = []
4133 chandransh 9715 
          (_etype122, _size119) = iprot.readListBegin()
9716 
          for _i123 in xrange(_size119):
9717 
            _elem124 = iprot.readDouble();
9718 
            self.success.append(_elem124)
483 rajveer 9719 
          iprot.readListEnd()
94 ashish 9720 
        else:
9721 
          iprot.skip(ftype)
9722 
      else:
9723 
        iprot.skip(ftype)
9724 
      iprot.readFieldEnd()
9725 
    iprot.readStructEnd()
9726 
 
9727 
  def write(self, oprot):
9728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9730 
      return
3064 chandransh 9731 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 9732 
    if self.success is not None:
483 rajveer 9733 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 9734 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 9735 
      for iter125 in self.success:
9736 
        oprot.writeDouble(iter125)
483 rajveer 9737 
      oprot.writeListEnd()
94 ashish 9738 
      oprot.writeFieldEnd()
9739 
    oprot.writeFieldStop()
9740 
    oprot.writeStructEnd()
9741 
 
3431 rajveer 9742 
  def validate(self):
9743 
    return
9744 
 
9745 
 
94 ashish 9746 
  def __repr__(self):
9747 
    L = ['%s=%r' % (key, value)
9748 
      for key, value in self.__dict__.iteritems()]
9749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9750 
 
9751 
  def __eq__(self, other):
9752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9753 
 
9754 
  def __ne__(self, other):
9755 
    return not (self == other)
9756 
 
3064 chandransh 9757 
class getValidOrders_args:
1528 ankur.sing 9758 
  """
9759 
  Attributes:
3064 chandransh 9760 
   - limit
1528 ankur.sing 9761 
  """
9762 
 
9763 
  thrift_spec = (
9764 
    None, # 0
3064 chandransh 9765 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 9766 
  )
9767 
 
3064 chandransh 9768 
  def __init__(self, limit=None,):
9769 
    self.limit = limit
1528 ankur.sing 9770 
 
9771 
  def read(self, iprot):
9772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9774 
      return
9775 
    iprot.readStructBegin()
9776 
    while True:
9777 
      (fname, ftype, fid) = iprot.readFieldBegin()
9778 
      if ftype == TType.STOP:
9779 
        break
9780 
      if fid == 1:
9781 
        if ftype == TType.I64:
3064 chandransh 9782 
          self.limit = iprot.readI64();
1528 ankur.sing 9783 
        else:
9784 
          iprot.skip(ftype)
9785 
      else:
9786 
        iprot.skip(ftype)
9787 
      iprot.readFieldEnd()
9788 
    iprot.readStructEnd()
9789 
 
9790 
  def write(self, oprot):
9791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9793 
      return
3064 chandransh 9794 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 9795 
    if self.limit is not None:
3064 chandransh 9796 
      oprot.writeFieldBegin('limit', TType.I64, 1)
9797 
      oprot.writeI64(self.limit)
1528 ankur.sing 9798 
      oprot.writeFieldEnd()
9799 
    oprot.writeFieldStop()
9800 
    oprot.writeStructEnd()
9801 
 
3431 rajveer 9802 
  def validate(self):
9803 
    return
9804 
 
9805 
 
1528 ankur.sing 9806 
  def __repr__(self):
9807 
    L = ['%s=%r' % (key, value)
9808 
      for key, value in self.__dict__.iteritems()]
9809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9810 
 
9811 
  def __eq__(self, other):
9812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9813 
 
9814 
  def __ne__(self, other):
9815 
    return not (self == other)
9816 
 
3064 chandransh 9817 
class getValidOrders_result:
1528 ankur.sing 9818 
  """
9819 
  Attributes:
9820 
   - success
9821 
  """
9822 
 
9823 
  thrift_spec = (
3064 chandransh 9824 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 9825 
  )
9826 
 
3064 chandransh 9827 
  def __init__(self, success=None,):
1528 ankur.sing 9828 
    self.success = success
9829 
 
9830 
  def read(self, iprot):
9831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9833 
      return
9834 
    iprot.readStructBegin()
9835 
    while True:
9836 
      (fname, ftype, fid) = iprot.readFieldBegin()
9837 
      if ftype == TType.STOP:
9838 
        break
9839 
      if fid == 0:
3064 chandransh 9840 
        if ftype == TType.LIST:
9841 
          self.success = []
4133 chandransh 9842 
          (_etype129, _size126) = iprot.readListBegin()
9843 
          for _i130 in xrange(_size126):
9844 
            _elem131 = Order()
9845 
            _elem131.read(iprot)
9846 
            self.success.append(_elem131)
3064 chandransh 9847 
          iprot.readListEnd()
1528 ankur.sing 9848 
        else:
9849 
          iprot.skip(ftype)
9850 
      else:
9851 
        iprot.skip(ftype)
9852 
      iprot.readFieldEnd()
9853 
    iprot.readStructEnd()
9854 
 
9855 
  def write(self, oprot):
9856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9858 
      return
3064 chandransh 9859 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9860 
    if self.success is not None:
3064 chandransh 9861 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9862 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9863 
      for iter132 in self.success:
9864 
        iter132.write(oprot)
3064 chandransh 9865 
      oprot.writeListEnd()
1528 ankur.sing 9866 
      oprot.writeFieldEnd()
9867 
    oprot.writeFieldStop()
9868 
    oprot.writeStructEnd()
9869 
 
3431 rajveer 9870 
  def validate(self):
9871 
    return
9872 
 
9873 
 
1528 ankur.sing 9874 
  def __repr__(self):
9875 
    L = ['%s=%r' % (key, value)
9876 
      for key, value in self.__dict__.iteritems()]
9877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9878 
 
9879 
  def __eq__(self, other):
9880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9881 
 
9882 
  def __ne__(self, other):
9883 
    return not (self == other)
9884 
 
1220 chandransh 9885 
class batchOrders_args:
9886 
  """
9887 
  Attributes:
9888 
   - warehouseId
9889 
  """
9890 
 
9891 
  thrift_spec = (
9892 
    None, # 0
9893 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9894 
  )
9895 
 
9896 
  def __init__(self, warehouseId=None,):
9897 
    self.warehouseId = warehouseId
9898 
 
9899 
  def read(self, iprot):
9900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9902 
      return
9903 
    iprot.readStructBegin()
9904 
    while True:
9905 
      (fname, ftype, fid) = iprot.readFieldBegin()
9906 
      if ftype == TType.STOP:
9907 
        break
9908 
      if fid == 1:
9909 
        if ftype == TType.I64:
9910 
          self.warehouseId = iprot.readI64();
9911 
        else:
9912 
          iprot.skip(ftype)
9913 
      else:
9914 
        iprot.skip(ftype)
9915 
      iprot.readFieldEnd()
9916 
    iprot.readStructEnd()
9917 
 
9918 
  def write(self, oprot):
9919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9921 
      return
9922 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9923 
    if self.warehouseId is not None:
1220 chandransh 9924 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9925 
      oprot.writeI64(self.warehouseId)
9926 
      oprot.writeFieldEnd()
9927 
    oprot.writeFieldStop()
9928 
    oprot.writeStructEnd()
9929 
 
3431 rajveer 9930 
  def validate(self):
9931 
    return
9932 
 
9933 
 
1220 chandransh 9934 
  def __repr__(self):
9935 
    L = ['%s=%r' % (key, value)
9936 
      for key, value in self.__dict__.iteritems()]
9937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9938 
 
9939 
  def __eq__(self, other):
9940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9941 
 
9942 
  def __ne__(self, other):
9943 
    return not (self == other)
9944 
 
9945 
class batchOrders_result:
9946 
  """
9947 
  Attributes:
9948 
   - success
9949 
   - ex
9950 
  """
9951 
 
9952 
  thrift_spec = (
9953 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9954 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9955 
  )
9956 
 
9957 
  def __init__(self, success=None, ex=None,):
9958 
    self.success = success
9959 
    self.ex = ex
9960 
 
9961 
  def read(self, iprot):
9962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9964 
      return
9965 
    iprot.readStructBegin()
9966 
    while True:
9967 
      (fname, ftype, fid) = iprot.readFieldBegin()
9968 
      if ftype == TType.STOP:
9969 
        break
9970 
      if fid == 0:
9971 
        if ftype == TType.LIST:
9972 
          self.success = []
4133 chandransh 9973 
          (_etype136, _size133) = iprot.readListBegin()
9974 
          for _i137 in xrange(_size133):
9975 
            _elem138 = Order()
9976 
            _elem138.read(iprot)
9977 
            self.success.append(_elem138)
1220 chandransh 9978 
          iprot.readListEnd()
9979 
        else:
9980 
          iprot.skip(ftype)
9981 
      elif fid == 1:
9982 
        if ftype == TType.STRUCT:
9983 
          self.ex = TransactionServiceException()
9984 
          self.ex.read(iprot)
9985 
        else:
9986 
          iprot.skip(ftype)
9987 
      else:
9988 
        iprot.skip(ftype)
9989 
      iprot.readFieldEnd()
9990 
    iprot.readStructEnd()
9991 
 
9992 
  def write(self, oprot):
9993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9995 
      return
9996 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 9997 
    if self.success is not None:
1220 chandransh 9998 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9999 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10000 
      for iter139 in self.success:
10001 
        iter139.write(oprot)
1220 chandransh 10002 
      oprot.writeListEnd()
10003 
      oprot.writeFieldEnd()
3431 rajveer 10004 
    if self.ex is not None:
1220 chandransh 10005 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10006 
      self.ex.write(oprot)
10007 
      oprot.writeFieldEnd()
10008 
    oprot.writeFieldStop()
10009 
    oprot.writeStructEnd()
10010 
 
3431 rajveer 10011 
  def validate(self):
10012 
    return
10013 
 
10014 
 
1220 chandransh 10015 
  def __repr__(self):
10016 
    L = ['%s=%r' % (key, value)
10017 
      for key, value in self.__dict__.iteritems()]
10018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10019 
 
10020 
  def __eq__(self, other):
10021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10022 
 
10023 
  def __ne__(self, other):
10024 
    return not (self == other)
10025 
 
1208 chandransh 10026 
class markOrderAsOutOfStock_args:
10027 
  """
10028 
  Attributes:
10029 
   - orderId
10030 
  """
10031 
 
10032 
  thrift_spec = (
10033 
    None, # 0
10034 
    (1, TType.I64, 'orderId', None, None, ), # 1
10035 
  )
10036 
 
10037 
  def __init__(self, orderId=None,):
10038 
    self.orderId = orderId
10039 
 
10040 
  def read(self, iprot):
10041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10043 
      return
10044 
    iprot.readStructBegin()
10045 
    while True:
10046 
      (fname, ftype, fid) = iprot.readFieldBegin()
10047 
      if ftype == TType.STOP:
10048 
        break
10049 
      if fid == 1:
10050 
        if ftype == TType.I64:
10051 
          self.orderId = iprot.readI64();
10052 
        else:
10053 
          iprot.skip(ftype)
10054 
      else:
10055 
        iprot.skip(ftype)
10056 
      iprot.readFieldEnd()
10057 
    iprot.readStructEnd()
10058 
 
10059 
  def write(self, oprot):
10060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10062 
      return
10063 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 10064 
    if self.orderId is not None:
1208 chandransh 10065 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10066 
      oprot.writeI64(self.orderId)
10067 
      oprot.writeFieldEnd()
10068 
    oprot.writeFieldStop()
10069 
    oprot.writeStructEnd()
10070 
 
3431 rajveer 10071 
  def validate(self):
10072 
    return
10073 
 
10074 
 
1208 chandransh 10075 
  def __repr__(self):
10076 
    L = ['%s=%r' % (key, value)
10077 
      for key, value in self.__dict__.iteritems()]
10078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10079 
 
10080 
  def __eq__(self, other):
10081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10082 
 
10083 
  def __ne__(self, other):
10084 
    return not (self == other)
10085 
 
10086 
class markOrderAsOutOfStock_result:
10087 
  """
10088 
  Attributes:
10089 
   - success
10090 
   - ex
10091 
  """
10092 
 
10093 
  thrift_spec = (
10094 
    (0, TType.BOOL, 'success', None, None, ), # 0
10095 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10096 
  )
10097 
 
10098 
  def __init__(self, success=None, ex=None,):
10099 
    self.success = success
10100 
    self.ex = ex
10101 
 
10102 
  def read(self, iprot):
10103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10105 
      return
10106 
    iprot.readStructBegin()
10107 
    while True:
10108 
      (fname, ftype, fid) = iprot.readFieldBegin()
10109 
      if ftype == TType.STOP:
10110 
        break
10111 
      if fid == 0:
10112 
        if ftype == TType.BOOL:
10113 
          self.success = iprot.readBool();
10114 
        else:
10115 
          iprot.skip(ftype)
10116 
      elif fid == 1:
10117 
        if ftype == TType.STRUCT:
10118 
          self.ex = TransactionServiceException()
10119 
          self.ex.read(iprot)
10120 
        else:
10121 
          iprot.skip(ftype)
10122 
      else:
10123 
        iprot.skip(ftype)
10124 
      iprot.readFieldEnd()
10125 
    iprot.readStructEnd()
10126 
 
10127 
  def write(self, oprot):
10128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10130 
      return
10131 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 10132 
    if self.success is not None:
1208 chandransh 10133 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10134 
      oprot.writeBool(self.success)
10135 
      oprot.writeFieldEnd()
3431 rajveer 10136 
    if self.ex is not None:
1208 chandransh 10137 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10138 
      self.ex.write(oprot)
10139 
      oprot.writeFieldEnd()
10140 
    oprot.writeFieldStop()
10141 
    oprot.writeStructEnd()
10142 
 
3431 rajveer 10143 
  def validate(self):
10144 
    return
10145 
 
10146 
 
1208 chandransh 10147 
  def __repr__(self):
10148 
    L = ['%s=%r' % (key, value)
10149 
      for key, value in self.__dict__.iteritems()]
10150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10151 
 
10152 
  def __eq__(self, other):
10153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10154 
 
10155 
  def __ne__(self, other):
10156 
    return not (self == other)
10157 
 
3064 chandransh 10158 
class verifyOrder_args:
759 chandransh 10159 
  """
10160 
  Attributes:
3064 chandransh 10161 
   - orderId
759 chandransh 10162 
  """
10163 
 
10164 
  thrift_spec = (
10165 
    None, # 0
3064 chandransh 10166 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 10167 
  )
10168 
 
3064 chandransh 10169 
  def __init__(self, orderId=None,):
10170 
    self.orderId = orderId
759 chandransh 10171 
 
10172 
  def read(self, iprot):
10173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10175 
      return
10176 
    iprot.readStructBegin()
10177 
    while True:
10178 
      (fname, ftype, fid) = iprot.readFieldBegin()
10179 
      if ftype == TType.STOP:
10180 
        break
10181 
      if fid == 1:
10182 
        if ftype == TType.I64:
3064 chandransh 10183 
          self.orderId = iprot.readI64();
759 chandransh 10184 
        else:
10185 
          iprot.skip(ftype)
10186 
      else:
10187 
        iprot.skip(ftype)
10188 
      iprot.readFieldEnd()
10189 
    iprot.readStructEnd()
10190 
 
10191 
  def write(self, oprot):
10192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10194 
      return
3064 chandransh 10195 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 10196 
    if self.orderId is not None:
3064 chandransh 10197 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10198 
      oprot.writeI64(self.orderId)
759 chandransh 10199 
      oprot.writeFieldEnd()
10200 
    oprot.writeFieldStop()
10201 
    oprot.writeStructEnd()
10202 
 
3431 rajveer 10203 
  def validate(self):
10204 
    return
10205 
 
10206 
 
759 chandransh 10207 
  def __repr__(self):
10208 
    L = ['%s=%r' % (key, value)
10209 
      for key, value in self.__dict__.iteritems()]
10210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10211 
 
10212 
  def __eq__(self, other):
10213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10214 
 
10215 
  def __ne__(self, other):
10216 
    return not (self == other)
10217 
 
3064 chandransh 10218 
class verifyOrder_result:
759 chandransh 10219 
  """
10220 
  Attributes:
10221 
   - success
10222 
   - ex
10223 
  """
10224 
 
10225 
  thrift_spec = (
10226 
    (0, TType.BOOL, 'success', None, None, ), # 0
10227 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10228 
  )
10229 
 
10230 
  def __init__(self, success=None, ex=None,):
10231 
    self.success = success
10232 
    self.ex = ex
10233 
 
10234 
  def read(self, iprot):
10235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10237 
      return
10238 
    iprot.readStructBegin()
10239 
    while True:
10240 
      (fname, ftype, fid) = iprot.readFieldBegin()
10241 
      if ftype == TType.STOP:
10242 
        break
10243 
      if fid == 0:
10244 
        if ftype == TType.BOOL:
10245 
          self.success = iprot.readBool();
10246 
        else:
10247 
          iprot.skip(ftype)
10248 
      elif fid == 1:
10249 
        if ftype == TType.STRUCT:
10250 
          self.ex = TransactionServiceException()
10251 
          self.ex.read(iprot)
10252 
        else:
10253 
          iprot.skip(ftype)
10254 
      else:
10255 
        iprot.skip(ftype)
10256 
      iprot.readFieldEnd()
10257 
    iprot.readStructEnd()
10258 
 
10259 
  def write(self, oprot):
10260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10262 
      return
3064 chandransh 10263 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 10264 
    if self.success is not None:
759 chandransh 10265 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10266 
      oprot.writeBool(self.success)
10267 
      oprot.writeFieldEnd()
3431 rajveer 10268 
    if self.ex is not None:
759 chandransh 10269 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10270 
      self.ex.write(oprot)
10271 
      oprot.writeFieldEnd()
10272 
    oprot.writeFieldStop()
10273 
    oprot.writeStructEnd()
10274 
 
3431 rajveer 10275 
  def validate(self):
10276 
    return
10277 
 
10278 
 
759 chandransh 10279 
  def __repr__(self):
10280 
    L = ['%s=%r' % (key, value)
10281 
      for key, value in self.__dict__.iteritems()]
10282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10283 
 
10284 
  def __eq__(self, other):
10285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10286 
 
10287 
  def __ne__(self, other):
10288 
    return not (self == other)
10289 
 
3064 chandransh 10290 
class acceptOrder_args:
1113 chandransh 10291 
  """
10292 
  Attributes:
3064 chandransh 10293 
   - orderId
1113 chandransh 10294 
  """
10295 
 
10296 
  thrift_spec = (
10297 
    None, # 0
3064 chandransh 10298 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 10299 
  )
10300 
 
3064 chandransh 10301 
  def __init__(self, orderId=None,):
10302 
    self.orderId = orderId
1113 chandransh 10303 
 
10304 
  def read(self, iprot):
10305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10307 
      return
10308 
    iprot.readStructBegin()
10309 
    while True:
10310 
      (fname, ftype, fid) = iprot.readFieldBegin()
10311 
      if ftype == TType.STOP:
10312 
        break
10313 
      if fid == 1:
10314 
        if ftype == TType.I64:
3064 chandransh 10315 
          self.orderId = iprot.readI64();
1113 chandransh 10316 
        else:
10317 
          iprot.skip(ftype)
10318 
      else:
10319 
        iprot.skip(ftype)
10320 
      iprot.readFieldEnd()
10321 
    iprot.readStructEnd()
10322 
 
10323 
  def write(self, oprot):
10324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10326 
      return
3064 chandransh 10327 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 10328 
    if self.orderId is not None:
3064 chandransh 10329 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10330 
      oprot.writeI64(self.orderId)
1113 chandransh 10331 
      oprot.writeFieldEnd()
10332 
    oprot.writeFieldStop()
10333 
    oprot.writeStructEnd()
10334 
 
3431 rajveer 10335 
  def validate(self):
10336 
    return
10337 
 
10338 
 
1113 chandransh 10339 
  def __repr__(self):
10340 
    L = ['%s=%r' % (key, value)
10341 
      for key, value in self.__dict__.iteritems()]
10342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10343 
 
10344 
  def __eq__(self, other):
10345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10346 
 
10347 
  def __ne__(self, other):
10348 
    return not (self == other)
10349 
 
3064 chandransh 10350 
class acceptOrder_result:
1113 chandransh 10351 
  """
10352 
  Attributes:
10353 
   - success
10354 
   - ex
10355 
  """
10356 
 
10357 
  thrift_spec = (
3064 chandransh 10358 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 10359 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10360 
  )
10361 
 
10362 
  def __init__(self, success=None, ex=None,):
10363 
    self.success = success
10364 
    self.ex = ex
10365 
 
10366 
  def read(self, iprot):
10367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10369 
      return
10370 
    iprot.readStructBegin()
10371 
    while True:
10372 
      (fname, ftype, fid) = iprot.readFieldBegin()
10373 
      if ftype == TType.STOP:
10374 
        break
10375 
      if fid == 0:
3064 chandransh 10376 
        if ftype == TType.BOOL:
10377 
          self.success = iprot.readBool();
1113 chandransh 10378 
        else:
10379 
          iprot.skip(ftype)
10380 
      elif fid == 1:
10381 
        if ftype == TType.STRUCT:
10382 
          self.ex = TransactionServiceException()
10383 
          self.ex.read(iprot)
10384 
        else:
10385 
          iprot.skip(ftype)
10386 
      else:
10387 
        iprot.skip(ftype)
10388 
      iprot.readFieldEnd()
10389 
    iprot.readStructEnd()
10390 
 
10391 
  def write(self, oprot):
10392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10394 
      return
3064 chandransh 10395 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 10396 
    if self.success is not None:
3064 chandransh 10397 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10398 
      oprot.writeBool(self.success)
1113 chandransh 10399 
      oprot.writeFieldEnd()
3431 rajveer 10400 
    if self.ex is not None:
1113 chandransh 10401 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10402 
      self.ex.write(oprot)
10403 
      oprot.writeFieldEnd()
10404 
    oprot.writeFieldStop()
10405 
    oprot.writeStructEnd()
10406 
 
3431 rajveer 10407 
  def validate(self):
10408 
    return
10409 
 
10410 
 
1113 chandransh 10411 
  def __repr__(self):
10412 
    L = ['%s=%r' % (key, value)
10413 
      for key, value in self.__dict__.iteritems()]
10414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10415 
 
10416 
  def __eq__(self, other):
10417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10418 
 
10419 
  def __ne__(self, other):
10420 
    return not (self == other)
10421 
 
3064 chandransh 10422 
class addBillingDetails_args:
1135 chandransh 10423 
  """
10424 
  Attributes:
3064 chandransh 10425 
   - orderId
10426 
   - invoice_number
4658 mandeep.dh 10427 
   - serialNumber
4283 anupam.sin 10428 
   - itemNumber
3064 chandransh 10429 
   - billed_by
4264 rajveer 10430 
   - jacketNumber
4283 anupam.sin 10431 
   - billingType
10432 
   - vendorId
1135 chandransh 10433 
  """
10434 
 
10435 
  thrift_spec = (
10436 
    None, # 0
3064 chandransh 10437 
    (1, TType.I64, 'orderId', None, None, ), # 1
10438 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 10439 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 10440 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10441 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10442 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10443 
    (7, TType.I64, 'billingType', None, None, ), # 7
10444 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 10445 
  )
10446 
 
4658 mandeep.dh 10447 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 10448 
    self.orderId = orderId
10449 
    self.invoice_number = invoice_number
4658 mandeep.dh 10450 
    self.serialNumber = serialNumber
4283 anupam.sin 10451 
    self.itemNumber = itemNumber
3064 chandransh 10452 
    self.billed_by = billed_by
4264 rajveer 10453 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10454 
    self.billingType = billingType
10455 
    self.vendorId = vendorId
1135 chandransh 10456 
 
10457 
  def read(self, iprot):
10458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10460 
      return
10461 
    iprot.readStructBegin()
10462 
    while True:
10463 
      (fname, ftype, fid) = iprot.readFieldBegin()
10464 
      if ftype == TType.STOP:
10465 
        break
10466 
      if fid == 1:
10467 
        if ftype == TType.I64:
3064 chandransh 10468 
          self.orderId = iprot.readI64();
1135 chandransh 10469 
        else:
10470 
          iprot.skip(ftype)
10471 
      elif fid == 2:
3064 chandransh 10472 
        if ftype == TType.STRING:
10473 
          self.invoice_number = iprot.readString();
1135 chandransh 10474 
        else:
10475 
          iprot.skip(ftype)
3064 chandransh 10476 
      elif fid == 3:
4658 mandeep.dh 10477 
        if ftype == TType.STRING:
10478 
          self.serialNumber = iprot.readString();
3064 chandransh 10479 
        else:
10480 
          iprot.skip(ftype)
10481 
      elif fid == 4:
10482 
        if ftype == TType.STRING:
10483 
          self.itemNumber = iprot.readString();
10484 
        else:
10485 
          iprot.skip(ftype)
10486 
      elif fid == 5:
10487 
        if ftype == TType.STRING:
4283 anupam.sin 10488 
          self.billed_by = iprot.readString();
3064 chandransh 10489 
        else:
10490 
          iprot.skip(ftype)
10491 
      elif fid == 6:
10492 
        if ftype == TType.I64:
4283 anupam.sin 10493 
          self.jacketNumber = iprot.readI64();
10494 
        else:
10495 
          iprot.skip(ftype)
10496 
      elif fid == 7:
10497 
        if ftype == TType.I64:
3064 chandransh 10498 
          self.billingType = iprot.readI64();
10499 
        else:
10500 
          iprot.skip(ftype)
4283 anupam.sin 10501 
      elif fid == 8:
10502 
        if ftype == TType.I64:
10503 
          self.vendorId = iprot.readI64();
10504 
        else:
10505 
          iprot.skip(ftype)
1246 chandransh 10506 
      else:
10507 
        iprot.skip(ftype)
10508 
      iprot.readFieldEnd()
10509 
    iprot.readStructEnd()
10510 
 
10511 
  def write(self, oprot):
10512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10514 
      return
4283 anupam.sin 10515 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 10516 
    if self.orderId is not None:
3064 chandransh 10517 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10518 
      oprot.writeI64(self.orderId)
1246 chandransh 10519 
      oprot.writeFieldEnd()
4283 anupam.sin 10520 
    if self.invoice_number is not None:
10521 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
10522 
      oprot.writeString(self.invoice_number)
1246 chandransh 10523 
      oprot.writeFieldEnd()
4658 mandeep.dh 10524 
    if self.serialNumber is not None:
10525 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
10526 
      oprot.writeString(self.serialNumber)
3064 chandransh 10527 
      oprot.writeFieldEnd()
3431 rajveer 10528 
    if self.itemNumber is not None:
3064 chandransh 10529 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
10530 
      oprot.writeString(self.itemNumber)
10531 
      oprot.writeFieldEnd()
4283 anupam.sin 10532 
    if self.billed_by is not None:
10533 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
10534 
      oprot.writeString(self.billed_by)
3064 chandransh 10535 
      oprot.writeFieldEnd()
4283 anupam.sin 10536 
    if self.jacketNumber is not None:
10537 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
10538 
      oprot.writeI64(self.jacketNumber)
10539 
      oprot.writeFieldEnd()
3431 rajveer 10540 
    if self.billingType is not None:
4283 anupam.sin 10541 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 10542 
      oprot.writeI64(self.billingType)
10543 
      oprot.writeFieldEnd()
4283 anupam.sin 10544 
    if self.vendorId is not None:
10545 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
10546 
      oprot.writeI64(self.vendorId)
10547 
      oprot.writeFieldEnd()
1246 chandransh 10548 
    oprot.writeFieldStop()
10549 
    oprot.writeStructEnd()
10550 
 
3431 rajveer 10551 
  def validate(self):
10552 
    return
10553 
 
10554 
 
1246 chandransh 10555 
  def __repr__(self):
10556 
    L = ['%s=%r' % (key, value)
10557 
      for key, value in self.__dict__.iteritems()]
10558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10559 
 
10560 
  def __eq__(self, other):
10561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10562 
 
10563 
  def __ne__(self, other):
10564 
    return not (self == other)
10565 
 
4283 anupam.sin 10566 
class addBillingDetails_result:
1246 chandransh 10567 
  """
10568 
  Attributes:
3064 chandransh 10569 
   - success
1246 chandransh 10570 
   - ex
10571 
  """
10572 
 
10573 
  thrift_spec = (
3064 chandransh 10574 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 10575 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10576 
  )
10577 
 
3064 chandransh 10578 
  def __init__(self, success=None, ex=None,):
10579 
    self.success = success
1246 chandransh 10580 
    self.ex = ex
10581 
 
10582 
  def read(self, iprot):
10583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10585 
      return
10586 
    iprot.readStructBegin()
10587 
    while True:
10588 
      (fname, ftype, fid) = iprot.readFieldBegin()
10589 
      if ftype == TType.STOP:
10590 
        break
3064 chandransh 10591 
      if fid == 0:
10592 
        if ftype == TType.BOOL:
10593 
          self.success = iprot.readBool();
10594 
        else:
10595 
          iprot.skip(ftype)
10596 
      elif fid == 1:
1246 chandransh 10597 
        if ftype == TType.STRUCT:
10598 
          self.ex = TransactionServiceException()
10599 
          self.ex.read(iprot)
10600 
        else:
10601 
          iprot.skip(ftype)
10602 
      else:
10603 
        iprot.skip(ftype)
10604 
      iprot.readFieldEnd()
10605 
    iprot.readStructEnd()
10606 
 
10607 
  def write(self, oprot):
10608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10610 
      return
4283 anupam.sin 10611 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 10612 
    if self.success is not None:
3064 chandransh 10613 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10614 
      oprot.writeBool(self.success)
10615 
      oprot.writeFieldEnd()
3431 rajveer 10616 
    if self.ex is not None:
1246 chandransh 10617 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10618 
      self.ex.write(oprot)
10619 
      oprot.writeFieldEnd()
10620 
    oprot.writeFieldStop()
10621 
    oprot.writeStructEnd()
10622 
 
3431 rajveer 10623 
  def validate(self):
10624 
    return
10625 
 
10626 
 
1246 chandransh 10627 
  def __repr__(self):
10628 
    L = ['%s=%r' % (key, value)
10629 
      for key, value in self.__dict__.iteritems()]
10630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10631 
 
10632 
  def __eq__(self, other):
10633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10634 
 
10635 
  def __ne__(self, other):
10636 
    return not (self == other)
10637 
 
4579 rajveer 10638 
class addInvoiceNumber_args:
10639 
  """
10640 
  Attributes:
10641 
   - orderId
10642 
   - invoiceNumber
10643 
  """
10644 
 
10645 
  thrift_spec = (
10646 
    None, # 0
10647 
    (1, TType.I64, 'orderId', None, None, ), # 1
10648 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
10649 
  )
10650 
 
10651 
  def __init__(self, orderId=None, invoiceNumber=None,):
10652 
    self.orderId = orderId
10653 
    self.invoiceNumber = invoiceNumber
10654 
 
10655 
  def read(self, iprot):
10656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10658 
      return
10659 
    iprot.readStructBegin()
10660 
    while True:
10661 
      (fname, ftype, fid) = iprot.readFieldBegin()
10662 
      if ftype == TType.STOP:
10663 
        break
10664 
      if fid == 1:
10665 
        if ftype == TType.I64:
10666 
          self.orderId = iprot.readI64();
10667 
        else:
10668 
          iprot.skip(ftype)
10669 
      elif fid == 2:
10670 
        if ftype == TType.STRING:
10671 
          self.invoiceNumber = iprot.readString();
10672 
        else:
10673 
          iprot.skip(ftype)
10674 
      else:
10675 
        iprot.skip(ftype)
10676 
      iprot.readFieldEnd()
10677 
    iprot.readStructEnd()
10678 
 
10679 
  def write(self, oprot):
10680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10682 
      return
10683 
    oprot.writeStructBegin('addInvoiceNumber_args')
10684 
    if self.orderId is not None:
10685 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10686 
      oprot.writeI64(self.orderId)
10687 
      oprot.writeFieldEnd()
10688 
    if self.invoiceNumber is not None:
10689 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
10690 
      oprot.writeString(self.invoiceNumber)
10691 
      oprot.writeFieldEnd()
10692 
    oprot.writeFieldStop()
10693 
    oprot.writeStructEnd()
10694 
 
10695 
  def validate(self):
10696 
    return
10697 
 
10698 
 
10699 
  def __repr__(self):
10700 
    L = ['%s=%r' % (key, value)
10701 
      for key, value in self.__dict__.iteritems()]
10702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10703 
 
10704 
  def __eq__(self, other):
10705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10706 
 
10707 
  def __ne__(self, other):
10708 
    return not (self == other)
10709 
 
10710 
class addInvoiceNumber_result:
10711 
  """
10712 
  Attributes:
10713 
   - ex
10714 
  """
10715 
 
10716 
  thrift_spec = (
10717 
    None, # 0
10718 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10719 
  )
10720 
 
10721 
  def __init__(self, ex=None,):
10722 
    self.ex = ex
10723 
 
10724 
  def read(self, iprot):
10725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10727 
      return
10728 
    iprot.readStructBegin()
10729 
    while True:
10730 
      (fname, ftype, fid) = iprot.readFieldBegin()
10731 
      if ftype == TType.STOP:
10732 
        break
10733 
      if fid == 1:
10734 
        if ftype == TType.STRUCT:
10735 
          self.ex = TransactionServiceException()
10736 
          self.ex.read(iprot)
10737 
        else:
10738 
          iprot.skip(ftype)
10739 
      else:
10740 
        iprot.skip(ftype)
10741 
      iprot.readFieldEnd()
10742 
    iprot.readStructEnd()
10743 
 
10744 
  def write(self, oprot):
10745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10747 
      return
10748 
    oprot.writeStructBegin('addInvoiceNumber_result')
10749 
    if self.ex is not None:
10750 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10751 
      self.ex.write(oprot)
10752 
      oprot.writeFieldEnd()
10753 
    oprot.writeFieldStop()
10754 
    oprot.writeStructEnd()
10755 
 
10756 
  def validate(self):
10757 
    return
10758 
 
10759 
 
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 
 
3064 chandransh 10771 
class markOrdersAsManifested_args:
1408 ankur.sing 10772 
  """
10773 
  Attributes:
3064 chandransh 10774 
   - warehouseId
1408 ankur.sing 10775 
   - providerId
3064 chandransh 10776 
   - cod
1408 ankur.sing 10777 
  """
10778 
 
10779 
  thrift_spec = (
10780 
    None, # 0
3064 chandransh 10781 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10782 
    (2, TType.I64, 'providerId', None, None, ), # 2
10783 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 10784 
  )
10785 
 
3064 chandransh 10786 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10787 
    self.warehouseId = warehouseId
1408 ankur.sing 10788 
    self.providerId = providerId
3064 chandransh 10789 
    self.cod = cod
1408 ankur.sing 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:
3064 chandransh 10802 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 10803 
        else:
10804 
          iprot.skip(ftype)
10805 
      elif fid == 2:
10806 
        if ftype == TType.I64:
3064 chandransh 10807 
          self.providerId = iprot.readI64();
1408 ankur.sing 10808 
        else:
10809 
          iprot.skip(ftype)
3064 chandransh 10810 
      elif fid == 3:
10811 
        if ftype == TType.BOOL:
10812 
          self.cod = iprot.readBool();
10813 
        else:
10814 
          iprot.skip(ftype)
1408 ankur.sing 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
3064 chandransh 10824 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 10825 
    if self.warehouseId is not None:
3064 chandransh 10826 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10827 
      oprot.writeI64(self.warehouseId)
10828 
      oprot.writeFieldEnd()
3431 rajveer 10829 
    if self.providerId is not None:
3064 chandransh 10830 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 10831 
      oprot.writeI64(self.providerId)
10832 
      oprot.writeFieldEnd()
3431 rajveer 10833 
    if self.cod is not None:
3064 chandransh 10834 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10835 
      oprot.writeBool(self.cod)
1408 ankur.sing 10836 
      oprot.writeFieldEnd()
10837 
    oprot.writeFieldStop()
10838 
    oprot.writeStructEnd()
10839 
 
3431 rajveer 10840 
  def validate(self):
10841 
    return
10842 
 
10843 
 
1408 ankur.sing 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 
 
3064 chandransh 10855 
class markOrdersAsManifested_result:
1408 ankur.sing 10856 
  """
10857 
  Attributes:
10858 
   - success
3064 chandransh 10859 
   - ex
1408 ankur.sing 10860 
  """
10861 
 
10862 
  thrift_spec = (
3064 chandransh 10863 
    (0, TType.BOOL, 'success', None, None, ), # 0
10864 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10865 
  )
10866 
 
3064 chandransh 10867 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10868 
    self.success = success
3064 chandransh 10869 
    self.ex = ex
1408 ankur.sing 10870 
 
10871 
  def read(self, iprot):
10872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10874 
      return
10875 
    iprot.readStructBegin()
10876 
    while True:
10877 
      (fname, ftype, fid) = iprot.readFieldBegin()
10878 
      if ftype == TType.STOP:
10879 
        break
10880 
      if fid == 0:
3064 chandransh 10881 
        if ftype == TType.BOOL:
10882 
          self.success = iprot.readBool();
1408 ankur.sing 10883 
        else:
10884 
          iprot.skip(ftype)
3064 chandransh 10885 
      elif fid == 1:
10886 
        if ftype == TType.STRUCT:
10887 
          self.ex = TransactionServiceException()
10888 
          self.ex.read(iprot)
10889 
        else:
10890 
          iprot.skip(ftype)
1408 ankur.sing 10891 
      else:
10892 
        iprot.skip(ftype)
10893 
      iprot.readFieldEnd()
10894 
    iprot.readStructEnd()
10895 
 
10896 
  def write(self, oprot):
10897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10899 
      return
3064 chandransh 10900 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10901 
    if self.success is not None:
3064 chandransh 10902 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10903 
      oprot.writeBool(self.success)
1408 ankur.sing 10904 
      oprot.writeFieldEnd()
3431 rajveer 10905 
    if self.ex is not None:
3064 chandransh 10906 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10907 
      self.ex.write(oprot)
10908 
      oprot.writeFieldEnd()
1408 ankur.sing 10909 
    oprot.writeFieldStop()
10910 
    oprot.writeStructEnd()
10911 
 
3431 rajveer 10912 
  def validate(self):
10913 
    return
10914 
 
10915 
 
1408 ankur.sing 10916 
  def __repr__(self):
10917 
    L = ['%s=%r' % (key, value)
10918 
      for key, value in self.__dict__.iteritems()]
10919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10920 
 
10921 
  def __eq__(self, other):
10922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10923 
 
10924 
  def __ne__(self, other):
10925 
    return not (self == other)
10926 
 
4410 rajveer 10927 
class markOrdersAsShippedFromWarehouse_args:
10928 
  """
10929 
  Attributes:
10930 
   - warehouseId
10931 
   - providerId
10932 
   - cod
10933 
  """
10934 
 
10935 
  thrift_spec = (
10936 
    None, # 0
10937 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10938 
    (2, TType.I64, 'providerId', None, None, ), # 2
10939 
    (3, TType.BOOL, 'cod', None, None, ), # 3
10940 
  )
10941 
 
10942 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10943 
    self.warehouseId = warehouseId
10944 
    self.providerId = providerId
10945 
    self.cod = cod
10946 
 
10947 
  def read(self, iprot):
10948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10950 
      return
10951 
    iprot.readStructBegin()
10952 
    while True:
10953 
      (fname, ftype, fid) = iprot.readFieldBegin()
10954 
      if ftype == TType.STOP:
10955 
        break
10956 
      if fid == 1:
10957 
        if ftype == TType.I64:
10958 
          self.warehouseId = iprot.readI64();
10959 
        else:
10960 
          iprot.skip(ftype)
10961 
      elif fid == 2:
10962 
        if ftype == TType.I64:
10963 
          self.providerId = iprot.readI64();
10964 
        else:
10965 
          iprot.skip(ftype)
10966 
      elif fid == 3:
10967 
        if ftype == TType.BOOL:
10968 
          self.cod = iprot.readBool();
10969 
        else:
10970 
          iprot.skip(ftype)
10971 
      else:
10972 
        iprot.skip(ftype)
10973 
      iprot.readFieldEnd()
10974 
    iprot.readStructEnd()
10975 
 
10976 
  def write(self, oprot):
10977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10979 
      return
10980 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
10981 
    if self.warehouseId is not None:
10982 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10983 
      oprot.writeI64(self.warehouseId)
10984 
      oprot.writeFieldEnd()
10985 
    if self.providerId is not None:
10986 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
10987 
      oprot.writeI64(self.providerId)
10988 
      oprot.writeFieldEnd()
10989 
    if self.cod is not None:
10990 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10991 
      oprot.writeBool(self.cod)
10992 
      oprot.writeFieldEnd()
10993 
    oprot.writeFieldStop()
10994 
    oprot.writeStructEnd()
10995 
 
10996 
  def validate(self):
10997 
    return
10998 
 
10999 
 
11000 
  def __repr__(self):
11001 
    L = ['%s=%r' % (key, value)
11002 
      for key, value in self.__dict__.iteritems()]
11003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11004 
 
11005 
  def __eq__(self, other):
11006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11007 
 
11008 
  def __ne__(self, other):
11009 
    return not (self == other)
11010 
 
11011 
class markOrdersAsShippedFromWarehouse_result:
11012 
  """
11013 
  Attributes:
11014 
   - success
11015 
   - ex
11016 
  """
11017 
 
11018 
  thrift_spec = (
11019 
    (0, TType.BOOL, 'success', None, None, ), # 0
11020 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11021 
  )
11022 
 
11023 
  def __init__(self, success=None, ex=None,):
11024 
    self.success = success
11025 
    self.ex = ex
11026 
 
11027 
  def read(self, iprot):
11028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11030 
      return
11031 
    iprot.readStructBegin()
11032 
    while True:
11033 
      (fname, ftype, fid) = iprot.readFieldBegin()
11034 
      if ftype == TType.STOP:
11035 
        break
11036 
      if fid == 0:
11037 
        if ftype == TType.BOOL:
11038 
          self.success = iprot.readBool();
11039 
        else:
11040 
          iprot.skip(ftype)
11041 
      elif fid == 1:
11042 
        if ftype == TType.STRUCT:
11043 
          self.ex = TransactionServiceException()
11044 
          self.ex.read(iprot)
11045 
        else:
11046 
          iprot.skip(ftype)
11047 
      else:
11048 
        iprot.skip(ftype)
11049 
      iprot.readFieldEnd()
11050 
    iprot.readStructEnd()
11051 
 
11052 
  def write(self, oprot):
11053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11055 
      return
11056 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
11057 
    if self.success is not None:
11058 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11059 
      oprot.writeBool(self.success)
11060 
      oprot.writeFieldEnd()
11061 
    if self.ex is not None:
11062 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11063 
      self.ex.write(oprot)
11064 
      oprot.writeFieldEnd()
11065 
    oprot.writeFieldStop()
11066 
    oprot.writeStructEnd()
11067 
 
11068 
  def validate(self):
11069 
    return
11070 
 
11071 
 
11072 
  def __repr__(self):
11073 
    L = ['%s=%r' % (key, value)
11074 
      for key, value in self.__dict__.iteritems()]
11075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11076 
 
11077 
  def __eq__(self, other):
11078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11079 
 
11080 
  def __ne__(self, other):
11081 
    return not (self == other)
11082 
 
3064 chandransh 11083 
class markOrdersAsPickedUp_args:
304 ashish 11084 
  """
11085 
  Attributes:
3064 chandransh 11086 
   - providerId
11087 
   - pickupDetails
304 ashish 11088 
  """
94 ashish 11089 
 
304 ashish 11090 
  thrift_spec = (
11091 
    None, # 0
3064 chandransh 11092 
    (1, TType.I64, 'providerId', None, None, ), # 1
11093 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11094 
  )
11095 
 
3064 chandransh 11096 
  def __init__(self, providerId=None, pickupDetails=None,):
11097 
    self.providerId = providerId
11098 
    self.pickupDetails = pickupDetails
304 ashish 11099 
 
11100 
  def read(self, iprot):
11101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11103 
      return
11104 
    iprot.readStructBegin()
11105 
    while True:
11106 
      (fname, ftype, fid) = iprot.readFieldBegin()
11107 
      if ftype == TType.STOP:
11108 
        break
11109 
      if fid == 1:
11110 
        if ftype == TType.I64:
3064 chandransh 11111 
          self.providerId = iprot.readI64();
304 ashish 11112 
        else:
11113 
          iprot.skip(ftype)
11114 
      elif fid == 2:
3064 chandransh 11115 
        if ftype == TType.MAP:
11116 
          self.pickupDetails = {}
4133 chandransh 11117 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
11118 
          for _i144 in xrange(_size140):
11119 
            _key145 = iprot.readString();
11120 
            _val146 = iprot.readString();
11121 
            self.pickupDetails[_key145] = _val146
3064 chandransh 11122 
          iprot.readMapEnd()
304 ashish 11123 
        else:
11124 
          iprot.skip(ftype)
11125 
      else:
11126 
        iprot.skip(ftype)
11127 
      iprot.readFieldEnd()
11128 
    iprot.readStructEnd()
11129 
 
11130 
  def write(self, oprot):
11131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11133 
      return
3064 chandransh 11134 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 11135 
    if self.providerId is not None:
3064 chandransh 11136 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11137 
      oprot.writeI64(self.providerId)
304 ashish 11138 
      oprot.writeFieldEnd()
3431 rajveer 11139 
    if self.pickupDetails is not None:
3064 chandransh 11140 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11141 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 11142 
      for kiter147,viter148 in self.pickupDetails.items():
11143 
        oprot.writeString(kiter147)
11144 
        oprot.writeString(viter148)
3064 chandransh 11145 
      oprot.writeMapEnd()
304 ashish 11146 
      oprot.writeFieldEnd()
11147 
    oprot.writeFieldStop()
11148 
    oprot.writeStructEnd()
11149 
 
3431 rajveer 11150 
  def validate(self):
11151 
    return
11152 
 
11153 
 
304 ashish 11154 
  def __repr__(self):
11155 
    L = ['%s=%r' % (key, value)
11156 
      for key, value in self.__dict__.iteritems()]
11157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11158 
 
11159 
  def __eq__(self, other):
11160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11161 
 
11162 
  def __ne__(self, other):
11163 
    return not (self == other)
11164 
 
3064 chandransh 11165 
class markOrdersAsPickedUp_result:
304 ashish 11166 
  """
11167 
  Attributes:
11168 
   - success
3064 chandransh 11169 
   - ex
304 ashish 11170 
  """
11171 
 
11172 
  thrift_spec = (
3064 chandransh 11173 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11174 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11175 
  )
11176 
 
3064 chandransh 11177 
  def __init__(self, success=None, ex=None,):
304 ashish 11178 
    self.success = success
3064 chandransh 11179 
    self.ex = ex
304 ashish 11180 
 
11181 
  def read(self, iprot):
11182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11184 
      return
11185 
    iprot.readStructBegin()
11186 
    while True:
11187 
      (fname, ftype, fid) = iprot.readFieldBegin()
11188 
      if ftype == TType.STOP:
11189 
        break
11190 
      if fid == 0:
11191 
        if ftype == TType.LIST:
11192 
          self.success = []
4133 chandransh 11193 
          (_etype152, _size149) = iprot.readListBegin()
11194 
          for _i153 in xrange(_size149):
11195 
            _elem154 = Order()
11196 
            _elem154.read(iprot)
11197 
            self.success.append(_elem154)
304 ashish 11198 
          iprot.readListEnd()
11199 
        else:
11200 
          iprot.skip(ftype)
3064 chandransh 11201 
      elif fid == 1:
11202 
        if ftype == TType.STRUCT:
11203 
          self.ex = TransactionServiceException()
11204 
          self.ex.read(iprot)
11205 
        else:
11206 
          iprot.skip(ftype)
304 ashish 11207 
      else:
11208 
        iprot.skip(ftype)
11209 
      iprot.readFieldEnd()
11210 
    iprot.readStructEnd()
11211 
 
11212 
  def write(self, oprot):
11213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11215 
      return
3064 chandransh 11216 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 11217 
    if self.success is not None:
304 ashish 11218 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11219 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11220 
      for iter155 in self.success:
11221 
        iter155.write(oprot)
304 ashish 11222 
      oprot.writeListEnd()
11223 
      oprot.writeFieldEnd()
3431 rajveer 11224 
    if self.ex is not None:
3064 chandransh 11225 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11226 
      self.ex.write(oprot)
11227 
      oprot.writeFieldEnd()
304 ashish 11228 
    oprot.writeFieldStop()
11229 
    oprot.writeStructEnd()
11230 
 
3431 rajveer 11231 
  def validate(self):
11232 
    return
11233 
 
11234 
 
304 ashish 11235 
  def __repr__(self):
11236 
    L = ['%s=%r' % (key, value)
11237 
      for key, value in self.__dict__.iteritems()]
11238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11239 
 
11240 
  def __eq__(self, other):
11241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11242 
 
11243 
  def __ne__(self, other):
11244 
    return not (self == other)
11245 
 
3064 chandransh 11246 
class markOrdersAsDelivered_args:
304 ashish 11247 
  """
11248 
  Attributes:
3064 chandransh 11249 
   - providerId
11250 
   - deliveredOrders
304 ashish 11251 
  """
11252 
 
11253 
  thrift_spec = (
11254 
    None, # 0
3064 chandransh 11255 
    (1, TType.I64, 'providerId', None, None, ), # 1
11256 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11257 
  )
11258 
 
3064 chandransh 11259 
  def __init__(self, providerId=None, deliveredOrders=None,):
11260 
    self.providerId = providerId
11261 
    self.deliveredOrders = deliveredOrders
304 ashish 11262 
 
11263 
  def read(self, iprot):
11264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11266 
      return
11267 
    iprot.readStructBegin()
11268 
    while True:
11269 
      (fname, ftype, fid) = iprot.readFieldBegin()
11270 
      if ftype == TType.STOP:
11271 
        break
11272 
      if fid == 1:
11273 
        if ftype == TType.I64:
3064 chandransh 11274 
          self.providerId = iprot.readI64();
304 ashish 11275 
        else:
11276 
          iprot.skip(ftype)
11277 
      elif fid == 2:
3064 chandransh 11278 
        if ftype == TType.MAP:
11279 
          self.deliveredOrders = {}
4133 chandransh 11280 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
11281 
          for _i160 in xrange(_size156):
11282 
            _key161 = iprot.readString();
11283 
            _val162 = iprot.readString();
11284 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 11285 
          iprot.readMapEnd()
304 ashish 11286 
        else:
11287 
          iprot.skip(ftype)
11288 
      else:
11289 
        iprot.skip(ftype)
11290 
      iprot.readFieldEnd()
11291 
    iprot.readStructEnd()
11292 
 
11293 
  def write(self, oprot):
11294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11296 
      return
3064 chandransh 11297 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 11298 
    if self.providerId is not None:
3064 chandransh 11299 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11300 
      oprot.writeI64(self.providerId)
304 ashish 11301 
      oprot.writeFieldEnd()
3431 rajveer 11302 
    if self.deliveredOrders is not None:
3064 chandransh 11303 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
11304 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 11305 
      for kiter163,viter164 in self.deliveredOrders.items():
11306 
        oprot.writeString(kiter163)
11307 
        oprot.writeString(viter164)
3064 chandransh 11308 
      oprot.writeMapEnd()
304 ashish 11309 
      oprot.writeFieldEnd()
11310 
    oprot.writeFieldStop()
11311 
    oprot.writeStructEnd()
11312 
 
3431 rajveer 11313 
  def validate(self):
11314 
    return
11315 
 
11316 
 
304 ashish 11317 
  def __repr__(self):
11318 
    L = ['%s=%r' % (key, value)
11319 
      for key, value in self.__dict__.iteritems()]
11320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11321 
 
11322 
  def __eq__(self, other):
11323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11324 
 
11325 
  def __ne__(self, other):
11326 
    return not (self == other)
11327 
 
3064 chandransh 11328 
class markOrdersAsDelivered_result:
11329 
  """
11330 
  Attributes:
11331 
   - ex
11332 
  """
304 ashish 11333 
 
11334 
  thrift_spec = (
3064 chandransh 11335 
    None, # 0
11336 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11337 
  )
11338 
 
3064 chandransh 11339 
  def __init__(self, ex=None,):
11340 
    self.ex = ex
304 ashish 11341 
 
1596 ankur.sing 11342 
  def read(self, iprot):
11343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11345 
      return
11346 
    iprot.readStructBegin()
11347 
    while True:
11348 
      (fname, ftype, fid) = iprot.readFieldBegin()
11349 
      if ftype == TType.STOP:
11350 
        break
3064 chandransh 11351 
      if fid == 1:
11352 
        if ftype == TType.STRUCT:
11353 
          self.ex = TransactionServiceException()
11354 
          self.ex.read(iprot)
11355 
        else:
11356 
          iprot.skip(ftype)
1596 ankur.sing 11357 
      else:
11358 
        iprot.skip(ftype)
11359 
      iprot.readFieldEnd()
11360 
    iprot.readStructEnd()
11361 
 
11362 
  def write(self, oprot):
11363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11365 
      return
3064 chandransh 11366 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 11367 
    if self.ex is not None:
3064 chandransh 11368 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11369 
      self.ex.write(oprot)
11370 
      oprot.writeFieldEnd()
1596 ankur.sing 11371 
    oprot.writeFieldStop()
11372 
    oprot.writeStructEnd()
11373 
 
3431 rajveer 11374 
  def validate(self):
11375 
    return
11376 
 
11377 
 
1596 ankur.sing 11378 
  def __repr__(self):
11379 
    L = ['%s=%r' % (key, value)
11380 
      for key, value in self.__dict__.iteritems()]
11381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11382 
 
11383 
  def __eq__(self, other):
11384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11385 
 
11386 
  def __ne__(self, other):
11387 
    return not (self == other)
11388 
 
3064 chandransh 11389 
class markOrdersAsFailed_args:
1596 ankur.sing 11390 
  """
11391 
  Attributes:
3064 chandransh 11392 
   - providerId
11393 
   - returnedOrders
1596 ankur.sing 11394 
  """
11395 
 
11396 
  thrift_spec = (
3064 chandransh 11397 
    None, # 0
11398 
    (1, TType.I64, 'providerId', None, None, ), # 1
11399 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 11400 
  )
11401 
 
3064 chandransh 11402 
  def __init__(self, providerId=None, returnedOrders=None,):
11403 
    self.providerId = providerId
11404 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11405 
 
11406 
  def read(self, iprot):
11407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11409 
      return
11410 
    iprot.readStructBegin()
11411 
    while True:
11412 
      (fname, ftype, fid) = iprot.readFieldBegin()
11413 
      if ftype == TType.STOP:
11414 
        break
3064 chandransh 11415 
      if fid == 1:
1596 ankur.sing 11416 
        if ftype == TType.I64:
3064 chandransh 11417 
          self.providerId = iprot.readI64();
1596 ankur.sing 11418 
        else:
11419 
          iprot.skip(ftype)
3064 chandransh 11420 
      elif fid == 2:
11421 
        if ftype == TType.MAP:
11422 
          self.returnedOrders = {}
4133 chandransh 11423 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
11424 
          for _i169 in xrange(_size165):
11425 
            _key170 = iprot.readString();
11426 
            _val171 = iprot.readString();
11427 
            self.returnedOrders[_key170] = _val171
3064 chandransh 11428 
          iprot.readMapEnd()
11429 
        else:
11430 
          iprot.skip(ftype)
1596 ankur.sing 11431 
      else:
11432 
        iprot.skip(ftype)
11433 
      iprot.readFieldEnd()
11434 
    iprot.readStructEnd()
11435 
 
11436 
  def write(self, oprot):
11437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11439 
      return
3064 chandransh 11440 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 11441 
    if self.providerId is not None:
3064 chandransh 11442 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11443 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11444 
      oprot.writeFieldEnd()
3431 rajveer 11445 
    if self.returnedOrders is not None:
3064 chandransh 11446 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11447 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 11448 
      for kiter172,viter173 in self.returnedOrders.items():
11449 
        oprot.writeString(kiter172)
11450 
        oprot.writeString(viter173)
3064 chandransh 11451 
      oprot.writeMapEnd()
11452 
      oprot.writeFieldEnd()
1596 ankur.sing 11453 
    oprot.writeFieldStop()
11454 
    oprot.writeStructEnd()
11455 
 
3431 rajveer 11456 
  def validate(self):
11457 
    return
11458 
 
11459 
 
1596 ankur.sing 11460 
  def __repr__(self):
11461 
    L = ['%s=%r' % (key, value)
11462 
      for key, value in self.__dict__.iteritems()]
11463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11464 
 
11465 
  def __eq__(self, other):
11466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11467 
 
11468 
  def __ne__(self, other):
11469 
    return not (self == other)
11470 
 
3064 chandransh 11471 
class markOrdersAsFailed_result:
11472 
  """
11473 
  Attributes:
11474 
   - ex
11475 
  """
1596 ankur.sing 11476 
 
1627 ankur.sing 11477 
  thrift_spec = (
3064 chandransh 11478 
    None, # 0
11479 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11480 
  )
11481 
 
3064 chandransh 11482 
  def __init__(self, ex=None,):
11483 
    self.ex = ex
11484 
 
1627 ankur.sing 11485 
  def read(self, iprot):
11486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11488 
      return
11489 
    iprot.readStructBegin()
11490 
    while True:
11491 
      (fname, ftype, fid) = iprot.readFieldBegin()
11492 
      if ftype == TType.STOP:
11493 
        break
3064 chandransh 11494 
      if fid == 1:
11495 
        if ftype == TType.STRUCT:
11496 
          self.ex = TransactionServiceException()
11497 
          self.ex.read(iprot)
11498 
        else:
11499 
          iprot.skip(ftype)
1627 ankur.sing 11500 
      else:
11501 
        iprot.skip(ftype)
11502 
      iprot.readFieldEnd()
11503 
    iprot.readStructEnd()
11504 
 
11505 
  def write(self, oprot):
11506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11508 
      return
3064 chandransh 11509 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 11510 
    if self.ex is not None:
3064 chandransh 11511 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11512 
      self.ex.write(oprot)
11513 
      oprot.writeFieldEnd()
1627 ankur.sing 11514 
    oprot.writeFieldStop()
11515 
    oprot.writeStructEnd()
11516 
 
3431 rajveer 11517 
  def validate(self):
11518 
    return
11519 
 
11520 
 
1627 ankur.sing 11521 
  def __repr__(self):
11522 
    L = ['%s=%r' % (key, value)
11523 
      for key, value in self.__dict__.iteritems()]
11524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11525 
 
11526 
  def __eq__(self, other):
11527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11528 
 
11529 
  def __ne__(self, other):
11530 
    return not (self == other)
11531 
 
3064 chandransh 11532 
class updateNonDeliveryReason_args:
1627 ankur.sing 11533 
  """
11534 
  Attributes:
3064 chandransh 11535 
   - providerId
11536 
   - undeliveredOrders
1627 ankur.sing 11537 
  """
11538 
 
11539 
  thrift_spec = (
3064 chandransh 11540 
    None, # 0
11541 
    (1, TType.I64, 'providerId', None, None, ), # 1
11542 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 11543 
  )
11544 
 
3064 chandransh 11545 
  def __init__(self, providerId=None, undeliveredOrders=None,):
11546 
    self.providerId = providerId
11547 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 11548 
 
11549 
  def read(self, iprot):
11550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11552 
      return
11553 
    iprot.readStructBegin()
11554 
    while True:
11555 
      (fname, ftype, fid) = iprot.readFieldBegin()
11556 
      if ftype == TType.STOP:
11557 
        break
3064 chandransh 11558 
      if fid == 1:
1627 ankur.sing 11559 
        if ftype == TType.I64:
3064 chandransh 11560 
          self.providerId = iprot.readI64();
1627 ankur.sing 11561 
        else:
11562 
          iprot.skip(ftype)
3064 chandransh 11563 
      elif fid == 2:
11564 
        if ftype == TType.MAP:
11565 
          self.undeliveredOrders = {}
4133 chandransh 11566 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
11567 
          for _i178 in xrange(_size174):
11568 
            _key179 = iprot.readString();
11569 
            _val180 = iprot.readString();
11570 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 11571 
          iprot.readMapEnd()
11572 
        else:
11573 
          iprot.skip(ftype)
1627 ankur.sing 11574 
      else:
11575 
        iprot.skip(ftype)
11576 
      iprot.readFieldEnd()
11577 
    iprot.readStructEnd()
11578 
 
11579 
  def write(self, oprot):
11580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11582 
      return
3064 chandransh 11583 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 11584 
    if self.providerId is not None:
3064 chandransh 11585 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11586 
      oprot.writeI64(self.providerId)
1627 ankur.sing 11587 
      oprot.writeFieldEnd()
3431 rajveer 11588 
    if self.undeliveredOrders is not None:
3064 chandransh 11589 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
11590 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 11591 
      for kiter181,viter182 in self.undeliveredOrders.items():
11592 
        oprot.writeString(kiter181)
11593 
        oprot.writeString(viter182)
3064 chandransh 11594 
      oprot.writeMapEnd()
11595 
      oprot.writeFieldEnd()
1627 ankur.sing 11596 
    oprot.writeFieldStop()
11597 
    oprot.writeStructEnd()
11598 
 
3431 rajveer 11599 
  def validate(self):
11600 
    return
11601 
 
11602 
 
1627 ankur.sing 11603 
  def __repr__(self):
11604 
    L = ['%s=%r' % (key, value)
11605 
      for key, value in self.__dict__.iteritems()]
11606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11607 
 
11608 
  def __eq__(self, other):
11609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11610 
 
11611 
  def __ne__(self, other):
11612 
    return not (self == other)
11613 
 
3064 chandransh 11614 
class updateNonDeliveryReason_result:
1627 ankur.sing 11615 
  """
11616 
  Attributes:
4581 phani.kuma 11617 
   - success
3064 chandransh 11618 
   - ex
1627 ankur.sing 11619 
  """
11620 
 
11621 
  thrift_spec = (
4581 phani.kuma 11622 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 11623 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11624 
  )
11625 
 
4581 phani.kuma 11626 
  def __init__(self, success=None, ex=None,):
11627 
    self.success = success
3064 chandransh 11628 
    self.ex = ex
1627 ankur.sing 11629 
 
11630 
  def read(self, iprot):
11631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11633 
      return
11634 
    iprot.readStructBegin()
11635 
    while True:
11636 
      (fname, ftype, fid) = iprot.readFieldBegin()
11637 
      if ftype == TType.STOP:
11638 
        break
4581 phani.kuma 11639 
      if fid == 0:
11640 
        if ftype == TType.LIST:
11641 
          self.success = []
11642 
          (_etype186, _size183) = iprot.readListBegin()
11643 
          for _i187 in xrange(_size183):
11644 
            _elem188 = Order()
11645 
            _elem188.read(iprot)
11646 
            self.success.append(_elem188)
11647 
          iprot.readListEnd()
11648 
        else:
11649 
          iprot.skip(ftype)
11650 
      elif fid == 1:
3064 chandransh 11651 
        if ftype == TType.STRUCT:
11652 
          self.ex = TransactionServiceException()
11653 
          self.ex.read(iprot)
1627 ankur.sing 11654 
        else:
11655 
          iprot.skip(ftype)
11656 
      else:
11657 
        iprot.skip(ftype)
11658 
      iprot.readFieldEnd()
11659 
    iprot.readStructEnd()
11660 
 
11661 
  def write(self, oprot):
11662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11664 
      return
3064 chandransh 11665 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 11666 
    if self.success is not None:
11667 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11668 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11669 
      for iter189 in self.success:
11670 
        iter189.write(oprot)
11671 
      oprot.writeListEnd()
11672 
      oprot.writeFieldEnd()
3431 rajveer 11673 
    if self.ex is not None:
3064 chandransh 11674 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11675 
      self.ex.write(oprot)
1627 ankur.sing 11676 
      oprot.writeFieldEnd()
11677 
    oprot.writeFieldStop()
11678 
    oprot.writeStructEnd()
11679 
 
3431 rajveer 11680 
  def validate(self):
11681 
    return
11682 
 
11683 
 
1627 ankur.sing 11684 
  def __repr__(self):
11685 
    L = ['%s=%r' % (key, value)
11686 
      for key, value in self.__dict__.iteritems()]
11687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11688 
 
11689 
  def __eq__(self, other):
11690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11691 
 
11692 
  def __ne__(self, other):
11693 
    return not (self == other)
11694 
 
3064 chandransh 11695 
class getUndeliveredOrders_args:
1886 ankur.sing 11696 
  """
11697 
  Attributes:
3064 chandransh 11698 
   - providerId
11699 
   - warehouseId
1886 ankur.sing 11700 
  """
1627 ankur.sing 11701 
 
1886 ankur.sing 11702 
  thrift_spec = (
11703 
    None, # 0
3064 chandransh 11704 
    (1, TType.I64, 'providerId', None, None, ), # 1
11705 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 11706 
  )
11707 
 
3064 chandransh 11708 
  def __init__(self, providerId=None, warehouseId=None,):
11709 
    self.providerId = providerId
11710 
    self.warehouseId = warehouseId
1886 ankur.sing 11711 
 
11712 
  def read(self, iprot):
11713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11715 
      return
11716 
    iprot.readStructBegin()
11717 
    while True:
11718 
      (fname, ftype, fid) = iprot.readFieldBegin()
11719 
      if ftype == TType.STOP:
11720 
        break
11721 
      if fid == 1:
11722 
        if ftype == TType.I64:
3064 chandransh 11723 
          self.providerId = iprot.readI64();
1886 ankur.sing 11724 
        else:
11725 
          iprot.skip(ftype)
3064 chandransh 11726 
      elif fid == 2:
11727 
        if ftype == TType.I64:
11728 
          self.warehouseId = iprot.readI64();
11729 
        else:
11730 
          iprot.skip(ftype)
1886 ankur.sing 11731 
      else:
11732 
        iprot.skip(ftype)
11733 
      iprot.readFieldEnd()
11734 
    iprot.readStructEnd()
11735 
 
11736 
  def write(self, oprot):
11737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11739 
      return
3064 chandransh 11740 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 11741 
    if self.providerId is not None:
3064 chandransh 11742 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11743 
      oprot.writeI64(self.providerId)
1886 ankur.sing 11744 
      oprot.writeFieldEnd()
3431 rajveer 11745 
    if self.warehouseId is not None:
3064 chandransh 11746 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11747 
      oprot.writeI64(self.warehouseId)
11748 
      oprot.writeFieldEnd()
1886 ankur.sing 11749 
    oprot.writeFieldStop()
11750 
    oprot.writeStructEnd()
11751 
 
3431 rajveer 11752 
  def validate(self):
11753 
    return
11754 
 
11755 
 
1886 ankur.sing 11756 
  def __repr__(self):
11757 
    L = ['%s=%r' % (key, value)
11758 
      for key, value in self.__dict__.iteritems()]
11759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11760 
 
11761 
  def __eq__(self, other):
11762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11763 
 
11764 
  def __ne__(self, other):
11765 
    return not (self == other)
11766 
 
3064 chandransh 11767 
class getUndeliveredOrders_result:
1886 ankur.sing 11768 
  """
11769 
  Attributes:
11770 
   - success
11771 
  """
11772 
 
11773 
  thrift_spec = (
11774 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11775 
  )
11776 
 
11777 
  def __init__(self, success=None,):
11778 
    self.success = success
11779 
 
11780 
  def read(self, iprot):
11781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11783 
      return
11784 
    iprot.readStructBegin()
11785 
    while True:
11786 
      (fname, ftype, fid) = iprot.readFieldBegin()
11787 
      if ftype == TType.STOP:
11788 
        break
11789 
      if fid == 0:
11790 
        if ftype == TType.LIST:
11791 
          self.success = []
4581 phani.kuma 11792 
          (_etype193, _size190) = iprot.readListBegin()
11793 
          for _i194 in xrange(_size190):
11794 
            _elem195 = Order()
11795 
            _elem195.read(iprot)
11796 
            self.success.append(_elem195)
1886 ankur.sing 11797 
          iprot.readListEnd()
11798 
        else:
11799 
          iprot.skip(ftype)
11800 
      else:
11801 
        iprot.skip(ftype)
11802 
      iprot.readFieldEnd()
11803 
    iprot.readStructEnd()
11804 
 
11805 
  def write(self, oprot):
11806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11808 
      return
3064 chandransh 11809 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 11810 
    if self.success is not None:
1886 ankur.sing 11811 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11812 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 11813 
      for iter196 in self.success:
11814 
        iter196.write(oprot)
1886 ankur.sing 11815 
      oprot.writeListEnd()
11816 
      oprot.writeFieldEnd()
11817 
    oprot.writeFieldStop()
11818 
    oprot.writeStructEnd()
11819 
 
3431 rajveer 11820 
  def validate(self):
11821 
    return
11822 
 
11823 
 
1886 ankur.sing 11824 
  def __repr__(self):
11825 
    L = ['%s=%r' % (key, value)
11826 
      for key, value in self.__dict__.iteritems()]
11827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11828 
 
11829 
  def __eq__(self, other):
11830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11831 
 
11832 
  def __ne__(self, other):
11833 
    return not (self == other)
11834 
 
2536 chandransh 11835 
class toggleDOAFlag_args:
11836 
  """
11837 
  Attributes:
11838 
   - orderId
11839 
  """
1886 ankur.sing 11840 
 
2536 chandransh 11841 
  thrift_spec = (
11842 
    None, # 0
11843 
    (1, TType.I64, 'orderId', None, None, ), # 1
11844 
  )
11845 
 
11846 
  def __init__(self, orderId=None,):
11847 
    self.orderId = orderId
11848 
 
11849 
  def read(self, iprot):
11850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11852 
      return
11853 
    iprot.readStructBegin()
11854 
    while True:
11855 
      (fname, ftype, fid) = iprot.readFieldBegin()
11856 
      if ftype == TType.STOP:
11857 
        break
11858 
      if fid == 1:
11859 
        if ftype == TType.I64:
11860 
          self.orderId = iprot.readI64();
11861 
        else:
11862 
          iprot.skip(ftype)
11863 
      else:
11864 
        iprot.skip(ftype)
11865 
      iprot.readFieldEnd()
11866 
    iprot.readStructEnd()
11867 
 
11868 
  def write(self, oprot):
11869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11871 
      return
11872 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 11873 
    if self.orderId is not None:
2536 chandransh 11874 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11875 
      oprot.writeI64(self.orderId)
11876 
      oprot.writeFieldEnd()
11877 
    oprot.writeFieldStop()
11878 
    oprot.writeStructEnd()
11879 
 
3431 rajveer 11880 
  def validate(self):
11881 
    return
11882 
 
11883 
 
2536 chandransh 11884 
  def __repr__(self):
11885 
    L = ['%s=%r' % (key, value)
11886 
      for key, value in self.__dict__.iteritems()]
11887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11888 
 
11889 
  def __eq__(self, other):
11890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11891 
 
11892 
  def __ne__(self, other):
11893 
    return not (self == other)
11894 
 
11895 
class toggleDOAFlag_result:
11896 
  """
11897 
  Attributes:
11898 
   - success
11899 
   - ex
11900 
  """
11901 
 
11902 
  thrift_spec = (
11903 
    (0, TType.BOOL, 'success', None, None, ), # 0
11904 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11905 
  )
11906 
 
11907 
  def __init__(self, success=None, ex=None,):
11908 
    self.success = success
11909 
    self.ex = ex
11910 
 
11911 
  def read(self, iprot):
11912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11914 
      return
11915 
    iprot.readStructBegin()
11916 
    while True:
11917 
      (fname, ftype, fid) = iprot.readFieldBegin()
11918 
      if ftype == TType.STOP:
11919 
        break
11920 
      if fid == 0:
11921 
        if ftype == TType.BOOL:
11922 
          self.success = iprot.readBool();
11923 
        else:
11924 
          iprot.skip(ftype)
11925 
      elif fid == 1:
11926 
        if ftype == TType.STRUCT:
11927 
          self.ex = TransactionServiceException()
11928 
          self.ex.read(iprot)
11929 
        else:
11930 
          iprot.skip(ftype)
11931 
      else:
11932 
        iprot.skip(ftype)
11933 
      iprot.readFieldEnd()
11934 
    iprot.readStructEnd()
11935 
 
11936 
  def write(self, oprot):
11937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11939 
      return
11940 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 11941 
    if self.success is not None:
2536 chandransh 11942 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11943 
      oprot.writeBool(self.success)
11944 
      oprot.writeFieldEnd()
3431 rajveer 11945 
    if self.ex is not None:
2536 chandransh 11946 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11947 
      self.ex.write(oprot)
11948 
      oprot.writeFieldEnd()
11949 
    oprot.writeFieldStop()
11950 
    oprot.writeStructEnd()
11951 
 
3431 rajveer 11952 
  def validate(self):
11953 
    return
11954 
 
11955 
 
2536 chandransh 11956 
  def __repr__(self):
11957 
    L = ['%s=%r' % (key, value)
11958 
      for key, value in self.__dict__.iteritems()]
11959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11960 
 
11961 
  def __eq__(self, other):
11962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11963 
 
11964 
  def __ne__(self, other):
11965 
    return not (self == other)
11966 
 
4712 rajveer 11967 
class markOrderAsDelivered_args:
11968 
  """
11969 
  Attributes:
11970 
   - orderId
11971 
   - deliveryTimestamp
11972 
   - receiver
11973 
  """
11974 
 
11975 
  thrift_spec = None
11976 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
11977 
    self.orderId = orderId
11978 
    self.deliveryTimestamp = deliveryTimestamp
11979 
    self.receiver = receiver
11980 
 
11981 
  def read(self, iprot):
11982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11984 
      return
11985 
    iprot.readStructBegin()
11986 
    while True:
11987 
      (fname, ftype, fid) = iprot.readFieldBegin()
11988 
      if ftype == TType.STOP:
11989 
        break
11990 
      if fid == 1:
11991 
        if ftype == TType.I64:
11992 
          self.orderId = iprot.readI64();
11993 
        else:
11994 
          iprot.skip(ftype)
11995 
      elif fid == 2:
11996 
        if ftype == TType.I64:
11997 
          self.deliveryTimestamp = iprot.readI64();
11998 
        else:
11999 
          iprot.skip(ftype)
12000 
      elif fid == -1:
12001 
        if ftype == TType.STRING:
12002 
          self.receiver = iprot.readString();
12003 
        else:
12004 
          iprot.skip(ftype)
12005 
      else:
12006 
        iprot.skip(ftype)
12007 
      iprot.readFieldEnd()
12008 
    iprot.readStructEnd()
12009 
 
12010 
  def write(self, oprot):
12011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12013 
      return
12014 
    oprot.writeStructBegin('markOrderAsDelivered_args')
12015 
    if self.receiver is not None:
12016 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
12017 
      oprot.writeString(self.receiver)
12018 
      oprot.writeFieldEnd()
12019 
    if self.orderId is not None:
12020 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12021 
      oprot.writeI64(self.orderId)
12022 
      oprot.writeFieldEnd()
12023 
    if self.deliveryTimestamp is not None:
12024 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
12025 
      oprot.writeI64(self.deliveryTimestamp)
12026 
      oprot.writeFieldEnd()
12027 
    oprot.writeFieldStop()
12028 
    oprot.writeStructEnd()
12029 
 
12030 
  def validate(self):
12031 
    return
12032 
 
12033 
 
12034 
  def __repr__(self):
12035 
    L = ['%s=%r' % (key, value)
12036 
      for key, value in self.__dict__.iteritems()]
12037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12038 
 
12039 
  def __eq__(self, other):
12040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12041 
 
12042 
  def __ne__(self, other):
12043 
    return not (self == other)
12044 
 
12045 
class markOrderAsDelivered_result:
12046 
  """
12047 
  Attributes:
12048 
   - ex
12049 
  """
12050 
 
12051 
  thrift_spec = (
12052 
    None, # 0
12053 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12054 
  )
12055 
 
12056 
  def __init__(self, ex=None,):
12057 
    self.ex = ex
12058 
 
12059 
  def read(self, iprot):
12060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12062 
      return
12063 
    iprot.readStructBegin()
12064 
    while True:
12065 
      (fname, ftype, fid) = iprot.readFieldBegin()
12066 
      if ftype == TType.STOP:
12067 
        break
12068 
      if fid == 1:
12069 
        if ftype == TType.STRUCT:
12070 
          self.ex = TransactionServiceException()
12071 
          self.ex.read(iprot)
12072 
        else:
12073 
          iprot.skip(ftype)
12074 
      else:
12075 
        iprot.skip(ftype)
12076 
      iprot.readFieldEnd()
12077 
    iprot.readStructEnd()
12078 
 
12079 
  def write(self, oprot):
12080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12082 
      return
12083 
    oprot.writeStructBegin('markOrderAsDelivered_result')
12084 
    if self.ex is not None:
12085 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12086 
      self.ex.write(oprot)
12087 
      oprot.writeFieldEnd()
12088 
    oprot.writeFieldStop()
12089 
    oprot.writeStructEnd()
12090 
 
12091 
  def validate(self):
12092 
    return
12093 
 
12094 
 
12095 
  def __repr__(self):
12096 
    L = ['%s=%r' % (key, value)
12097 
      for key, value in self.__dict__.iteritems()]
12098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12099 
 
12100 
  def __eq__(self, other):
12101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12102 
 
12103 
  def __ne__(self, other):
12104 
    return not (self == other)
12105 
 
4454 rajveer 12106 
class markOrderDoaRequestReceived_args:
12107 
  """
12108 
  Attributes:
12109 
   - orderId
12110 
  """
12111 
 
12112 
  thrift_spec = (
12113 
    None, # 0
12114 
    (1, TType.I64, 'orderId', None, None, ), # 1
12115 
  )
12116 
 
12117 
  def __init__(self, orderId=None,):
12118 
    self.orderId = orderId
12119 
 
12120 
  def read(self, iprot):
12121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12123 
      return
12124 
    iprot.readStructBegin()
12125 
    while True:
12126 
      (fname, ftype, fid) = iprot.readFieldBegin()
12127 
      if ftype == TType.STOP:
12128 
        break
12129 
      if fid == 1:
12130 
        if ftype == TType.I64:
12131 
          self.orderId = iprot.readI64();
12132 
        else:
12133 
          iprot.skip(ftype)
12134 
      else:
12135 
        iprot.skip(ftype)
12136 
      iprot.readFieldEnd()
12137 
    iprot.readStructEnd()
12138 
 
12139 
  def write(self, oprot):
12140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12142 
      return
12143 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
12144 
    if self.orderId is not None:
12145 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12146 
      oprot.writeI64(self.orderId)
12147 
      oprot.writeFieldEnd()
12148 
    oprot.writeFieldStop()
12149 
    oprot.writeStructEnd()
12150 
 
12151 
  def validate(self):
12152 
    return
12153 
 
12154 
 
12155 
  def __repr__(self):
12156 
    L = ['%s=%r' % (key, value)
12157 
      for key, value in self.__dict__.iteritems()]
12158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12159 
 
12160 
  def __eq__(self, other):
12161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12162 
 
12163 
  def __ne__(self, other):
12164 
    return not (self == other)
12165 
 
12166 
class markOrderDoaRequestReceived_result:
12167 
  """
12168 
  Attributes:
12169 
   - success
12170 
   - ex
12171 
  """
12172 
 
12173 
  thrift_spec = (
12174 
    (0, TType.BOOL, 'success', None, None, ), # 0
12175 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12176 
  )
12177 
 
12178 
  def __init__(self, success=None, ex=None,):
12179 
    self.success = success
12180 
    self.ex = ex
12181 
 
12182 
  def read(self, iprot):
12183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12185 
      return
12186 
    iprot.readStructBegin()
12187 
    while True:
12188 
      (fname, ftype, fid) = iprot.readFieldBegin()
12189 
      if ftype == TType.STOP:
12190 
        break
12191 
      if fid == 0:
12192 
        if ftype == TType.BOOL:
12193 
          self.success = iprot.readBool();
12194 
        else:
12195 
          iprot.skip(ftype)
12196 
      elif fid == 1:
12197 
        if ftype == TType.STRUCT:
12198 
          self.ex = TransactionServiceException()
12199 
          self.ex.read(iprot)
12200 
        else:
12201 
          iprot.skip(ftype)
12202 
      else:
12203 
        iprot.skip(ftype)
12204 
      iprot.readFieldEnd()
12205 
    iprot.readStructEnd()
12206 
 
12207 
  def write(self, oprot):
12208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12210 
      return
12211 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
12212 
    if self.success is not None:
12213 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12214 
      oprot.writeBool(self.success)
12215 
      oprot.writeFieldEnd()
12216 
    if self.ex is not None:
12217 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12218 
      self.ex.write(oprot)
12219 
      oprot.writeFieldEnd()
12220 
    oprot.writeFieldStop()
12221 
    oprot.writeStructEnd()
12222 
 
12223 
  def validate(self):
12224 
    return
12225 
 
12226 
 
12227 
  def __repr__(self):
12228 
    L = ['%s=%r' % (key, value)
12229 
      for key, value in self.__dict__.iteritems()]
12230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12231 
 
12232 
  def __eq__(self, other):
12233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12234 
 
12235 
  def __ne__(self, other):
12236 
    return not (self == other)
12237 
 
12238 
class markOrderDoaRequestAuthorized_args:
12239 
  """
12240 
  Attributes:
12241 
   - orderId
12242 
   - isAuthorized
12243 
  """
12244 
 
12245 
  thrift_spec = (
12246 
    None, # 0
12247 
    (1, TType.I64, 'orderId', None, None, ), # 1
12248 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12249 
  )
12250 
 
12251 
  def __init__(self, orderId=None, isAuthorized=None,):
12252 
    self.orderId = orderId
12253 
    self.isAuthorized = isAuthorized
12254 
 
12255 
  def read(self, iprot):
12256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12258 
      return
12259 
    iprot.readStructBegin()
12260 
    while True:
12261 
      (fname, ftype, fid) = iprot.readFieldBegin()
12262 
      if ftype == TType.STOP:
12263 
        break
12264 
      if fid == 1:
12265 
        if ftype == TType.I64:
12266 
          self.orderId = iprot.readI64();
12267 
        else:
12268 
          iprot.skip(ftype)
12269 
      elif fid == 2:
12270 
        if ftype == TType.BOOL:
12271 
          self.isAuthorized = iprot.readBool();
12272 
        else:
12273 
          iprot.skip(ftype)
12274 
      else:
12275 
        iprot.skip(ftype)
12276 
      iprot.readFieldEnd()
12277 
    iprot.readStructEnd()
12278 
 
12279 
  def write(self, oprot):
12280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12282 
      return
12283 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
12284 
    if self.orderId is not None:
12285 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12286 
      oprot.writeI64(self.orderId)
12287 
      oprot.writeFieldEnd()
12288 
    if self.isAuthorized is not None:
12289 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12290 
      oprot.writeBool(self.isAuthorized)
12291 
      oprot.writeFieldEnd()
12292 
    oprot.writeFieldStop()
12293 
    oprot.writeStructEnd()
12294 
 
12295 
  def validate(self):
12296 
    return
12297 
 
12298 
 
12299 
  def __repr__(self):
12300 
    L = ['%s=%r' % (key, value)
12301 
      for key, value in self.__dict__.iteritems()]
12302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12303 
 
12304 
  def __eq__(self, other):
12305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12306 
 
12307 
  def __ne__(self, other):
12308 
    return not (self == other)
12309 
 
12310 
class markOrderDoaRequestAuthorized_result:
12311 
  """
12312 
  Attributes:
12313 
   - success
12314 
   - ex
12315 
  """
12316 
 
12317 
  thrift_spec = (
12318 
    (0, TType.BOOL, 'success', None, None, ), # 0
12319 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12320 
  )
12321 
 
12322 
  def __init__(self, success=None, ex=None,):
12323 
    self.success = success
12324 
    self.ex = ex
12325 
 
12326 
  def read(self, iprot):
12327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12329 
      return
12330 
    iprot.readStructBegin()
12331 
    while True:
12332 
      (fname, ftype, fid) = iprot.readFieldBegin()
12333 
      if ftype == TType.STOP:
12334 
        break
12335 
      if fid == 0:
12336 
        if ftype == TType.BOOL:
12337 
          self.success = iprot.readBool();
12338 
        else:
12339 
          iprot.skip(ftype)
12340 
      elif fid == 1:
12341 
        if ftype == TType.STRUCT:
12342 
          self.ex = TransactionServiceException()
12343 
          self.ex.read(iprot)
12344 
        else:
12345 
          iprot.skip(ftype)
12346 
      else:
12347 
        iprot.skip(ftype)
12348 
      iprot.readFieldEnd()
12349 
    iprot.readStructEnd()
12350 
 
12351 
  def write(self, oprot):
12352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12354 
      return
12355 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
12356 
    if self.success is not None:
12357 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12358 
      oprot.writeBool(self.success)
12359 
      oprot.writeFieldEnd()
12360 
    if self.ex is not None:
12361 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12362 
      self.ex.write(oprot)
12363 
      oprot.writeFieldEnd()
12364 
    oprot.writeFieldStop()
12365 
    oprot.writeStructEnd()
12366 
 
12367 
  def validate(self):
12368 
    return
12369 
 
12370 
 
12371 
  def __repr__(self):
12372 
    L = ['%s=%r' % (key, value)
12373 
      for key, value in self.__dict__.iteritems()]
12374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12375 
 
12376 
  def __eq__(self, other):
12377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12378 
 
12379 
  def __ne__(self, other):
12380 
    return not (self == other)
12381 
 
4488 rajveer 12382 
class markOrderReturnRequestReceived_args:
12383 
  """
12384 
  Attributes:
12385 
   - orderId
12386 
  """
12387 
 
12388 
  thrift_spec = (
12389 
    None, # 0
12390 
    (1, TType.I64, 'orderId', None, None, ), # 1
12391 
  )
12392 
 
12393 
  def __init__(self, orderId=None,):
12394 
    self.orderId = orderId
12395 
 
12396 
  def read(self, iprot):
12397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12399 
      return
12400 
    iprot.readStructBegin()
12401 
    while True:
12402 
      (fname, ftype, fid) = iprot.readFieldBegin()
12403 
      if ftype == TType.STOP:
12404 
        break
12405 
      if fid == 1:
12406 
        if ftype == TType.I64:
12407 
          self.orderId = iprot.readI64();
12408 
        else:
12409 
          iprot.skip(ftype)
12410 
      else:
12411 
        iprot.skip(ftype)
12412 
      iprot.readFieldEnd()
12413 
    iprot.readStructEnd()
12414 
 
12415 
  def write(self, oprot):
12416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12418 
      return
12419 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
12420 
    if self.orderId is not None:
12421 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12422 
      oprot.writeI64(self.orderId)
12423 
      oprot.writeFieldEnd()
12424 
    oprot.writeFieldStop()
12425 
    oprot.writeStructEnd()
12426 
 
12427 
  def validate(self):
12428 
    return
12429 
 
12430 
 
12431 
  def __repr__(self):
12432 
    L = ['%s=%r' % (key, value)
12433 
      for key, value in self.__dict__.iteritems()]
12434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12435 
 
12436 
  def __eq__(self, other):
12437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12438 
 
12439 
  def __ne__(self, other):
12440 
    return not (self == other)
12441 
 
12442 
class markOrderReturnRequestReceived_result:
12443 
  """
12444 
  Attributes:
12445 
   - success
12446 
   - ex
12447 
  """
12448 
 
12449 
  thrift_spec = (
12450 
    (0, TType.BOOL, 'success', None, None, ), # 0
12451 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12452 
  )
12453 
 
12454 
  def __init__(self, success=None, ex=None,):
12455 
    self.success = success
12456 
    self.ex = ex
12457 
 
12458 
  def read(self, iprot):
12459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12461 
      return
12462 
    iprot.readStructBegin()
12463 
    while True:
12464 
      (fname, ftype, fid) = iprot.readFieldBegin()
12465 
      if ftype == TType.STOP:
12466 
        break
12467 
      if fid == 0:
12468 
        if ftype == TType.BOOL:
12469 
          self.success = iprot.readBool();
12470 
        else:
12471 
          iprot.skip(ftype)
12472 
      elif fid == 1:
12473 
        if ftype == TType.STRUCT:
12474 
          self.ex = TransactionServiceException()
12475 
          self.ex.read(iprot)
12476 
        else:
12477 
          iprot.skip(ftype)
12478 
      else:
12479 
        iprot.skip(ftype)
12480 
      iprot.readFieldEnd()
12481 
    iprot.readStructEnd()
12482 
 
12483 
  def write(self, oprot):
12484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12486 
      return
12487 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
12488 
    if self.success is not None:
12489 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12490 
      oprot.writeBool(self.success)
12491 
      oprot.writeFieldEnd()
12492 
    if self.ex is not None:
12493 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12494 
      self.ex.write(oprot)
12495 
      oprot.writeFieldEnd()
12496 
    oprot.writeFieldStop()
12497 
    oprot.writeStructEnd()
12498 
 
12499 
  def validate(self):
12500 
    return
12501 
 
12502 
 
12503 
  def __repr__(self):
12504 
    L = ['%s=%r' % (key, value)
12505 
      for key, value in self.__dict__.iteritems()]
12506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12507 
 
12508 
  def __eq__(self, other):
12509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12510 
 
12511 
  def __ne__(self, other):
12512 
    return not (self == other)
12513 
 
12514 
class markOrderReturnRequestAuthorized_args:
12515 
  """
12516 
  Attributes:
12517 
   - orderId
12518 
   - isAuthorized
12519 
  """
12520 
 
12521 
  thrift_spec = (
12522 
    None, # 0
12523 
    (1, TType.I64, 'orderId', None, None, ), # 1
12524 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12525 
  )
12526 
 
12527 
  def __init__(self, orderId=None, isAuthorized=None,):
12528 
    self.orderId = orderId
12529 
    self.isAuthorized = isAuthorized
12530 
 
12531 
  def read(self, iprot):
12532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12534 
      return
12535 
    iprot.readStructBegin()
12536 
    while True:
12537 
      (fname, ftype, fid) = iprot.readFieldBegin()
12538 
      if ftype == TType.STOP:
12539 
        break
12540 
      if fid == 1:
12541 
        if ftype == TType.I64:
12542 
          self.orderId = iprot.readI64();
12543 
        else:
12544 
          iprot.skip(ftype)
12545 
      elif fid == 2:
12546 
        if ftype == TType.BOOL:
12547 
          self.isAuthorized = iprot.readBool();
12548 
        else:
12549 
          iprot.skip(ftype)
12550 
      else:
12551 
        iprot.skip(ftype)
12552 
      iprot.readFieldEnd()
12553 
    iprot.readStructEnd()
12554 
 
12555 
  def write(self, oprot):
12556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12558 
      return
12559 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
12560 
    if self.orderId is not None:
12561 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12562 
      oprot.writeI64(self.orderId)
12563 
      oprot.writeFieldEnd()
12564 
    if self.isAuthorized is not None:
12565 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12566 
      oprot.writeBool(self.isAuthorized)
12567 
      oprot.writeFieldEnd()
12568 
    oprot.writeFieldStop()
12569 
    oprot.writeStructEnd()
12570 
 
12571 
  def validate(self):
12572 
    return
12573 
 
12574 
 
12575 
  def __repr__(self):
12576 
    L = ['%s=%r' % (key, value)
12577 
      for key, value in self.__dict__.iteritems()]
12578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12579 
 
12580 
  def __eq__(self, other):
12581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12582 
 
12583 
  def __ne__(self, other):
12584 
    return not (self == other)
12585 
 
12586 
class markOrderReturnRequestAuthorized_result:
12587 
  """
12588 
  Attributes:
12589 
   - success
12590 
   - ex
12591 
  """
12592 
 
12593 
  thrift_spec = (
12594 
    (0, TType.BOOL, 'success', None, None, ), # 0
12595 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12596 
  )
12597 
 
12598 
  def __init__(self, success=None, ex=None,):
12599 
    self.success = success
12600 
    self.ex = ex
12601 
 
12602 
  def read(self, iprot):
12603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12605 
      return
12606 
    iprot.readStructBegin()
12607 
    while True:
12608 
      (fname, ftype, fid) = iprot.readFieldBegin()
12609 
      if ftype == TType.STOP:
12610 
        break
12611 
      if fid == 0:
12612 
        if ftype == TType.BOOL:
12613 
          self.success = iprot.readBool();
12614 
        else:
12615 
          iprot.skip(ftype)
12616 
      elif fid == 1:
12617 
        if ftype == TType.STRUCT:
12618 
          self.ex = TransactionServiceException()
12619 
          self.ex.read(iprot)
12620 
        else:
12621 
          iprot.skip(ftype)
12622 
      else:
12623 
        iprot.skip(ftype)
12624 
      iprot.readFieldEnd()
12625 
    iprot.readStructEnd()
12626 
 
12627 
  def write(self, oprot):
12628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12630 
      return
12631 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
12632 
    if self.success is not None:
12633 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12634 
      oprot.writeBool(self.success)
12635 
      oprot.writeFieldEnd()
12636 
    if self.ex is not None:
12637 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12638 
      self.ex.write(oprot)
12639 
      oprot.writeFieldEnd()
12640 
    oprot.writeFieldStop()
12641 
    oprot.writeStructEnd()
12642 
 
12643 
  def validate(self):
12644 
    return
12645 
 
12646 
 
12647 
  def __repr__(self):
12648 
    L = ['%s=%r' % (key, value)
12649 
      for key, value in self.__dict__.iteritems()]
12650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12651 
 
12652 
  def __eq__(self, other):
12653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12654 
 
12655 
  def __ne__(self, other):
12656 
    return not (self == other)
12657 
 
2536 chandransh 12658 
class requestPickupNumber_args:
12659 
  """
12660 
  Attributes:
12661 
   - orderId
4579 rajveer 12662 
   - providerId
2536 chandransh 12663 
  """
12664 
 
12665 
  thrift_spec = (
12666 
    None, # 0
12667 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 12668 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 12669 
  )
12670 
 
4579 rajveer 12671 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 12672 
    self.orderId = orderId
4579 rajveer 12673 
    self.providerId = providerId
2536 chandransh 12674 
 
12675 
  def read(self, iprot):
12676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12678 
      return
12679 
    iprot.readStructBegin()
12680 
    while True:
12681 
      (fname, ftype, fid) = iprot.readFieldBegin()
12682 
      if ftype == TType.STOP:
12683 
        break
12684 
      if fid == 1:
12685 
        if ftype == TType.I64:
12686 
          self.orderId = iprot.readI64();
12687 
        else:
12688 
          iprot.skip(ftype)
4579 rajveer 12689 
      elif fid == 2:
12690 
        if ftype == TType.I64:
12691 
          self.providerId = iprot.readI64();
12692 
        else:
12693 
          iprot.skip(ftype)
2536 chandransh 12694 
      else:
12695 
        iprot.skip(ftype)
12696 
      iprot.readFieldEnd()
12697 
    iprot.readStructEnd()
12698 
 
12699 
  def write(self, oprot):
12700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12702 
      return
12703 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 12704 
    if self.orderId is not None:
2536 chandransh 12705 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12706 
      oprot.writeI64(self.orderId)
12707 
      oprot.writeFieldEnd()
4579 rajveer 12708 
    if self.providerId is not None:
12709 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
12710 
      oprot.writeI64(self.providerId)
12711 
      oprot.writeFieldEnd()
2536 chandransh 12712 
    oprot.writeFieldStop()
12713 
    oprot.writeStructEnd()
12714 
 
3431 rajveer 12715 
  def validate(self):
12716 
    return
12717 
 
12718 
 
2536 chandransh 12719 
  def __repr__(self):
12720 
    L = ['%s=%r' % (key, value)
12721 
      for key, value in self.__dict__.iteritems()]
12722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12723 
 
12724 
  def __eq__(self, other):
12725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12726 
 
12727 
  def __ne__(self, other):
12728 
    return not (self == other)
12729 
 
12730 
class requestPickupNumber_result:
12731 
  """
12732 
  Attributes:
12733 
   - success
12734 
   - ex
12735 
  """
12736 
 
12737 
  thrift_spec = (
12738 
    (0, TType.BOOL, 'success', None, None, ), # 0
12739 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12740 
  )
12741 
 
12742 
  def __init__(self, success=None, ex=None,):
12743 
    self.success = success
12744 
    self.ex = ex
12745 
 
12746 
  def read(self, iprot):
12747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12749 
      return
12750 
    iprot.readStructBegin()
12751 
    while True:
12752 
      (fname, ftype, fid) = iprot.readFieldBegin()
12753 
      if ftype == TType.STOP:
12754 
        break
12755 
      if fid == 0:
12756 
        if ftype == TType.BOOL:
12757 
          self.success = iprot.readBool();
12758 
        else:
12759 
          iprot.skip(ftype)
12760 
      elif fid == 1:
12761 
        if ftype == TType.STRUCT:
12762 
          self.ex = TransactionServiceException()
12763 
          self.ex.read(iprot)
12764 
        else:
12765 
          iprot.skip(ftype)
12766 
      else:
12767 
        iprot.skip(ftype)
12768 
      iprot.readFieldEnd()
12769 
    iprot.readStructEnd()
12770 
 
12771 
  def write(self, oprot):
12772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12774 
      return
12775 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 12776 
    if self.success is not None:
2536 chandransh 12777 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12778 
      oprot.writeBool(self.success)
12779 
      oprot.writeFieldEnd()
3431 rajveer 12780 
    if self.ex is not None:
2536 chandransh 12781 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12782 
      self.ex.write(oprot)
12783 
      oprot.writeFieldEnd()
12784 
    oprot.writeFieldStop()
12785 
    oprot.writeStructEnd()
12786 
 
3431 rajveer 12787 
  def validate(self):
12788 
    return
12789 
 
12790 
 
2536 chandransh 12791 
  def __repr__(self):
12792 
    L = ['%s=%r' % (key, value)
12793 
      for key, value in self.__dict__.iteritems()]
12794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12795 
 
12796 
  def __eq__(self, other):
12797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12798 
 
12799 
  def __ne__(self, other):
12800 
    return not (self == other)
12801 
 
12802 
class authorizePickup_args:
12803 
  """
12804 
  Attributes:
12805 
   - orderId
12806 
   - pickupNumber
4602 rajveer 12807 
   - providerId
2536 chandransh 12808 
  """
12809 
 
12810 
  thrift_spec = (
12811 
    None, # 0
12812 
    (1, TType.I64, 'orderId', None, None, ), # 1
12813 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 12814 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 12815 
  )
12816 
 
4602 rajveer 12817 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 12818 
    self.orderId = orderId
12819 
    self.pickupNumber = pickupNumber
4602 rajveer 12820 
    self.providerId = providerId
2536 chandransh 12821 
 
12822 
  def read(self, iprot):
12823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12825 
      return
12826 
    iprot.readStructBegin()
12827 
    while True:
12828 
      (fname, ftype, fid) = iprot.readFieldBegin()
12829 
      if ftype == TType.STOP:
12830 
        break
12831 
      if fid == 1:
12832 
        if ftype == TType.I64:
12833 
          self.orderId = iprot.readI64();
12834 
        else:
12835 
          iprot.skip(ftype)
12836 
      elif fid == 2:
12837 
        if ftype == TType.STRING:
12838 
          self.pickupNumber = iprot.readString();
12839 
        else:
12840 
          iprot.skip(ftype)
4602 rajveer 12841 
      elif fid == 3:
12842 
        if ftype == TType.I64:
12843 
          self.providerId = iprot.readI64();
12844 
        else:
12845 
          iprot.skip(ftype)
2536 chandransh 12846 
      else:
12847 
        iprot.skip(ftype)
12848 
      iprot.readFieldEnd()
12849 
    iprot.readStructEnd()
12850 
 
12851 
  def write(self, oprot):
12852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12854 
      return
12855 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 12856 
    if self.orderId is not None:
2536 chandransh 12857 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12858 
      oprot.writeI64(self.orderId)
12859 
      oprot.writeFieldEnd()
3431 rajveer 12860 
    if self.pickupNumber is not None:
2536 chandransh 12861 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
12862 
      oprot.writeString(self.pickupNumber)
12863 
      oprot.writeFieldEnd()
4602 rajveer 12864 
    if self.providerId is not None:
12865 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
12866 
      oprot.writeI64(self.providerId)
12867 
      oprot.writeFieldEnd()
2536 chandransh 12868 
    oprot.writeFieldStop()
12869 
    oprot.writeStructEnd()
12870 
 
3431 rajveer 12871 
  def validate(self):
12872 
    return
12873 
 
12874 
 
2536 chandransh 12875 
  def __repr__(self):
12876 
    L = ['%s=%r' % (key, value)
12877 
      for key, value in self.__dict__.iteritems()]
12878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12879 
 
12880 
  def __eq__(self, other):
12881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12882 
 
12883 
  def __ne__(self, other):
12884 
    return not (self == other)
12885 
 
12886 
class authorizePickup_result:
12887 
  """
12888 
  Attributes:
12889 
   - success
12890 
   - ex
12891 
  """
12892 
 
12893 
  thrift_spec = (
12894 
    (0, TType.BOOL, 'success', None, None, ), # 0
12895 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12896 
  )
12897 
 
12898 
  def __init__(self, success=None, ex=None,):
12899 
    self.success = success
12900 
    self.ex = ex
12901 
 
12902 
  def read(self, iprot):
12903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12905 
      return
12906 
    iprot.readStructBegin()
12907 
    while True:
12908 
      (fname, ftype, fid) = iprot.readFieldBegin()
12909 
      if ftype == TType.STOP:
12910 
        break
12911 
      if fid == 0:
12912 
        if ftype == TType.BOOL:
12913 
          self.success = iprot.readBool();
12914 
        else:
12915 
          iprot.skip(ftype)
12916 
      elif fid == 1:
12917 
        if ftype == TType.STRUCT:
12918 
          self.ex = TransactionServiceException()
12919 
          self.ex.read(iprot)
12920 
        else:
12921 
          iprot.skip(ftype)
12922 
      else:
12923 
        iprot.skip(ftype)
12924 
      iprot.readFieldEnd()
12925 
    iprot.readStructEnd()
12926 
 
12927 
  def write(self, oprot):
12928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12930 
      return
12931 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 12932 
    if self.success is not None:
2536 chandransh 12933 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12934 
      oprot.writeBool(self.success)
12935 
      oprot.writeFieldEnd()
3431 rajveer 12936 
    if self.ex is not None:
2536 chandransh 12937 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12938 
      self.ex.write(oprot)
12939 
      oprot.writeFieldEnd()
12940 
    oprot.writeFieldStop()
12941 
    oprot.writeStructEnd()
12942 
 
3431 rajveer 12943 
  def validate(self):
12944 
    return
12945 
 
12946 
 
2536 chandransh 12947 
  def __repr__(self):
12948 
    L = ['%s=%r' % (key, value)
12949 
      for key, value in self.__dict__.iteritems()]
12950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12951 
 
12952 
  def __eq__(self, other):
12953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12954 
 
12955 
  def __ne__(self, other):
12956 
    return not (self == other)
12957 
 
2764 chandransh 12958 
class markDoasAsPickedUp_args:
12959 
  """
12960 
  Attributes:
12961 
   - providerId
12962 
   - pickupDetails
12963 
  """
12964 
 
12965 
  thrift_spec = (
12966 
    None, # 0
12967 
    (1, TType.I64, 'providerId', None, None, ), # 1
12968 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
12969 
  )
12970 
 
12971 
  def __init__(self, providerId=None, pickupDetails=None,):
12972 
    self.providerId = providerId
12973 
    self.pickupDetails = pickupDetails
12974 
 
12975 
  def read(self, iprot):
12976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12978 
      return
12979 
    iprot.readStructBegin()
12980 
    while True:
12981 
      (fname, ftype, fid) = iprot.readFieldBegin()
12982 
      if ftype == TType.STOP:
12983 
        break
12984 
      if fid == 1:
12985 
        if ftype == TType.I64:
12986 
          self.providerId = iprot.readI64();
12987 
        else:
12988 
          iprot.skip(ftype)
12989 
      elif fid == 2:
12990 
        if ftype == TType.MAP:
12991 
          self.pickupDetails = {}
4581 phani.kuma 12992 
          (_ktype198, _vtype199, _size197 ) = iprot.readMapBegin()
12993 
          for _i201 in xrange(_size197):
12994 
            _key202 = iprot.readString();
12995 
            _val203 = iprot.readString();
12996 
            self.pickupDetails[_key202] = _val203
2764 chandransh 12997 
          iprot.readMapEnd()
12998 
        else:
12999 
          iprot.skip(ftype)
13000 
      else:
13001 
        iprot.skip(ftype)
13002 
      iprot.readFieldEnd()
13003 
    iprot.readStructEnd()
13004 
 
13005 
  def write(self, oprot):
13006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13008 
      return
13009 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 13010 
    if self.providerId is not None:
2764 chandransh 13011 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13012 
      oprot.writeI64(self.providerId)
13013 
      oprot.writeFieldEnd()
3431 rajveer 13014 
    if self.pickupDetails is not None:
2764 chandransh 13015 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13016 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4581 phani.kuma 13017 
      for kiter204,viter205 in self.pickupDetails.items():
13018 
        oprot.writeString(kiter204)
13019 
        oprot.writeString(viter205)
2764 chandransh 13020 
      oprot.writeMapEnd()
13021 
      oprot.writeFieldEnd()
13022 
    oprot.writeFieldStop()
13023 
    oprot.writeStructEnd()
13024 
 
3431 rajveer 13025 
  def validate(self):
13026 
    return
13027 
 
13028 
 
2764 chandransh 13029 
  def __repr__(self):
13030 
    L = ['%s=%r' % (key, value)
13031 
      for key, value in self.__dict__.iteritems()]
13032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13033 
 
13034 
  def __eq__(self, other):
13035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13036 
 
13037 
  def __ne__(self, other):
13038 
    return not (self == other)
13039 
 
13040 
class markDoasAsPickedUp_result:
13041 
  """
13042 
  Attributes:
13043 
   - success
13044 
  """
13045 
 
13046 
  thrift_spec = (
13047 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13048 
  )
13049 
 
13050 
  def __init__(self, success=None,):
13051 
    self.success = success
13052 
 
13053 
  def read(self, iprot):
13054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13056 
      return
13057 
    iprot.readStructBegin()
13058 
    while True:
13059 
      (fname, ftype, fid) = iprot.readFieldBegin()
13060 
      if ftype == TType.STOP:
13061 
        break
13062 
      if fid == 0:
13063 
        if ftype == TType.LIST:
13064 
          self.success = []
4581 phani.kuma 13065 
          (_etype209, _size206) = iprot.readListBegin()
13066 
          for _i210 in xrange(_size206):
13067 
            _elem211 = Order()
13068 
            _elem211.read(iprot)
13069 
            self.success.append(_elem211)
2764 chandransh 13070 
          iprot.readListEnd()
13071 
        else:
13072 
          iprot.skip(ftype)
13073 
      else:
13074 
        iprot.skip(ftype)
13075 
      iprot.readFieldEnd()
13076 
    iprot.readStructEnd()
13077 
 
13078 
  def write(self, oprot):
13079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13081 
      return
13082 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 13083 
    if self.success is not None:
2764 chandransh 13084 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13085 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 13086 
      for iter212 in self.success:
13087 
        iter212.write(oprot)
2764 chandransh 13088 
      oprot.writeListEnd()
13089 
      oprot.writeFieldEnd()
13090 
    oprot.writeFieldStop()
13091 
    oprot.writeStructEnd()
13092 
 
3431 rajveer 13093 
  def validate(self):
13094 
    return
13095 
 
13096 
 
2764 chandransh 13097 
  def __repr__(self):
13098 
    L = ['%s=%r' % (key, value)
13099 
      for key, value in self.__dict__.iteritems()]
13100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13101 
 
13102 
  def __eq__(self, other):
13103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13104 
 
13105 
  def __ne__(self, other):
13106 
    return not (self == other)
13107 
 
4741 phani.kuma 13108 
class markReturnOrdersAsPickedUp_args:
13109 
  """
13110 
  Attributes:
13111 
   - providerId
13112 
   - pickupDetails
13113 
  """
13114 
 
13115 
  thrift_spec = (
13116 
    None, # 0
13117 
    (1, TType.I64, 'providerId', None, None, ), # 1
13118 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
13119 
  )
13120 
 
13121 
  def __init__(self, providerId=None, pickupDetails=None,):
13122 
    self.providerId = providerId
13123 
    self.pickupDetails = pickupDetails
13124 
 
13125 
  def read(self, iprot):
13126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13128 
      return
13129 
    iprot.readStructBegin()
13130 
    while True:
13131 
      (fname, ftype, fid) = iprot.readFieldBegin()
13132 
      if ftype == TType.STOP:
13133 
        break
13134 
      if fid == 1:
13135 
        if ftype == TType.I64:
13136 
          self.providerId = iprot.readI64();
13137 
        else:
13138 
          iprot.skip(ftype)
13139 
      elif fid == 2:
13140 
        if ftype == TType.MAP:
13141 
          self.pickupDetails = {}
13142 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
13143 
          for _i217 in xrange(_size213):
13144 
            _key218 = iprot.readString();
13145 
            _val219 = iprot.readString();
13146 
            self.pickupDetails[_key218] = _val219
13147 
          iprot.readMapEnd()
13148 
        else:
13149 
          iprot.skip(ftype)
13150 
      else:
13151 
        iprot.skip(ftype)
13152 
      iprot.readFieldEnd()
13153 
    iprot.readStructEnd()
13154 
 
13155 
  def write(self, oprot):
13156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13158 
      return
13159 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
13160 
    if self.providerId is not None:
13161 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13162 
      oprot.writeI64(self.providerId)
13163 
      oprot.writeFieldEnd()
13164 
    if self.pickupDetails is not None:
13165 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13166 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
13167 
      for kiter220,viter221 in self.pickupDetails.items():
13168 
        oprot.writeString(kiter220)
13169 
        oprot.writeString(viter221)
13170 
      oprot.writeMapEnd()
13171 
      oprot.writeFieldEnd()
13172 
    oprot.writeFieldStop()
13173 
    oprot.writeStructEnd()
13174 
 
13175 
  def validate(self):
13176 
    return
13177 
 
13178 
 
13179 
  def __repr__(self):
13180 
    L = ['%s=%r' % (key, value)
13181 
      for key, value in self.__dict__.iteritems()]
13182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13183 
 
13184 
  def __eq__(self, other):
13185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13186 
 
13187 
  def __ne__(self, other):
13188 
    return not (self == other)
13189 
 
13190 
class markReturnOrdersAsPickedUp_result:
13191 
  """
13192 
  Attributes:
13193 
   - success
13194 
  """
13195 
 
13196 
  thrift_spec = (
13197 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13198 
  )
13199 
 
13200 
  def __init__(self, success=None,):
13201 
    self.success = success
13202 
 
13203 
  def read(self, iprot):
13204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13206 
      return
13207 
    iprot.readStructBegin()
13208 
    while True:
13209 
      (fname, ftype, fid) = iprot.readFieldBegin()
13210 
      if ftype == TType.STOP:
13211 
        break
13212 
      if fid == 0:
13213 
        if ftype == TType.LIST:
13214 
          self.success = []
13215 
          (_etype225, _size222) = iprot.readListBegin()
13216 
          for _i226 in xrange(_size222):
13217 
            _elem227 = Order()
13218 
            _elem227.read(iprot)
13219 
            self.success.append(_elem227)
13220 
          iprot.readListEnd()
13221 
        else:
13222 
          iprot.skip(ftype)
13223 
      else:
13224 
        iprot.skip(ftype)
13225 
      iprot.readFieldEnd()
13226 
    iprot.readStructEnd()
13227 
 
13228 
  def write(self, oprot):
13229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13231 
      return
13232 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
13233 
    if self.success is not None:
13234 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13235 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13236 
      for iter228 in self.success:
13237 
        iter228.write(oprot)
13238 
      oprot.writeListEnd()
13239 
      oprot.writeFieldEnd()
13240 
    oprot.writeFieldStop()
13241 
    oprot.writeStructEnd()
13242 
 
13243 
  def validate(self):
13244 
    return
13245 
 
13246 
 
13247 
  def __repr__(self):
13248 
    L = ['%s=%r' % (key, value)
13249 
      for key, value in self.__dict__.iteritems()]
13250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13251 
 
13252 
  def __eq__(self, other):
13253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13254 
 
13255 
  def __ne__(self, other):
13256 
    return not (self == other)
13257 
 
2616 chandransh 13258 
class receiveReturn_args:
2591 chandransh 13259 
  """
13260 
  Attributes:
13261 
   - orderId
4479 rajveer 13262 
   - receiveCondition
2591 chandransh 13263 
  """
2536 chandransh 13264 
 
2591 chandransh 13265 
  thrift_spec = (
13266 
    None, # 0
13267 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 13268 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 13269 
  )
13270 
 
4479 rajveer 13271 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 13272 
    self.orderId = orderId
4479 rajveer 13273 
    self.receiveCondition = receiveCondition
2591 chandransh 13274 
 
13275 
  def read(self, iprot):
13276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13278 
      return
13279 
    iprot.readStructBegin()
13280 
    while True:
13281 
      (fname, ftype, fid) = iprot.readFieldBegin()
13282 
      if ftype == TType.STOP:
13283 
        break
13284 
      if fid == 1:
13285 
        if ftype == TType.I64:
13286 
          self.orderId = iprot.readI64();
13287 
        else:
13288 
          iprot.skip(ftype)
4479 rajveer 13289 
      elif fid == 2:
13290 
        if ftype == TType.I64:
13291 
          self.receiveCondition = iprot.readI64();
13292 
        else:
13293 
          iprot.skip(ftype)
2591 chandransh 13294 
      else:
13295 
        iprot.skip(ftype)
13296 
      iprot.readFieldEnd()
13297 
    iprot.readStructEnd()
13298 
 
13299 
  def write(self, oprot):
13300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13302 
      return
2616 chandransh 13303 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 13304 
    if self.orderId is not None:
2591 chandransh 13305 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13306 
      oprot.writeI64(self.orderId)
13307 
      oprot.writeFieldEnd()
4479 rajveer 13308 
    if self.receiveCondition is not None:
13309 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
13310 
      oprot.writeI64(self.receiveCondition)
13311 
      oprot.writeFieldEnd()
2591 chandransh 13312 
    oprot.writeFieldStop()
13313 
    oprot.writeStructEnd()
13314 
 
3431 rajveer 13315 
  def validate(self):
13316 
    return
13317 
 
13318 
 
2591 chandransh 13319 
  def __repr__(self):
13320 
    L = ['%s=%r' % (key, value)
13321 
      for key, value in self.__dict__.iteritems()]
13322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13323 
 
13324 
  def __eq__(self, other):
13325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13326 
 
13327 
  def __ne__(self, other):
13328 
    return not (self == other)
13329 
 
2616 chandransh 13330 
class receiveReturn_result:
2591 chandransh 13331 
  """
13332 
  Attributes:
13333 
   - success
13334 
   - ex
13335 
  """
13336 
 
13337 
  thrift_spec = (
13338 
    (0, TType.BOOL, 'success', None, None, ), # 0
13339 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13340 
  )
13341 
 
13342 
  def __init__(self, success=None, ex=None,):
13343 
    self.success = success
13344 
    self.ex = ex
13345 
 
13346 
  def read(self, iprot):
13347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13349 
      return
13350 
    iprot.readStructBegin()
13351 
    while True:
13352 
      (fname, ftype, fid) = iprot.readFieldBegin()
13353 
      if ftype == TType.STOP:
13354 
        break
13355 
      if fid == 0:
13356 
        if ftype == TType.BOOL:
13357 
          self.success = iprot.readBool();
13358 
        else:
13359 
          iprot.skip(ftype)
13360 
      elif fid == 1:
13361 
        if ftype == TType.STRUCT:
13362 
          self.ex = TransactionServiceException()
13363 
          self.ex.read(iprot)
13364 
        else:
13365 
          iprot.skip(ftype)
13366 
      else:
13367 
        iprot.skip(ftype)
13368 
      iprot.readFieldEnd()
13369 
    iprot.readStructEnd()
13370 
 
13371 
  def write(self, oprot):
13372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13374 
      return
2616 chandransh 13375 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 13376 
    if self.success is not None:
2591 chandransh 13377 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13378 
      oprot.writeBool(self.success)
13379 
      oprot.writeFieldEnd()
3431 rajveer 13380 
    if self.ex is not None:
2591 chandransh 13381 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13382 
      self.ex.write(oprot)
13383 
      oprot.writeFieldEnd()
13384 
    oprot.writeFieldStop()
13385 
    oprot.writeStructEnd()
13386 
 
3431 rajveer 13387 
  def validate(self):
13388 
    return
13389 
 
13390 
 
2591 chandransh 13391 
  def __repr__(self):
13392 
    L = ['%s=%r' % (key, value)
13393 
      for key, value in self.__dict__.iteritems()]
13394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13395 
 
13396 
  def __eq__(self, other):
13397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13398 
 
13399 
  def __ne__(self, other):
13400 
    return not (self == other)
13401 
 
13402 
class validateDoa_args:
13403 
  """
13404 
  Attributes:
13405 
   - orderId
13406 
   - isValid
13407 
  """
13408 
 
13409 
  thrift_spec = (
13410 
    None, # 0
13411 
    (1, TType.I64, 'orderId', None, None, ), # 1
13412 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
13413 
  )
13414 
 
13415 
  def __init__(self, orderId=None, isValid=None,):
13416 
    self.orderId = orderId
13417 
    self.isValid = isValid
13418 
 
13419 
  def read(self, iprot):
13420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13422 
      return
13423 
    iprot.readStructBegin()
13424 
    while True:
13425 
      (fname, ftype, fid) = iprot.readFieldBegin()
13426 
      if ftype == TType.STOP:
13427 
        break
13428 
      if fid == 1:
13429 
        if ftype == TType.I64:
13430 
          self.orderId = iprot.readI64();
13431 
        else:
13432 
          iprot.skip(ftype)
13433 
      elif fid == 2:
13434 
        if ftype == TType.BOOL:
13435 
          self.isValid = iprot.readBool();
13436 
        else:
13437 
          iprot.skip(ftype)
13438 
      else:
13439 
        iprot.skip(ftype)
13440 
      iprot.readFieldEnd()
13441 
    iprot.readStructEnd()
13442 
 
13443 
  def write(self, oprot):
13444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13446 
      return
13447 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 13448 
    if self.orderId is not None:
2591 chandransh 13449 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13450 
      oprot.writeI64(self.orderId)
13451 
      oprot.writeFieldEnd()
3431 rajveer 13452 
    if self.isValid is not None:
2591 chandransh 13453 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
13454 
      oprot.writeBool(self.isValid)
13455 
      oprot.writeFieldEnd()
13456 
    oprot.writeFieldStop()
13457 
    oprot.writeStructEnd()
13458 
 
3431 rajveer 13459 
  def validate(self):
13460 
    return
13461 
 
13462 
 
2591 chandransh 13463 
  def __repr__(self):
13464 
    L = ['%s=%r' % (key, value)
13465 
      for key, value in self.__dict__.iteritems()]
13466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13467 
 
13468 
  def __eq__(self, other):
13469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13470 
 
13471 
  def __ne__(self, other):
13472 
    return not (self == other)
13473 
 
13474 
class validateDoa_result:
13475 
  """
13476 
  Attributes:
13477 
   - success
13478 
   - ex
13479 
  """
13480 
 
13481 
  thrift_spec = (
13482 
    (0, TType.BOOL, 'success', None, None, ), # 0
13483 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13484 
  )
13485 
 
13486 
  def __init__(self, success=None, ex=None,):
13487 
    self.success = success
13488 
    self.ex = ex
13489 
 
13490 
  def read(self, iprot):
13491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13493 
      return
13494 
    iprot.readStructBegin()
13495 
    while True:
13496 
      (fname, ftype, fid) = iprot.readFieldBegin()
13497 
      if ftype == TType.STOP:
13498 
        break
13499 
      if fid == 0:
13500 
        if ftype == TType.BOOL:
13501 
          self.success = iprot.readBool();
13502 
        else:
13503 
          iprot.skip(ftype)
13504 
      elif fid == 1:
13505 
        if ftype == TType.STRUCT:
13506 
          self.ex = TransactionServiceException()
13507 
          self.ex.read(iprot)
13508 
        else:
13509 
          iprot.skip(ftype)
13510 
      else:
13511 
        iprot.skip(ftype)
13512 
      iprot.readFieldEnd()
13513 
    iprot.readStructEnd()
13514 
 
13515 
  def write(self, oprot):
13516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13518 
      return
13519 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 13520 
    if self.success is not None:
2591 chandransh 13521 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13522 
      oprot.writeBool(self.success)
13523 
      oprot.writeFieldEnd()
3431 rajveer 13524 
    if self.ex is not None:
2591 chandransh 13525 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13526 
      self.ex.write(oprot)
13527 
      oprot.writeFieldEnd()
13528 
    oprot.writeFieldStop()
13529 
    oprot.writeStructEnd()
13530 
 
3431 rajveer 13531 
  def validate(self):
13532 
    return
13533 
 
13534 
 
2591 chandransh 13535 
  def __repr__(self):
13536 
    L = ['%s=%r' % (key, value)
13537 
      for key, value in self.__dict__.iteritems()]
13538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13539 
 
13540 
  def __eq__(self, other):
13541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13542 
 
13543 
  def __ne__(self, other):
13544 
    return not (self == other)
13545 
 
4495 rajveer 13546 
class validateReturnProduct_args:
13547 
  """
13548 
  Attributes:
13549 
   - orderId
13550 
   - isUsable
13551 
  """
13552 
 
13553 
  thrift_spec = (
13554 
    None, # 0
13555 
    (1, TType.I64, 'orderId', None, None, ), # 1
13556 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
13557 
  )
13558 
 
13559 
  def __init__(self, orderId=None, isUsable=None,):
13560 
    self.orderId = orderId
13561 
    self.isUsable = isUsable
13562 
 
13563 
  def read(self, iprot):
13564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13566 
      return
13567 
    iprot.readStructBegin()
13568 
    while True:
13569 
      (fname, ftype, fid) = iprot.readFieldBegin()
13570 
      if ftype == TType.STOP:
13571 
        break
13572 
      if fid == 1:
13573 
        if ftype == TType.I64:
13574 
          self.orderId = iprot.readI64();
13575 
        else:
13576 
          iprot.skip(ftype)
13577 
      elif fid == 2:
13578 
        if ftype == TType.BOOL:
13579 
          self.isUsable = iprot.readBool();
13580 
        else:
13581 
          iprot.skip(ftype)
13582 
      else:
13583 
        iprot.skip(ftype)
13584 
      iprot.readFieldEnd()
13585 
    iprot.readStructEnd()
13586 
 
13587 
  def write(self, oprot):
13588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13590 
      return
13591 
    oprot.writeStructBegin('validateReturnProduct_args')
13592 
    if self.orderId is not None:
13593 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13594 
      oprot.writeI64(self.orderId)
13595 
      oprot.writeFieldEnd()
13596 
    if self.isUsable is not None:
13597 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
13598 
      oprot.writeBool(self.isUsable)
13599 
      oprot.writeFieldEnd()
13600 
    oprot.writeFieldStop()
13601 
    oprot.writeStructEnd()
13602 
 
13603 
  def validate(self):
13604 
    return
13605 
 
13606 
 
13607 
  def __repr__(self):
13608 
    L = ['%s=%r' % (key, value)
13609 
      for key, value in self.__dict__.iteritems()]
13610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13611 
 
13612 
  def __eq__(self, other):
13613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13614 
 
13615 
  def __ne__(self, other):
13616 
    return not (self == other)
13617 
 
13618 
class validateReturnProduct_result:
13619 
  """
13620 
  Attributes:
13621 
   - success
13622 
   - ex
13623 
  """
13624 
 
13625 
  thrift_spec = (
13626 
    (0, TType.BOOL, 'success', None, None, ), # 0
13627 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13628 
  )
13629 
 
13630 
  def __init__(self, success=None, ex=None,):
13631 
    self.success = success
13632 
    self.ex = ex
13633 
 
13634 
  def read(self, iprot):
13635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13637 
      return
13638 
    iprot.readStructBegin()
13639 
    while True:
13640 
      (fname, ftype, fid) = iprot.readFieldBegin()
13641 
      if ftype == TType.STOP:
13642 
        break
13643 
      if fid == 0:
13644 
        if ftype == TType.BOOL:
13645 
          self.success = iprot.readBool();
13646 
        else:
13647 
          iprot.skip(ftype)
13648 
      elif fid == 1:
13649 
        if ftype == TType.STRUCT:
13650 
          self.ex = TransactionServiceException()
13651 
          self.ex.read(iprot)
13652 
        else:
13653 
          iprot.skip(ftype)
13654 
      else:
13655 
        iprot.skip(ftype)
13656 
      iprot.readFieldEnd()
13657 
    iprot.readStructEnd()
13658 
 
13659 
  def write(self, oprot):
13660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13662 
      return
13663 
    oprot.writeStructBegin('validateReturnProduct_result')
13664 
    if self.success is not None:
13665 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13666 
      oprot.writeBool(self.success)
13667 
      oprot.writeFieldEnd()
13668 
    if self.ex is not None:
13669 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13670 
      self.ex.write(oprot)
13671 
      oprot.writeFieldEnd()
13672 
    oprot.writeFieldStop()
13673 
    oprot.writeStructEnd()
13674 
 
13675 
  def validate(self):
13676 
    return
13677 
 
13678 
 
13679 
  def __repr__(self):
13680 
    L = ['%s=%r' % (key, value)
13681 
      for key, value in self.__dict__.iteritems()]
13682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13683 
 
13684 
  def __eq__(self, other):
13685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13686 
 
13687 
  def __ne__(self, other):
13688 
    return not (self == other)
13689 
 
2616 chandransh 13690 
class reshipOrder_args:
13691 
  """
13692 
  Attributes:
13693 
   - orderId
13694 
  """
2591 chandransh 13695 
 
2616 chandransh 13696 
  thrift_spec = (
13697 
    None, # 0
13698 
    (1, TType.I64, 'orderId', None, None, ), # 1
13699 
  )
13700 
 
13701 
  def __init__(self, orderId=None,):
13702 
    self.orderId = orderId
13703 
 
13704 
  def read(self, iprot):
13705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13707 
      return
13708 
    iprot.readStructBegin()
13709 
    while True:
13710 
      (fname, ftype, fid) = iprot.readFieldBegin()
13711 
      if ftype == TType.STOP:
13712 
        break
13713 
      if fid == 1:
13714 
        if ftype == TType.I64:
13715 
          self.orderId = iprot.readI64();
13716 
        else:
13717 
          iprot.skip(ftype)
13718 
      else:
13719 
        iprot.skip(ftype)
13720 
      iprot.readFieldEnd()
13721 
    iprot.readStructEnd()
13722 
 
13723 
  def write(self, oprot):
13724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13726 
      return
13727 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 13728 
    if self.orderId is not None:
2616 chandransh 13729 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13730 
      oprot.writeI64(self.orderId)
13731 
      oprot.writeFieldEnd()
13732 
    oprot.writeFieldStop()
13733 
    oprot.writeStructEnd()
13734 
 
3431 rajveer 13735 
  def validate(self):
13736 
    return
13737 
 
13738 
 
2616 chandransh 13739 
  def __repr__(self):
13740 
    L = ['%s=%r' % (key, value)
13741 
      for key, value in self.__dict__.iteritems()]
13742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13743 
 
13744 
  def __eq__(self, other):
13745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13746 
 
13747 
  def __ne__(self, other):
13748 
    return not (self == other)
13749 
 
13750 
class reshipOrder_result:
13751 
  """
13752 
  Attributes:
13753 
   - success
13754 
   - ex
13755 
  """
13756 
 
13757 
  thrift_spec = (
13758 
    (0, TType.I64, 'success', None, None, ), # 0
13759 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13760 
  )
13761 
 
13762 
  def __init__(self, success=None, ex=None,):
13763 
    self.success = success
13764 
    self.ex = ex
13765 
 
13766 
  def read(self, iprot):
13767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13769 
      return
13770 
    iprot.readStructBegin()
13771 
    while True:
13772 
      (fname, ftype, fid) = iprot.readFieldBegin()
13773 
      if ftype == TType.STOP:
13774 
        break
13775 
      if fid == 0:
13776 
        if ftype == TType.I64:
13777 
          self.success = iprot.readI64();
13778 
        else:
13779 
          iprot.skip(ftype)
13780 
      elif fid == 1:
13781 
        if ftype == TType.STRUCT:
13782 
          self.ex = TransactionServiceException()
13783 
          self.ex.read(iprot)
13784 
        else:
13785 
          iprot.skip(ftype)
13786 
      else:
13787 
        iprot.skip(ftype)
13788 
      iprot.readFieldEnd()
13789 
    iprot.readStructEnd()
13790 
 
13791 
  def write(self, oprot):
13792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13794 
      return
13795 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 13796 
    if self.success is not None:
2616 chandransh 13797 
      oprot.writeFieldBegin('success', TType.I64, 0)
13798 
      oprot.writeI64(self.success)
13799 
      oprot.writeFieldEnd()
3431 rajveer 13800 
    if self.ex is not None:
2616 chandransh 13801 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13802 
      self.ex.write(oprot)
13803 
      oprot.writeFieldEnd()
13804 
    oprot.writeFieldStop()
13805 
    oprot.writeStructEnd()
13806 
 
3431 rajveer 13807 
  def validate(self):
13808 
    return
13809 
 
13810 
 
2616 chandransh 13811 
  def __repr__(self):
13812 
    L = ['%s=%r' % (key, value)
13813 
      for key, value in self.__dict__.iteritems()]
13814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13815 
 
13816 
  def __eq__(self, other):
13817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13818 
 
13819 
  def __ne__(self, other):
13820 
    return not (self == other)
13821 
 
13822 
class refundOrder_args:
13823 
  """
13824 
  Attributes:
13825 
   - orderId
3226 chandransh 13826 
   - refundedBy
13827 
   - reason
2616 chandransh 13828 
  """
13829 
 
13830 
  thrift_spec = (
13831 
    None, # 0
13832 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 13833 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13834 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 13835 
  )
13836 
 
3226 chandransh 13837 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 13838 
    self.orderId = orderId
3226 chandransh 13839 
    self.refundedBy = refundedBy
13840 
    self.reason = reason
2616 chandransh 13841 
 
13842 
  def read(self, iprot):
13843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13845 
      return
13846 
    iprot.readStructBegin()
13847 
    while True:
13848 
      (fname, ftype, fid) = iprot.readFieldBegin()
13849 
      if ftype == TType.STOP:
13850 
        break
13851 
      if fid == 1:
13852 
        if ftype == TType.I64:
13853 
          self.orderId = iprot.readI64();
13854 
        else:
13855 
          iprot.skip(ftype)
3226 chandransh 13856 
      elif fid == 2:
13857 
        if ftype == TType.STRING:
13858 
          self.refundedBy = iprot.readString();
13859 
        else:
13860 
          iprot.skip(ftype)
13861 
      elif fid == 3:
13862 
        if ftype == TType.STRING:
13863 
          self.reason = iprot.readString();
13864 
        else:
13865 
          iprot.skip(ftype)
2616 chandransh 13866 
      else:
13867 
        iprot.skip(ftype)
13868 
      iprot.readFieldEnd()
13869 
    iprot.readStructEnd()
13870 
 
13871 
  def write(self, oprot):
13872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13874 
      return
13875 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 13876 
    if self.orderId is not None:
2616 chandransh 13877 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13878 
      oprot.writeI64(self.orderId)
13879 
      oprot.writeFieldEnd()
3431 rajveer 13880 
    if self.refundedBy is not None:
3226 chandransh 13881 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13882 
      oprot.writeString(self.refundedBy)
13883 
      oprot.writeFieldEnd()
3431 rajveer 13884 
    if self.reason is not None:
3226 chandransh 13885 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13886 
      oprot.writeString(self.reason)
13887 
      oprot.writeFieldEnd()
2616 chandransh 13888 
    oprot.writeFieldStop()
13889 
    oprot.writeStructEnd()
13890 
 
3431 rajveer 13891 
  def validate(self):
13892 
    return
13893 
 
13894 
 
2616 chandransh 13895 
  def __repr__(self):
13896 
    L = ['%s=%r' % (key, value)
13897 
      for key, value in self.__dict__.iteritems()]
13898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13899 
 
13900 
  def __eq__(self, other):
13901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13902 
 
13903 
  def __ne__(self, other):
13904 
    return not (self == other)
13905 
 
13906 
class refundOrder_result:
13907 
  """
13908 
  Attributes:
13909 
   - success
13910 
   - ex
13911 
  """
13912 
 
13913 
  thrift_spec = (
13914 
    (0, TType.BOOL, 'success', None, None, ), # 0
13915 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13916 
  )
13917 
 
13918 
  def __init__(self, success=None, ex=None,):
13919 
    self.success = success
13920 
    self.ex = ex
13921 
 
13922 
  def read(self, iprot):
13923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13925 
      return
13926 
    iprot.readStructBegin()
13927 
    while True:
13928 
      (fname, ftype, fid) = iprot.readFieldBegin()
13929 
      if ftype == TType.STOP:
13930 
        break
13931 
      if fid == 0:
13932 
        if ftype == TType.BOOL:
13933 
          self.success = iprot.readBool();
13934 
        else:
13935 
          iprot.skip(ftype)
13936 
      elif fid == 1:
13937 
        if ftype == TType.STRUCT:
13938 
          self.ex = TransactionServiceException()
13939 
          self.ex.read(iprot)
13940 
        else:
13941 
          iprot.skip(ftype)
13942 
      else:
13943 
        iprot.skip(ftype)
13944 
      iprot.readFieldEnd()
13945 
    iprot.readStructEnd()
13946 
 
13947 
  def write(self, oprot):
13948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13950 
      return
13951 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 13952 
    if self.success is not None:
2616 chandransh 13953 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13954 
      oprot.writeBool(self.success)
13955 
      oprot.writeFieldEnd()
3431 rajveer 13956 
    if self.ex is not None:
2616 chandransh 13957 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13958 
      self.ex.write(oprot)
13959 
      oprot.writeFieldEnd()
13960 
    oprot.writeFieldStop()
13961 
    oprot.writeStructEnd()
13962 
 
3431 rajveer 13963 
  def validate(self):
13964 
    return
13965 
 
13966 
 
2616 chandransh 13967 
  def __repr__(self):
13968 
    L = ['%s=%r' % (key, value)
13969 
      for key, value in self.__dict__.iteritems()]
13970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13971 
 
13972 
  def __eq__(self, other):
13973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13974 
 
13975 
  def __ne__(self, other):
13976 
    return not (self == other)
13977 
 
2690 chandransh 13978 
class getReturnOrders_args:
13979 
  """
13980 
  Attributes:
13981 
   - warehouseId
13982 
   - fromDate
13983 
   - toDate
13984 
  """
2616 chandransh 13985 
 
2690 chandransh 13986 
  thrift_spec = (
13987 
    None, # 0
13988 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13989 
    (2, TType.I64, 'fromDate', None, None, ), # 2
13990 
    (3, TType.I64, 'toDate', None, None, ), # 3
13991 
  )
13992 
 
13993 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
13994 
    self.warehouseId = warehouseId
13995 
    self.fromDate = fromDate
13996 
    self.toDate = toDate
13997 
 
13998 
  def read(self, iprot):
13999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14001 
      return
14002 
    iprot.readStructBegin()
14003 
    while True:
14004 
      (fname, ftype, fid) = iprot.readFieldBegin()
14005 
      if ftype == TType.STOP:
14006 
        break
14007 
      if fid == 1:
14008 
        if ftype == TType.I64:
14009 
          self.warehouseId = iprot.readI64();
14010 
        else:
14011 
          iprot.skip(ftype)
14012 
      elif fid == 2:
14013 
        if ftype == TType.I64:
14014 
          self.fromDate = iprot.readI64();
14015 
        else:
14016 
          iprot.skip(ftype)
14017 
      elif fid == 3:
14018 
        if ftype == TType.I64:
14019 
          self.toDate = iprot.readI64();
14020 
        else:
14021 
          iprot.skip(ftype)
14022 
      else:
14023 
        iprot.skip(ftype)
14024 
      iprot.readFieldEnd()
14025 
    iprot.readStructEnd()
14026 
 
14027 
  def write(self, oprot):
14028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14030 
      return
14031 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 14032 
    if self.warehouseId is not None:
2690 chandransh 14033 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14034 
      oprot.writeI64(self.warehouseId)
14035 
      oprot.writeFieldEnd()
3431 rajveer 14036 
    if self.fromDate is not None:
2690 chandransh 14037 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
14038 
      oprot.writeI64(self.fromDate)
14039 
      oprot.writeFieldEnd()
3431 rajveer 14040 
    if self.toDate is not None:
2690 chandransh 14041 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
14042 
      oprot.writeI64(self.toDate)
14043 
      oprot.writeFieldEnd()
14044 
    oprot.writeFieldStop()
14045 
    oprot.writeStructEnd()
14046 
 
3431 rajveer 14047 
  def validate(self):
14048 
    return
14049 
 
14050 
 
2690 chandransh 14051 
  def __repr__(self):
14052 
    L = ['%s=%r' % (key, value)
14053 
      for key, value in self.__dict__.iteritems()]
14054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14055 
 
14056 
  def __eq__(self, other):
14057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14058 
 
14059 
  def __ne__(self, other):
14060 
    return not (self == other)
14061 
 
14062 
class getReturnOrders_result:
14063 
  """
14064 
  Attributes:
14065 
   - success
14066 
  """
14067 
 
14068 
  thrift_spec = (
14069 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
14070 
  )
14071 
 
14072 
  def __init__(self, success=None,):
14073 
    self.success = success
14074 
 
14075 
  def read(self, iprot):
14076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14078 
      return
14079 
    iprot.readStructBegin()
14080 
    while True:
14081 
      (fname, ftype, fid) = iprot.readFieldBegin()
14082 
      if ftype == TType.STOP:
14083 
        break
14084 
      if fid == 0:
14085 
        if ftype == TType.LIST:
14086 
          self.success = []
4741 phani.kuma 14087 
          (_etype232, _size229) = iprot.readListBegin()
14088 
          for _i233 in xrange(_size229):
14089 
            _elem234 = ReturnOrder()
14090 
            _elem234.read(iprot)
14091 
            self.success.append(_elem234)
2690 chandransh 14092 
          iprot.readListEnd()
14093 
        else:
14094 
          iprot.skip(ftype)
14095 
      else:
14096 
        iprot.skip(ftype)
14097 
      iprot.readFieldEnd()
14098 
    iprot.readStructEnd()
14099 
 
14100 
  def write(self, oprot):
14101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14103 
      return
14104 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 14105 
    if self.success is not None:
2690 chandransh 14106 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14107 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4741 phani.kuma 14108 
      for iter235 in self.success:
14109 
        iter235.write(oprot)
2690 chandransh 14110 
      oprot.writeListEnd()
14111 
      oprot.writeFieldEnd()
14112 
    oprot.writeFieldStop()
14113 
    oprot.writeStructEnd()
14114 
 
3431 rajveer 14115 
  def validate(self):
14116 
    return
14117 
 
14118 
 
2690 chandransh 14119 
  def __repr__(self):
14120 
    L = ['%s=%r' % (key, value)
14121 
      for key, value in self.__dict__.iteritems()]
14122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14123 
 
14124 
  def __eq__(self, other):
14125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14126 
 
14127 
  def __ne__(self, other):
14128 
    return not (self == other)
14129 
 
2700 chandransh 14130 
class getReturnOrder_args:
14131 
  """
14132 
  Attributes:
14133 
   - id
14134 
  """
14135 
 
14136 
  thrift_spec = (
14137 
    None, # 0
14138 
    (1, TType.I64, 'id', None, None, ), # 1
14139 
  )
14140 
 
14141 
  def __init__(self, id=None,):
14142 
    self.id = id
14143 
 
14144 
  def read(self, iprot):
14145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14147 
      return
14148 
    iprot.readStructBegin()
14149 
    while True:
14150 
      (fname, ftype, fid) = iprot.readFieldBegin()
14151 
      if ftype == TType.STOP:
14152 
        break
14153 
      if fid == 1:
14154 
        if ftype == TType.I64:
14155 
          self.id = iprot.readI64();
14156 
        else:
14157 
          iprot.skip(ftype)
14158 
      else:
14159 
        iprot.skip(ftype)
14160 
      iprot.readFieldEnd()
14161 
    iprot.readStructEnd()
14162 
 
14163 
  def write(self, oprot):
14164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14166 
      return
14167 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 14168 
    if self.id is not None:
2700 chandransh 14169 
      oprot.writeFieldBegin('id', TType.I64, 1)
14170 
      oprot.writeI64(self.id)
14171 
      oprot.writeFieldEnd()
14172 
    oprot.writeFieldStop()
14173 
    oprot.writeStructEnd()
14174 
 
3431 rajveer 14175 
  def validate(self):
14176 
    return
14177 
 
14178 
 
2700 chandransh 14179 
  def __repr__(self):
14180 
    L = ['%s=%r' % (key, value)
14181 
      for key, value in self.__dict__.iteritems()]
14182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14183 
 
14184 
  def __eq__(self, other):
14185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14186 
 
14187 
  def __ne__(self, other):
14188 
    return not (self == other)
14189 
 
14190 
class getReturnOrder_result:
14191 
  """
14192 
  Attributes:
14193 
   - success
14194 
   - ex
14195 
  """
14196 
 
14197 
  thrift_spec = (
14198 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
14199 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14200 
  )
14201 
 
14202 
  def __init__(self, success=None, ex=None,):
14203 
    self.success = success
14204 
    self.ex = ex
14205 
 
14206 
  def read(self, iprot):
14207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14209 
      return
14210 
    iprot.readStructBegin()
14211 
    while True:
14212 
      (fname, ftype, fid) = iprot.readFieldBegin()
14213 
      if ftype == TType.STOP:
14214 
        break
14215 
      if fid == 0:
14216 
        if ftype == TType.STRUCT:
14217 
          self.success = ReturnOrder()
14218 
          self.success.read(iprot)
14219 
        else:
14220 
          iprot.skip(ftype)
14221 
      elif fid == 1:
14222 
        if ftype == TType.STRUCT:
14223 
          self.ex = TransactionServiceException()
14224 
          self.ex.read(iprot)
14225 
        else:
14226 
          iprot.skip(ftype)
14227 
      else:
14228 
        iprot.skip(ftype)
14229 
      iprot.readFieldEnd()
14230 
    iprot.readStructEnd()
14231 
 
14232 
  def write(self, oprot):
14233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14235 
      return
14236 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 14237 
    if self.success is not None:
2700 chandransh 14238 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14239 
      self.success.write(oprot)
14240 
      oprot.writeFieldEnd()
3431 rajveer 14241 
    if self.ex is not None:
2700 chandransh 14242 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14243 
      self.ex.write(oprot)
14244 
      oprot.writeFieldEnd()
14245 
    oprot.writeFieldStop()
14246 
    oprot.writeStructEnd()
14247 
 
3431 rajveer 14248 
  def validate(self):
14249 
    return
14250 
 
14251 
 
2700 chandransh 14252 
  def __repr__(self):
14253 
    L = ['%s=%r' % (key, value)
14254 
      for key, value in self.__dict__.iteritems()]
14255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14256 
 
14257 
  def __eq__(self, other):
14258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14259 
 
14260 
  def __ne__(self, other):
14261 
    return not (self == other)
14262 
 
2690 chandransh 14263 
class processReturn_args:
14264 
  """
14265 
  Attributes:
14266 
   - returnOrderId
14267 
  """
14268 
 
14269 
  thrift_spec = (
14270 
    None, # 0
14271 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
14272 
  )
14273 
 
14274 
  def __init__(self, returnOrderId=None,):
14275 
    self.returnOrderId = returnOrderId
14276 
 
14277 
  def read(self, iprot):
14278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14280 
      return
14281 
    iprot.readStructBegin()
14282 
    while True:
14283 
      (fname, ftype, fid) = iprot.readFieldBegin()
14284 
      if ftype == TType.STOP:
14285 
        break
14286 
      if fid == 1:
14287 
        if ftype == TType.I64:
14288 
          self.returnOrderId = iprot.readI64();
14289 
        else:
14290 
          iprot.skip(ftype)
14291 
      else:
14292 
        iprot.skip(ftype)
14293 
      iprot.readFieldEnd()
14294 
    iprot.readStructEnd()
14295 
 
14296 
  def write(self, oprot):
14297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14299 
      return
14300 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 14301 
    if self.returnOrderId is not None:
2690 chandransh 14302 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
14303 
      oprot.writeI64(self.returnOrderId)
14304 
      oprot.writeFieldEnd()
14305 
    oprot.writeFieldStop()
14306 
    oprot.writeStructEnd()
14307 
 
3431 rajveer 14308 
  def validate(self):
14309 
    return
14310 
 
14311 
 
2690 chandransh 14312 
  def __repr__(self):
14313 
    L = ['%s=%r' % (key, value)
14314 
      for key, value in self.__dict__.iteritems()]
14315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14316 
 
14317 
  def __eq__(self, other):
14318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14319 
 
14320 
  def __ne__(self, other):
14321 
    return not (self == other)
14322 
 
14323 
class processReturn_result:
14324 
  """
14325 
  Attributes:
14326 
   - ex
14327 
  """
14328 
 
14329 
  thrift_spec = (
14330 
    None, # 0
14331 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14332 
  )
14333 
 
14334 
  def __init__(self, ex=None,):
14335 
    self.ex = ex
14336 
 
14337 
  def read(self, iprot):
14338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14340 
      return
14341 
    iprot.readStructBegin()
14342 
    while True:
14343 
      (fname, ftype, fid) = iprot.readFieldBegin()
14344 
      if ftype == TType.STOP:
14345 
        break
14346 
      if fid == 1:
14347 
        if ftype == TType.STRUCT:
14348 
          self.ex = TransactionServiceException()
14349 
          self.ex.read(iprot)
14350 
        else:
14351 
          iprot.skip(ftype)
14352 
      else:
14353 
        iprot.skip(ftype)
14354 
      iprot.readFieldEnd()
14355 
    iprot.readStructEnd()
14356 
 
14357 
  def write(self, oprot):
14358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14360 
      return
14361 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 14362 
    if self.ex is not None:
2690 chandransh 14363 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14364 
      self.ex.write(oprot)
14365 
      oprot.writeFieldEnd()
14366 
    oprot.writeFieldStop()
14367 
    oprot.writeStructEnd()
14368 
 
3431 rajveer 14369 
  def validate(self):
14370 
    return
14371 
 
14372 
 
2690 chandransh 14373 
  def __repr__(self):
14374 
    L = ['%s=%r' % (key, value)
14375 
      for key, value in self.__dict__.iteritems()]
14376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14377 
 
14378 
  def __eq__(self, other):
14379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14380 
 
14381 
  def __ne__(self, other):
14382 
    return not (self == other)
14383 
 
3451 chandransh 14384 
class updateWeight_args:
14385 
  """
14386 
  Attributes:
14387 
   - orderId
14388 
   - weight
14389 
  """
14390 
 
14391 
  thrift_spec = (
14392 
    None, # 0
14393 
    (1, TType.I64, 'orderId', None, None, ), # 1
14394 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
14395 
  )
14396 
 
14397 
  def __init__(self, orderId=None, weight=None,):
14398 
    self.orderId = orderId
14399 
    self.weight = weight
14400 
 
14401 
  def read(self, iprot):
14402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14404 
      return
14405 
    iprot.readStructBegin()
14406 
    while True:
14407 
      (fname, ftype, fid) = iprot.readFieldBegin()
14408 
      if ftype == TType.STOP:
14409 
        break
14410 
      if fid == 1:
14411 
        if ftype == TType.I64:
14412 
          self.orderId = iprot.readI64();
14413 
        else:
14414 
          iprot.skip(ftype)
14415 
      elif fid == 2:
14416 
        if ftype == TType.DOUBLE:
14417 
          self.weight = iprot.readDouble();
14418 
        else:
14419 
          iprot.skip(ftype)
14420 
      else:
14421 
        iprot.skip(ftype)
14422 
      iprot.readFieldEnd()
14423 
    iprot.readStructEnd()
14424 
 
14425 
  def write(self, oprot):
14426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14428 
      return
14429 
    oprot.writeStructBegin('updateWeight_args')
14430 
    if self.orderId is not None:
14431 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14432 
      oprot.writeI64(self.orderId)
14433 
      oprot.writeFieldEnd()
14434 
    if self.weight is not None:
14435 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
14436 
      oprot.writeDouble(self.weight)
14437 
      oprot.writeFieldEnd()
14438 
    oprot.writeFieldStop()
14439 
    oprot.writeStructEnd()
14440 
 
14441 
  def validate(self):
14442 
    return
14443 
 
14444 
 
14445 
  def __repr__(self):
14446 
    L = ['%s=%r' % (key, value)
14447 
      for key, value in self.__dict__.iteritems()]
14448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14449 
 
14450 
  def __eq__(self, other):
14451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14452 
 
14453 
  def __ne__(self, other):
14454 
    return not (self == other)
14455 
 
14456 
class updateWeight_result:
14457 
  """
14458 
  Attributes:
14459 
   - success
14460 
   - ex
14461 
  """
14462 
 
14463 
  thrift_spec = (
14464 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14465 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14466 
  )
14467 
 
14468 
  def __init__(self, success=None, ex=None,):
14469 
    self.success = success
14470 
    self.ex = ex
14471 
 
14472 
  def read(self, iprot):
14473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14475 
      return
14476 
    iprot.readStructBegin()
14477 
    while True:
14478 
      (fname, ftype, fid) = iprot.readFieldBegin()
14479 
      if ftype == TType.STOP:
14480 
        break
14481 
      if fid == 0:
14482 
        if ftype == TType.STRUCT:
14483 
          self.success = Order()
14484 
          self.success.read(iprot)
14485 
        else:
14486 
          iprot.skip(ftype)
14487 
      elif fid == 1:
14488 
        if ftype == TType.STRUCT:
14489 
          self.ex = TransactionServiceException()
14490 
          self.ex.read(iprot)
14491 
        else:
14492 
          iprot.skip(ftype)
14493 
      else:
14494 
        iprot.skip(ftype)
14495 
      iprot.readFieldEnd()
14496 
    iprot.readStructEnd()
14497 
 
14498 
  def write(self, oprot):
14499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14501 
      return
14502 
    oprot.writeStructBegin('updateWeight_result')
14503 
    if self.success is not None:
14504 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14505 
      self.success.write(oprot)
14506 
      oprot.writeFieldEnd()
14507 
    if self.ex is not None:
14508 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14509 
      self.ex.write(oprot)
14510 
      oprot.writeFieldEnd()
14511 
    oprot.writeFieldStop()
14512 
    oprot.writeStructEnd()
14513 
 
14514 
  def validate(self):
14515 
    return
14516 
 
14517 
 
14518 
  def __repr__(self):
14519 
    L = ['%s=%r' % (key, value)
14520 
      for key, value in self.__dict__.iteritems()]
14521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14522 
 
14523 
  def __eq__(self, other):
14524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14525 
 
14526 
  def __ne__(self, other):
14527 
    return not (self == other)
3469 chandransh 14528 
 
14529 
class changeItem_args:
14530 
  """
14531 
  Attributes:
14532 
   - orderId
14533 
   - itemId
14534 
  """
14535 
 
14536 
  thrift_spec = (
14537 
    None, # 0
14538 
    (1, TType.I64, 'orderId', None, None, ), # 1
14539 
    (2, TType.I64, 'itemId', None, None, ), # 2
14540 
  )
14541 
 
14542 
  def __init__(self, orderId=None, itemId=None,):
14543 
    self.orderId = orderId
14544 
    self.itemId = itemId
14545 
 
14546 
  def read(self, iprot):
14547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14549 
      return
14550 
    iprot.readStructBegin()
14551 
    while True:
14552 
      (fname, ftype, fid) = iprot.readFieldBegin()
14553 
      if ftype == TType.STOP:
14554 
        break
14555 
      if fid == 1:
14556 
        if ftype == TType.I64:
14557 
          self.orderId = iprot.readI64();
14558 
        else:
14559 
          iprot.skip(ftype)
14560 
      elif fid == 2:
14561 
        if ftype == TType.I64:
14562 
          self.itemId = iprot.readI64();
14563 
        else:
14564 
          iprot.skip(ftype)
14565 
      else:
14566 
        iprot.skip(ftype)
14567 
      iprot.readFieldEnd()
14568 
    iprot.readStructEnd()
14569 
 
14570 
  def write(self, oprot):
14571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14573 
      return
14574 
    oprot.writeStructBegin('changeItem_args')
14575 
    if self.orderId is not None:
14576 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14577 
      oprot.writeI64(self.orderId)
14578 
      oprot.writeFieldEnd()
14579 
    if self.itemId is not None:
14580 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14581 
      oprot.writeI64(self.itemId)
14582 
      oprot.writeFieldEnd()
14583 
    oprot.writeFieldStop()
14584 
    oprot.writeStructEnd()
14585 
 
14586 
  def validate(self):
14587 
    return
14588 
 
14589 
 
14590 
  def __repr__(self):
14591 
    L = ['%s=%r' % (key, value)
14592 
      for key, value in self.__dict__.iteritems()]
14593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14594 
 
14595 
  def __eq__(self, other):
14596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14597 
 
14598 
  def __ne__(self, other):
14599 
    return not (self == other)
14600 
 
14601 
class changeItem_result:
14602 
  """
14603 
  Attributes:
14604 
   - success
14605 
   - ex
14606 
  """
14607 
 
14608 
  thrift_spec = (
14609 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14610 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14611 
  )
14612 
 
14613 
  def __init__(self, success=None, ex=None,):
14614 
    self.success = success
14615 
    self.ex = ex
14616 
 
14617 
  def read(self, iprot):
14618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14620 
      return
14621 
    iprot.readStructBegin()
14622 
    while True:
14623 
      (fname, ftype, fid) = iprot.readFieldBegin()
14624 
      if ftype == TType.STOP:
14625 
        break
14626 
      if fid == 0:
14627 
        if ftype == TType.STRUCT:
14628 
          self.success = Order()
14629 
          self.success.read(iprot)
14630 
        else:
14631 
          iprot.skip(ftype)
14632 
      elif fid == 1:
14633 
        if ftype == TType.STRUCT:
14634 
          self.ex = TransactionServiceException()
14635 
          self.ex.read(iprot)
14636 
        else:
14637 
          iprot.skip(ftype)
14638 
      else:
14639 
        iprot.skip(ftype)
14640 
      iprot.readFieldEnd()
14641 
    iprot.readStructEnd()
14642 
 
14643 
  def write(self, oprot):
14644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14646 
      return
14647 
    oprot.writeStructBegin('changeItem_result')
14648 
    if self.success is not None:
14649 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14650 
      self.success.write(oprot)
14651 
      oprot.writeFieldEnd()
14652 
    if self.ex is not None:
14653 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14654 
      self.ex.write(oprot)
14655 
      oprot.writeFieldEnd()
14656 
    oprot.writeFieldStop()
14657 
    oprot.writeStructEnd()
14658 
 
14659 
  def validate(self):
14660 
    return
14661 
 
14662 
 
14663 
  def __repr__(self):
14664 
    L = ['%s=%r' % (key, value)
14665 
      for key, value in self.__dict__.iteritems()]
14666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14667 
 
14668 
  def __eq__(self, other):
14669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14670 
 
14671 
  def __ne__(self, other):
14672 
    return not (self == other)
14673 
 
14674 
class shiftToWarehouse_args:
14675 
  """
14676 
  Attributes:
14677 
   - orderId
14678 
   - warehouseId
14679 
  """
14680 
 
14681 
  thrift_spec = (
14682 
    None, # 0
14683 
    (1, TType.I64, 'orderId', None, None, ), # 1
14684 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
14685 
  )
14686 
 
14687 
  def __init__(self, orderId=None, warehouseId=None,):
14688 
    self.orderId = orderId
14689 
    self.warehouseId = warehouseId
14690 
 
14691 
  def read(self, iprot):
14692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14694 
      return
14695 
    iprot.readStructBegin()
14696 
    while True:
14697 
      (fname, ftype, fid) = iprot.readFieldBegin()
14698 
      if ftype == TType.STOP:
14699 
        break
14700 
      if fid == 1:
14701 
        if ftype == TType.I64:
14702 
          self.orderId = iprot.readI64();
14703 
        else:
14704 
          iprot.skip(ftype)
14705 
      elif fid == 2:
14706 
        if ftype == TType.I64:
14707 
          self.warehouseId = iprot.readI64();
14708 
        else:
14709 
          iprot.skip(ftype)
14710 
      else:
14711 
        iprot.skip(ftype)
14712 
      iprot.readFieldEnd()
14713 
    iprot.readStructEnd()
14714 
 
14715 
  def write(self, oprot):
14716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14718 
      return
14719 
    oprot.writeStructBegin('shiftToWarehouse_args')
14720 
    if self.orderId is not None:
14721 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14722 
      oprot.writeI64(self.orderId)
14723 
      oprot.writeFieldEnd()
14724 
    if self.warehouseId is not None:
14725 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14726 
      oprot.writeI64(self.warehouseId)
14727 
      oprot.writeFieldEnd()
14728 
    oprot.writeFieldStop()
14729 
    oprot.writeStructEnd()
14730 
 
14731 
  def validate(self):
14732 
    return
14733 
 
14734 
 
14735 
  def __repr__(self):
14736 
    L = ['%s=%r' % (key, value)
14737 
      for key, value in self.__dict__.iteritems()]
14738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14739 
 
14740 
  def __eq__(self, other):
14741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14742 
 
14743 
  def __ne__(self, other):
14744 
    return not (self == other)
14745 
 
14746 
class shiftToWarehouse_result:
14747 
  """
14748 
  Attributes:
14749 
   - success
14750 
   - ex
14751 
  """
14752 
 
14753 
  thrift_spec = (
14754 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14755 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14756 
  )
14757 
 
14758 
  def __init__(self, success=None, ex=None,):
14759 
    self.success = success
14760 
    self.ex = ex
14761 
 
14762 
  def read(self, iprot):
14763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14765 
      return
14766 
    iprot.readStructBegin()
14767 
    while True:
14768 
      (fname, ftype, fid) = iprot.readFieldBegin()
14769 
      if ftype == TType.STOP:
14770 
        break
14771 
      if fid == 0:
14772 
        if ftype == TType.STRUCT:
14773 
          self.success = Order()
14774 
          self.success.read(iprot)
14775 
        else:
14776 
          iprot.skip(ftype)
14777 
      elif fid == 1:
14778 
        if ftype == TType.STRUCT:
14779 
          self.ex = TransactionServiceException()
14780 
          self.ex.read(iprot)
14781 
        else:
14782 
          iprot.skip(ftype)
14783 
      else:
14784 
        iprot.skip(ftype)
14785 
      iprot.readFieldEnd()
14786 
    iprot.readStructEnd()
14787 
 
14788 
  def write(self, oprot):
14789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14791 
      return
14792 
    oprot.writeStructBegin('shiftToWarehouse_result')
14793 
    if self.success is not None:
14794 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14795 
      self.success.write(oprot)
14796 
      oprot.writeFieldEnd()
14797 
    if self.ex is not None:
14798 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14799 
      self.ex.write(oprot)
14800 
      oprot.writeFieldEnd()
14801 
    oprot.writeFieldStop()
14802 
    oprot.writeStructEnd()
14803 
 
14804 
  def validate(self):
14805 
    return
14806 
 
14807 
 
14808 
  def __repr__(self):
14809 
    L = ['%s=%r' % (key, value)
14810 
      for key, value in self.__dict__.iteritems()]
14811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14812 
 
14813 
  def __eq__(self, other):
14814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14815 
 
14816 
  def __ne__(self, other):
14817 
    return not (self == other)
3553 chandransh 14818 
 
14819 
class addDelayReason_args:
14820 
  """
14821 
  Attributes:
14822 
   - orderId
14823 
   - delayReason
3986 chandransh 14824 
   - furtherDelay
4647 rajveer 14825 
   - delayReasonText
3553 chandransh 14826 
  """
14827 
 
14828 
  thrift_spec = (
14829 
    None, # 0
14830 
    (1, TType.I64, 'orderId', None, None, ), # 1
14831 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 14832 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 14833 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 14834 
  )
14835 
 
4647 rajveer 14836 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 14837 
    self.orderId = orderId
14838 
    self.delayReason = delayReason
3986 chandransh 14839 
    self.furtherDelay = furtherDelay
4647 rajveer 14840 
    self.delayReasonText = delayReasonText
3553 chandransh 14841 
 
14842 
  def read(self, iprot):
14843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14845 
      return
14846 
    iprot.readStructBegin()
14847 
    while True:
14848 
      (fname, ftype, fid) = iprot.readFieldBegin()
14849 
      if ftype == TType.STOP:
14850 
        break
14851 
      if fid == 1:
14852 
        if ftype == TType.I64:
14853 
          self.orderId = iprot.readI64();
14854 
        else:
14855 
          iprot.skip(ftype)
14856 
      elif fid == 2:
14857 
        if ftype == TType.I32:
14858 
          self.delayReason = iprot.readI32();
14859 
        else:
14860 
          iprot.skip(ftype)
3986 chandransh 14861 
      elif fid == 3:
14862 
        if ftype == TType.I64:
14863 
          self.furtherDelay = iprot.readI64();
14864 
        else:
14865 
          iprot.skip(ftype)
4647 rajveer 14866 
      elif fid == 4:
14867 
        if ftype == TType.STRING:
14868 
          self.delayReasonText = iprot.readString();
14869 
        else:
14870 
          iprot.skip(ftype)
3553 chandransh 14871 
      else:
14872 
        iprot.skip(ftype)
14873 
      iprot.readFieldEnd()
14874 
    iprot.readStructEnd()
14875 
 
14876 
  def write(self, oprot):
14877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14879 
      return
14880 
    oprot.writeStructBegin('addDelayReason_args')
14881 
    if self.orderId is not None:
14882 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14883 
      oprot.writeI64(self.orderId)
14884 
      oprot.writeFieldEnd()
14885 
    if self.delayReason is not None:
14886 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
14887 
      oprot.writeI32(self.delayReason)
14888 
      oprot.writeFieldEnd()
3986 chandransh 14889 
    if self.furtherDelay is not None:
14890 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
14891 
      oprot.writeI64(self.furtherDelay)
14892 
      oprot.writeFieldEnd()
4647 rajveer 14893 
    if self.delayReasonText is not None:
14894 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
14895 
      oprot.writeString(self.delayReasonText)
14896 
      oprot.writeFieldEnd()
3553 chandransh 14897 
    oprot.writeFieldStop()
14898 
    oprot.writeStructEnd()
14899 
 
14900 
  def validate(self):
14901 
    return
14902 
 
14903 
 
14904 
  def __repr__(self):
14905 
    L = ['%s=%r' % (key, value)
14906 
      for key, value in self.__dict__.iteritems()]
14907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14908 
 
14909 
  def __eq__(self, other):
14910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14911 
 
14912 
  def __ne__(self, other):
14913 
    return not (self == other)
14914 
 
14915 
class addDelayReason_result:
14916 
  """
14917 
  Attributes:
14918 
   - success
14919 
   - ex
14920 
  """
14921 
 
14922 
  thrift_spec = (
14923 
    (0, TType.BOOL, 'success', None, None, ), # 0
14924 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14925 
  )
14926 
 
14927 
  def __init__(self, success=None, ex=None,):
14928 
    self.success = success
14929 
    self.ex = ex
14930 
 
14931 
  def read(self, iprot):
14932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14934 
      return
14935 
    iprot.readStructBegin()
14936 
    while True:
14937 
      (fname, ftype, fid) = iprot.readFieldBegin()
14938 
      if ftype == TType.STOP:
14939 
        break
14940 
      if fid == 0:
14941 
        if ftype == TType.BOOL:
14942 
          self.success = iprot.readBool();
14943 
        else:
14944 
          iprot.skip(ftype)
14945 
      elif fid == 1:
14946 
        if ftype == TType.STRUCT:
14947 
          self.ex = TransactionServiceException()
14948 
          self.ex.read(iprot)
14949 
        else:
14950 
          iprot.skip(ftype)
14951 
      else:
14952 
        iprot.skip(ftype)
14953 
      iprot.readFieldEnd()
14954 
    iprot.readStructEnd()
14955 
 
14956 
  def write(self, oprot):
14957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14959 
      return
14960 
    oprot.writeStructBegin('addDelayReason_result')
14961 
    if self.success is not None:
14962 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14963 
      oprot.writeBool(self.success)
14964 
      oprot.writeFieldEnd()
14965 
    if self.ex is not None:
14966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14967 
      self.ex.write(oprot)
14968 
      oprot.writeFieldEnd()
14969 
    oprot.writeFieldStop()
14970 
    oprot.writeStructEnd()
14971 
 
14972 
  def validate(self):
14973 
    return
14974 
 
14975 
 
14976 
  def __repr__(self):
14977 
    L = ['%s=%r' % (key, value)
14978 
      for key, value in self.__dict__.iteritems()]
14979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14980 
 
14981 
  def __eq__(self, other):
14982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14983 
 
14984 
  def __ne__(self, other):
14985 
    return not (self == other)
3956 chandransh 14986 
 
14987 
class reconcileCodCollection_args:
14988 
  """
14989 
  Attributes:
14990 
   - collectedAmountMap
14991 
   - xferBy
14992 
   - xferTxnId
14993 
   - xferDate
14994 
  """
14995 
 
14996 
  thrift_spec = (
14997 
    None, # 0
14998 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
14999 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
15000 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
15001 
    (4, TType.I64, 'xferDate', None, None, ), # 4
15002 
  )
15003 
 
15004 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
15005 
    self.collectedAmountMap = collectedAmountMap
15006 
    self.xferBy = xferBy
15007 
    self.xferTxnId = xferTxnId
15008 
    self.xferDate = xferDate
15009 
 
15010 
  def read(self, iprot):
15011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15013 
      return
15014 
    iprot.readStructBegin()
15015 
    while True:
15016 
      (fname, ftype, fid) = iprot.readFieldBegin()
15017 
      if ftype == TType.STOP:
15018 
        break
15019 
      if fid == 1:
15020 
        if ftype == TType.MAP:
15021 
          self.collectedAmountMap = {}
4757 mandeep.dh 15022 
          (_ktype237, _vtype238, _size236 ) = iprot.readMapBegin()
15023 
          for _i240 in xrange(_size236):
15024 
            _key241 = iprot.readString();
15025 
            _val242 = iprot.readDouble();
15026 
            self.collectedAmountMap[_key241] = _val242
3956 chandransh 15027 
          iprot.readMapEnd()
15028 
        else:
15029 
          iprot.skip(ftype)
15030 
      elif fid == 2:
15031 
        if ftype == TType.STRING:
15032 
          self.xferBy = iprot.readString();
15033 
        else:
15034 
          iprot.skip(ftype)
15035 
      elif fid == 3:
15036 
        if ftype == TType.STRING:
15037 
          self.xferTxnId = iprot.readString();
15038 
        else:
15039 
          iprot.skip(ftype)
15040 
      elif fid == 4:
15041 
        if ftype == TType.I64:
15042 
          self.xferDate = iprot.readI64();
15043 
        else:
15044 
          iprot.skip(ftype)
15045 
      else:
15046 
        iprot.skip(ftype)
15047 
      iprot.readFieldEnd()
15048 
    iprot.readStructEnd()
15049 
 
15050 
  def write(self, oprot):
15051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15053 
      return
15054 
    oprot.writeStructBegin('reconcileCodCollection_args')
15055 
    if self.collectedAmountMap is not None:
15056 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
15057 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4757 mandeep.dh 15058 
      for kiter243,viter244 in self.collectedAmountMap.items():
15059 
        oprot.writeString(kiter243)
15060 
        oprot.writeDouble(viter244)
3956 chandransh 15061 
      oprot.writeMapEnd()
15062 
      oprot.writeFieldEnd()
15063 
    if self.xferBy is not None:
15064 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
15065 
      oprot.writeString(self.xferBy)
15066 
      oprot.writeFieldEnd()
15067 
    if self.xferTxnId is not None:
15068 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
15069 
      oprot.writeString(self.xferTxnId)
15070 
      oprot.writeFieldEnd()
15071 
    if self.xferDate is not None:
15072 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
15073 
      oprot.writeI64(self.xferDate)
15074 
      oprot.writeFieldEnd()
15075 
    oprot.writeFieldStop()
15076 
    oprot.writeStructEnd()
15077 
 
15078 
  def validate(self):
15079 
    return
15080 
 
15081 
 
15082 
  def __repr__(self):
15083 
    L = ['%s=%r' % (key, value)
15084 
      for key, value in self.__dict__.iteritems()]
15085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15086 
 
15087 
  def __eq__(self, other):
15088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15089 
 
15090 
  def __ne__(self, other):
15091 
    return not (self == other)
15092 
 
15093 
class reconcileCodCollection_result:
15094 
  """
15095 
  Attributes:
15096 
   - success
15097 
   - ex
15098 
  """
15099 
 
15100 
  thrift_spec = (
15101 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15102 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15103 
  )
15104 
 
15105 
  def __init__(self, success=None, ex=None,):
15106 
    self.success = success
15107 
    self.ex = ex
15108 
 
15109 
  def read(self, iprot):
15110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15112 
      return
15113 
    iprot.readStructBegin()
15114 
    while True:
15115 
      (fname, ftype, fid) = iprot.readFieldBegin()
15116 
      if ftype == TType.STOP:
15117 
        break
15118 
      if fid == 0:
15119 
        if ftype == TType.MAP:
15120 
          self.success = {}
4757 mandeep.dh 15121 
          (_ktype246, _vtype247, _size245 ) = iprot.readMapBegin()
15122 
          for _i249 in xrange(_size245):
15123 
            _key250 = iprot.readString();
15124 
            _val251 = iprot.readString();
15125 
            self.success[_key250] = _val251
3956 chandransh 15126 
          iprot.readMapEnd()
15127 
        else:
15128 
          iprot.skip(ftype)
15129 
      elif fid == 1:
15130 
        if ftype == TType.STRUCT:
15131 
          self.ex = TransactionServiceException()
15132 
          self.ex.read(iprot)
15133 
        else:
15134 
          iprot.skip(ftype)
15135 
      else:
15136 
        iprot.skip(ftype)
15137 
      iprot.readFieldEnd()
15138 
    iprot.readStructEnd()
15139 
 
15140 
  def write(self, oprot):
15141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15143 
      return
15144 
    oprot.writeStructBegin('reconcileCodCollection_result')
15145 
    if self.success is not None:
15146 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15147 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4757 mandeep.dh 15148 
      for kiter252,viter253 in self.success.items():
15149 
        oprot.writeString(kiter252)
15150 
        oprot.writeString(viter253)
3956 chandransh 15151 
      oprot.writeMapEnd()
15152 
      oprot.writeFieldEnd()
15153 
    if self.ex is not None:
15154 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15155 
      self.ex.write(oprot)
15156 
      oprot.writeFieldEnd()
15157 
    oprot.writeFieldStop()
15158 
    oprot.writeStructEnd()
15159 
 
15160 
  def validate(self):
15161 
    return
15162 
 
15163 
 
15164 
  def __repr__(self):
15165 
    L = ['%s=%r' % (key, value)
15166 
      for key, value in self.__dict__.iteritems()]
15167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15168 
 
15169 
  def __eq__(self, other):
15170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15171 
 
15172 
  def __ne__(self, other):
15173 
    return not (self == other)
4008 mandeep.dh 15174 
 
15175 
class getTransactionsRequiringExtraProcessing_args:
15176 
  """
15177 
  Attributes:
15178 
   - category
15179 
  """
15180 
 
15181 
  thrift_spec = (
15182 
    None, # 0
15183 
    (1, TType.I32, 'category', None, None, ), # 1
15184 
  )
15185 
 
15186 
  def __init__(self, category=None,):
15187 
    self.category = category
15188 
 
15189 
  def read(self, iprot):
15190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15192 
      return
15193 
    iprot.readStructBegin()
15194 
    while True:
15195 
      (fname, ftype, fid) = iprot.readFieldBegin()
15196 
      if ftype == TType.STOP:
15197 
        break
15198 
      if fid == 1:
15199 
        if ftype == TType.I32:
15200 
          self.category = iprot.readI32();
15201 
        else:
15202 
          iprot.skip(ftype)
15203 
      else:
15204 
        iprot.skip(ftype)
15205 
      iprot.readFieldEnd()
15206 
    iprot.readStructEnd()
15207 
 
15208 
  def write(self, oprot):
15209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15211 
      return
15212 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
15213 
    if self.category is not None:
15214 
      oprot.writeFieldBegin('category', TType.I32, 1)
15215 
      oprot.writeI32(self.category)
15216 
      oprot.writeFieldEnd()
15217 
    oprot.writeFieldStop()
15218 
    oprot.writeStructEnd()
15219 
 
15220 
  def validate(self):
15221 
    return
15222 
 
15223 
 
15224 
  def __repr__(self):
15225 
    L = ['%s=%r' % (key, value)
15226 
      for key, value in self.__dict__.iteritems()]
15227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15228 
 
15229 
  def __eq__(self, other):
15230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15231 
 
15232 
  def __ne__(self, other):
15233 
    return not (self == other)
15234 
 
15235 
class getTransactionsRequiringExtraProcessing_result:
15236 
  """
15237 
  Attributes:
15238 
   - success
15239 
  """
15240 
 
15241 
  thrift_spec = (
15242 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15243 
  )
15244 
 
15245 
  def __init__(self, success=None,):
15246 
    self.success = success
15247 
 
15248 
  def read(self, iprot):
15249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15251 
      return
15252 
    iprot.readStructBegin()
15253 
    while True:
15254 
      (fname, ftype, fid) = iprot.readFieldBegin()
15255 
      if ftype == TType.STOP:
15256 
        break
15257 
      if fid == 0:
15258 
        if ftype == TType.LIST:
15259 
          self.success = []
4757 mandeep.dh 15260 
          (_etype257, _size254) = iprot.readListBegin()
15261 
          for _i258 in xrange(_size254):
15262 
            _elem259 = iprot.readI64();
15263 
            self.success.append(_elem259)
4008 mandeep.dh 15264 
          iprot.readListEnd()
15265 
        else:
15266 
          iprot.skip(ftype)
15267 
      else:
15268 
        iprot.skip(ftype)
15269 
      iprot.readFieldEnd()
15270 
    iprot.readStructEnd()
15271 
 
15272 
  def write(self, oprot):
15273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15275 
      return
15276 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
15277 
    if self.success is not None:
15278 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15279 
      oprot.writeListBegin(TType.I64, len(self.success))
4757 mandeep.dh 15280 
      for iter260 in self.success:
15281 
        oprot.writeI64(iter260)
4008 mandeep.dh 15282 
      oprot.writeListEnd()
15283 
      oprot.writeFieldEnd()
15284 
    oprot.writeFieldStop()
15285 
    oprot.writeStructEnd()
15286 
 
15287 
  def validate(self):
15288 
    return
15289 
 
15290 
 
15291 
  def __repr__(self):
15292 
    L = ['%s=%r' % (key, value)
15293 
      for key, value in self.__dict__.iteritems()]
15294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15295 
 
15296 
  def __eq__(self, other):
15297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15298 
 
15299 
  def __ne__(self, other):
15300 
    return not (self == other)
15301 
 
15302 
class markTransactionAsProcessed_args:
15303 
  """
15304 
  Attributes:
15305 
   - transactionId
15306 
   - category
15307 
  """
15308 
 
15309 
  thrift_spec = (
15310 
    None, # 0
15311 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15312 
    (2, TType.I32, 'category', None, None, ), # 2
15313 
  )
15314 
 
15315 
  def __init__(self, transactionId=None, category=None,):
15316 
    self.transactionId = transactionId
15317 
    self.category = category
15318 
 
15319 
  def read(self, iprot):
15320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15322 
      return
15323 
    iprot.readStructBegin()
15324 
    while True:
15325 
      (fname, ftype, fid) = iprot.readFieldBegin()
15326 
      if ftype == TType.STOP:
15327 
        break
15328 
      if fid == 1:
15329 
        if ftype == TType.I64:
15330 
          self.transactionId = iprot.readI64();
15331 
        else:
15332 
          iprot.skip(ftype)
15333 
      elif fid == 2:
15334 
        if ftype == TType.I32:
15335 
          self.category = iprot.readI32();
15336 
        else:
15337 
          iprot.skip(ftype)
15338 
      else:
15339 
        iprot.skip(ftype)
15340 
      iprot.readFieldEnd()
15341 
    iprot.readStructEnd()
15342 
 
15343 
  def write(self, oprot):
15344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15346 
      return
15347 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
15348 
    if self.transactionId is not None:
15349 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15350 
      oprot.writeI64(self.transactionId)
15351 
      oprot.writeFieldEnd()
15352 
    if self.category is not None:
15353 
      oprot.writeFieldBegin('category', TType.I32, 2)
15354 
      oprot.writeI32(self.category)
15355 
      oprot.writeFieldEnd()
15356 
    oprot.writeFieldStop()
15357 
    oprot.writeStructEnd()
15358 
 
15359 
  def validate(self):
15360 
    return
15361 
 
15362 
 
15363 
  def __repr__(self):
15364 
    L = ['%s=%r' % (key, value)
15365 
      for key, value in self.__dict__.iteritems()]
15366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15367 
 
15368 
  def __eq__(self, other):
15369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15370 
 
15371 
  def __ne__(self, other):
15372 
    return not (self == other)
15373 
 
15374 
class markTransactionAsProcessed_result:
15375 
 
15376 
  thrift_spec = (
15377 
  )
15378 
 
15379 
  def read(self, iprot):
15380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15382 
      return
15383 
    iprot.readStructBegin()
15384 
    while True:
15385 
      (fname, ftype, fid) = iprot.readFieldBegin()
15386 
      if ftype == TType.STOP:
15387 
        break
15388 
      else:
15389 
        iprot.skip(ftype)
15390 
      iprot.readFieldEnd()
15391 
    iprot.readStructEnd()
15392 
 
15393 
  def write(self, oprot):
15394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15396 
      return
15397 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
15398 
    oprot.writeFieldStop()
15399 
    oprot.writeStructEnd()
15400 
 
15401 
  def validate(self):
15402 
    return
15403 
 
15404 
 
15405 
  def __repr__(self):
15406 
    L = ['%s=%r' % (key, value)
15407 
      for key, value in self.__dict__.iteritems()]
15408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15409 
 
15410 
  def __eq__(self, other):
15411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15412 
 
15413 
  def __ne__(self, other):
15414 
    return not (self == other)
4018 chandransh 15415 
 
15416 
class getItemWiseRiskyOrdersCount_args:
15417 
 
15418 
  thrift_spec = (
15419 
  )
15420 
 
15421 
  def read(self, iprot):
15422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15424 
      return
15425 
    iprot.readStructBegin()
15426 
    while True:
15427 
      (fname, ftype, fid) = iprot.readFieldBegin()
15428 
      if ftype == TType.STOP:
15429 
        break
15430 
      else:
15431 
        iprot.skip(ftype)
15432 
      iprot.readFieldEnd()
15433 
    iprot.readStructEnd()
15434 
 
15435 
  def write(self, oprot):
15436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15438 
      return
15439 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
15440 
    oprot.writeFieldStop()
15441 
    oprot.writeStructEnd()
15442 
 
15443 
  def validate(self):
15444 
    return
15445 
 
15446 
 
15447 
  def __repr__(self):
15448 
    L = ['%s=%r' % (key, value)
15449 
      for key, value in self.__dict__.iteritems()]
15450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15451 
 
15452 
  def __eq__(self, other):
15453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15454 
 
15455 
  def __ne__(self, other):
15456 
    return not (self == other)
15457 
 
15458 
class getItemWiseRiskyOrdersCount_result:
15459 
  """
15460 
  Attributes:
15461 
   - success
15462 
  """
15463 
 
15464 
  thrift_spec = (
15465 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
15466 
  )
15467 
 
15468 
  def __init__(self, success=None,):
15469 
    self.success = success
15470 
 
15471 
  def read(self, iprot):
15472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15474 
      return
15475 
    iprot.readStructBegin()
15476 
    while True:
15477 
      (fname, ftype, fid) = iprot.readFieldBegin()
15478 
      if ftype == TType.STOP:
15479 
        break
15480 
      if fid == 0:
15481 
        if ftype == TType.MAP:
15482 
          self.success = {}
4757 mandeep.dh 15483 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
15484 
          for _i265 in xrange(_size261):
15485 
            _key266 = iprot.readI64();
15486 
            _val267 = iprot.readI64();
15487 
            self.success[_key266] = _val267
4018 chandransh 15488 
          iprot.readMapEnd()
15489 
        else:
15490 
          iprot.skip(ftype)
15491 
      else:
15492 
        iprot.skip(ftype)
15493 
      iprot.readFieldEnd()
15494 
    iprot.readStructEnd()
15495 
 
15496 
  def write(self, oprot):
15497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15499 
      return
15500 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
15501 
    if self.success is not None:
15502 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15503 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4757 mandeep.dh 15504 
      for kiter268,viter269 in self.success.items():
15505 
        oprot.writeI64(kiter268)
15506 
        oprot.writeI64(viter269)
4018 chandransh 15507 
      oprot.writeMapEnd()
15508 
      oprot.writeFieldEnd()
15509 
    oprot.writeFieldStop()
15510 
    oprot.writeStructEnd()
15511 
 
15512 
  def validate(self):
15513 
    return
15514 
 
15515 
 
15516 
  def __repr__(self):
15517 
    L = ['%s=%r' % (key, value)
15518 
      for key, value in self.__dict__.iteritems()]
15519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15520 
 
15521 
  def __eq__(self, other):
15522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15523 
 
15524 
  def __ne__(self, other):
15525 
    return not (self == other)
4247 rajveer 15526 
 
4295 varun.gupt 15527 
class getOrdersForItemIds_args:
15528 
  """
15529 
  Attributes:
15530 
   - itemIds
15531 
  """
15532 
 
15533 
  thrift_spec = (
15534 
    None, # 0
15535 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15536 
  )
15537 
 
15538 
  def __init__(self, itemIds=None,):
15539 
    self.itemIds = itemIds
15540 
 
15541 
  def read(self, iprot):
15542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15544 
      return
15545 
    iprot.readStructBegin()
15546 
    while True:
15547 
      (fname, ftype, fid) = iprot.readFieldBegin()
15548 
      if ftype == TType.STOP:
15549 
        break
15550 
      if fid == 1:
15551 
        if ftype == TType.LIST:
15552 
          self.itemIds = []
4757 mandeep.dh 15553 
          (_etype273, _size270) = iprot.readListBegin()
15554 
          for _i274 in xrange(_size270):
15555 
            _elem275 = iprot.readI64();
15556 
            self.itemIds.append(_elem275)
4295 varun.gupt 15557 
          iprot.readListEnd()
15558 
        else:
15559 
          iprot.skip(ftype)
15560 
      else:
15561 
        iprot.skip(ftype)
15562 
      iprot.readFieldEnd()
15563 
    iprot.readStructEnd()
15564 
 
15565 
  def write(self, oprot):
15566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15568 
      return
15569 
    oprot.writeStructBegin('getOrdersForItemIds_args')
15570 
    if self.itemIds is not None:
15571 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15572 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4757 mandeep.dh 15573 
      for iter276 in self.itemIds:
15574 
        oprot.writeI64(iter276)
4295 varun.gupt 15575 
      oprot.writeListEnd()
15576 
      oprot.writeFieldEnd()
15577 
    oprot.writeFieldStop()
15578 
    oprot.writeStructEnd()
15579 
 
15580 
  def validate(self):
15581 
    return
15582 
 
15583 
 
15584 
  def __repr__(self):
15585 
    L = ['%s=%r' % (key, value)
15586 
      for key, value in self.__dict__.iteritems()]
15587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15588 
 
15589 
  def __eq__(self, other):
15590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15591 
 
15592 
  def __ne__(self, other):
15593 
    return not (self == other)
15594 
 
15595 
class getOrdersForItemIds_result:
15596 
  """
15597 
  Attributes:
15598 
   - success
15599 
  """
15600 
 
15601 
  thrift_spec = (
15602 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15603 
  )
15604 
 
15605 
  def __init__(self, success=None,):
15606 
    self.success = success
15607 
 
15608 
  def read(self, iprot):
15609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15611 
      return
15612 
    iprot.readStructBegin()
15613 
    while True:
15614 
      (fname, ftype, fid) = iprot.readFieldBegin()
15615 
      if ftype == TType.STOP:
15616 
        break
15617 
      if fid == 0:
15618 
        if ftype == TType.LIST:
15619 
          self.success = []
4757 mandeep.dh 15620 
          (_etype280, _size277) = iprot.readListBegin()
15621 
          for _i281 in xrange(_size277):
15622 
            _elem282 = Order()
15623 
            _elem282.read(iprot)
15624 
            self.success.append(_elem282)
4295 varun.gupt 15625 
          iprot.readListEnd()
15626 
        else:
15627 
          iprot.skip(ftype)
15628 
      else:
15629 
        iprot.skip(ftype)
15630 
      iprot.readFieldEnd()
15631 
    iprot.readStructEnd()
15632 
 
15633 
  def write(self, oprot):
15634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15636 
      return
15637 
    oprot.writeStructBegin('getOrdersForItemIds_result')
15638 
    if self.success is not None:
15639 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15640 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4757 mandeep.dh 15641 
      for iter283 in self.success:
15642 
        iter283.write(oprot)
4295 varun.gupt 15643 
      oprot.writeListEnd()
15644 
      oprot.writeFieldEnd()
15645 
    oprot.writeFieldStop()
15646 
    oprot.writeStructEnd()
15647 
 
15648 
  def validate(self):
15649 
    return
15650 
 
15651 
 
15652 
  def __repr__(self):
15653 
    L = ['%s=%r' % (key, value)
15654 
      for key, value in self.__dict__.iteritems()]
15655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15656 
 
15657 
  def __eq__(self, other):
15658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15659 
 
15660 
  def __ne__(self, other):
15661 
    return not (self == other)
15662 
 
4247 rajveer 15663 
class markOrderCancellationRequestReceived_args:
15664 
  """
15665 
  Attributes:
15666 
   - orderId
15667 
  """
15668 
 
15669 
  thrift_spec = (
15670 
    None, # 0
15671 
    (1, TType.I64, 'orderId', None, None, ), # 1
15672 
  )
15673 
 
15674 
  def __init__(self, orderId=None,):
15675 
    self.orderId = orderId
15676 
 
15677 
  def read(self, iprot):
15678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15680 
      return
15681 
    iprot.readStructBegin()
15682 
    while True:
15683 
      (fname, ftype, fid) = iprot.readFieldBegin()
15684 
      if ftype == TType.STOP:
15685 
        break
15686 
      if fid == 1:
15687 
        if ftype == TType.I64:
15688 
          self.orderId = iprot.readI64();
15689 
        else:
15690 
          iprot.skip(ftype)
15691 
      else:
15692 
        iprot.skip(ftype)
15693 
      iprot.readFieldEnd()
15694 
    iprot.readStructEnd()
15695 
 
15696 
  def write(self, oprot):
15697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15699 
      return
15700 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
15701 
    if self.orderId is not None:
15702 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15703 
      oprot.writeI64(self.orderId)
15704 
      oprot.writeFieldEnd()
15705 
    oprot.writeFieldStop()
15706 
    oprot.writeStructEnd()
15707 
 
15708 
  def validate(self):
15709 
    return
15710 
 
15711 
 
15712 
  def __repr__(self):
15713 
    L = ['%s=%r' % (key, value)
15714 
      for key, value in self.__dict__.iteritems()]
15715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15716 
 
15717 
  def __eq__(self, other):
15718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15719 
 
15720 
  def __ne__(self, other):
15721 
    return not (self == other)
15722 
 
15723 
class markOrderCancellationRequestReceived_result:
15724 
  """
15725 
  Attributes:
15726 
   - ex
15727 
  """
15728 
 
15729 
  thrift_spec = (
15730 
    None, # 0
15731 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15732 
  )
15733 
 
15734 
  def __init__(self, ex=None,):
15735 
    self.ex = ex
15736 
 
15737 
  def read(self, iprot):
15738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15740 
      return
15741 
    iprot.readStructBegin()
15742 
    while True:
15743 
      (fname, ftype, fid) = iprot.readFieldBegin()
15744 
      if ftype == TType.STOP:
15745 
        break
15746 
      if fid == 1:
15747 
        if ftype == TType.STRUCT:
15748 
          self.ex = TransactionServiceException()
15749 
          self.ex.read(iprot)
15750 
        else:
15751 
          iprot.skip(ftype)
15752 
      else:
15753 
        iprot.skip(ftype)
15754 
      iprot.readFieldEnd()
15755 
    iprot.readStructEnd()
15756 
 
15757 
  def write(self, oprot):
15758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15760 
      return
15761 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
15762 
    if self.ex is not None:
15763 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15764 
      self.ex.write(oprot)
15765 
      oprot.writeFieldEnd()
15766 
    oprot.writeFieldStop()
15767 
    oprot.writeStructEnd()
15768 
 
15769 
  def validate(self):
15770 
    return
15771 
 
15772 
 
15773 
  def __repr__(self):
15774 
    L = ['%s=%r' % (key, value)
15775 
      for key, value in self.__dict__.iteritems()]
15776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15777 
 
15778 
  def __eq__(self, other):
15779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15780 
 
15781 
  def __ne__(self, other):
15782 
    return not (self == other)
15783 
 
15784 
class markOrderCancellationRequestConfirmed_args:
15785 
  """
15786 
  Attributes:
15787 
   - orderId
15788 
  """
15789 
 
15790 
  thrift_spec = (
15791 
    None, # 0
15792 
    (1, TType.I64, 'orderId', None, None, ), # 1
15793 
  )
15794 
 
15795 
  def __init__(self, orderId=None,):
15796 
    self.orderId = orderId
15797 
 
15798 
  def read(self, iprot):
15799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15801 
      return
15802 
    iprot.readStructBegin()
15803 
    while True:
15804 
      (fname, ftype, fid) = iprot.readFieldBegin()
15805 
      if ftype == TType.STOP:
15806 
        break
15807 
      if fid == 1:
15808 
        if ftype == TType.I64:
15809 
          self.orderId = iprot.readI64();
15810 
        else:
15811 
          iprot.skip(ftype)
15812 
      else:
15813 
        iprot.skip(ftype)
15814 
      iprot.readFieldEnd()
15815 
    iprot.readStructEnd()
15816 
 
15817 
  def write(self, oprot):
15818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15820 
      return
15821 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
15822 
    if self.orderId is not None:
15823 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15824 
      oprot.writeI64(self.orderId)
15825 
      oprot.writeFieldEnd()
15826 
    oprot.writeFieldStop()
15827 
    oprot.writeStructEnd()
15828 
 
15829 
  def validate(self):
15830 
    return
15831 
 
15832 
 
15833 
  def __repr__(self):
15834 
    L = ['%s=%r' % (key, value)
15835 
      for key, value in self.__dict__.iteritems()]
15836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15837 
 
15838 
  def __eq__(self, other):
15839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15840 
 
15841 
  def __ne__(self, other):
15842 
    return not (self == other)
15843 
 
15844 
class markOrderCancellationRequestConfirmed_result:
15845 
  """
15846 
  Attributes:
15847 
   - ex
15848 
  """
15849 
 
15850 
  thrift_spec = (
15851 
    None, # 0
15852 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15853 
  )
15854 
 
15855 
  def __init__(self, ex=None,):
15856 
    self.ex = ex
15857 
 
15858 
  def read(self, iprot):
15859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15861 
      return
15862 
    iprot.readStructBegin()
15863 
    while True:
15864 
      (fname, ftype, fid) = iprot.readFieldBegin()
15865 
      if ftype == TType.STOP:
15866 
        break
15867 
      if fid == 1:
15868 
        if ftype == TType.STRUCT:
15869 
          self.ex = TransactionServiceException()
15870 
          self.ex.read(iprot)
15871 
        else:
15872 
          iprot.skip(ftype)
15873 
      else:
15874 
        iprot.skip(ftype)
15875 
      iprot.readFieldEnd()
15876 
    iprot.readStructEnd()
15877 
 
15878 
  def write(self, oprot):
15879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15881 
      return
15882 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
15883 
    if self.ex is not None:
15884 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15885 
      self.ex.write(oprot)
15886 
      oprot.writeFieldEnd()
15887 
    oprot.writeFieldStop()
15888 
    oprot.writeStructEnd()
15889 
 
15890 
  def validate(self):
15891 
    return
15892 
 
15893 
 
15894 
  def __repr__(self):
15895 
    L = ['%s=%r' % (key, value)
15896 
      for key, value in self.__dict__.iteritems()]
15897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15898 
 
15899 
  def __eq__(self, other):
15900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15901 
 
15902 
  def __ne__(self, other):
15903 
    return not (self == other)
15904 
 
15905 
class markOrderCancellationRequestDenied_args:
15906 
  """
15907 
  Attributes:
15908 
   - orderId
15909 
  """
15910 
 
15911 
  thrift_spec = (
15912 
    None, # 0
15913 
    (1, TType.I64, 'orderId', None, None, ), # 1
15914 
  )
15915 
 
15916 
  def __init__(self, orderId=None,):
15917 
    self.orderId = orderId
15918 
 
15919 
  def read(self, iprot):
15920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15922 
      return
15923 
    iprot.readStructBegin()
15924 
    while True:
15925 
      (fname, ftype, fid) = iprot.readFieldBegin()
15926 
      if ftype == TType.STOP:
15927 
        break
15928 
      if fid == 1:
15929 
        if ftype == TType.I64:
15930 
          self.orderId = iprot.readI64();
15931 
        else:
15932 
          iprot.skip(ftype)
15933 
      else:
15934 
        iprot.skip(ftype)
15935 
      iprot.readFieldEnd()
15936 
    iprot.readStructEnd()
15937 
 
15938 
  def write(self, oprot):
15939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15941 
      return
15942 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
15943 
    if self.orderId is not None:
15944 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15945 
      oprot.writeI64(self.orderId)
15946 
      oprot.writeFieldEnd()
15947 
    oprot.writeFieldStop()
15948 
    oprot.writeStructEnd()
15949 
 
15950 
  def validate(self):
15951 
    return
15952 
 
15953 
 
15954 
  def __repr__(self):
15955 
    L = ['%s=%r' % (key, value)
15956 
      for key, value in self.__dict__.iteritems()]
15957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15958 
 
15959 
  def __eq__(self, other):
15960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15961 
 
15962 
  def __ne__(self, other):
15963 
    return not (self == other)
15964 
 
15965 
class markOrderCancellationRequestDenied_result:
15966 
  """
15967 
  Attributes:
15968 
   - ex
15969 
  """
15970 
 
15971 
  thrift_spec = (
15972 
    None, # 0
15973 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15974 
  )
15975 
 
15976 
  def __init__(self, ex=None,):
15977 
    self.ex = ex
15978 
 
15979 
  def read(self, iprot):
15980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15982 
      return
15983 
    iprot.readStructBegin()
15984 
    while True:
15985 
      (fname, ftype, fid) = iprot.readFieldBegin()
15986 
      if ftype == TType.STOP:
15987 
        break
15988 
      if fid == 1:
15989 
        if ftype == TType.STRUCT:
15990 
          self.ex = TransactionServiceException()
15991 
          self.ex.read(iprot)
15992 
        else:
15993 
          iprot.skip(ftype)
15994 
      else:
15995 
        iprot.skip(ftype)
15996 
      iprot.readFieldEnd()
15997 
    iprot.readStructEnd()
15998 
 
15999 
  def write(self, oprot):
16000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16002 
      return
16003 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
16004 
    if self.ex is not None:
16005 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16006 
      self.ex.write(oprot)
16007 
      oprot.writeFieldEnd()
16008 
    oprot.writeFieldStop()
16009 
    oprot.writeStructEnd()
16010 
 
16011 
  def validate(self):
16012 
    return
16013 
 
16014 
 
16015 
  def __repr__(self):
16016 
    L = ['%s=%r' % (key, value)
16017 
      for key, value in self.__dict__.iteritems()]
16018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16019 
 
16020 
  def __eq__(self, other):
16021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16022 
 
16023 
  def __ne__(self, other):
16024 
    return not (self == other)
16025 
 
4258 rajveer 16026 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 16027 
  """
16028 
  Attributes:
4258 rajveer 16029 
   - transactionId
4247 rajveer 16030 
  """
16031 
 
16032 
  thrift_spec = (
16033 
    None, # 0
4258 rajveer 16034 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 16035 
  )
16036 
 
4258 rajveer 16037 
  def __init__(self, transactionId=None,):
16038 
    self.transactionId = transactionId
4247 rajveer 16039 
 
16040 
  def read(self, iprot):
16041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16043 
      return
16044 
    iprot.readStructBegin()
16045 
    while True:
16046 
      (fname, ftype, fid) = iprot.readFieldBegin()
16047 
      if ftype == TType.STOP:
16048 
        break
16049 
      if fid == 1:
16050 
        if ftype == TType.I64:
4258 rajveer 16051 
          self.transactionId = iprot.readI64();
4247 rajveer 16052 
        else:
16053 
          iprot.skip(ftype)
16054 
      else:
16055 
        iprot.skip(ftype)
16056 
      iprot.readFieldEnd()
16057 
    iprot.readStructEnd()
16058 
 
16059 
  def write(self, oprot):
16060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16062 
      return
4258 rajveer 16063 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
16064 
    if self.transactionId is not None:
16065 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16066 
      oprot.writeI64(self.transactionId)
4247 rajveer 16067 
      oprot.writeFieldEnd()
16068 
    oprot.writeFieldStop()
16069 
    oprot.writeStructEnd()
16070 
 
16071 
  def validate(self):
16072 
    return
16073 
 
16074 
 
16075 
  def __repr__(self):
16076 
    L = ['%s=%r' % (key, value)
16077 
      for key, value in self.__dict__.iteritems()]
16078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16079 
 
16080 
  def __eq__(self, other):
16081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16082 
 
16083 
  def __ne__(self, other):
16084 
    return not (self == other)
16085 
 
4258 rajveer 16086 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 16087 
  """
16088 
  Attributes:
16089 
   - ex
16090 
  """
16091 
 
16092 
  thrift_spec = (
16093 
    None, # 0
16094 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16095 
  )
16096 
 
16097 
  def __init__(self, ex=None,):
16098 
    self.ex = ex
16099 
 
16100 
  def read(self, iprot):
16101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16103 
      return
16104 
    iprot.readStructBegin()
16105 
    while True:
16106 
      (fname, ftype, fid) = iprot.readFieldBegin()
16107 
      if ftype == TType.STOP:
16108 
        break
16109 
      if fid == 1:
16110 
        if ftype == TType.STRUCT:
16111 
          self.ex = TransactionServiceException()
16112 
          self.ex.read(iprot)
16113 
        else:
16114 
          iprot.skip(ftype)
16115 
      else:
16116 
        iprot.skip(ftype)
16117 
      iprot.readFieldEnd()
16118 
    iprot.readStructEnd()
16119 
 
16120 
  def write(self, oprot):
16121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16123 
      return
4258 rajveer 16124 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 16125 
    if self.ex is not None:
16126 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16127 
      self.ex.write(oprot)
16128 
      oprot.writeFieldEnd()
16129 
    oprot.writeFieldStop()
16130 
    oprot.writeStructEnd()
16131 
 
16132 
  def validate(self):
16133 
    return
16134 
 
16135 
 
16136 
  def __repr__(self):
16137 
    L = ['%s=%r' % (key, value)
16138 
      for key, value in self.__dict__.iteritems()]
16139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16140 
 
16141 
  def __eq__(self, other):
16142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16143 
 
16144 
  def __ne__(self, other):
16145 
    return not (self == other)
4259 anupam.sin 16146 
 
16147 
class refundTransaction_args:
16148 
  """
16149 
  Attributes:
16150 
   - transactionId
16151 
   - refundedBy
16152 
   - reason
16153 
  """
16154 
 
16155 
  thrift_spec = (
16156 
    None, # 0
16157 
    (1, TType.I64, 'transactionId', None, None, ), # 1
16158 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
16159 
    (3, TType.STRING, 'reason', None, None, ), # 3
16160 
  )
16161 
 
16162 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
16163 
    self.transactionId = transactionId
16164 
    self.refundedBy = refundedBy
16165 
    self.reason = reason
16166 
 
16167 
  def read(self, iprot):
16168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16170 
      return
16171 
    iprot.readStructBegin()
16172 
    while True:
16173 
      (fname, ftype, fid) = iprot.readFieldBegin()
16174 
      if ftype == TType.STOP:
16175 
        break
16176 
      if fid == 1:
16177 
        if ftype == TType.I64:
16178 
          self.transactionId = iprot.readI64();
16179 
        else:
16180 
          iprot.skip(ftype)
16181 
      elif fid == 2:
16182 
        if ftype == TType.STRING:
16183 
          self.refundedBy = iprot.readString();
16184 
        else:
16185 
          iprot.skip(ftype)
16186 
      elif fid == 3:
16187 
        if ftype == TType.STRING:
16188 
          self.reason = iprot.readString();
16189 
        else:
16190 
          iprot.skip(ftype)
16191 
      else:
16192 
        iprot.skip(ftype)
16193 
      iprot.readFieldEnd()
16194 
    iprot.readStructEnd()
16195 
 
16196 
  def write(self, oprot):
16197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16199 
      return
16200 
    oprot.writeStructBegin('refundTransaction_args')
16201 
    if self.transactionId is not None:
16202 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16203 
      oprot.writeI64(self.transactionId)
16204 
      oprot.writeFieldEnd()
16205 
    if self.refundedBy is not None:
16206 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16207 
      oprot.writeString(self.refundedBy)
16208 
      oprot.writeFieldEnd()
16209 
    if self.reason is not None:
16210 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16211 
      oprot.writeString(self.reason)
16212 
      oprot.writeFieldEnd()
16213 
    oprot.writeFieldStop()
16214 
    oprot.writeStructEnd()
16215 
 
16216 
  def validate(self):
16217 
    return
16218 
 
16219 
 
16220 
  def __repr__(self):
16221 
    L = ['%s=%r' % (key, value)
16222 
      for key, value in self.__dict__.iteritems()]
16223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16224 
 
16225 
  def __eq__(self, other):
16226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16227 
 
16228 
  def __ne__(self, other):
16229 
    return not (self == other)
16230 
 
16231 
class refundTransaction_result:
16232 
  """
16233 
  Attributes:
16234 
   - ex
16235 
  """
16236 
 
16237 
  thrift_spec = (
16238 
    None, # 0
16239 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16240 
  )
16241 
 
16242 
  def __init__(self, ex=None,):
16243 
    self.ex = ex
16244 
 
16245 
  def read(self, iprot):
16246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16248 
      return
16249 
    iprot.readStructBegin()
16250 
    while True:
16251 
      (fname, ftype, fid) = iprot.readFieldBegin()
16252 
      if ftype == TType.STOP:
16253 
        break
16254 
      if fid == 1:
16255 
        if ftype == TType.STRUCT:
16256 
          self.ex = TransactionServiceException()
16257 
          self.ex.read(iprot)
16258 
        else:
16259 
          iprot.skip(ftype)
16260 
      else:
16261 
        iprot.skip(ftype)
16262 
      iprot.readFieldEnd()
16263 
    iprot.readStructEnd()
16264 
 
16265 
  def write(self, oprot):
16266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16268 
      return
16269 
    oprot.writeStructBegin('refundTransaction_result')
16270 
    if self.ex is not None:
16271 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16272 
      self.ex.write(oprot)
16273 
      oprot.writeFieldEnd()
16274 
    oprot.writeFieldStop()
16275 
    oprot.writeStructEnd()
16276 
 
16277 
  def validate(self):
16278 
    return
16279 
 
16280 
 
16281 
  def __repr__(self):
16282 
    L = ['%s=%r' % (key, value)
16283 
      for key, value in self.__dict__.iteritems()]
16284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16285 
 
16286 
  def __eq__(self, other):
16287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16288 
 
16289 
  def __ne__(self, other):
16290 
    return not (self == other)
4285 rajveer 16291 
 
4324 mandeep.dh 16292 
class updateShipmentAddress_args:
16293 
  """
16294 
  Attributes:
16295 
   - orderId
16296 
   - addressId
16297 
  """
16298 
 
16299 
  thrift_spec = (
16300 
    None, # 0
16301 
    (1, TType.I64, 'orderId', None, None, ), # 1
16302 
    (2, TType.I64, 'addressId', None, None, ), # 2
16303 
  )
16304 
 
16305 
  def __init__(self, orderId=None, addressId=None,):
16306 
    self.orderId = orderId
16307 
    self.addressId = addressId
16308 
 
16309 
  def read(self, iprot):
16310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16312 
      return
16313 
    iprot.readStructBegin()
16314 
    while True:
16315 
      (fname, ftype, fid) = iprot.readFieldBegin()
16316 
      if ftype == TType.STOP:
16317 
        break
16318 
      if fid == 1:
16319 
        if ftype == TType.I64:
16320 
          self.orderId = iprot.readI64();
16321 
        else:
16322 
          iprot.skip(ftype)
16323 
      elif fid == 2:
16324 
        if ftype == TType.I64:
16325 
          self.addressId = iprot.readI64();
16326 
        else:
16327 
          iprot.skip(ftype)
16328 
      else:
16329 
        iprot.skip(ftype)
16330 
      iprot.readFieldEnd()
16331 
    iprot.readStructEnd()
16332 
 
16333 
  def write(self, oprot):
16334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16336 
      return
16337 
    oprot.writeStructBegin('updateShipmentAddress_args')
16338 
    if self.orderId is not None:
16339 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16340 
      oprot.writeI64(self.orderId)
16341 
      oprot.writeFieldEnd()
16342 
    if self.addressId is not None:
16343 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
16344 
      oprot.writeI64(self.addressId)
16345 
      oprot.writeFieldEnd()
16346 
    oprot.writeFieldStop()
16347 
    oprot.writeStructEnd()
16348 
 
16349 
  def validate(self):
16350 
    return
16351 
 
16352 
 
16353 
  def __repr__(self):
16354 
    L = ['%s=%r' % (key, value)
16355 
      for key, value in self.__dict__.iteritems()]
16356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16357 
 
16358 
  def __eq__(self, other):
16359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16360 
 
16361 
  def __ne__(self, other):
16362 
    return not (self == other)
16363 
 
16364 
class updateShipmentAddress_result:
16365 
  """
16366 
  Attributes:
16367 
   - ex
16368 
  """
16369 
 
16370 
  thrift_spec = (
16371 
    None, # 0
16372 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16373 
  )
16374 
 
16375 
  def __init__(self, ex=None,):
16376 
    self.ex = ex
16377 
 
16378 
  def read(self, iprot):
16379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16381 
      return
16382 
    iprot.readStructBegin()
16383 
    while True:
16384 
      (fname, ftype, fid) = iprot.readFieldBegin()
16385 
      if ftype == TType.STOP:
16386 
        break
16387 
      if fid == 1:
16388 
        if ftype == TType.STRUCT:
16389 
          self.ex = TransactionServiceException()
16390 
          self.ex.read(iprot)
16391 
        else:
16392 
          iprot.skip(ftype)
16393 
      else:
16394 
        iprot.skip(ftype)
16395 
      iprot.readFieldEnd()
16396 
    iprot.readStructEnd()
16397 
 
16398 
  def write(self, oprot):
16399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16401 
      return
16402 
    oprot.writeStructBegin('updateShipmentAddress_result')
16403 
    if self.ex is not None:
16404 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16405 
      self.ex.write(oprot)
16406 
      oprot.writeFieldEnd()
16407 
    oprot.writeFieldStop()
16408 
    oprot.writeStructEnd()
16409 
 
16410 
  def validate(self):
16411 
    return
16412 
 
16413 
 
16414 
  def __repr__(self):
16415 
    L = ['%s=%r' % (key, value)
16416 
      for key, value in self.__dict__.iteritems()]
16417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16418 
 
16419 
  def __eq__(self, other):
16420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16421 
 
16422 
  def __ne__(self, other):
16423 
    return not (self == other)
16424 
 
4285 rajveer 16425 
class acceptOrdersForItemId_args:
16426 
  """
16427 
  Attributes:
16428 
   - itemId
16429 
   - inventory
16430 
  """
16431 
 
16432 
  thrift_spec = (
16433 
    None, # 0
16434 
    (1, TType.I64, 'itemId', None, None, ), # 1
16435 
    (2, TType.I64, 'inventory', None, None, ), # 2
16436 
  )
16437 
 
16438 
  def __init__(self, itemId=None, inventory=None,):
16439 
    self.itemId = itemId
16440 
    self.inventory = inventory
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.itemId = iprot.readI64();
16454 
        else:
16455 
          iprot.skip(ftype)
16456 
      elif fid == 2:
16457 
        if ftype == TType.I64:
16458 
          self.inventory = iprot.readI64();
16459 
        else:
16460 
          iprot.skip(ftype)
16461 
      else:
16462 
        iprot.skip(ftype)
16463 
      iprot.readFieldEnd()
16464 
    iprot.readStructEnd()
16465 
 
16466 
  def write(self, oprot):
16467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16469 
      return
16470 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
16471 
    if self.itemId is not None:
16472 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16473 
      oprot.writeI64(self.itemId)
16474 
      oprot.writeFieldEnd()
16475 
    if self.inventory is not None:
16476 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
16477 
      oprot.writeI64(self.inventory)
16478 
      oprot.writeFieldEnd()
16479 
    oprot.writeFieldStop()
16480 
    oprot.writeStructEnd()
16481 
 
16482 
  def validate(self):
16483 
    return
16484 
 
16485 
 
16486 
  def __repr__(self):
16487 
    L = ['%s=%r' % (key, value)
16488 
      for key, value in self.__dict__.iteritems()]
16489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16490 
 
16491 
  def __eq__(self, other):
16492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16493 
 
16494 
  def __ne__(self, other):
16495 
    return not (self == other)
16496 
 
16497 
class acceptOrdersForItemId_result:
16498 
  """
16499 
  Attributes:
16500 
   - success
16501 
   - ex
16502 
  """
16503 
 
16504 
  thrift_spec = (
16505 
    (0, TType.BOOL, 'success', None, None, ), # 0
16506 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16507 
  )
16508 
 
16509 
  def __init__(self, success=None, ex=None,):
16510 
    self.success = success
16511 
    self.ex = ex
16512 
 
16513 
  def read(self, iprot):
16514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16516 
      return
16517 
    iprot.readStructBegin()
16518 
    while True:
16519 
      (fname, ftype, fid) = iprot.readFieldBegin()
16520 
      if ftype == TType.STOP:
16521 
        break
16522 
      if fid == 0:
16523 
        if ftype == TType.BOOL:
16524 
          self.success = iprot.readBool();
16525 
        else:
16526 
          iprot.skip(ftype)
16527 
      elif fid == 1:
16528 
        if ftype == TType.STRUCT:
16529 
          self.ex = TransactionServiceException()
16530 
          self.ex.read(iprot)
16531 
        else:
16532 
          iprot.skip(ftype)
16533 
      else:
16534 
        iprot.skip(ftype)
16535 
      iprot.readFieldEnd()
16536 
    iprot.readStructEnd()
16537 
 
16538 
  def write(self, oprot):
16539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16541 
      return
16542 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
16543 
    if self.success is not None:
16544 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16545 
      oprot.writeBool(self.success)
16546 
      oprot.writeFieldEnd()
16547 
    if self.ex is not None:
16548 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16549 
      self.ex.write(oprot)
16550 
      oprot.writeFieldEnd()
16551 
    oprot.writeFieldStop()
16552 
    oprot.writeStructEnd()
16553 
 
16554 
  def validate(self):
16555 
    return
16556 
 
16557 
 
16558 
  def __repr__(self):
16559 
    L = ['%s=%r' % (key, value)
16560 
      for key, value in self.__dict__.iteritems()]
16561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16562 
 
16563 
  def __eq__(self, other):
16564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16565 
 
16566 
  def __ne__(self, other):
16567 
    return not (self == other)
4303 rajveer 16568 
 
16569 
class markOrdersAsPORaised_args:
16570 
  """
16571 
  Attributes:
16572 
   - vendorId
16573 
   - itemId
16574 
   - quantity
16575 
   - estimate
4369 rajveer 16576 
   - isReminder
4303 rajveer 16577 
  """
16578 
 
16579 
  thrift_spec = (
16580 
    None, # 0
16581 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16582 
    (2, TType.I64, 'itemId', None, None, ), # 2
16583 
    (3, TType.I64, 'quantity', None, None, ), # 3
16584 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16585 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16586 
  )
16587 
 
4369 rajveer 16588 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16589 
    self.vendorId = vendorId
16590 
    self.itemId = itemId
16591 
    self.quantity = quantity
16592 
    self.estimate = estimate
4369 rajveer 16593 
    self.isReminder = isReminder
4303 rajveer 16594 
 
16595 
  def read(self, iprot):
16596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16598 
      return
16599 
    iprot.readStructBegin()
16600 
    while True:
16601 
      (fname, ftype, fid) = iprot.readFieldBegin()
16602 
      if ftype == TType.STOP:
16603 
        break
16604 
      if fid == 1:
16605 
        if ftype == TType.I64:
16606 
          self.vendorId = iprot.readI64();
16607 
        else:
16608 
          iprot.skip(ftype)
16609 
      elif fid == 2:
16610 
        if ftype == TType.I64:
16611 
          self.itemId = iprot.readI64();
16612 
        else:
16613 
          iprot.skip(ftype)
16614 
      elif fid == 3:
16615 
        if ftype == TType.I64:
16616 
          self.quantity = iprot.readI64();
16617 
        else:
16618 
          iprot.skip(ftype)
16619 
      elif fid == 4:
16620 
        if ftype == TType.I64:
16621 
          self.estimate = iprot.readI64();
16622 
        else:
16623 
          iprot.skip(ftype)
4369 rajveer 16624 
      elif fid == 5:
16625 
        if ftype == TType.BOOL:
16626 
          self.isReminder = iprot.readBool();
16627 
        else:
16628 
          iprot.skip(ftype)
4303 rajveer 16629 
      else:
16630 
        iprot.skip(ftype)
16631 
      iprot.readFieldEnd()
16632 
    iprot.readStructEnd()
16633 
 
16634 
  def write(self, oprot):
16635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16637 
      return
16638 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
16639 
    if self.vendorId is not None:
16640 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16641 
      oprot.writeI64(self.vendorId)
16642 
      oprot.writeFieldEnd()
16643 
    if self.itemId is not None:
16644 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16645 
      oprot.writeI64(self.itemId)
16646 
      oprot.writeFieldEnd()
16647 
    if self.quantity is not None:
16648 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16649 
      oprot.writeI64(self.quantity)
16650 
      oprot.writeFieldEnd()
16651 
    if self.estimate is not None:
16652 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16653 
      oprot.writeI64(self.estimate)
16654 
      oprot.writeFieldEnd()
4369 rajveer 16655 
    if self.isReminder is not None:
16656 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16657 
      oprot.writeBool(self.isReminder)
16658 
      oprot.writeFieldEnd()
4303 rajveer 16659 
    oprot.writeFieldStop()
16660 
    oprot.writeStructEnd()
16661 
 
16662 
  def validate(self):
16663 
    return
16664 
 
16665 
 
16666 
  def __repr__(self):
16667 
    L = ['%s=%r' % (key, value)
16668 
      for key, value in self.__dict__.iteritems()]
16669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16670 
 
16671 
  def __eq__(self, other):
16672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16673 
 
16674 
  def __ne__(self, other):
16675 
    return not (self == other)
16676 
 
16677 
class markOrdersAsPORaised_result:
16678 
  """
16679 
  Attributes:
16680 
   - ex
16681 
  """
16682 
 
16683 
  thrift_spec = (
16684 
    None, # 0
16685 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16686 
  )
16687 
 
16688 
  def __init__(self, ex=None,):
16689 
    self.ex = ex
16690 
 
16691 
  def read(self, iprot):
16692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16694 
      return
16695 
    iprot.readStructBegin()
16696 
    while True:
16697 
      (fname, ftype, fid) = iprot.readFieldBegin()
16698 
      if ftype == TType.STOP:
16699 
        break
16700 
      if fid == 1:
16701 
        if ftype == TType.STRUCT:
16702 
          self.ex = TransactionServiceException()
16703 
          self.ex.read(iprot)
16704 
        else:
16705 
          iprot.skip(ftype)
16706 
      else:
16707 
        iprot.skip(ftype)
16708 
      iprot.readFieldEnd()
16709 
    iprot.readStructEnd()
16710 
 
16711 
  def write(self, oprot):
16712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16714 
      return
16715 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
16716 
    if self.ex is not None:
16717 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16718 
      self.ex.write(oprot)
16719 
      oprot.writeFieldEnd()
16720 
    oprot.writeFieldStop()
16721 
    oprot.writeStructEnd()
16722 
 
16723 
  def validate(self):
16724 
    return
16725 
 
16726 
 
16727 
  def __repr__(self):
16728 
    L = ['%s=%r' % (key, value)
16729 
      for key, value in self.__dict__.iteritems()]
16730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16731 
 
16732 
  def __eq__(self, other):
16733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16734 
 
16735 
  def __ne__(self, other):
16736 
    return not (self == other)
16737 
 
16738 
class markOrdersAsReversalInitiated_args:
16739 
  """
16740 
  Attributes:
16741 
   - vendorId
16742 
   - itemId
16743 
   - quantity
16744 
   - estimate
4369 rajveer 16745 
   - isReminder
4303 rajveer 16746 
  """
16747 
 
16748 
  thrift_spec = (
16749 
    None, # 0
16750 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16751 
    (2, TType.I64, 'itemId', None, None, ), # 2
16752 
    (3, TType.I64, 'quantity', None, None, ), # 3
16753 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16754 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16755 
  )
16756 
 
4369 rajveer 16757 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16758 
    self.vendorId = vendorId
16759 
    self.itemId = itemId
16760 
    self.quantity = quantity
16761 
    self.estimate = estimate
4369 rajveer 16762 
    self.isReminder = isReminder
4303 rajveer 16763 
 
16764 
  def read(self, iprot):
16765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16767 
      return
16768 
    iprot.readStructBegin()
16769 
    while True:
16770 
      (fname, ftype, fid) = iprot.readFieldBegin()
16771 
      if ftype == TType.STOP:
16772 
        break
16773 
      if fid == 1:
16774 
        if ftype == TType.I64:
16775 
          self.vendorId = iprot.readI64();
16776 
        else:
16777 
          iprot.skip(ftype)
16778 
      elif fid == 2:
16779 
        if ftype == TType.I64:
16780 
          self.itemId = iprot.readI64();
16781 
        else:
16782 
          iprot.skip(ftype)
16783 
      elif fid == 3:
16784 
        if ftype == TType.I64:
16785 
          self.quantity = iprot.readI64();
16786 
        else:
16787 
          iprot.skip(ftype)
16788 
      elif fid == 4:
16789 
        if ftype == TType.I64:
16790 
          self.estimate = iprot.readI64();
16791 
        else:
16792 
          iprot.skip(ftype)
4369 rajveer 16793 
      elif fid == 5:
16794 
        if ftype == TType.BOOL:
16795 
          self.isReminder = iprot.readBool();
16796 
        else:
16797 
          iprot.skip(ftype)
4303 rajveer 16798 
      else:
16799 
        iprot.skip(ftype)
16800 
      iprot.readFieldEnd()
16801 
    iprot.readStructEnd()
16802 
 
16803 
  def write(self, oprot):
16804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16806 
      return
16807 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
16808 
    if self.vendorId is not None:
16809 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16810 
      oprot.writeI64(self.vendorId)
16811 
      oprot.writeFieldEnd()
16812 
    if self.itemId is not None:
16813 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16814 
      oprot.writeI64(self.itemId)
16815 
      oprot.writeFieldEnd()
16816 
    if self.quantity is not None:
16817 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16818 
      oprot.writeI64(self.quantity)
16819 
      oprot.writeFieldEnd()
16820 
    if self.estimate is not None:
16821 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16822 
      oprot.writeI64(self.estimate)
16823 
      oprot.writeFieldEnd()
4369 rajveer 16824 
    if self.isReminder is not None:
16825 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16826 
      oprot.writeBool(self.isReminder)
16827 
      oprot.writeFieldEnd()
4303 rajveer 16828 
    oprot.writeFieldStop()
16829 
    oprot.writeStructEnd()
16830 
 
16831 
  def validate(self):
16832 
    return
16833 
 
16834 
 
16835 
  def __repr__(self):
16836 
    L = ['%s=%r' % (key, value)
16837 
      for key, value in self.__dict__.iteritems()]
16838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16839 
 
16840 
  def __eq__(self, other):
16841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16842 
 
16843 
  def __ne__(self, other):
16844 
    return not (self == other)
16845 
 
16846 
class markOrdersAsReversalInitiated_result:
16847 
  """
16848 
  Attributes:
16849 
   - ex
16850 
  """
16851 
 
16852 
  thrift_spec = (
16853 
    None, # 0
16854 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16855 
  )
16856 
 
16857 
  def __init__(self, ex=None,):
16858 
    self.ex = ex
16859 
 
16860 
  def read(self, iprot):
16861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16863 
      return
16864 
    iprot.readStructBegin()
16865 
    while True:
16866 
      (fname, ftype, fid) = iprot.readFieldBegin()
16867 
      if ftype == TType.STOP:
16868 
        break
16869 
      if fid == 1:
16870 
        if ftype == TType.STRUCT:
16871 
          self.ex = TransactionServiceException()
16872 
          self.ex.read(iprot)
16873 
        else:
16874 
          iprot.skip(ftype)
16875 
      else:
16876 
        iprot.skip(ftype)
16877 
      iprot.readFieldEnd()
16878 
    iprot.readStructEnd()
16879 
 
16880 
  def write(self, oprot):
16881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16883 
      return
16884 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
16885 
    if self.ex is not None:
16886 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16887 
      self.ex.write(oprot)
16888 
      oprot.writeFieldEnd()
16889 
    oprot.writeFieldStop()
16890 
    oprot.writeStructEnd()
16891 
 
16892 
  def validate(self):
16893 
    return
16894 
 
16895 
 
16896 
  def __repr__(self):
16897 
    L = ['%s=%r' % (key, value)
16898 
      for key, value in self.__dict__.iteritems()]
16899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16900 
 
16901 
  def __eq__(self, other):
16902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16903 
 
16904 
  def __ne__(self, other):
16905 
    return not (self == other)
16906 
 
16907 
class markOrdersAsNotAvailabke_args:
16908 
  """
16909 
  Attributes:
16910 
   - vendorId
16911 
   - itemId
16912 
   - quantity
16913 
   - estimate
4369 rajveer 16914 
   - isReminder
4303 rajveer 16915 
  """
16916 
 
16917 
  thrift_spec = (
16918 
    None, # 0
16919 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16920 
    (2, TType.I64, 'itemId', None, None, ), # 2
16921 
    (3, TType.I64, 'quantity', None, None, ), # 3
16922 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16923 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16924 
  )
16925 
 
4369 rajveer 16926 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16927 
    self.vendorId = vendorId
16928 
    self.itemId = itemId
16929 
    self.quantity = quantity
16930 
    self.estimate = estimate
4369 rajveer 16931 
    self.isReminder = isReminder
4303 rajveer 16932 
 
16933 
  def read(self, iprot):
16934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16936 
      return
16937 
    iprot.readStructBegin()
16938 
    while True:
16939 
      (fname, ftype, fid) = iprot.readFieldBegin()
16940 
      if ftype == TType.STOP:
16941 
        break
16942 
      if fid == 1:
16943 
        if ftype == TType.I64:
16944 
          self.vendorId = iprot.readI64();
16945 
        else:
16946 
          iprot.skip(ftype)
16947 
      elif fid == 2:
16948 
        if ftype == TType.I64:
16949 
          self.itemId = iprot.readI64();
16950 
        else:
16951 
          iprot.skip(ftype)
16952 
      elif fid == 3:
16953 
        if ftype == TType.I64:
16954 
          self.quantity = iprot.readI64();
16955 
        else:
16956 
          iprot.skip(ftype)
16957 
      elif fid == 4:
16958 
        if ftype == TType.I64:
16959 
          self.estimate = iprot.readI64();
16960 
        else:
16961 
          iprot.skip(ftype)
4369 rajveer 16962 
      elif fid == 5:
16963 
        if ftype == TType.BOOL:
16964 
          self.isReminder = iprot.readBool();
16965 
        else:
16966 
          iprot.skip(ftype)
4303 rajveer 16967 
      else:
16968 
        iprot.skip(ftype)
16969 
      iprot.readFieldEnd()
16970 
    iprot.readStructEnd()
16971 
 
16972 
  def write(self, oprot):
16973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16975 
      return
16976 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
16977 
    if self.vendorId is not None:
16978 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16979 
      oprot.writeI64(self.vendorId)
16980 
      oprot.writeFieldEnd()
16981 
    if self.itemId is not None:
16982 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16983 
      oprot.writeI64(self.itemId)
16984 
      oprot.writeFieldEnd()
16985 
    if self.quantity is not None:
16986 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16987 
      oprot.writeI64(self.quantity)
16988 
      oprot.writeFieldEnd()
16989 
    if self.estimate is not None:
16990 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16991 
      oprot.writeI64(self.estimate)
16992 
      oprot.writeFieldEnd()
4369 rajveer 16993 
    if self.isReminder is not None:
16994 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16995 
      oprot.writeBool(self.isReminder)
16996 
      oprot.writeFieldEnd()
4303 rajveer 16997 
    oprot.writeFieldStop()
16998 
    oprot.writeStructEnd()
16999 
 
17000 
  def validate(self):
17001 
    return
17002 
 
17003 
 
17004 
  def __repr__(self):
17005 
    L = ['%s=%r' % (key, value)
17006 
      for key, value in self.__dict__.iteritems()]
17007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17008 
 
17009 
  def __eq__(self, other):
17010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17011 
 
17012 
  def __ne__(self, other):
17013 
    return not (self == other)
17014 
 
17015 
class markOrdersAsNotAvailabke_result:
17016 
  """
17017 
  Attributes:
17018 
   - ex
17019 
  """
17020 
 
17021 
  thrift_spec = (
17022 
    None, # 0
17023 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17024 
  )
17025 
 
17026 
  def __init__(self, ex=None,):
17027 
    self.ex = ex
17028 
 
17029 
  def read(self, iprot):
17030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17032 
      return
17033 
    iprot.readStructBegin()
17034 
    while True:
17035 
      (fname, ftype, fid) = iprot.readFieldBegin()
17036 
      if ftype == TType.STOP:
17037 
        break
17038 
      if fid == 1:
17039 
        if ftype == TType.STRUCT:
17040 
          self.ex = TransactionServiceException()
17041 
          self.ex.read(iprot)
17042 
        else:
17043 
          iprot.skip(ftype)
17044 
      else:
17045 
        iprot.skip(ftype)
17046 
      iprot.readFieldEnd()
17047 
    iprot.readStructEnd()
17048 
 
17049 
  def write(self, oprot):
17050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17052 
      return
17053 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
17054 
    if self.ex is not None:
17055 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17056 
      self.ex.write(oprot)
17057 
      oprot.writeFieldEnd()
17058 
    oprot.writeFieldStop()
17059 
    oprot.writeStructEnd()
17060 
 
17061 
  def validate(self):
17062 
    return
17063 
 
17064 
 
17065 
  def __repr__(self):
17066 
    L = ['%s=%r' % (key, value)
17067 
      for key, value in self.__dict__.iteritems()]
17068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17069 
 
17070 
  def __eq__(self, other):
17071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17072 
 
17073 
  def __ne__(self, other):
17074 
    return not (self == other)
4369 rajveer 17075 
 
17076 
class markOrdersAsTimeout_args:
17077 
  """
17078 
  Attributes:
17079 
   - vendorId
17080 
  """
17081 
 
17082 
  thrift_spec = (
17083 
    None, # 0
17084 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17085 
  )
17086 
 
17087 
  def __init__(self, vendorId=None,):
17088 
    self.vendorId = vendorId
17089 
 
17090 
  def read(self, iprot):
17091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17093 
      return
17094 
    iprot.readStructBegin()
17095 
    while True:
17096 
      (fname, ftype, fid) = iprot.readFieldBegin()
17097 
      if ftype == TType.STOP:
17098 
        break
17099 
      if fid == 1:
17100 
        if ftype == TType.I64:
17101 
          self.vendorId = iprot.readI64();
17102 
        else:
17103 
          iprot.skip(ftype)
17104 
      else:
17105 
        iprot.skip(ftype)
17106 
      iprot.readFieldEnd()
17107 
    iprot.readStructEnd()
17108 
 
17109 
  def write(self, oprot):
17110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17112 
      return
17113 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
17114 
    if self.vendorId is not None:
17115 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17116 
      oprot.writeI64(self.vendorId)
17117 
      oprot.writeFieldEnd()
17118 
    oprot.writeFieldStop()
17119 
    oprot.writeStructEnd()
17120 
 
17121 
  def validate(self):
17122 
    return
17123 
 
17124 
 
17125 
  def __repr__(self):
17126 
    L = ['%s=%r' % (key, value)
17127 
      for key, value in self.__dict__.iteritems()]
17128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17129 
 
17130 
  def __eq__(self, other):
17131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17132 
 
17133 
  def __ne__(self, other):
17134 
    return not (self == other)
17135 
 
17136 
class markOrdersAsTimeout_result:
17137 
  """
17138 
  Attributes:
17139 
   - success
17140 
   - ex
17141 
  """
17142 
 
17143 
  thrift_spec = (
17144 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
17145 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17146 
  )
17147 
 
17148 
  def __init__(self, success=None, ex=None,):
17149 
    self.success = success
17150 
    self.ex = ex
17151 
 
17152 
  def read(self, iprot):
17153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17155 
      return
17156 
    iprot.readStructBegin()
17157 
    while True:
17158 
      (fname, ftype, fid) = iprot.readFieldBegin()
17159 
      if ftype == TType.STOP:
17160 
        break
17161 
      if fid == 0:
17162 
        if ftype == TType.MAP:
17163 
          self.success = {}
4757 mandeep.dh 17164 
          (_ktype285, _vtype286, _size284 ) = iprot.readMapBegin()
17165 
          for _i288 in xrange(_size284):
17166 
            _key289 = iprot.readI32();
17167 
            _val290 = TimeoutSummary()
17168 
            _val290.read(iprot)
17169 
            self.success[_key289] = _val290
4369 rajveer 17170 
          iprot.readMapEnd()
17171 
        else:
17172 
          iprot.skip(ftype)
17173 
      elif fid == 1:
17174 
        if ftype == TType.STRUCT:
17175 
          self.ex = TransactionServiceException()
17176 
          self.ex.read(iprot)
17177 
        else:
17178 
          iprot.skip(ftype)
17179 
      else:
17180 
        iprot.skip(ftype)
17181 
      iprot.readFieldEnd()
17182 
    iprot.readStructEnd()
17183 
 
17184 
  def write(self, oprot):
17185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17187 
      return
17188 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
17189 
    if self.success is not None:
17190 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17191 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4757 mandeep.dh 17192 
      for kiter291,viter292 in self.success.items():
17193 
        oprot.writeI32(kiter291)
17194 
        viter292.write(oprot)
4369 rajveer 17195 
      oprot.writeMapEnd()
17196 
      oprot.writeFieldEnd()
17197 
    if self.ex is not None:
17198 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17199 
      self.ex.write(oprot)
17200 
      oprot.writeFieldEnd()
17201 
    oprot.writeFieldStop()
17202 
    oprot.writeStructEnd()
17203 
 
17204 
  def validate(self):
17205 
    return
17206 
 
17207 
 
17208 
  def __repr__(self):
17209 
    L = ['%s=%r' % (key, value)
17210 
      for key, value in self.__dict__.iteritems()]
17211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17212 
 
17213 
  def __eq__(self, other):
17214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17215 
 
17216 
  def __ne__(self, other):
17217 
    return not (self == other)
4386 anupam.sin 17218 
 
4662 rajveer 17219 
class markOrderAsLostInTransit_args:
17220 
  """
17221 
  Attributes:
17222 
   - orderId
17223 
  """
17224 
 
17225 
  thrift_spec = (
17226 
    None, # 0
17227 
    (1, TType.I64, 'orderId', None, None, ), # 1
17228 
  )
17229 
 
17230 
  def __init__(self, orderId=None,):
17231 
    self.orderId = orderId
17232 
 
17233 
  def read(self, iprot):
17234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17236 
      return
17237 
    iprot.readStructBegin()
17238 
    while True:
17239 
      (fname, ftype, fid) = iprot.readFieldBegin()
17240 
      if ftype == TType.STOP:
17241 
        break
17242 
      if fid == 1:
17243 
        if ftype == TType.I64:
17244 
          self.orderId = iprot.readI64();
17245 
        else:
17246 
          iprot.skip(ftype)
17247 
      else:
17248 
        iprot.skip(ftype)
17249 
      iprot.readFieldEnd()
17250 
    iprot.readStructEnd()
17251 
 
17252 
  def write(self, oprot):
17253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17255 
      return
17256 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
17257 
    if self.orderId is not None:
17258 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17259 
      oprot.writeI64(self.orderId)
17260 
      oprot.writeFieldEnd()
17261 
    oprot.writeFieldStop()
17262 
    oprot.writeStructEnd()
17263 
 
17264 
  def validate(self):
17265 
    return
17266 
 
17267 
 
17268 
  def __repr__(self):
17269 
    L = ['%s=%r' % (key, value)
17270 
      for key, value in self.__dict__.iteritems()]
17271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17272 
 
17273 
  def __eq__(self, other):
17274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17275 
 
17276 
  def __ne__(self, other):
17277 
    return not (self == other)
17278 
 
17279 
class markOrderAsLostInTransit_result:
17280 
  """
17281 
  Attributes:
17282 
   - success
17283 
   - ex
17284 
  """
17285 
 
17286 
  thrift_spec = (
17287 
    (0, TType.BOOL, 'success', None, None, ), # 0
17288 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17289 
  )
17290 
 
17291 
  def __init__(self, success=None, ex=None,):
17292 
    self.success = success
17293 
    self.ex = ex
17294 
 
17295 
  def read(self, iprot):
17296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17298 
      return
17299 
    iprot.readStructBegin()
17300 
    while True:
17301 
      (fname, ftype, fid) = iprot.readFieldBegin()
17302 
      if ftype == TType.STOP:
17303 
        break
17304 
      if fid == 0:
17305 
        if ftype == TType.BOOL:
17306 
          self.success = iprot.readBool();
17307 
        else:
17308 
          iprot.skip(ftype)
17309 
      elif fid == 1:
17310 
        if ftype == TType.STRUCT:
17311 
          self.ex = TransactionServiceException()
17312 
          self.ex.read(iprot)
17313 
        else:
17314 
          iprot.skip(ftype)
17315 
      else:
17316 
        iprot.skip(ftype)
17317 
      iprot.readFieldEnd()
17318 
    iprot.readStructEnd()
17319 
 
17320 
  def write(self, oprot):
17321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17323 
      return
17324 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
17325 
    if self.success is not None:
17326 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17327 
      oprot.writeBool(self.success)
17328 
      oprot.writeFieldEnd()
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)
17350 
 
4386 anupam.sin 17351 
class getOrderForAwb_args:
17352 
  """
17353 
  Attributes:
17354 
   - awb
17355 
  """
17356 
 
17357 
  thrift_spec = (
17358 
    None, # 0
17359 
    (1, TType.STRING, 'awb', None, None, ), # 1
17360 
  )
17361 
 
17362 
  def __init__(self, awb=None,):
17363 
    self.awb = awb
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.STRING:
17376 
          self.awb = iprot.readString();
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('getOrderForAwb_args')
17389 
    if self.awb is not None:
17390 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
17391 
      oprot.writeString(self.awb)
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 getOrderForAwb_result:
17412 
  """
17413 
  Attributes:
17414 
   - success
17415 
   - ex
17416 
  """
17417 
 
17418 
  thrift_spec = (
17419 
    (0, TType.STRUCT, 'success', (Order, Order.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.STRUCT:
17438 
          self.success = Order()
17439 
          self.success.read(iprot)
17440 
        else:
17441 
          iprot.skip(ftype)
17442 
      elif fid == 1:
17443 
        if ftype == TType.STRUCT:
17444 
          self.ex = TransactionServiceException()
17445 
          self.ex.read(iprot)
17446 
        else:
17447 
          iprot.skip(ftype)
17448 
      else:
17449 
        iprot.skip(ftype)
17450 
      iprot.readFieldEnd()
17451 
    iprot.readStructEnd()
17452 
 
17453 
  def write(self, oprot):
17454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17456 
      return
17457 
    oprot.writeStructBegin('getOrderForAwb_result')
17458 
    if self.success is not None:
17459 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17460 
      self.success.write(oprot)
17461 
      oprot.writeFieldEnd()
17462 
    if self.ex is not None:
17463 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17464 
      self.ex.write(oprot)
17465 
      oprot.writeFieldEnd()
17466 
    oprot.writeFieldStop()
17467 
    oprot.writeStructEnd()
17468 
 
17469 
  def validate(self):
17470 
    return
17471 
 
17472 
 
17473 
  def __repr__(self):
17474 
    L = ['%s=%r' % (key, value)
17475 
      for key, value in self.__dict__.iteritems()]
17476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17477 
 
17478 
  def __eq__(self, other):
17479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17480 
 
17481 
  def __ne__(self, other):
17482 
    return not (self == other)
4506 phani.kuma 17483 
 
17484 
class getOrdersForProviderForStatus_args:
17485 
  """
17486 
  Attributes:
17487 
   - logistics_provider_id
17488 
   - order_status
17489 
  """
17490 
 
17491 
  thrift_spec = (
17492 
    None, # 0
17493 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
17494 
    (2, TType.I32, 'order_status', None, None, ), # 2
17495 
  )
17496 
 
17497 
  def __init__(self, logistics_provider_id=None, order_status=None,):
17498 
    self.logistics_provider_id = logistics_provider_id
17499 
    self.order_status = order_status
17500 
 
17501 
  def read(self, iprot):
17502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17504 
      return
17505 
    iprot.readStructBegin()
17506 
    while True:
17507 
      (fname, ftype, fid) = iprot.readFieldBegin()
17508 
      if ftype == TType.STOP:
17509 
        break
17510 
      if fid == 1:
17511 
        if ftype == TType.I64:
17512 
          self.logistics_provider_id = iprot.readI64();
17513 
        else:
17514 
          iprot.skip(ftype)
17515 
      elif fid == 2:
17516 
        if ftype == TType.I32:
17517 
          self.order_status = iprot.readI32();
17518 
        else:
17519 
          iprot.skip(ftype)
17520 
      else:
17521 
        iprot.skip(ftype)
17522 
      iprot.readFieldEnd()
17523 
    iprot.readStructEnd()
17524 
 
17525 
  def write(self, oprot):
17526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17528 
      return
17529 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
17530 
    if self.logistics_provider_id is not None:
17531 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
17532 
      oprot.writeI64(self.logistics_provider_id)
17533 
      oprot.writeFieldEnd()
17534 
    if self.order_status is not None:
17535 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
17536 
      oprot.writeI32(self.order_status)
17537 
      oprot.writeFieldEnd()
17538 
    oprot.writeFieldStop()
17539 
    oprot.writeStructEnd()
17540 
 
17541 
  def validate(self):
17542 
    return
17543 
 
17544 
 
17545 
  def __repr__(self):
17546 
    L = ['%s=%r' % (key, value)
17547 
      for key, value in self.__dict__.iteritems()]
17548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17549 
 
17550 
  def __eq__(self, other):
17551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17552 
 
17553 
  def __ne__(self, other):
17554 
    return not (self == other)
17555 
 
17556 
class getOrdersForProviderForStatus_result:
17557 
  """
17558 
  Attributes:
17559 
   - success
17560 
   - ex
17561 
  """
17562 
 
17563 
  thrift_spec = (
17564 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17565 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17566 
  )
17567 
 
17568 
  def __init__(self, success=None, ex=None,):
17569 
    self.success = success
17570 
    self.ex = ex
17571 
 
17572 
  def read(self, iprot):
17573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17575 
      return
17576 
    iprot.readStructBegin()
17577 
    while True:
17578 
      (fname, ftype, fid) = iprot.readFieldBegin()
17579 
      if ftype == TType.STOP:
17580 
        break
17581 
      if fid == 0:
17582 
        if ftype == TType.LIST:
17583 
          self.success = []
4757 mandeep.dh 17584 
          (_etype296, _size293) = iprot.readListBegin()
17585 
          for _i297 in xrange(_size293):
17586 
            _elem298 = Order()
17587 
            _elem298.read(iprot)
17588 
            self.success.append(_elem298)
4506 phani.kuma 17589 
          iprot.readListEnd()
17590 
        else:
17591 
          iprot.skip(ftype)
17592 
      elif fid == 1:
17593 
        if ftype == TType.STRUCT:
17594 
          self.ex = TransactionServiceException()
17595 
          self.ex.read(iprot)
17596 
        else:
17597 
          iprot.skip(ftype)
17598 
      else:
17599 
        iprot.skip(ftype)
17600 
      iprot.readFieldEnd()
17601 
    iprot.readStructEnd()
17602 
 
17603 
  def write(self, oprot):
17604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17606 
      return
17607 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
17608 
    if self.success is not None:
17609 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17610 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4757 mandeep.dh 17611 
      for iter299 in self.success:
17612 
        iter299.write(oprot)
4506 phani.kuma 17613 
      oprot.writeListEnd()
17614 
      oprot.writeFieldEnd()
17615 
    if self.ex is not None:
17616 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17617 
      self.ex.write(oprot)
17618 
      oprot.writeFieldEnd()
17619 
    oprot.writeFieldStop()
17620 
    oprot.writeStructEnd()
17621 
 
17622 
  def validate(self):
17623 
    return
17624 
 
17625 
 
17626 
  def __repr__(self):
17627 
    L = ['%s=%r' % (key, value)
17628 
      for key, value in self.__dict__.iteritems()]
17629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17630 
 
17631 
  def __eq__(self, other):
17632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17633 
 
17634 
  def __ne__(self, other):
17635 
    return not (self == other)
4600 varun.gupt 17636 
 
17637 
class getBilledOrdersForVendor_args:
17638 
  """
17639 
  Attributes:
17640 
   - vendorId
17641 
   - billingDateFrom
17642 
   - billingDateTo
17643 
  """
17644 
 
17645 
  thrift_spec = (
17646 
    None, # 0
17647 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17648 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
17649 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
17650 
  )
17651 
 
17652 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
17653 
    self.vendorId = vendorId
17654 
    self.billingDateFrom = billingDateFrom
17655 
    self.billingDateTo = billingDateTo
17656 
 
17657 
  def read(self, iprot):
17658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17660 
      return
17661 
    iprot.readStructBegin()
17662 
    while True:
17663 
      (fname, ftype, fid) = iprot.readFieldBegin()
17664 
      if ftype == TType.STOP:
17665 
        break
17666 
      if fid == 1:
17667 
        if ftype == TType.I64:
17668 
          self.vendorId = iprot.readI64();
17669 
        else:
17670 
          iprot.skip(ftype)
17671 
      elif fid == 2:
17672 
        if ftype == TType.I64:
17673 
          self.billingDateFrom = iprot.readI64();
17674 
        else:
17675 
          iprot.skip(ftype)
17676 
      elif fid == 3:
17677 
        if ftype == TType.I64:
17678 
          self.billingDateTo = iprot.readI64();
17679 
        else:
17680 
          iprot.skip(ftype)
17681 
      else:
17682 
        iprot.skip(ftype)
17683 
      iprot.readFieldEnd()
17684 
    iprot.readStructEnd()
17685 
 
17686 
  def write(self, oprot):
17687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17689 
      return
17690 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
17691 
    if self.vendorId is not None:
17692 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17693 
      oprot.writeI64(self.vendorId)
17694 
      oprot.writeFieldEnd()
17695 
    if self.billingDateFrom is not None:
17696 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
17697 
      oprot.writeI64(self.billingDateFrom)
17698 
      oprot.writeFieldEnd()
17699 
    if self.billingDateTo is not None:
17700 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
17701 
      oprot.writeI64(self.billingDateTo)
17702 
      oprot.writeFieldEnd()
17703 
    oprot.writeFieldStop()
17704 
    oprot.writeStructEnd()
17705 
 
17706 
  def validate(self):
17707 
    return
17708 
 
17709 
 
17710 
  def __repr__(self):
17711 
    L = ['%s=%r' % (key, value)
17712 
      for key, value in self.__dict__.iteritems()]
17713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17714 
 
17715 
  def __eq__(self, other):
17716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17717 
 
17718 
  def __ne__(self, other):
17719 
    return not (self == other)
17720 
 
17721 
class getBilledOrdersForVendor_result:
17722 
  """
17723 
  Attributes:
17724 
   - success
17725 
   - ex
17726 
  """
17727 
 
17728 
  thrift_spec = (
17729 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17730 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17731 
  )
17732 
 
17733 
  def __init__(self, success=None, ex=None,):
17734 
    self.success = success
17735 
    self.ex = ex
17736 
 
17737 
  def read(self, iprot):
17738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17740 
      return
17741 
    iprot.readStructBegin()
17742 
    while True:
17743 
      (fname, ftype, fid) = iprot.readFieldBegin()
17744 
      if ftype == TType.STOP:
17745 
        break
17746 
      if fid == 0:
17747 
        if ftype == TType.LIST:
17748 
          self.success = []
4757 mandeep.dh 17749 
          (_etype303, _size300) = iprot.readListBegin()
17750 
          for _i304 in xrange(_size300):
17751 
            _elem305 = Order()
17752 
            _elem305.read(iprot)
17753 
            self.success.append(_elem305)
4600 varun.gupt 17754 
          iprot.readListEnd()
17755 
        else:
17756 
          iprot.skip(ftype)
17757 
      elif fid == 1:
17758 
        if ftype == TType.STRUCT:
17759 
          self.ex = TransactionServiceException()
17760 
          self.ex.read(iprot)
17761 
        else:
17762 
          iprot.skip(ftype)
17763 
      else:
17764 
        iprot.skip(ftype)
17765 
      iprot.readFieldEnd()
17766 
    iprot.readStructEnd()
17767 
 
17768 
  def write(self, oprot):
17769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17771 
      return
17772 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
17773 
    if self.success is not None:
17774 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17775 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4757 mandeep.dh 17776 
      for iter306 in self.success:
17777 
        iter306.write(oprot)
4600 varun.gupt 17778 
      oprot.writeListEnd()
17779 
      oprot.writeFieldEnd()
17780 
    if self.ex is not None:
17781 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17782 
      self.ex.write(oprot)
17783 
      oprot.writeFieldEnd()
17784 
    oprot.writeFieldStop()
17785 
    oprot.writeStructEnd()
17786 
 
17787 
  def validate(self):
17788 
    return
17789 
 
17790 
 
17791 
  def __repr__(self):
17792 
    L = ['%s=%r' % (key, value)
17793 
      for key, value in self.__dict__.iteritems()]
17794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17795 
 
17796 
  def __eq__(self, other):
17797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17798 
 
17799 
  def __ne__(self, other):
17800 
    return not (self == other)
17801 
 
4607 rajveer 17802 
class getSlippedSippingDateOrders_args:
17803 
 
17804 
  thrift_spec = (
17805 
  )
17806 
 
17807 
  def read(self, iprot):
17808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17810 
      return
17811 
    iprot.readStructBegin()
17812 
    while True:
17813 
      (fname, ftype, fid) = iprot.readFieldBegin()
17814 
      if ftype == TType.STOP:
17815 
        break
17816 
      else:
17817 
        iprot.skip(ftype)
17818 
      iprot.readFieldEnd()
17819 
    iprot.readStructEnd()
17820 
 
17821 
  def write(self, oprot):
17822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17824 
      return
17825 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
17826 
    oprot.writeFieldStop()
17827 
    oprot.writeStructEnd()
17828 
 
17829 
  def validate(self):
17830 
    return
17831 
 
17832 
 
17833 
  def __repr__(self):
17834 
    L = ['%s=%r' % (key, value)
17835 
      for key, value in self.__dict__.iteritems()]
17836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17837 
 
17838 
  def __eq__(self, other):
17839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17840 
 
17841 
  def __ne__(self, other):
17842 
    return not (self == other)
17843 
 
17844 
class getSlippedSippingDateOrders_result:
17845 
  """
17846 
  Attributes:
17847 
   - success
17848 
   - ex
17849 
  """
17850 
 
17851 
  thrift_spec = (
17852 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17853 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17854 
  )
17855 
 
17856 
  def __init__(self, success=None, ex=None,):
17857 
    self.success = success
17858 
    self.ex = ex
17859 
 
17860 
  def read(self, iprot):
17861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17863 
      return
17864 
    iprot.readStructBegin()
17865 
    while True:
17866 
      (fname, ftype, fid) = iprot.readFieldBegin()
17867 
      if ftype == TType.STOP:
17868 
        break
17869 
      if fid == 0:
17870 
        if ftype == TType.LIST:
17871 
          self.success = []
4757 mandeep.dh 17872 
          (_etype310, _size307) = iprot.readListBegin()
17873 
          for _i311 in xrange(_size307):
17874 
            _elem312 = Order()
17875 
            _elem312.read(iprot)
17876 
            self.success.append(_elem312)
4607 rajveer 17877 
          iprot.readListEnd()
17878 
        else:
17879 
          iprot.skip(ftype)
17880 
      elif fid == 1:
17881 
        if ftype == TType.STRUCT:
17882 
          self.ex = TransactionServiceException()
17883 
          self.ex.read(iprot)
17884 
        else:
17885 
          iprot.skip(ftype)
17886 
      else:
17887 
        iprot.skip(ftype)
17888 
      iprot.readFieldEnd()
17889 
    iprot.readStructEnd()
17890 
 
17891 
  def write(self, oprot):
17892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17894 
      return
17895 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
17896 
    if self.success is not None:
17897 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17898 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4757 mandeep.dh 17899 
      for iter313 in self.success:
17900 
        iter313.write(oprot)
4607 rajveer 17901 
      oprot.writeListEnd()
17902 
      oprot.writeFieldEnd()
17903 
    if self.ex is not None:
17904 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17905 
      self.ex.write(oprot)
17906 
      oprot.writeFieldEnd()
17907 
    oprot.writeFieldStop()
17908 
    oprot.writeStructEnd()
17909 
 
17910 
  def validate(self):
17911 
    return
17912 
 
17913 
 
17914 
  def __repr__(self):
17915 
    L = ['%s=%r' % (key, value)
17916 
      for key, value in self.__dict__.iteritems()]
17917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17918 
 
17919 
  def __eq__(self, other):
17920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17921 
 
17922 
  def __ne__(self, other):
17923 
    return not (self == other)
17924 
 
4709 rajveer 17925 
class getCancelledOrders_args:
17926 
  """
17927 
  Attributes:
17928 
   - cancelDateFrom
17929 
   - cancelDateTo
17930 
  """
17931 
 
17932 
  thrift_spec = (
17933 
    None, # 0
17934 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
17935 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
17936 
  )
17937 
 
17938 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
17939 
    self.cancelDateFrom = cancelDateFrom
17940 
    self.cancelDateTo = cancelDateTo
17941 
 
17942 
  def read(self, iprot):
17943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17945 
      return
17946 
    iprot.readStructBegin()
17947 
    while True:
17948 
      (fname, ftype, fid) = iprot.readFieldBegin()
17949 
      if ftype == TType.STOP:
17950 
        break
17951 
      if fid == 1:
17952 
        if ftype == TType.I64:
17953 
          self.cancelDateFrom = iprot.readI64();
17954 
        else:
17955 
          iprot.skip(ftype)
17956 
      elif fid == 2:
17957 
        if ftype == TType.I64:
17958 
          self.cancelDateTo = iprot.readI64();
17959 
        else:
17960 
          iprot.skip(ftype)
17961 
      else:
17962 
        iprot.skip(ftype)
17963 
      iprot.readFieldEnd()
17964 
    iprot.readStructEnd()
17965 
 
17966 
  def write(self, oprot):
17967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17969 
      return
17970 
    oprot.writeStructBegin('getCancelledOrders_args')
17971 
    if self.cancelDateFrom is not None:
17972 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
17973 
      oprot.writeI64(self.cancelDateFrom)
17974 
      oprot.writeFieldEnd()
17975 
    if self.cancelDateTo is not None:
17976 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
17977 
      oprot.writeI64(self.cancelDateTo)
17978 
      oprot.writeFieldEnd()
17979 
    oprot.writeFieldStop()
17980 
    oprot.writeStructEnd()
17981 
 
17982 
  def validate(self):
17983 
    return
17984 
 
17985 
 
17986 
  def __repr__(self):
17987 
    L = ['%s=%r' % (key, value)
17988 
      for key, value in self.__dict__.iteritems()]
17989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17990 
 
17991 
  def __eq__(self, other):
17992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17993 
 
17994 
  def __ne__(self, other):
17995 
    return not (self == other)
17996 
 
17997 
class getCancelledOrders_result:
17998 
  """
17999 
  Attributes:
18000 
   - success
18001 
   - ex
18002 
  """
18003 
 
18004 
  thrift_spec = (
18005 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18006 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18007 
  )
18008 
 
18009 
  def __init__(self, success=None, ex=None,):
18010 
    self.success = success
18011 
    self.ex = ex
18012 
 
18013 
  def read(self, iprot):
18014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18016 
      return
18017 
    iprot.readStructBegin()
18018 
    while True:
18019 
      (fname, ftype, fid) = iprot.readFieldBegin()
18020 
      if ftype == TType.STOP:
18021 
        break
18022 
      if fid == 0:
18023 
        if ftype == TType.LIST:
18024 
          self.success = []
4757 mandeep.dh 18025 
          (_etype317, _size314) = iprot.readListBegin()
18026 
          for _i318 in xrange(_size314):
18027 
            _elem319 = Order()
18028 
            _elem319.read(iprot)
18029 
            self.success.append(_elem319)
4709 rajveer 18030 
          iprot.readListEnd()
18031 
        else:
18032 
          iprot.skip(ftype)
18033 
      elif fid == 1:
18034 
        if ftype == TType.STRUCT:
18035 
          self.ex = TransactionServiceException()
18036 
          self.ex.read(iprot)
18037 
        else:
18038 
          iprot.skip(ftype)
18039 
      else:
18040 
        iprot.skip(ftype)
18041 
      iprot.readFieldEnd()
18042 
    iprot.readStructEnd()
18043 
 
18044 
  def write(self, oprot):
18045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18047 
      return
18048 
    oprot.writeStructBegin('getCancelledOrders_result')
18049 
    if self.success is not None:
18050 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18051 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4757 mandeep.dh 18052 
      for iter320 in self.success:
18053 
        iter320.write(oprot)
4709 rajveer 18054 
      oprot.writeListEnd()
18055 
      oprot.writeFieldEnd()
18056 
    if self.ex is not None:
18057 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18058 
      self.ex.write(oprot)
18059 
      oprot.writeFieldEnd()
18060 
    oprot.writeFieldStop()
18061 
    oprot.writeStructEnd()
18062 
 
18063 
  def validate(self):
18064 
    return
18065 
 
18066 
 
18067 
  def __repr__(self):
18068 
    L = ['%s=%r' % (key, value)
18069 
      for key, value in self.__dict__.iteritems()]
18070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18071 
 
18072 
  def __eq__(self, other):
18073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18074 
 
18075 
  def __ne__(self, other):
18076 
    return not (self == other)
18077 
 
4600 varun.gupt 18078 
class saveBluedartSettlements_args:
18079 
  """
18080 
  Attributes:
18081 
   - mapAWBAndAmount
18082 
  """
18083 
 
18084 
  thrift_spec = (
18085 
    None, # 0
18086 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
18087 
  )
18088 
 
18089 
  def __init__(self, mapAWBAndAmount=None,):
18090 
    self.mapAWBAndAmount = mapAWBAndAmount
18091 
 
18092 
  def read(self, iprot):
18093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18095 
      return
18096 
    iprot.readStructBegin()
18097 
    while True:
18098 
      (fname, ftype, fid) = iprot.readFieldBegin()
18099 
      if ftype == TType.STOP:
18100 
        break
18101 
      if fid == 1:
18102 
        if ftype == TType.MAP:
18103 
          self.mapAWBAndAmount = {}
4757 mandeep.dh 18104 
          (_ktype322, _vtype323, _size321 ) = iprot.readMapBegin()
18105 
          for _i325 in xrange(_size321):
18106 
            _key326 = iprot.readI64();
18107 
            _val327 = iprot.readDouble();
18108 
            self.mapAWBAndAmount[_key326] = _val327
4600 varun.gupt 18109 
          iprot.readMapEnd()
18110 
        else:
18111 
          iprot.skip(ftype)
18112 
      else:
18113 
        iprot.skip(ftype)
18114 
      iprot.readFieldEnd()
18115 
    iprot.readStructEnd()
18116 
 
18117 
  def write(self, oprot):
18118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18120 
      return
18121 
    oprot.writeStructBegin('saveBluedartSettlements_args')
18122 
    if self.mapAWBAndAmount is not None:
18123 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
18124 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
4757 mandeep.dh 18125 
      for kiter328,viter329 in self.mapAWBAndAmount.items():
18126 
        oprot.writeI64(kiter328)
18127 
        oprot.writeDouble(viter329)
4600 varun.gupt 18128 
      oprot.writeMapEnd()
18129 
      oprot.writeFieldEnd()
18130 
    oprot.writeFieldStop()
18131 
    oprot.writeStructEnd()
18132 
 
18133 
  def validate(self):
18134 
    return
18135 
 
18136 
 
18137 
  def __repr__(self):
18138 
    L = ['%s=%r' % (key, value)
18139 
      for key, value in self.__dict__.iteritems()]
18140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18141 
 
18142 
  def __eq__(self, other):
18143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18144 
 
18145 
  def __ne__(self, other):
18146 
    return not (self == other)
18147 
 
18148 
class saveBluedartSettlements_result:
18149 
  """
18150 
  Attributes:
18151 
   - ex
18152 
  """
18153 
 
18154 
  thrift_spec = (
18155 
    None, # 0
18156 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18157 
  )
18158 
 
18159 
  def __init__(self, ex=None,):
18160 
    self.ex = ex
18161 
 
18162 
  def read(self, iprot):
18163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18165 
      return
18166 
    iprot.readStructBegin()
18167 
    while True:
18168 
      (fname, ftype, fid) = iprot.readFieldBegin()
18169 
      if ftype == TType.STOP:
18170 
        break
18171 
      if fid == 1:
18172 
        if ftype == TType.STRUCT:
18173 
          self.ex = TransactionServiceException()
18174 
          self.ex.read(iprot)
18175 
        else:
18176 
          iprot.skip(ftype)
18177 
      else:
18178 
        iprot.skip(ftype)
18179 
      iprot.readFieldEnd()
18180 
    iprot.readStructEnd()
18181 
 
18182 
  def write(self, oprot):
18183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18185 
      return
18186 
    oprot.writeStructBegin('saveBluedartSettlements_result')
18187 
    if self.ex is not None:
18188 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18189 
      self.ex.write(oprot)
18190 
      oprot.writeFieldEnd()
18191 
    oprot.writeFieldStop()
18192 
    oprot.writeStructEnd()
18193 
 
18194 
  def validate(self):
18195 
    return
18196 
 
18197 
 
18198 
  def __repr__(self):
18199 
    L = ['%s=%r' % (key, value)
18200 
      for key, value in self.__dict__.iteritems()]
18201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18202 
 
18203 
  def __eq__(self, other):
18204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18205 
 
18206 
  def __ne__(self, other):
18207 
    return not (self == other)
18208 
 
18209 
class savePaymentSettlements_args:
18210 
  """
18211 
  Attributes:
18212 
   - settlementDate
18213 
   - paymentGatewayId
18214 
   - paymentId
18215 
   - serviceTax
18216 
   - otherCharges
18217 
   - netCollection
18218 
  """
18219 
 
18220 
  thrift_spec = (
18221 
    None, # 0
18222 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
18223 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
18224 
    (3, TType.I64, 'paymentId', None, None, ), # 3
18225 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
18226 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
18227 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
18228 
  )
18229 
 
18230 
  def __init__(self, settlementDate=None, paymentGatewayId=None, paymentId=None, serviceTax=None, otherCharges=None, netCollection=None,):
18231 
    self.settlementDate = settlementDate
18232 
    self.paymentGatewayId = paymentGatewayId
18233 
    self.paymentId = paymentId
18234 
    self.serviceTax = serviceTax
18235 
    self.otherCharges = otherCharges
18236 
    self.netCollection = netCollection
18237 
 
18238 
  def read(self, iprot):
18239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18241 
      return
18242 
    iprot.readStructBegin()
18243 
    while True:
18244 
      (fname, ftype, fid) = iprot.readFieldBegin()
18245 
      if ftype == TType.STOP:
18246 
        break
18247 
      if fid == 1:
18248 
        if ftype == TType.I64:
18249 
          self.settlementDate = iprot.readI64();
18250 
        else:
18251 
          iprot.skip(ftype)
18252 
      elif fid == 2:
18253 
        if ftype == TType.I64:
18254 
          self.paymentGatewayId = iprot.readI64();
18255 
        else:
18256 
          iprot.skip(ftype)
18257 
      elif fid == 3:
18258 
        if ftype == TType.I64:
18259 
          self.paymentId = iprot.readI64();
18260 
        else:
18261 
          iprot.skip(ftype)
18262 
      elif fid == 4:
18263 
        if ftype == TType.DOUBLE:
18264 
          self.serviceTax = iprot.readDouble();
18265 
        else:
18266 
          iprot.skip(ftype)
18267 
      elif fid == 5:
18268 
        if ftype == TType.DOUBLE:
18269 
          self.otherCharges = iprot.readDouble();
18270 
        else:
18271 
          iprot.skip(ftype)
18272 
      elif fid == 6:
18273 
        if ftype == TType.DOUBLE:
18274 
          self.netCollection = iprot.readDouble();
18275 
        else:
18276 
          iprot.skip(ftype)
18277 
      else:
18278 
        iprot.skip(ftype)
18279 
      iprot.readFieldEnd()
18280 
    iprot.readStructEnd()
18281 
 
18282 
  def write(self, oprot):
18283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18285 
      return
18286 
    oprot.writeStructBegin('savePaymentSettlements_args')
18287 
    if self.settlementDate is not None:
18288 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
18289 
      oprot.writeI64(self.settlementDate)
18290 
      oprot.writeFieldEnd()
18291 
    if self.paymentGatewayId is not None:
18292 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
18293 
      oprot.writeI64(self.paymentGatewayId)
18294 
      oprot.writeFieldEnd()
18295 
    if self.paymentId is not None:
18296 
      oprot.writeFieldBegin('paymentId', TType.I64, 3)
18297 
      oprot.writeI64(self.paymentId)
18298 
      oprot.writeFieldEnd()
18299 
    if self.serviceTax is not None:
18300 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
18301 
      oprot.writeDouble(self.serviceTax)
18302 
      oprot.writeFieldEnd()
18303 
    if self.otherCharges is not None:
18304 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
18305 
      oprot.writeDouble(self.otherCharges)
18306 
      oprot.writeFieldEnd()
18307 
    if self.netCollection is not None:
18308 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
18309 
      oprot.writeDouble(self.netCollection)
18310 
      oprot.writeFieldEnd()
18311 
    oprot.writeFieldStop()
18312 
    oprot.writeStructEnd()
18313 
 
18314 
  def validate(self):
18315 
    return
18316 
 
18317 
 
18318 
  def __repr__(self):
18319 
    L = ['%s=%r' % (key, value)
18320 
      for key, value in self.__dict__.iteritems()]
18321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18322 
 
18323 
  def __eq__(self, other):
18324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18325 
 
18326 
  def __ne__(self, other):
18327 
    return not (self == other)
18328 
 
18329 
class savePaymentSettlements_result:
18330 
  """
18331 
  Attributes:
18332 
   - ex
18333 
  """
18334 
 
18335 
  thrift_spec = (
18336 
    None, # 0
18337 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18338 
  )
18339 
 
18340 
  def __init__(self, ex=None,):
18341 
    self.ex = ex
18342 
 
18343 
  def read(self, iprot):
18344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18346 
      return
18347 
    iprot.readStructBegin()
18348 
    while True:
18349 
      (fname, ftype, fid) = iprot.readFieldBegin()
18350 
      if ftype == TType.STOP:
18351 
        break
18352 
      if fid == 1:
18353 
        if ftype == TType.STRUCT:
18354 
          self.ex = TransactionServiceException()
18355 
          self.ex.read(iprot)
18356 
        else:
18357 
          iprot.skip(ftype)
18358 
      else:
18359 
        iprot.skip(ftype)
18360 
      iprot.readFieldEnd()
18361 
    iprot.readStructEnd()
18362 
 
18363 
  def write(self, oprot):
18364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18366 
      return
18367 
    oprot.writeStructBegin('savePaymentSettlements_result')
18368 
    if self.ex is not None:
18369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18370 
      self.ex.write(oprot)
18371 
      oprot.writeFieldEnd()
18372 
    oprot.writeFieldStop()
18373 
    oprot.writeStructEnd()
18374 
 
18375 
  def validate(self):
18376 
    return
18377 
 
18378 
 
18379 
  def __repr__(self):
18380 
    L = ['%s=%r' % (key, value)
18381 
      for key, value in self.__dict__.iteritems()]
18382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18383 
 
18384 
  def __eq__(self, other):
18385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18386 
 
18387 
  def __ne__(self, other):
18388 
    return not (self == other)
18389 
 
18390 
class saveEBSSettlementSummary_args:
18391 
  """
18392 
  Attributes:
18393 
   - settlementId
18394 
   - settlementDate
18395 
   - transactionDateFrom
18396 
   - transactionDateTo
18397 
   - amount
18398 
  """
18399 
 
18400 
  thrift_spec = (
18401 
    None, # 0
18402 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18403 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
18404 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
18405 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
18406 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
18407 
  )
18408 
 
18409 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
18410 
    self.settlementId = settlementId
18411 
    self.settlementDate = settlementDate
18412 
    self.transactionDateFrom = transactionDateFrom
18413 
    self.transactionDateTo = transactionDateTo
18414 
    self.amount = amount
18415 
 
18416 
  def read(self, iprot):
18417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18419 
      return
18420 
    iprot.readStructBegin()
18421 
    while True:
18422 
      (fname, ftype, fid) = iprot.readFieldBegin()
18423 
      if ftype == TType.STOP:
18424 
        break
18425 
      if fid == 1:
18426 
        if ftype == TType.I64:
18427 
          self.settlementId = iprot.readI64();
18428 
        else:
18429 
          iprot.skip(ftype)
18430 
      elif fid == 2:
18431 
        if ftype == TType.I64:
18432 
          self.settlementDate = iprot.readI64();
18433 
        else:
18434 
          iprot.skip(ftype)
18435 
      elif fid == 3:
18436 
        if ftype == TType.I64:
18437 
          self.transactionDateFrom = iprot.readI64();
18438 
        else:
18439 
          iprot.skip(ftype)
18440 
      elif fid == 4:
18441 
        if ftype == TType.I64:
18442 
          self.transactionDateTo = iprot.readI64();
18443 
        else:
18444 
          iprot.skip(ftype)
18445 
      elif fid == 5:
18446 
        if ftype == TType.DOUBLE:
18447 
          self.amount = iprot.readDouble();
18448 
        else:
18449 
          iprot.skip(ftype)
18450 
      else:
18451 
        iprot.skip(ftype)
18452 
      iprot.readFieldEnd()
18453 
    iprot.readStructEnd()
18454 
 
18455 
  def write(self, oprot):
18456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18458 
      return
18459 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
18460 
    if self.settlementId is not None:
18461 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18462 
      oprot.writeI64(self.settlementId)
18463 
      oprot.writeFieldEnd()
18464 
    if self.settlementDate is not None:
18465 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
18466 
      oprot.writeI64(self.settlementDate)
18467 
      oprot.writeFieldEnd()
18468 
    if self.transactionDateFrom is not None:
18469 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
18470 
      oprot.writeI64(self.transactionDateFrom)
18471 
      oprot.writeFieldEnd()
18472 
    if self.transactionDateTo is not None:
18473 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
18474 
      oprot.writeI64(self.transactionDateTo)
18475 
      oprot.writeFieldEnd()
18476 
    if self.amount is not None:
18477 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
18478 
      oprot.writeDouble(self.amount)
18479 
      oprot.writeFieldEnd()
18480 
    oprot.writeFieldStop()
18481 
    oprot.writeStructEnd()
18482 
 
18483 
  def validate(self):
18484 
    return
18485 
 
18486 
 
18487 
  def __repr__(self):
18488 
    L = ['%s=%r' % (key, value)
18489 
      for key, value in self.__dict__.iteritems()]
18490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18491 
 
18492 
  def __eq__(self, other):
18493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18494 
 
18495 
  def __ne__(self, other):
18496 
    return not (self == other)
18497 
 
18498 
class saveEBSSettlementSummary_result:
18499 
  """
18500 
  Attributes:
18501 
   - ex
18502 
  """
18503 
 
18504 
  thrift_spec = (
18505 
    None, # 0
18506 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18507 
  )
18508 
 
18509 
  def __init__(self, ex=None,):
18510 
    self.ex = ex
18511 
 
18512 
  def read(self, iprot):
18513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18515 
      return
18516 
    iprot.readStructBegin()
18517 
    while True:
18518 
      (fname, ftype, fid) = iprot.readFieldBegin()
18519 
      if ftype == TType.STOP:
18520 
        break
18521 
      if fid == 1:
18522 
        if ftype == TType.STRUCT:
18523 
          self.ex = TransactionServiceException()
18524 
          self.ex.read(iprot)
18525 
        else:
18526 
          iprot.skip(ftype)
18527 
      else:
18528 
        iprot.skip(ftype)
18529 
      iprot.readFieldEnd()
18530 
    iprot.readStructEnd()
18531 
 
18532 
  def write(self, oprot):
18533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18535 
      return
18536 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
18537 
    if self.ex is not None:
18538 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18539 
      self.ex.write(oprot)
18540 
      oprot.writeFieldEnd()
18541 
    oprot.writeFieldStop()
18542 
    oprot.writeStructEnd()
18543 
 
18544 
  def validate(self):
18545 
    return
18546 
 
18547 
 
18548 
  def __repr__(self):
18549 
    L = ['%s=%r' % (key, value)
18550 
      for key, value in self.__dict__.iteritems()]
18551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18552 
 
18553 
  def __eq__(self, other):
18554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18555 
 
18556 
  def __ne__(self, other):
18557 
    return not (self == other)
18558 
 
18559 
class getSettlementForPaymentId_args:
18560 
  """
18561 
  Attributes:
18562 
   - paymentId
18563 
  """
18564 
 
18565 
  thrift_spec = (
18566 
    None, # 0
18567 
    (1, TType.I64, 'paymentId', None, None, ), # 1
18568 
  )
18569 
 
18570 
  def __init__(self, paymentId=None,):
18571 
    self.paymentId = paymentId
18572 
 
18573 
  def read(self, iprot):
18574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18576 
      return
18577 
    iprot.readStructBegin()
18578 
    while True:
18579 
      (fname, ftype, fid) = iprot.readFieldBegin()
18580 
      if ftype == TType.STOP:
18581 
        break
18582 
      if fid == 1:
18583 
        if ftype == TType.I64:
18584 
          self.paymentId = iprot.readI64();
18585 
        else:
18586 
          iprot.skip(ftype)
18587 
      else:
18588 
        iprot.skip(ftype)
18589 
      iprot.readFieldEnd()
18590 
    iprot.readStructEnd()
18591 
 
18592 
  def write(self, oprot):
18593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18595 
      return
18596 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
18597 
    if self.paymentId is not None:
18598 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
18599 
      oprot.writeI64(self.paymentId)
18600 
      oprot.writeFieldEnd()
18601 
    oprot.writeFieldStop()
18602 
    oprot.writeStructEnd()
18603 
 
18604 
  def validate(self):
18605 
    return
18606 
 
18607 
 
18608 
  def __repr__(self):
18609 
    L = ['%s=%r' % (key, value)
18610 
      for key, value in self.__dict__.iteritems()]
18611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18612 
 
18613 
  def __eq__(self, other):
18614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18615 
 
18616 
  def __ne__(self, other):
18617 
    return not (self == other)
18618 
 
18619 
class getSettlementForPaymentId_result:
18620 
  """
18621 
  Attributes:
18622 
   - success
18623 
   - ex
18624 
  """
18625 
 
18626 
  thrift_spec = (
18627 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
18628 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18629 
  )
18630 
 
18631 
  def __init__(self, success=None, ex=None,):
18632 
    self.success = success
18633 
    self.ex = ex
18634 
 
18635 
  def read(self, iprot):
18636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18638 
      return
18639 
    iprot.readStructBegin()
18640 
    while True:
18641 
      (fname, ftype, fid) = iprot.readFieldBegin()
18642 
      if ftype == TType.STOP:
18643 
        break
18644 
      if fid == 0:
18645 
        if ftype == TType.STRUCT:
18646 
          self.success = PaymentSettlement()
18647 
          self.success.read(iprot)
18648 
        else:
18649 
          iprot.skip(ftype)
18650 
      elif fid == 1:
18651 
        if ftype == TType.STRUCT:
18652 
          self.ex = TransactionServiceException()
18653 
          self.ex.read(iprot)
18654 
        else:
18655 
          iprot.skip(ftype)
18656 
      else:
18657 
        iprot.skip(ftype)
18658 
      iprot.readFieldEnd()
18659 
    iprot.readStructEnd()
18660 
 
18661 
  def write(self, oprot):
18662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18664 
      return
18665 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
18666 
    if self.success is not None:
18667 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18668 
      self.success.write(oprot)
18669 
      oprot.writeFieldEnd()
18670 
    if self.ex is not None:
18671 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18672 
      self.ex.write(oprot)
18673 
      oprot.writeFieldEnd()
18674 
    oprot.writeFieldStop()
18675 
    oprot.writeStructEnd()
18676 
 
18677 
  def validate(self):
18678 
    return
18679 
 
18680 
 
18681 
  def __repr__(self):
18682 
    L = ['%s=%r' % (key, value)
18683 
      for key, value in self.__dict__.iteritems()]
18684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18685 
 
18686 
  def __eq__(self, other):
18687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18688 
 
18689 
  def __ne__(self, other):
18690 
    return not (self == other)
18691 
 
18692 
class getEBSSettlementSummaries_args:
18693 
 
18694 
  thrift_spec = (
18695 
  )
18696 
 
18697 
  def read(self, iprot):
18698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18700 
      return
18701 
    iprot.readStructBegin()
18702 
    while True:
18703 
      (fname, ftype, fid) = iprot.readFieldBegin()
18704 
      if ftype == TType.STOP:
18705 
        break
18706 
      else:
18707 
        iprot.skip(ftype)
18708 
      iprot.readFieldEnd()
18709 
    iprot.readStructEnd()
18710 
 
18711 
  def write(self, oprot):
18712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18714 
      return
18715 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
18716 
    oprot.writeFieldStop()
18717 
    oprot.writeStructEnd()
18718 
 
18719 
  def validate(self):
18720 
    return
18721 
 
18722 
 
18723 
  def __repr__(self):
18724 
    L = ['%s=%r' % (key, value)
18725 
      for key, value in self.__dict__.iteritems()]
18726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18727 
 
18728 
  def __eq__(self, other):
18729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18730 
 
18731 
  def __ne__(self, other):
18732 
    return not (self == other)
18733 
 
18734 
class getEBSSettlementSummaries_result:
18735 
  """
18736 
  Attributes:
18737 
   - success
18738 
   - ex
18739 
  """
18740 
 
18741 
  thrift_spec = (
18742 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
18743 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18744 
  )
18745 
 
18746 
  def __init__(self, success=None, ex=None,):
18747 
    self.success = success
18748 
    self.ex = ex
18749 
 
18750 
  def read(self, iprot):
18751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18753 
      return
18754 
    iprot.readStructBegin()
18755 
    while True:
18756 
      (fname, ftype, fid) = iprot.readFieldBegin()
18757 
      if ftype == TType.STOP:
18758 
        break
18759 
      if fid == 0:
18760 
        if ftype == TType.MAP:
18761 
          self.success = {}
4757 mandeep.dh 18762 
          (_ktype331, _vtype332, _size330 ) = iprot.readMapBegin()
18763 
          for _i334 in xrange(_size330):
18764 
            _key335 = iprot.readI64();
18765 
            _val336 = iprot.readString();
18766 
            self.success[_key335] = _val336
4600 varun.gupt 18767 
          iprot.readMapEnd()
18768 
        else:
18769 
          iprot.skip(ftype)
18770 
      elif fid == 1:
18771 
        if ftype == TType.STRUCT:
18772 
          self.ex = TransactionServiceException()
18773 
          self.ex.read(iprot)
18774 
        else:
18775 
          iprot.skip(ftype)
18776 
      else:
18777 
        iprot.skip(ftype)
18778 
      iprot.readFieldEnd()
18779 
    iprot.readStructEnd()
18780 
 
18781 
  def write(self, oprot):
18782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18784 
      return
18785 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
18786 
    if self.success is not None:
18787 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18788 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
4757 mandeep.dh 18789 
      for kiter337,viter338 in self.success.items():
18790 
        oprot.writeI64(kiter337)
18791 
        oprot.writeString(viter338)
4600 varun.gupt 18792 
      oprot.writeMapEnd()
18793 
      oprot.writeFieldEnd()
18794 
    if self.ex is not None:
18795 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18796 
      self.ex.write(oprot)
18797 
      oprot.writeFieldEnd()
18798 
    oprot.writeFieldStop()
18799 
    oprot.writeStructEnd()
18800 
 
18801 
  def validate(self):
18802 
    return
18803 
 
18804 
 
18805 
  def __repr__(self):
18806 
    L = ['%s=%r' % (key, value)
18807 
      for key, value in self.__dict__.iteritems()]
18808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18809 
 
18810 
  def __eq__(self, other):
18811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18812 
 
18813 
  def __ne__(self, other):
18814 
    return not (self == other)
18815 
 
18816 
class markEBSSettlementUploaded_args:
18817 
  """
18818 
  Attributes:
18819 
   - settlementId
18820 
  """
18821 
 
18822 
  thrift_spec = (
18823 
    None, # 0
18824 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18825 
  )
18826 
 
18827 
  def __init__(self, settlementId=None,):
18828 
    self.settlementId = settlementId
18829 
 
18830 
  def read(self, iprot):
18831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18833 
      return
18834 
    iprot.readStructBegin()
18835 
    while True:
18836 
      (fname, ftype, fid) = iprot.readFieldBegin()
18837 
      if ftype == TType.STOP:
18838 
        break
18839 
      if fid == 1:
18840 
        if ftype == TType.I64:
18841 
          self.settlementId = iprot.readI64();
18842 
        else:
18843 
          iprot.skip(ftype)
18844 
      else:
18845 
        iprot.skip(ftype)
18846 
      iprot.readFieldEnd()
18847 
    iprot.readStructEnd()
18848 
 
18849 
  def write(self, oprot):
18850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18852 
      return
18853 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
18854 
    if self.settlementId is not None:
18855 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18856 
      oprot.writeI64(self.settlementId)
18857 
      oprot.writeFieldEnd()
18858 
    oprot.writeFieldStop()
18859 
    oprot.writeStructEnd()
18860 
 
18861 
  def validate(self):
18862 
    return
18863 
 
18864 
 
18865 
  def __repr__(self):
18866 
    L = ['%s=%r' % (key, value)
18867 
      for key, value in self.__dict__.iteritems()]
18868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18869 
 
18870 
  def __eq__(self, other):
18871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18872 
 
18873 
  def __ne__(self, other):
18874 
    return not (self == other)
18875 
 
18876 
class markEBSSettlementUploaded_result:
18877 
  """
18878 
  Attributes:
18879 
   - ex
18880 
  """
18881 
 
18882 
  thrift_spec = (
18883 
    None, # 0
18884 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18885 
  )
18886 
 
18887 
  def __init__(self, ex=None,):
18888 
    self.ex = ex
18889 
 
18890 
  def read(self, iprot):
18891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18893 
      return
18894 
    iprot.readStructBegin()
18895 
    while True:
18896 
      (fname, ftype, fid) = iprot.readFieldBegin()
18897 
      if ftype == TType.STOP:
18898 
        break
18899 
      if fid == 1:
18900 
        if ftype == TType.STRUCT:
18901 
          self.ex = TransactionServiceException()
18902 
          self.ex.read(iprot)
18903 
        else:
18904 
          iprot.skip(ftype)
18905 
      else:
18906 
        iprot.skip(ftype)
18907 
      iprot.readFieldEnd()
18908 
    iprot.readStructEnd()
18909 
 
18910 
  def write(self, oprot):
18911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18913 
      return
18914 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
18915 
    if self.ex is not None:
18916 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18917 
      self.ex.write(oprot)
18918 
      oprot.writeFieldEnd()
18919 
    oprot.writeFieldStop()
18920 
    oprot.writeStructEnd()
18921 
 
18922 
  def validate(self):
18923 
    return
18924 
 
18925 
 
18926 
  def __repr__(self):
18927 
    L = ['%s=%r' % (key, value)
18928 
      for key, value in self.__dict__.iteritems()]
18929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18930 
 
18931 
  def __eq__(self, other):
18932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18933 
 
18934 
  def __ne__(self, other):
18935 
    return not (self == other)
18936 
 
18937 
class getEBSSettlementDate_args:
18938 
  """
18939 
  Attributes:
18940 
   - settlementId
18941 
  """
18942 
 
18943 
  thrift_spec = (
18944 
    None, # 0
18945 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18946 
  )
18947 
 
18948 
  def __init__(self, settlementId=None,):
18949 
    self.settlementId = settlementId
18950 
 
18951 
  def read(self, iprot):
18952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18954 
      return
18955 
    iprot.readStructBegin()
18956 
    while True:
18957 
      (fname, ftype, fid) = iprot.readFieldBegin()
18958 
      if ftype == TType.STOP:
18959 
        break
18960 
      if fid == 1:
18961 
        if ftype == TType.I64:
18962 
          self.settlementId = iprot.readI64();
18963 
        else:
18964 
          iprot.skip(ftype)
18965 
      else:
18966 
        iprot.skip(ftype)
18967 
      iprot.readFieldEnd()
18968 
    iprot.readStructEnd()
18969 
 
18970 
  def write(self, oprot):
18971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18973 
      return
18974 
    oprot.writeStructBegin('getEBSSettlementDate_args')
18975 
    if self.settlementId is not None:
18976 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18977 
      oprot.writeI64(self.settlementId)
18978 
      oprot.writeFieldEnd()
18979 
    oprot.writeFieldStop()
18980 
    oprot.writeStructEnd()
18981 
 
18982 
  def validate(self):
18983 
    return
18984 
 
18985 
 
18986 
  def __repr__(self):
18987 
    L = ['%s=%r' % (key, value)
18988 
      for key, value in self.__dict__.iteritems()]
18989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18990 
 
18991 
  def __eq__(self, other):
18992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18993 
 
18994 
  def __ne__(self, other):
18995 
    return not (self == other)
18996 
 
18997 
class getEBSSettlementDate_result:
18998 
  """
18999 
  Attributes:
19000 
   - success
19001 
   - ex
19002 
  """
19003 
 
19004 
  thrift_spec = (
19005 
    (0, TType.I64, 'success', None, None, ), # 0
19006 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19007 
  )
19008 
 
19009 
  def __init__(self, success=None, ex=None,):
19010 
    self.success = success
19011 
    self.ex = ex
19012 
 
19013 
  def read(self, iprot):
19014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19016 
      return
19017 
    iprot.readStructBegin()
19018 
    while True:
19019 
      (fname, ftype, fid) = iprot.readFieldBegin()
19020 
      if ftype == TType.STOP:
19021 
        break
19022 
      if fid == 0:
19023 
        if ftype == TType.I64:
19024 
          self.success = iprot.readI64();
19025 
        else:
19026 
          iprot.skip(ftype)
19027 
      elif fid == 1:
19028 
        if ftype == TType.STRUCT:
19029 
          self.ex = TransactionServiceException()
19030 
          self.ex.read(iprot)
19031 
        else:
19032 
          iprot.skip(ftype)
19033 
      else:
19034 
        iprot.skip(ftype)
19035 
      iprot.readFieldEnd()
19036 
    iprot.readStructEnd()
19037 
 
19038 
  def write(self, oprot):
19039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19041 
      return
19042 
    oprot.writeStructBegin('getEBSSettlementDate_result')
19043 
    if self.success is not None:
19044 
      oprot.writeFieldBegin('success', TType.I64, 0)
19045 
      oprot.writeI64(self.success)
19046 
      oprot.writeFieldEnd()
19047 
    if self.ex is not None:
19048 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19049 
      self.ex.write(oprot)
19050 
      oprot.writeFieldEnd()
19051 
    oprot.writeFieldStop()
19052 
    oprot.writeStructEnd()
19053 
 
19054 
  def validate(self):
19055 
    return
19056 
 
19057 
 
19058 
  def __repr__(self):
19059 
    L = ['%s=%r' % (key, value)
19060 
      for key, value in self.__dict__.iteritems()]
19061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19062 
 
19063 
  def __eq__(self, other):
19064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19065 
 
19066 
  def __ne__(self, other):
19067 
    return not (self == other)
4715 varun.gupt 19068 
 
19069 
class getSettlementsByDate_args:
19070 
  """
19071 
  Attributes:
19072 
   - settlementDateFrom
19073 
   - settlementDateTo
19074 
   - isRefund
19075 
  """
19076 
 
19077 
  thrift_spec = (
19078 
    None, # 0
19079 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
19080 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
19081 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
19082 
  )
19083 
 
19084 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
19085 
    self.settlementDateFrom = settlementDateFrom
19086 
    self.settlementDateTo = settlementDateTo
19087 
    self.isRefund = isRefund
19088 
 
19089 
  def read(self, iprot):
19090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19092 
      return
19093 
    iprot.readStructBegin()
19094 
    while True:
19095 
      (fname, ftype, fid) = iprot.readFieldBegin()
19096 
      if ftype == TType.STOP:
19097 
        break
19098 
      if fid == 1:
19099 
        if ftype == TType.I64:
19100 
          self.settlementDateFrom = iprot.readI64();
19101 
        else:
19102 
          iprot.skip(ftype)
19103 
      elif fid == 2:
19104 
        if ftype == TType.I64:
19105 
          self.settlementDateTo = iprot.readI64();
19106 
        else:
19107 
          iprot.skip(ftype)
19108 
      elif fid == 3:
19109 
        if ftype == TType.BOOL:
19110 
          self.isRefund = iprot.readBool();
19111 
        else:
19112 
          iprot.skip(ftype)
19113 
      else:
19114 
        iprot.skip(ftype)
19115 
      iprot.readFieldEnd()
19116 
    iprot.readStructEnd()
19117 
 
19118 
  def write(self, oprot):
19119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19121 
      return
19122 
    oprot.writeStructBegin('getSettlementsByDate_args')
19123 
    if self.settlementDateFrom is not None:
19124 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
19125 
      oprot.writeI64(self.settlementDateFrom)
19126 
      oprot.writeFieldEnd()
19127 
    if self.settlementDateTo is not None:
19128 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
19129 
      oprot.writeI64(self.settlementDateTo)
19130 
      oprot.writeFieldEnd()
19131 
    if self.isRefund is not None:
19132 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
19133 
      oprot.writeBool(self.isRefund)
19134 
      oprot.writeFieldEnd()
19135 
    oprot.writeFieldStop()
19136 
    oprot.writeStructEnd()
19137 
 
19138 
  def validate(self):
19139 
    return
19140 
 
19141 
 
19142 
  def __repr__(self):
19143 
    L = ['%s=%r' % (key, value)
19144 
      for key, value in self.__dict__.iteritems()]
19145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19146 
 
19147 
  def __eq__(self, other):
19148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19149 
 
19150 
  def __ne__(self, other):
19151 
    return not (self == other)
19152 
 
19153 
class getSettlementsByDate_result:
19154 
  """
19155 
  Attributes:
19156 
   - success
19157 
   - ex
19158 
  """
19159 
 
19160 
  thrift_spec = (
19161 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
19162 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19163 
  )
19164 
 
19165 
  def __init__(self, success=None, ex=None,):
19166 
    self.success = success
19167 
    self.ex = ex
19168 
 
19169 
  def read(self, iprot):
19170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19172 
      return
19173 
    iprot.readStructBegin()
19174 
    while True:
19175 
      (fname, ftype, fid) = iprot.readFieldBegin()
19176 
      if ftype == TType.STOP:
19177 
        break
19178 
      if fid == 0:
19179 
        if ftype == TType.LIST:
19180 
          self.success = []
4757 mandeep.dh 19181 
          (_etype342, _size339) = iprot.readListBegin()
19182 
          for _i343 in xrange(_size339):
19183 
            _elem344 = PaymentSettlement()
19184 
            _elem344.read(iprot)
19185 
            self.success.append(_elem344)
4715 varun.gupt 19186 
          iprot.readListEnd()
19187 
        else:
19188 
          iprot.skip(ftype)
19189 
      elif fid == 1:
19190 
        if ftype == TType.STRUCT:
19191 
          self.ex = TransactionServiceException()
19192 
          self.ex.read(iprot)
19193 
        else:
19194 
          iprot.skip(ftype)
19195 
      else:
19196 
        iprot.skip(ftype)
19197 
      iprot.readFieldEnd()
19198 
    iprot.readStructEnd()
19199 
 
19200 
  def write(self, oprot):
19201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19203 
      return
19204 
    oprot.writeStructBegin('getSettlementsByDate_result')
19205 
    if self.success is not None:
19206 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19207 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4757 mandeep.dh 19208 
      for iter345 in self.success:
19209 
        iter345.write(oprot)
4715 varun.gupt 19210 
      oprot.writeListEnd()
19211 
      oprot.writeFieldEnd()
19212 
    if self.ex is not None:
19213 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19214 
      self.ex.write(oprot)
19215 
      oprot.writeFieldEnd()
19216 
    oprot.writeFieldStop()
19217 
    oprot.writeStructEnd()
19218 
 
19219 
  def validate(self):
19220 
    return
19221 
 
19222 
 
19223 
  def __repr__(self):
19224 
    L = ['%s=%r' % (key, value)
19225 
      for key, value in self.__dict__.iteritems()]
19226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19227 
 
19228 
  def __eq__(self, other):
19229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19230 
 
19231 
  def __ne__(self, other):
19232 
    return not (self == other)
19233 
 
19234 
class getReshippedOrderIds_args:
19235 
  """
19236 
  Attributes:
19237 
   - orderIds
19238 
  """
19239 
 
19240 
  thrift_spec = (
19241 
    None, # 0
19242 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
19243 
  )
19244 
 
19245 
  def __init__(self, orderIds=None,):
19246 
    self.orderIds = orderIds
19247 
 
19248 
  def read(self, iprot):
19249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19251 
      return
19252 
    iprot.readStructBegin()
19253 
    while True:
19254 
      (fname, ftype, fid) = iprot.readFieldBegin()
19255 
      if ftype == TType.STOP:
19256 
        break
19257 
      if fid == 1:
19258 
        if ftype == TType.LIST:
19259 
          self.orderIds = []
4757 mandeep.dh 19260 
          (_etype349, _size346) = iprot.readListBegin()
19261 
          for _i350 in xrange(_size346):
19262 
            _elem351 = iprot.readI64();
19263 
            self.orderIds.append(_elem351)
4715 varun.gupt 19264 
          iprot.readListEnd()
19265 
        else:
19266 
          iprot.skip(ftype)
19267 
      else:
19268 
        iprot.skip(ftype)
19269 
      iprot.readFieldEnd()
19270 
    iprot.readStructEnd()
19271 
 
19272 
  def write(self, oprot):
19273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19275 
      return
19276 
    oprot.writeStructBegin('getReshippedOrderIds_args')
19277 
    if self.orderIds is not None:
19278 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
19279 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
4757 mandeep.dh 19280 
      for iter352 in self.orderIds:
19281 
        oprot.writeI64(iter352)
4715 varun.gupt 19282 
      oprot.writeListEnd()
19283 
      oprot.writeFieldEnd()
19284 
    oprot.writeFieldStop()
19285 
    oprot.writeStructEnd()
19286 
 
19287 
  def validate(self):
19288 
    return
19289 
 
19290 
 
19291 
  def __repr__(self):
19292 
    L = ['%s=%r' % (key, value)
19293 
      for key, value in self.__dict__.iteritems()]
19294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19295 
 
19296 
  def __eq__(self, other):
19297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19298 
 
19299 
  def __ne__(self, other):
19300 
    return not (self == other)
19301 
 
19302 
class getReshippedOrderIds_result:
19303 
  """
19304 
  Attributes:
19305 
   - success
19306 
   - ex
19307 
  """
19308 
 
19309 
  thrift_spec = (
19310 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19311 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19312 
  )
19313 
 
19314 
  def __init__(self, success=None, ex=None,):
19315 
    self.success = success
19316 
    self.ex = ex
19317 
 
19318 
  def read(self, iprot):
19319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19321 
      return
19322 
    iprot.readStructBegin()
19323 
    while True:
19324 
      (fname, ftype, fid) = iprot.readFieldBegin()
19325 
      if ftype == TType.STOP:
19326 
        break
19327 
      if fid == 0:
19328 
        if ftype == TType.LIST:
19329 
          self.success = []
4757 mandeep.dh 19330 
          (_etype356, _size353) = iprot.readListBegin()
19331 
          for _i357 in xrange(_size353):
19332 
            _elem358 = iprot.readI64();
19333 
            self.success.append(_elem358)
4715 varun.gupt 19334 
          iprot.readListEnd()
19335 
        else:
19336 
          iprot.skip(ftype)
19337 
      elif fid == 1:
19338 
        if ftype == TType.STRUCT:
19339 
          self.ex = TransactionServiceException()
19340 
          self.ex.read(iprot)
19341 
        else:
19342 
          iprot.skip(ftype)
19343 
      else:
19344 
        iprot.skip(ftype)
19345 
      iprot.readFieldEnd()
19346 
    iprot.readStructEnd()
19347 
 
19348 
  def write(self, oprot):
19349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19351 
      return
19352 
    oprot.writeStructBegin('getReshippedOrderIds_result')
19353 
    if self.success is not None:
19354 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19355 
      oprot.writeListBegin(TType.I64, len(self.success))
4757 mandeep.dh 19356 
      for iter359 in self.success:
19357 
        oprot.writeI64(iter359)
4715 varun.gupt 19358 
      oprot.writeListEnd()
19359 
      oprot.writeFieldEnd()
19360 
    if self.ex is not None:
19361 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19362 
      self.ex.write(oprot)
19363 
      oprot.writeFieldEnd()
19364 
    oprot.writeFieldStop()
19365 
    oprot.writeStructEnd()
19366 
 
19367 
  def validate(self):
19368 
    return
19369 
 
19370 
 
19371 
  def __repr__(self):
19372 
    L = ['%s=%r' % (key, value)
19373 
      for key, value in self.__dict__.iteritems()]
19374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19375 
 
19376 
  def __eq__(self, other):
19377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19378 
 
19379 
  def __ne__(self, other):
19380 
    return not (self == other)
4757 mandeep.dh 19381 
 
19382 
class updateOrdersAsPORaised_args:
19383 
  """
19384 
  Attributes:
19385 
   - itemIdQuantityMap
19386 
   - purchaseOrderId
19387 
   - warehouseId
19388 
  """
19389 
 
19390 
  thrift_spec = (
19391 
    None, # 0
19392 
    (1, TType.MAP, 'itemIdQuantityMap', (TType.I64,None,TType.I64,None), None, ), # 1
19393 
    (2, TType.I64, 'purchaseOrderId', None, None, ), # 2
19394 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
19395 
  )
19396 
 
19397 
  def __init__(self, itemIdQuantityMap=None, purchaseOrderId=None, warehouseId=None,):
19398 
    self.itemIdQuantityMap = itemIdQuantityMap
19399 
    self.purchaseOrderId = purchaseOrderId
19400 
    self.warehouseId = warehouseId
19401 
 
19402 
  def read(self, iprot):
19403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19405 
      return
19406 
    iprot.readStructBegin()
19407 
    while True:
19408 
      (fname, ftype, fid) = iprot.readFieldBegin()
19409 
      if ftype == TType.STOP:
19410 
        break
19411 
      if fid == 1:
19412 
        if ftype == TType.MAP:
19413 
          self.itemIdQuantityMap = {}
19414 
          (_ktype361, _vtype362, _size360 ) = iprot.readMapBegin()
19415 
          for _i364 in xrange(_size360):
19416 
            _key365 = iprot.readI64();
19417 
            _val366 = iprot.readI64();
19418 
            self.itemIdQuantityMap[_key365] = _val366
19419 
          iprot.readMapEnd()
19420 
        else:
19421 
          iprot.skip(ftype)
19422 
      elif fid == 2:
19423 
        if ftype == TType.I64:
19424 
          self.purchaseOrderId = iprot.readI64();
19425 
        else:
19426 
          iprot.skip(ftype)
19427 
      elif fid == 3:
19428 
        if ftype == TType.I64:
19429 
          self.warehouseId = iprot.readI64();
19430 
        else:
19431 
          iprot.skip(ftype)
19432 
      else:
19433 
        iprot.skip(ftype)
19434 
      iprot.readFieldEnd()
19435 
    iprot.readStructEnd()
19436 
 
19437 
  def write(self, oprot):
19438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19440 
      return
19441 
    oprot.writeStructBegin('updateOrdersAsPORaised_args')
19442 
    if self.itemIdQuantityMap is not None:
19443 
      oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
19444 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
19445 
      for kiter367,viter368 in self.itemIdQuantityMap.items():
19446 
        oprot.writeI64(kiter367)
19447 
        oprot.writeI64(viter368)
19448 
      oprot.writeMapEnd()
19449 
      oprot.writeFieldEnd()
19450 
    if self.purchaseOrderId is not None:
19451 
      oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
19452 
      oprot.writeI64(self.purchaseOrderId)
19453 
      oprot.writeFieldEnd()
19454 
    if self.warehouseId is not None:
19455 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
19456 
      oprot.writeI64(self.warehouseId)
19457 
      oprot.writeFieldEnd()
19458 
    oprot.writeFieldStop()
19459 
    oprot.writeStructEnd()
19460 
 
19461 
  def validate(self):
19462 
    return
19463 
 
19464 
 
19465 
  def __repr__(self):
19466 
    L = ['%s=%r' % (key, value)
19467 
      for key, value in self.__dict__.iteritems()]
19468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19469 
 
19470 
  def __eq__(self, other):
19471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19472 
 
19473 
  def __ne__(self, other):
19474 
    return not (self == other)
19475 
 
19476 
class updateOrdersAsPORaised_result:
19477 
  """
19478 
  Attributes:
19479 
   - ex
19480 
  """
19481 
 
19482 
  thrift_spec = (
19483 
    None, # 0
19484 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19485 
  )
19486 
 
19487 
  def __init__(self, ex=None,):
19488 
    self.ex = ex
19489 
 
19490 
  def read(self, iprot):
19491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19493 
      return
19494 
    iprot.readStructBegin()
19495 
    while True:
19496 
      (fname, ftype, fid) = iprot.readFieldBegin()
19497 
      if ftype == TType.STOP:
19498 
        break
19499 
      if fid == 1:
19500 
        if ftype == TType.STRUCT:
19501 
          self.ex = TransactionServiceException()
19502 
          self.ex.read(iprot)
19503 
        else:
19504 
          iprot.skip(ftype)
19505 
      else:
19506 
        iprot.skip(ftype)
19507 
      iprot.readFieldEnd()
19508 
    iprot.readStructEnd()
19509 
 
19510 
  def write(self, oprot):
19511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19513 
      return
19514 
    oprot.writeStructBegin('updateOrdersAsPORaised_result')
19515 
    if self.ex is not None:
19516 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19517 
      self.ex.write(oprot)
19518 
      oprot.writeFieldEnd()
19519 
    oprot.writeFieldStop()
19520 
    oprot.writeStructEnd()
19521 
 
19522 
  def validate(self):
19523 
    return
19524 
 
19525 
 
19526 
  def __repr__(self):
19527 
    L = ['%s=%r' % (key, value)
19528 
      for key, value in self.__dict__.iteritems()]
19529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19530 
 
19531 
  def __eq__(self, other):
19532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19533 
 
19534 
  def __ne__(self, other):
19535 
    return not (self == other)