Subversion Repositories SmartDukaan

Rev

Rev 4712 | Rev 4741 | 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 
 
4479 rajveer 533 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 534 
    """
4452 rajveer 535 
    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 536 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 537 
    If the order is in any other state, it returns false.
538 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 539 
 
2591 chandransh 540 
    Parameters:
541 
     - orderId
4479 rajveer 542 
     - receiveCondition
2591 chandransh 543 
    """
544 
    pass
2536 chandransh 545 
 
2591 chandransh 546 
  def validateDoa(self, orderId, isValid):
547 
    """
4452 rajveer 548 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 549 
    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 550 
    If the order is in any other state, it returns false.
551 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 552 
 
2591 chandransh 553 
    Parameters:
554 
     - orderId
555 
     - isValid
556 
    """
557 
    pass
558 
 
4495 rajveer 559 
  def validateReturnProduct(self, orderId, isUsable):
560 
    """
561 
    Parameters:
562 
     - orderId
563 
     - isUsable
564 
    """
565 
    pass
566 
 
2616 chandransh 567 
  def reshipOrder(self, orderId):
568 
    """
4484 rajveer 569 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 570 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 571 
    	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 572 
 
573 
    If the order is in DOA_CERT_VALID state, it does the following:
574 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
575 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 576 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 577 
 
2616 chandransh 578 
    Returns the id of the newly created order.
3431 rajveer 579 
 
2616 chandransh 580 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 581 
 
2616 chandransh 582 
    Parameters:
583 
     - orderId
584 
    """
585 
    pass
2591 chandransh 586 
 
3226 chandransh 587 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 588 
    """
4484 rajveer 589 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 590 
    	1. Creates a refund request for batch processing.
591 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 592 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 593 
 
2616 chandransh 594 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
595 
    	1. Creates a refund request for batch processing.
3226 chandransh 596 
    	2. Cancels the reservation of the item in the warehouse.
597 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 598 
 
3226 chandransh 599 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
600 
    	1. Cancels the reservation of the item in the warehouse.
601 
    	2. Marks the current order as CANCELED.
602 
 
603 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
604 
 
2616 chandransh 605 
    Returns True if it is successful, False otherwise.
3431 rajveer 606 
 
2616 chandransh 607 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 608 
 
2616 chandransh 609 
    Parameters:
610 
     - orderId
3226 chandransh 611 
     - refundedBy
612 
     - reason
2616 chandransh 613 
    """
614 
    pass
615 
 
2690 chandransh 616 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
617 
    """
618 
    Get all return orders created between the from and to dates for the given warehouse.
619 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 620 
 
2690 chandransh 621 
    Parameters:
622 
     - warehouseId
623 
     - fromDate
624 
     - toDate
625 
    """
626 
    pass
2616 chandransh 627 
 
2700 chandransh 628 
  def getReturnOrder(self, id):
629 
    """
630 
    Returns the ReturnOrder corresponding to the given id.
631 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 632 
 
2700 chandransh 633 
    Parameters:
634 
     - id
635 
    """
636 
    pass
637 
 
2690 chandransh 638 
  def processReturn(self, returnOrderId):
639 
    """
640 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 641 
 
2690 chandransh 642 
    Parameters:
643 
     - returnOrderId
644 
    """
645 
    pass
646 
 
2819 chandransh 647 
  def createPurchaseOrder(self, warehouseId):
648 
    """
4586 mandeep.dh 649 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
650 
    Returns the list of PO no. of the newly created purchase order.
651 
    Returns null if no new purchase order had to be created.
3431 rajveer 652 
 
2819 chandransh 653 
    Parameters:
654 
     - warehouseId
655 
    """
656 
    pass
2690 chandransh 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 
 
1002 
 
3376 rajveer 1003 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1004 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1005 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1006 
 
1007 
  def createTransaction(self, transaction):
1008 
    """
1009 
    Parameters:
1010 
     - transaction
1011 
    """
1012 
    self.send_createTransaction(transaction)
132 ashish 1013 
    return self.recv_createTransaction()
94 ashish 1014 
 
1015 
  def send_createTransaction(self, transaction):
1016 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1017 
    args = createTransaction_args()
1018 
    args.transaction = transaction
1019 
    args.write(self._oprot)
1020 
    self._oprot.writeMessageEnd()
1021 
    self._oprot.trans.flush()
1022 
 
1023 
  def recv_createTransaction(self, ):
1024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1025 
    if mtype == TMessageType.EXCEPTION:
1026 
      x = TApplicationException()
1027 
      x.read(self._iprot)
1028 
      self._iprot.readMessageEnd()
1029 
      raise x
1030 
    result = createTransaction_result()
1031 
    result.read(self._iprot)
1032 
    self._iprot.readMessageEnd()
3431 rajveer 1033 
    if result.success is not None:
132 ashish 1034 
      return result.success
3431 rajveer 1035 
    if result.ex is not None:
94 ashish 1036 
      raise result.ex
132 ashish 1037 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1038 
 
1039 
  def getTransaction(self, id):
1040 
    """
1041 
    Parameters:
1042 
     - id
1043 
    """
1044 
    self.send_getTransaction(id)
1045 
    return self.recv_getTransaction()
1046 
 
1047 
  def send_getTransaction(self, id):
1048 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1049 
    args = getTransaction_args()
1050 
    args.id = id
1051 
    args.write(self._oprot)
1052 
    self._oprot.writeMessageEnd()
1053 
    self._oprot.trans.flush()
1054 
 
1055 
  def recv_getTransaction(self, ):
1056 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1057 
    if mtype == TMessageType.EXCEPTION:
1058 
      x = TApplicationException()
1059 
      x.read(self._iprot)
1060 
      self._iprot.readMessageEnd()
1061 
      raise x
1062 
    result = getTransaction_result()
1063 
    result.read(self._iprot)
1064 
    self._iprot.readMessageEnd()
3431 rajveer 1065 
    if result.success is not None:
94 ashish 1066 
      return result.success
3431 rajveer 1067 
    if result.ex is not None:
94 ashish 1068 
      raise result.ex
1069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1070 
 
1071 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1072 
    """
1073 
    Parameters:
1074 
     - customerId
1075 
     - from_date
1076 
     - to_date
1077 
     - status
1078 
    """
1079 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1080 
    return self.recv_getTransactionsForCustomer()
1081 
 
1082 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1083 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1084 
    args = getTransactionsForCustomer_args()
1085 
    args.customerId = customerId
1086 
    args.from_date = from_date
1087 
    args.to_date = to_date
1088 
    args.status = status
1089 
    args.write(self._oprot)
1090 
    self._oprot.writeMessageEnd()
1091 
    self._oprot.trans.flush()
1092 
 
1093 
  def recv_getTransactionsForCustomer(self, ):
1094 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1095 
    if mtype == TMessageType.EXCEPTION:
1096 
      x = TApplicationException()
1097 
      x.read(self._iprot)
1098 
      self._iprot.readMessageEnd()
1099 
      raise x
1100 
    result = getTransactionsForCustomer_result()
1101 
    result.read(self._iprot)
1102 
    self._iprot.readMessageEnd()
3431 rajveer 1103 
    if result.success is not None:
94 ashish 1104 
      return result.success
3431 rajveer 1105 
    if result.ex is not None:
94 ashish 1106 
      raise result.ex
1107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1108 
 
132 ashish 1109 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1110 
    """
1111 
    Parameters:
1112 
     - shoppingCartId
1113 
    """
1114 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1115 
    return self.recv_getTransactionsForShoppingCartId()
1116 
 
1117 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1118 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1119 
    args = getTransactionsForShoppingCartId_args()
1120 
    args.shoppingCartId = shoppingCartId
1121 
    args.write(self._oprot)
1122 
    self._oprot.writeMessageEnd()
1123 
    self._oprot.trans.flush()
1124 
 
1125 
  def recv_getTransactionsForShoppingCartId(self, ):
1126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1127 
    if mtype == TMessageType.EXCEPTION:
1128 
      x = TApplicationException()
1129 
      x.read(self._iprot)
1130 
      self._iprot.readMessageEnd()
1131 
      raise x
1132 
    result = getTransactionsForShoppingCartId_result()
1133 
    result.read(self._iprot)
1134 
    self._iprot.readMessageEnd()
3431 rajveer 1135 
    if result.success is not None:
132 ashish 1136 
      return result.success
3431 rajveer 1137 
    if result.ex is not None:
132 ashish 1138 
      raise result.ex
1139 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1140 
 
94 ashish 1141 
  def getTransactionStatus(self, transactionId):
1142 
    """
1143 
    Parameters:
1144 
     - transactionId
1145 
    """
1146 
    self.send_getTransactionStatus(transactionId)
1147 
    return self.recv_getTransactionStatus()
1148 
 
1149 
  def send_getTransactionStatus(self, transactionId):
1150 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1151 
    args = getTransactionStatus_args()
1152 
    args.transactionId = transactionId
1153 
    args.write(self._oprot)
1154 
    self._oprot.writeMessageEnd()
1155 
    self._oprot.trans.flush()
1156 
 
1157 
  def recv_getTransactionStatus(self, ):
1158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1159 
    if mtype == TMessageType.EXCEPTION:
1160 
      x = TApplicationException()
1161 
      x.read(self._iprot)
1162 
      self._iprot.readMessageEnd()
1163 
      raise x
1164 
    result = getTransactionStatus_result()
1165 
    result.read(self._iprot)
1166 
    self._iprot.readMessageEnd()
3431 rajveer 1167 
    if result.success is not None:
94 ashish 1168 
      return result.success
3431 rajveer 1169 
    if result.ex is not None:
94 ashish 1170 
      raise result.ex
1171 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1172 
 
1173 
  def changeTransactionStatus(self, transactionId, status, description):
1174 
    """
1175 
    Parameters:
1176 
     - transactionId
1177 
     - status
1178 
     - description
1179 
    """
1180 
    self.send_changeTransactionStatus(transactionId, status, description)
1181 
    return self.recv_changeTransactionStatus()
1182 
 
1183 
  def send_changeTransactionStatus(self, transactionId, status, description):
1184 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1185 
    args = changeTransactionStatus_args()
1186 
    args.transactionId = transactionId
1187 
    args.status = status
1188 
    args.description = description
1189 
    args.write(self._oprot)
1190 
    self._oprot.writeMessageEnd()
1191 
    self._oprot.trans.flush()
1192 
 
1193 
  def recv_changeTransactionStatus(self, ):
1194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1195 
    if mtype == TMessageType.EXCEPTION:
1196 
      x = TApplicationException()
1197 
      x.read(self._iprot)
1198 
      self._iprot.readMessageEnd()
1199 
      raise x
1200 
    result = changeTransactionStatus_result()
1201 
    result.read(self._iprot)
1202 
    self._iprot.readMessageEnd()
3431 rajveer 1203 
    if result.success is not None:
94 ashish 1204 
      return result.success
3431 rajveer 1205 
    if result.ex is not None:
94 ashish 1206 
      raise result.ex
1207 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1208 
 
1398 varun.gupt 1209 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1210 
    """
1211 
    Parameters:
1212 
     - transactionId
1213 
    """
1398 varun.gupt 1214 
    self.send_enqueueTransactionInfoEmail(transactionId)
1215 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1216 
 
1398 varun.gupt 1217 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1218 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1219 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1220 
    args.transactionId = transactionId
1221 
    args.write(self._oprot)
1222 
    self._oprot.writeMessageEnd()
1223 
    self._oprot.trans.flush()
1224 
 
1398 varun.gupt 1225 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1227 
    if mtype == TMessageType.EXCEPTION:
1228 
      x = TApplicationException()
1229 
      x.read(self._iprot)
1230 
      self._iprot.readMessageEnd()
1231 
      raise x
1398 varun.gupt 1232 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1233 
    result.read(self._iprot)
1234 
    self._iprot.readMessageEnd()
3431 rajveer 1235 
    if result.success is not None:
1382 varun.gupt 1236 
      return result.success
3431 rajveer 1237 
    if result.ex is not None:
1382 varun.gupt 1238 
      raise result.ex
1398 varun.gupt 1239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1240 
 
483 rajveer 1241 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1242 
    """
1243 
    Parameters:
483 rajveer 1244 
     - status
1245 
     - from_date
1246 
     - to_date
1247 
     - warehouse_id
94 ashish 1248 
    """
483 rajveer 1249 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1250 
    return self.recv_getAllOrders()
94 ashish 1251 
 
483 rajveer 1252 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1253 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1254 
    args = getAllOrders_args()
1255 
    args.status = status
1256 
    args.from_date = from_date
1257 
    args.to_date = to_date
1258 
    args.warehouse_id = warehouse_id
94 ashish 1259 
    args.write(self._oprot)
1260 
    self._oprot.writeMessageEnd()
1261 
    self._oprot.trans.flush()
1262 
 
483 rajveer 1263 
  def recv_getAllOrders(self, ):
94 ashish 1264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1265 
    if mtype == TMessageType.EXCEPTION:
1266 
      x = TApplicationException()
1267 
      x.read(self._iprot)
1268 
      self._iprot.readMessageEnd()
1269 
      raise x
483 rajveer 1270 
    result = getAllOrders_result()
94 ashish 1271 
    result.read(self._iprot)
1272 
    self._iprot.readMessageEnd()
3431 rajveer 1273 
    if result.success is not None:
94 ashish 1274 
      return result.success
3431 rajveer 1275 
    if result.ex is not None:
94 ashish 1276 
      raise result.ex
483 rajveer 1277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1278 
 
4133 chandransh 1279 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1280 
    """
1281 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1282 
    Pass the status as null and the limit as 0 to ignore them.
1283 
 
1284 
    Parameters:
1285 
     - statuses
1286 
     - offset
1287 
     - limit
1288 
     - warehouse_id
1289 
    """
1290 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1291 
    return self.recv_getOrdersInBatch()
1292 
 
1293 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1294 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1295 
    args = getOrdersInBatch_args()
1296 
    args.statuses = statuses
1297 
    args.offset = offset
1298 
    args.limit = limit
1299 
    args.warehouse_id = warehouse_id
1300 
    args.write(self._oprot)
1301 
    self._oprot.writeMessageEnd()
1302 
    self._oprot.trans.flush()
1303 
 
1304 
  def recv_getOrdersInBatch(self, ):
1305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1306 
    if mtype == TMessageType.EXCEPTION:
1307 
      x = TApplicationException()
1308 
      x.read(self._iprot)
1309 
      self._iprot.readMessageEnd()
1310 
      raise x
1311 
    result = getOrdersInBatch_result()
1312 
    result.read(self._iprot)
1313 
    self._iprot.readMessageEnd()
1314 
    if result.success is not None:
1315 
      return result.success
1316 
    if result.ex is not None:
1317 
      raise result.ex
1318 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1319 
 
1320 
  def getOrderCount(self, statuses, warehouseId):
1321 
    """
1322 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1323 
 
1324 
    Parameters:
1325 
     - statuses
1326 
     - warehouseId
1327 
    """
1328 
    self.send_getOrderCount(statuses, warehouseId)
1329 
    return self.recv_getOrderCount()
1330 
 
1331 
  def send_getOrderCount(self, statuses, warehouseId):
1332 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1333 
    args = getOrderCount_args()
1334 
    args.statuses = statuses
1335 
    args.warehouseId = warehouseId
1336 
    args.write(self._oprot)
1337 
    self._oprot.writeMessageEnd()
1338 
    self._oprot.trans.flush()
1339 
 
1340 
  def recv_getOrderCount(self, ):
1341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1342 
    if mtype == TMessageType.EXCEPTION:
1343 
      x = TApplicationException()
1344 
      x.read(self._iprot)
1345 
      self._iprot.readMessageEnd()
1346 
      raise x
1347 
    result = getOrderCount_result()
1348 
    result.read(self._iprot)
1349 
    self._iprot.readMessageEnd()
1350 
    if result.success is not None:
1351 
      return result.success
1352 
    if result.ex is not None:
1353 
      raise result.ex
1354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1355 
 
999 varun.gupt 1356 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1357 
    """
1132 chandransh 1358 
    Returns orders within a range of their billing dates
3431 rajveer 1359 
 
999 varun.gupt 1360 
    Parameters:
1361 
     - status
1362 
     - start_billing_date
1363 
     - end_billing_date
1364 
     - warehouse_id
1365 
    """
1366 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1367 
    return self.recv_getOrdersByBillingDate()
1368 
 
1369 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1370 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1371 
    args = getOrdersByBillingDate_args()
1372 
    args.status = status
1373 
    args.start_billing_date = start_billing_date
1374 
    args.end_billing_date = end_billing_date
1375 
    args.warehouse_id = warehouse_id
1376 
    args.write(self._oprot)
1377 
    self._oprot.writeMessageEnd()
1378 
    self._oprot.trans.flush()
1379 
 
1380 
  def recv_getOrdersByBillingDate(self, ):
1381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1382 
    if mtype == TMessageType.EXCEPTION:
1383 
      x = TApplicationException()
1384 
      x.read(self._iprot)
1385 
      self._iprot.readMessageEnd()
1386 
      raise x
1387 
    result = getOrdersByBillingDate_result()
1388 
    result.read(self._iprot)
1389 
    self._iprot.readMessageEnd()
3431 rajveer 1390 
    if result.success is not None:
999 varun.gupt 1391 
      return result.success
3431 rajveer 1392 
    if result.ex is not None:
999 varun.gupt 1393 
      raise result.ex
1394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1395 
 
3451 chandransh 1396 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1397 
    """
1398 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1399 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1400 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1401 
 
3427 chandransh 1402 
    Parameters:
1403 
     - fromShippingDate
1404 
     - toShippingDate
1405 
     - providerId
1406 
     - warehouseId
3451 chandransh 1407 
     - cod
3427 chandransh 1408 
    """
3451 chandransh 1409 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1410 
    return self.recv_getOrdersByShippingDate()
1411 
 
3451 chandransh 1412 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1413 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1414 
    args = getOrdersByShippingDate_args()
1415 
    args.fromShippingDate = fromShippingDate
1416 
    args.toShippingDate = toShippingDate
1417 
    args.providerId = providerId
1418 
    args.warehouseId = warehouseId
3451 chandransh 1419 
    args.cod = cod
3427 chandransh 1420 
    args.write(self._oprot)
1421 
    self._oprot.writeMessageEnd()
1422 
    self._oprot.trans.flush()
1423 
 
1424 
  def recv_getOrdersByShippingDate(self, ):
1425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1426 
    if mtype == TMessageType.EXCEPTION:
1427 
      x = TApplicationException()
1428 
      x.read(self._iprot)
1429 
      self._iprot.readMessageEnd()
1430 
      raise x
1431 
    result = getOrdersByShippingDate_result()
1432 
    result.read(self._iprot)
1433 
    self._iprot.readMessageEnd()
3431 rajveer 1434 
    if result.success is not None:
3427 chandransh 1435 
      return result.success
3431 rajveer 1436 
    if result.ex is not None:
3427 chandransh 1437 
      raise result.ex
1438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1439 
 
1382 varun.gupt 1440 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1441 
    """
1442 
    Returns order ids for orders which can be returned
3431 rajveer 1443 
 
1382 varun.gupt 1444 
    Parameters:
1445 
     - customer_id
1446 
     - limit
1447 
    """
1448 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1449 
    return self.recv_getReturnableOrdersForCustomer()
1450 
 
1451 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1452 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1453 
    args = getReturnableOrdersForCustomer_args()
1454 
    args.customer_id = customer_id
1455 
    args.limit = limit
1456 
    args.write(self._oprot)
1457 
    self._oprot.writeMessageEnd()
1458 
    self._oprot.trans.flush()
1459 
 
1460 
  def recv_getReturnableOrdersForCustomer(self, ):
1461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1462 
    if mtype == TMessageType.EXCEPTION:
1463 
      x = TApplicationException()
1464 
      x.read(self._iprot)
1465 
      self._iprot.readMessageEnd()
1466 
      raise x
1467 
    result = getReturnableOrdersForCustomer_result()
1468 
    result.read(self._iprot)
1469 
    self._iprot.readMessageEnd()
3431 rajveer 1470 
    if result.success is not None:
1382 varun.gupt 1471 
      return result.success
3431 rajveer 1472 
    if result.ex is not None:
1382 varun.gupt 1473 
      raise result.ex
1474 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1475 
 
1476 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1477 
    """
1478 
    Returns order ids for orders which can be cancelled
3431 rajveer 1479 
 
1382 varun.gupt 1480 
    Parameters:
1481 
     - customer_id
1482 
     - limit
1483 
    """
1484 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1485 
    return self.recv_getCancellableOrdersForCustomer()
1486 
 
1487 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1488 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1489 
    args = getCancellableOrdersForCustomer_args()
1490 
    args.customer_id = customer_id
1491 
    args.limit = limit
1492 
    args.write(self._oprot)
1493 
    self._oprot.writeMessageEnd()
1494 
    self._oprot.trans.flush()
1495 
 
1496 
  def recv_getCancellableOrdersForCustomer(self, ):
1497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1498 
    if mtype == TMessageType.EXCEPTION:
1499 
      x = TApplicationException()
1500 
      x.read(self._iprot)
1501 
      self._iprot.readMessageEnd()
1502 
      raise x
1503 
    result = getCancellableOrdersForCustomer_result()
1504 
    result.read(self._iprot)
1505 
    self._iprot.readMessageEnd()
3431 rajveer 1506 
    if result.success is not None:
1382 varun.gupt 1507 
      return result.success
3431 rajveer 1508 
    if result.ex is not None:
1382 varun.gupt 1509 
      raise result.ex
1510 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1511 
 
483 rajveer 1512 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1513 
    """
1514 
    Parameters:
483 rajveer 1515 
     - orderId
1516 
     - status
1517 
     - description
94 ashish 1518 
    """
483 rajveer 1519 
    self.send_changeOrderStatus(orderId, status, description)
1520 
    return self.recv_changeOrderStatus()
94 ashish 1521 
 
483 rajveer 1522 
  def send_changeOrderStatus(self, orderId, status, description):
1523 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1524 
    args = changeOrderStatus_args()
1525 
    args.orderId = orderId
1526 
    args.status = status
1527 
    args.description = description
94 ashish 1528 
    args.write(self._oprot)
1529 
    self._oprot.writeMessageEnd()
1530 
    self._oprot.trans.flush()
1531 
 
483 rajveer 1532 
  def recv_changeOrderStatus(self, ):
94 ashish 1533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1534 
    if mtype == TMessageType.EXCEPTION:
1535 
      x = TApplicationException()
1536 
      x.read(self._iprot)
1537 
      self._iprot.readMessageEnd()
1538 
      raise x
483 rajveer 1539 
    result = changeOrderStatus_result()
94 ashish 1540 
    result.read(self._iprot)
1541 
    self._iprot.readMessageEnd()
3431 rajveer 1542 
    if result.success is not None:
94 ashish 1543 
      return result.success
3431 rajveer 1544 
    if result.ex is not None:
94 ashish 1545 
      raise result.ex
483 rajveer 1546 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1547 
 
1528 ankur.sing 1548 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1549 
    """
1528 ankur.sing 1550 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1551 
    only user who owns the transaction can view its order details.
3431 rajveer 1552 
 
94 ashish 1553 
    Parameters:
1554 
     - transactionId
1528 ankur.sing 1555 
     - customerId
94 ashish 1556 
    """
1528 ankur.sing 1557 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1558 
    return self.recv_getOrdersForTransaction()
94 ashish 1559 
 
1528 ankur.sing 1560 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1561 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1562 
    args = getOrdersForTransaction_args()
94 ashish 1563 
    args.transactionId = transactionId
1528 ankur.sing 1564 
    args.customerId = customerId
94 ashish 1565 
    args.write(self._oprot)
1566 
    self._oprot.writeMessageEnd()
1567 
    self._oprot.trans.flush()
1568 
 
483 rajveer 1569 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1571 
    if mtype == TMessageType.EXCEPTION:
1572 
      x = TApplicationException()
1573 
      x.read(self._iprot)
1574 
      self._iprot.readMessageEnd()
1575 
      raise x
483 rajveer 1576 
    result = getOrdersForTransaction_result()
94 ashish 1577 
    result.read(self._iprot)
1578 
    self._iprot.readMessageEnd()
3431 rajveer 1579 
    if result.success is not None:
94 ashish 1580 
      return result.success
3431 rajveer 1581 
    if result.ex is not None:
94 ashish 1582 
      raise result.ex
483 rajveer 1583 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1584 
 
3014 chandransh 1585 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1586 
    """
3014 chandransh 1587 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1588 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1589 
 
94 ashish 1590 
    Parameters:
483 rajveer 1591 
     - customerId
1592 
     - from_date
1593 
     - to_date
3014 chandransh 1594 
     - statuses
94 ashish 1595 
    """
3014 chandransh 1596 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1597 
    return self.recv_getOrdersForCustomer()
94 ashish 1598 
 
3014 chandransh 1599 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1600 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1601 
    args = getOrdersForCustomer_args()
1602 
    args.customerId = customerId
1603 
    args.from_date = from_date
1604 
    args.to_date = to_date
3014 chandransh 1605 
    args.statuses = statuses
94 ashish 1606 
    args.write(self._oprot)
1607 
    self._oprot.writeMessageEnd()
1608 
    self._oprot.trans.flush()
1609 
 
483 rajveer 1610 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1611 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1612 
    if mtype == TMessageType.EXCEPTION:
1613 
      x = TApplicationException()
1614 
      x.read(self._iprot)
1615 
      self._iprot.readMessageEnd()
1616 
      raise x
483 rajveer 1617 
    result = getOrdersForCustomer_result()
94 ashish 1618 
    result.read(self._iprot)
1619 
    self._iprot.readMessageEnd()
3431 rajveer 1620 
    if result.success is not None:
94 ashish 1621 
      return result.success
3431 rajveer 1622 
    if result.ex is not None:
94 ashish 1623 
      raise result.ex
483 rajveer 1624 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1625 
 
483 rajveer 1626 
  def createOrder(self, order):
94 ashish 1627 
    """
1628 
    Parameters:
483 rajveer 1629 
     - order
94 ashish 1630 
    """
483 rajveer 1631 
    self.send_createOrder(order)
1632 
    return self.recv_createOrder()
94 ashish 1633 
 
483 rajveer 1634 
  def send_createOrder(self, order):
1635 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1636 
    args = createOrder_args()
1637 
    args.order = order
94 ashish 1638 
    args.write(self._oprot)
1639 
    self._oprot.writeMessageEnd()
1640 
    self._oprot.trans.flush()
1641 
 
483 rajveer 1642 
  def recv_createOrder(self, ):
94 ashish 1643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1644 
    if mtype == TMessageType.EXCEPTION:
1645 
      x = TApplicationException()
1646 
      x.read(self._iprot)
1647 
      self._iprot.readMessageEnd()
1648 
      raise x
483 rajveer 1649 
    result = createOrder_result()
94 ashish 1650 
    result.read(self._iprot)
1651 
    self._iprot.readMessageEnd()
3431 rajveer 1652 
    if result.success is not None:
94 ashish 1653 
      return result.success
3431 rajveer 1654 
    if result.ex is not None:
94 ashish 1655 
      raise result.ex
483 rajveer 1656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1657 
 
483 rajveer 1658 
  def getOrder(self, id):
94 ashish 1659 
    """
1660 
    Parameters:
483 rajveer 1661 
     - id
94 ashish 1662 
    """
483 rajveer 1663 
    self.send_getOrder(id)
1664 
    return self.recv_getOrder()
94 ashish 1665 
 
483 rajveer 1666 
  def send_getOrder(self, id):
1667 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1668 
    args = getOrder_args()
1669 
    args.id = id
94 ashish 1670 
    args.write(self._oprot)
1671 
    self._oprot.writeMessageEnd()
1672 
    self._oprot.trans.flush()
1673 
 
483 rajveer 1674 
  def recv_getOrder(self, ):
94 ashish 1675 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1676 
    if mtype == TMessageType.EXCEPTION:
1677 
      x = TApplicationException()
1678 
      x.read(self._iprot)
1679 
      self._iprot.readMessageEnd()
1680 
      raise x
483 rajveer 1681 
    result = getOrder_result()
94 ashish 1682 
    result.read(self._iprot)
1683 
    self._iprot.readMessageEnd()
3431 rajveer 1684 
    if result.success is not None:
94 ashish 1685 
      return result.success
3431 rajveer 1686 
    if result.ex is not None:
94 ashish 1687 
      raise result.ex
483 rajveer 1688 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1689 
 
483 rajveer 1690 
  def getLineItemsForOrder(self, orderId):
94 ashish 1691 
    """
1692 
    Parameters:
483 rajveer 1693 
     - orderId
94 ashish 1694 
    """
483 rajveer 1695 
    self.send_getLineItemsForOrder(orderId)
1696 
    return self.recv_getLineItemsForOrder()
94 ashish 1697 
 
483 rajveer 1698 
  def send_getLineItemsForOrder(self, orderId):
1699 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1700 
    args = getLineItemsForOrder_args()
1701 
    args.orderId = orderId
94 ashish 1702 
    args.write(self._oprot)
1703 
    self._oprot.writeMessageEnd()
1704 
    self._oprot.trans.flush()
1705 
 
483 rajveer 1706 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1708 
    if mtype == TMessageType.EXCEPTION:
1709 
      x = TApplicationException()
1710 
      x.read(self._iprot)
1711 
      self._iprot.readMessageEnd()
1712 
      raise x
483 rajveer 1713 
    result = getLineItemsForOrder_result()
94 ashish 1714 
    result.read(self._iprot)
1715 
    self._iprot.readMessageEnd()
3431 rajveer 1716 
    if result.success is not None:
94 ashish 1717 
      return result.success
3431 rajveer 1718 
    if result.ex is not None:
94 ashish 1719 
      raise result.ex
483 rajveer 1720 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1721 
 
1528 ankur.sing 1722 
  def getOrderForCustomer(self, orderId, customerId):
1723 
    """
1724 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1725 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1726 
 
1528 ankur.sing 1727 
    Parameters:
1728 
     - orderId
1729 
     - customerId
1730 
    """
1731 
    self.send_getOrderForCustomer(orderId, customerId)
1732 
    return self.recv_getOrderForCustomer()
1733 
 
1734 
  def send_getOrderForCustomer(self, orderId, customerId):
1735 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1736 
    args = getOrderForCustomer_args()
1737 
    args.orderId = orderId
1738 
    args.customerId = customerId
1739 
    args.write(self._oprot)
1740 
    self._oprot.writeMessageEnd()
1741 
    self._oprot.trans.flush()
1742 
 
1743 
  def recv_getOrderForCustomer(self, ):
1744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1745 
    if mtype == TMessageType.EXCEPTION:
1746 
      x = TApplicationException()
1747 
      x.read(self._iprot)
1748 
      self._iprot.readMessageEnd()
1749 
      raise x
1750 
    result = getOrderForCustomer_result()
1751 
    result.read(self._iprot)
1752 
    self._iprot.readMessageEnd()
3431 rajveer 1753 
    if result.success is not None:
1528 ankur.sing 1754 
      return result.success
3431 rajveer 1755 
    if result.ex is not None:
1528 ankur.sing 1756 
      raise result.ex
1757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1758 
 
4444 rajveer 1759 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1760 
    """
1761 
    Parameters:
4394 rajveer 1762 
     - type
4444 rajveer 1763 
     - warehouseId
4394 rajveer 1764 
     - status
1765 
     - timestamp
3064 chandransh 1766 
    """
4444 rajveer 1767 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1768 
    return self.recv_getAlerts()
1769 
 
4444 rajveer 1770 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1771 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1772 
    args = getAlerts_args()
4394 rajveer 1773 
    args.type = type
4444 rajveer 1774 
    args.warehouseId = warehouseId
4394 rajveer 1775 
    args.status = status
1776 
    args.timestamp = timestamp
3064 chandransh 1777 
    args.write(self._oprot)
1778 
    self._oprot.writeMessageEnd()
1779 
    self._oprot.trans.flush()
1780 
 
1781 
  def recv_getAlerts(self, ):
1782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1783 
    if mtype == TMessageType.EXCEPTION:
1784 
      x = TApplicationException()
1785 
      x.read(self._iprot)
1786 
      self._iprot.readMessageEnd()
1787 
      raise x
1788 
    result = getAlerts_result()
1789 
    result.read(self._iprot)
1790 
    self._iprot.readMessageEnd()
3431 rajveer 1791 
    if result.success is not None:
3064 chandransh 1792 
      return result.success
1793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1794 
 
4444 rajveer 1795 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1796 
    """
1797 
    Parameters:
1798 
     - type
4444 rajveer 1799 
     - warehouseId
4394 rajveer 1800 
     - description
3064 chandransh 1801 
    """
4444 rajveer 1802 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1803 
    self.recv_addAlert()
3064 chandransh 1804 
 
4444 rajveer 1805 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1806 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1807 
    args = addAlert_args()
3064 chandransh 1808 
    args.type = type
4444 rajveer 1809 
    args.warehouseId = warehouseId
4394 rajveer 1810 
    args.description = description
3064 chandransh 1811 
    args.write(self._oprot)
1812 
    self._oprot.writeMessageEnd()
1813 
    self._oprot.trans.flush()
1814 
 
4394 rajveer 1815 
  def recv_addAlert(self, ):
3064 chandransh 1816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1817 
    if mtype == TMessageType.EXCEPTION:
1818 
      x = TApplicationException()
1819 
      x.read(self._iprot)
1820 
      self._iprot.readMessageEnd()
1821 
      raise x
4394 rajveer 1822 
    result = addAlert_result()
3064 chandransh 1823 
    result.read(self._iprot)
1824 
    self._iprot.readMessageEnd()
1825 
    return
1826 
 
4444 rajveer 1827 
  def markAlertsAsSeen(self, warehouseId):
1828 
    """
1829 
    Parameters:
1830 
     - warehouseId
1831 
    """
1832 
    self.send_markAlertsAsSeen(warehouseId)
1833 
    self.recv_markAlertsAsSeen()
1834 
 
1835 
  def send_markAlertsAsSeen(self, warehouseId):
1836 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1837 
    args = markAlertsAsSeen_args()
1838 
    args.warehouseId = warehouseId
1839 
    args.write(self._oprot)
1840 
    self._oprot.writeMessageEnd()
1841 
    self._oprot.trans.flush()
1842 
 
1843 
  def recv_markAlertsAsSeen(self, ):
1844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1845 
    if mtype == TMessageType.EXCEPTION:
1846 
      x = TApplicationException()
1847 
      x.read(self._iprot)
1848 
      self._iprot.readMessageEnd()
1849 
      raise x
1850 
    result = markAlertsAsSeen_result()
1851 
    result.read(self._iprot)
1852 
    self._iprot.readMessageEnd()
1853 
    return
1854 
 
3064 chandransh 1855 
  def getValidOrderCount(self, ):
1856 
    """
1857 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1858 
    """
1859 
    self.send_getValidOrderCount()
1860 
    return self.recv_getValidOrderCount()
1861 
 
1862 
  def send_getValidOrderCount(self, ):
1863 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1864 
    args = getValidOrderCount_args()
1865 
    args.write(self._oprot)
1866 
    self._oprot.writeMessageEnd()
1867 
    self._oprot.trans.flush()
1868 
 
1869 
  def recv_getValidOrderCount(self, ):
1870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1871 
    if mtype == TMessageType.EXCEPTION:
1872 
      x = TApplicationException()
1873 
      x.read(self._iprot)
1874 
      self._iprot.readMessageEnd()
1875 
      raise x
1876 
    result = getValidOrderCount_result()
1877 
    result.read(self._iprot)
1878 
    self._iprot.readMessageEnd()
3431 rajveer 1879 
    if result.success is not None:
3064 chandransh 1880 
      return result.success
1881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1882 
 
1883 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1884 
    """
1885 
    Returns the number of distinct customers who have done successful transactions
1886 
    """
1887 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1888 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1889 
 
1890 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1891 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1892 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1893 
    args.write(self._oprot)
1894 
    self._oprot.writeMessageEnd()
1895 
    self._oprot.trans.flush()
1896 
 
1897 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1899 
    if mtype == TMessageType.EXCEPTION:
1900 
      x = TApplicationException()
1901 
      x.read(self._iprot)
1902 
      self._iprot.readMessageEnd()
1903 
      raise x
1904 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1905 
    result.read(self._iprot)
1906 
    self._iprot.readMessageEnd()
3431 rajveer 1907 
    if result.success is not None:
3064 chandransh 1908 
      return result.success
1909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1910 
 
1911 
  def getValidOrdersAmountRange(self, ):
1912 
    """
1913 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1914 
    List contains two values, first minimum amount and second maximum amount.
1915 
    """
1916 
    self.send_getValidOrdersAmountRange()
1917 
    return self.recv_getValidOrdersAmountRange()
1918 
 
1919 
  def send_getValidOrdersAmountRange(self, ):
1920 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1921 
    args = getValidOrdersAmountRange_args()
1922 
    args.write(self._oprot)
1923 
    self._oprot.writeMessageEnd()
1924 
    self._oprot.trans.flush()
1925 
 
1926 
  def recv_getValidOrdersAmountRange(self, ):
1927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1928 
    if mtype == TMessageType.EXCEPTION:
1929 
      x = TApplicationException()
1930 
      x.read(self._iprot)
1931 
      self._iprot.readMessageEnd()
1932 
      raise x
1933 
    result = getValidOrdersAmountRange_result()
1934 
    result.read(self._iprot)
1935 
    self._iprot.readMessageEnd()
3431 rajveer 1936 
    if result.success is not None:
3064 chandransh 1937 
      return result.success
1938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1939 
 
1940 
  def getValidOrders(self, limit):
1941 
    """
1942 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1943 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1944 
 
3064 chandransh 1945 
    Parameters:
1946 
     - limit
1947 
    """
1948 
    self.send_getValidOrders(limit)
1949 
    return self.recv_getValidOrders()
1950 
 
1951 
  def send_getValidOrders(self, limit):
1952 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1953 
    args = getValidOrders_args()
1954 
    args.limit = limit
1955 
    args.write(self._oprot)
1956 
    self._oprot.writeMessageEnd()
1957 
    self._oprot.trans.flush()
1958 
 
1959 
  def recv_getValidOrders(self, ):
1960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1961 
    if mtype == TMessageType.EXCEPTION:
1962 
      x = TApplicationException()
1963 
      x.read(self._iprot)
1964 
      self._iprot.readMessageEnd()
1965 
      raise x
1966 
    result = getValidOrders_result()
1967 
    result.read(self._iprot)
1968 
    self._iprot.readMessageEnd()
3431 rajveer 1969 
    if result.success is not None:
3064 chandransh 1970 
      return result.success
1971 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1972 
 
1220 chandransh 1973 
  def batchOrders(self, warehouseId):
1974 
    """
1975 
    Create a batch of all the pending orders for the given warehouse.
1976 
    The returned list is orderd by created_timestamp.
1977 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1978 
 
1220 chandransh 1979 
    Parameters:
1980 
     - warehouseId
1981 
    """
1982 
    self.send_batchOrders(warehouseId)
1983 
    return self.recv_batchOrders()
1984 
 
1985 
  def send_batchOrders(self, warehouseId):
1986 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1987 
    args = batchOrders_args()
1988 
    args.warehouseId = warehouseId
1989 
    args.write(self._oprot)
1990 
    self._oprot.writeMessageEnd()
1991 
    self._oprot.trans.flush()
1992 
 
1993 
  def recv_batchOrders(self, ):
1994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1995 
    if mtype == TMessageType.EXCEPTION:
1996 
      x = TApplicationException()
1997 
      x.read(self._iprot)
1998 
      self._iprot.readMessageEnd()
1999 
      raise x
2000 
    result = batchOrders_result()
2001 
    result.read(self._iprot)
2002 
    self._iprot.readMessageEnd()
3431 rajveer 2003 
    if result.success is not None:
1220 chandransh 2004 
      return result.success
3431 rajveer 2005 
    if result.ex is not None:
1220 chandransh 2006 
      raise result.ex
2007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2008 
 
1208 chandransh 2009 
  def markOrderAsOutOfStock(self, orderId):
2010 
    """
2011 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2012 
 
1208 chandransh 2013 
    Parameters:
2014 
     - orderId
2015 
    """
2016 
    self.send_markOrderAsOutOfStock(orderId)
2017 
    return self.recv_markOrderAsOutOfStock()
2018 
 
2019 
  def send_markOrderAsOutOfStock(self, orderId):
2020 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2021 
    args = markOrderAsOutOfStock_args()
2022 
    args.orderId = orderId
2023 
    args.write(self._oprot)
2024 
    self._oprot.writeMessageEnd()
2025 
    self._oprot.trans.flush()
2026 
 
2027 
  def recv_markOrderAsOutOfStock(self, ):
2028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2029 
    if mtype == TMessageType.EXCEPTION:
2030 
      x = TApplicationException()
2031 
      x.read(self._iprot)
2032 
      self._iprot.readMessageEnd()
2033 
      raise x
2034 
    result = markOrderAsOutOfStock_result()
2035 
    result.read(self._iprot)
2036 
    self._iprot.readMessageEnd()
3431 rajveer 2037 
    if result.success is not None:
1208 chandransh 2038 
      return result.success
3431 rajveer 2039 
    if result.ex is not None:
1208 chandransh 2040 
      raise result.ex
2041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2042 
 
3064 chandransh 2043 
  def verifyOrder(self, orderId):
759 chandransh 2044 
    """
3064 chandransh 2045 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2046 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2047 
    used for all other orders as well.
2048 
    Throws an exception if no such order exists.
3431 rajveer 2049 
 
759 chandransh 2050 
    Parameters:
3064 chandransh 2051 
     - orderId
759 chandransh 2052 
    """
3064 chandransh 2053 
    self.send_verifyOrder(orderId)
2054 
    return self.recv_verifyOrder()
759 chandransh 2055 
 
3064 chandransh 2056 
  def send_verifyOrder(self, orderId):
2057 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2058 
    args = verifyOrder_args()
2059 
    args.orderId = orderId
759 chandransh 2060 
    args.write(self._oprot)
2061 
    self._oprot.writeMessageEnd()
2062 
    self._oprot.trans.flush()
2063 
 
3064 chandransh 2064 
  def recv_verifyOrder(self, ):
759 chandransh 2065 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2066 
    if mtype == TMessageType.EXCEPTION:
2067 
      x = TApplicationException()
2068 
      x.read(self._iprot)
2069 
      self._iprot.readMessageEnd()
2070 
      raise x
3064 chandransh 2071 
    result = verifyOrder_result()
759 chandransh 2072 
    result.read(self._iprot)
2073 
    self._iprot.readMessageEnd()
3431 rajveer 2074 
    if result.success is not None:
759 chandransh 2075 
      return result.success
3431 rajveer 2076 
    if result.ex is not None:
759 chandransh 2077 
      raise result.ex
3064 chandransh 2078 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2079 
 
3064 chandransh 2080 
  def acceptOrder(self, orderId):
1113 chandransh 2081 
    """
3064 chandransh 2082 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2083 
    given order is not a COD order, it also captures the payment if the same has
2084 
    not been captured.
2085 
    Throws an exception if no such order exists.
3431 rajveer 2086 
 
1113 chandransh 2087 
    Parameters:
3064 chandransh 2088 
     - orderId
1113 chandransh 2089 
    """
3064 chandransh 2090 
    self.send_acceptOrder(orderId)
2091 
    return self.recv_acceptOrder()
1113 chandransh 2092 
 
3064 chandransh 2093 
  def send_acceptOrder(self, orderId):
2094 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2095 
    args = acceptOrder_args()
2096 
    args.orderId = orderId
1113 chandransh 2097 
    args.write(self._oprot)
2098 
    self._oprot.writeMessageEnd()
2099 
    self._oprot.trans.flush()
2100 
 
3064 chandransh 2101 
  def recv_acceptOrder(self, ):
1113 chandransh 2102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2103 
    if mtype == TMessageType.EXCEPTION:
2104 
      x = TApplicationException()
2105 
      x.read(self._iprot)
2106 
      self._iprot.readMessageEnd()
2107 
      raise x
3064 chandransh 2108 
    result = acceptOrder_result()
1113 chandransh 2109 
    result.read(self._iprot)
2110 
    self._iprot.readMessageEnd()
3431 rajveer 2111 
    if result.success is not None:
1113 chandransh 2112 
      return result.success
3431 rajveer 2113 
    if result.ex is not None:
1113 chandransh 2114 
      raise result.ex
3064 chandransh 2115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2116 
 
4658 mandeep.dh 2117 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 2118 
    """
3064 chandransh 2119 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2120 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2121 
    the IMEI no. if a -1 is supplied.
2122 
    Also, it generates an invoice number for the order, marks the order as
2123 
    BILLED and sets the billing timestamp.
2124 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2125 
 
1135 chandransh 2126 
    Parameters:
3064 chandransh 2127 
     - orderId
2128 
     - invoice_number
4658 mandeep.dh 2129 
     - serialNumber
4283 anupam.sin 2130 
     - itemNumber
3064 chandransh 2131 
     - billed_by
4264 rajveer 2132 
     - jacketNumber
4283 anupam.sin 2133 
     - billingType
2134 
     - vendorId
1135 chandransh 2135 
    """
4658 mandeep.dh 2136 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 2137 
    return self.recv_addBillingDetails()
1135 chandransh 2138 
 
4658 mandeep.dh 2139 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 2140 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2141 
    args = addBillingDetails_args()
2142 
    args.orderId = orderId
2143 
    args.invoice_number = invoice_number
4658 mandeep.dh 2144 
    args.serialNumber = serialNumber
4283 anupam.sin 2145 
    args.itemNumber = itemNumber
3064 chandransh 2146 
    args.billed_by = billed_by
4264 rajveer 2147 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2148 
    args.billingType = billingType
2149 
    args.vendorId = vendorId
1135 chandransh 2150 
    args.write(self._oprot)
2151 
    self._oprot.writeMessageEnd()
2152 
    self._oprot.trans.flush()
2153 
 
3064 chandransh 2154 
  def recv_addBillingDetails(self, ):
1135 chandransh 2155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2156 
    if mtype == TMessageType.EXCEPTION:
2157 
      x = TApplicationException()
2158 
      x.read(self._iprot)
2159 
      self._iprot.readMessageEnd()
2160 
      raise x
3064 chandransh 2161 
    result = addBillingDetails_result()
1135 chandransh 2162 
    result.read(self._iprot)
2163 
    self._iprot.readMessageEnd()
3431 rajveer 2164 
    if result.success is not None:
3064 chandransh 2165 
      return result.success
3431 rajveer 2166 
    if result.ex is not None:
1135 chandransh 2167 
      raise result.ex
3064 chandransh 2168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2169 
 
4579 rajveer 2170 
  def addInvoiceNumber(self, orderId, invoiceNumber):
2171 
    """
2172 
    Add the invoice number to the order.
2173 
 
2174 
    Parameters:
2175 
     - orderId
2176 
     - invoiceNumber
2177 
    """
2178 
    self.send_addInvoiceNumber(orderId, invoiceNumber)
2179 
    self.recv_addInvoiceNumber()
2180 
 
2181 
  def send_addInvoiceNumber(self, orderId, invoiceNumber):
2182 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2183 
    args = addInvoiceNumber_args()
2184 
    args.orderId = orderId
2185 
    args.invoiceNumber = invoiceNumber
2186 
    args.write(self._oprot)
2187 
    self._oprot.writeMessageEnd()
2188 
    self._oprot.trans.flush()
2189 
 
2190 
  def recv_addInvoiceNumber(self, ):
2191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2192 
    if mtype == TMessageType.EXCEPTION:
2193 
      x = TApplicationException()
2194 
      x.read(self._iprot)
2195 
      self._iprot.readMessageEnd()
2196 
      raise x
2197 
    result = addInvoiceNumber_result()
2198 
    result.read(self._iprot)
2199 
    self._iprot.readMessageEnd()
2200 
    if result.ex is not None:
2201 
      raise result.ex
2202 
    return
2203 
 
3064 chandransh 2204 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2205 
    """
3064 chandransh 2206 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2207 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2208 
 
1408 ankur.sing 2209 
    Parameters:
3064 chandransh 2210 
     - warehouseId
1408 ankur.sing 2211 
     - providerId
3064 chandransh 2212 
     - cod
1408 ankur.sing 2213 
    """
3064 chandransh 2214 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2215 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2216 
 
3064 chandransh 2217 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2218 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2219 
    args = markOrdersAsManifested_args()
2220 
    args.warehouseId = warehouseId
1408 ankur.sing 2221 
    args.providerId = providerId
3064 chandransh 2222 
    args.cod = cod
1408 ankur.sing 2223 
    args.write(self._oprot)
2224 
    self._oprot.writeMessageEnd()
2225 
    self._oprot.trans.flush()
2226 
 
3064 chandransh 2227 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2229 
    if mtype == TMessageType.EXCEPTION:
2230 
      x = TApplicationException()
2231 
      x.read(self._iprot)
2232 
      self._iprot.readMessageEnd()
2233 
      raise x
3064 chandransh 2234 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2235 
    result.read(self._iprot)
2236 
    self._iprot.readMessageEnd()
3431 rajveer 2237 
    if result.success is not None:
1408 ankur.sing 2238 
      return result.success
3431 rajveer 2239 
    if result.ex is not None:
3064 chandransh 2240 
      raise result.ex
2241 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2242 
 
4410 rajveer 2243 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2244 
    """
2245 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2246 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2247 
 
2248 
    Parameters:
2249 
     - warehouseId
2250 
     - providerId
2251 
     - cod
2252 
    """
2253 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2254 
    return self.recv_markOrdersAsShippedFromWarehouse()
2255 
 
2256 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2257 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2258 
    args = markOrdersAsShippedFromWarehouse_args()
2259 
    args.warehouseId = warehouseId
2260 
    args.providerId = providerId
2261 
    args.cod = cod
2262 
    args.write(self._oprot)
2263 
    self._oprot.writeMessageEnd()
2264 
    self._oprot.trans.flush()
2265 
 
2266 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2267 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2268 
    if mtype == TMessageType.EXCEPTION:
2269 
      x = TApplicationException()
2270 
      x.read(self._iprot)
2271 
      self._iprot.readMessageEnd()
2272 
      raise x
2273 
    result = markOrdersAsShippedFromWarehouse_result()
2274 
    result.read(self._iprot)
2275 
    self._iprot.readMessageEnd()
2276 
    if result.success is not None:
2277 
      return result.success
2278 
    if result.ex is not None:
2279 
      raise result.ex
2280 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2281 
 
3064 chandransh 2282 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2283 
    """
3064 chandransh 2284 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2285 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2286 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2287 
 
94 ashish 2288 
    Parameters:
3064 chandransh 2289 
     - providerId
2290 
     - pickupDetails
304 ashish 2291 
    """
3064 chandransh 2292 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2293 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2294 
 
3064 chandransh 2295 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2296 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2297 
    args = markOrdersAsPickedUp_args()
2298 
    args.providerId = providerId
2299 
    args.pickupDetails = pickupDetails
304 ashish 2300 
    args.write(self._oprot)
2301 
    self._oprot.writeMessageEnd()
2302 
    self._oprot.trans.flush()
2303 
 
3064 chandransh 2304 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2306 
    if mtype == TMessageType.EXCEPTION:
2307 
      x = TApplicationException()
2308 
      x.read(self._iprot)
2309 
      self._iprot.readMessageEnd()
2310 
      raise x
3064 chandransh 2311 
    result = markOrdersAsPickedUp_result()
304 ashish 2312 
    result.read(self._iprot)
2313 
    self._iprot.readMessageEnd()
3431 rajveer 2314 
    if result.success is not None:
304 ashish 2315 
      return result.success
3431 rajveer 2316 
    if result.ex is not None:
3064 chandransh 2317 
      raise result.ex
2318 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2319 
 
3064 chandransh 2320 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2321 
    """
3064 chandransh 2322 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2323 
    the name of the receiver.
2324 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2325 
 
304 ashish 2326 
    Parameters:
3064 chandransh 2327 
     - providerId
2328 
     - deliveredOrders
304 ashish 2329 
    """
3064 chandransh 2330 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2331 
    self.recv_markOrdersAsDelivered()
304 ashish 2332 
 
3064 chandransh 2333 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2334 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2335 
    args = markOrdersAsDelivered_args()
2336 
    args.providerId = providerId
2337 
    args.deliveredOrders = deliveredOrders
304 ashish 2338 
    args.write(self._oprot)
2339 
    self._oprot.writeMessageEnd()
2340 
    self._oprot.trans.flush()
2341 
 
3064 chandransh 2342 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2344 
    if mtype == TMessageType.EXCEPTION:
2345 
      x = TApplicationException()
2346 
      x.read(self._iprot)
2347 
      self._iprot.readMessageEnd()
2348 
      raise x
3064 chandransh 2349 
    result = markOrdersAsDelivered_result()
304 ashish 2350 
    result.read(self._iprot)
2351 
    self._iprot.readMessageEnd()
3431 rajveer 2352 
    if result.ex is not None:
3064 chandransh 2353 
      raise result.ex
304 ashish 2354 
    return
2355 
 
3064 chandransh 2356 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2357 
    """
3064 chandransh 2358 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2359 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2360 
 
3064 chandransh 2361 
    Parameters:
2362 
     - providerId
2363 
     - returnedOrders
1596 ankur.sing 2364 
    """
3064 chandransh 2365 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2366 
    self.recv_markOrdersAsFailed()
304 ashish 2367 
 
3064 chandransh 2368 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2369 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2370 
    args = markOrdersAsFailed_args()
2371 
    args.providerId = providerId
2372 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2373 
    args.write(self._oprot)
2374 
    self._oprot.writeMessageEnd()
2375 
    self._oprot.trans.flush()
2376 
 
3064 chandransh 2377 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2379 
    if mtype == TMessageType.EXCEPTION:
2380 
      x = TApplicationException()
2381 
      x.read(self._iprot)
2382 
      self._iprot.readMessageEnd()
2383 
      raise x
3064 chandransh 2384 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2385 
    result.read(self._iprot)
2386 
    self._iprot.readMessageEnd()
3431 rajveer 2387 
    if result.ex is not None:
3064 chandransh 2388 
      raise result.ex
2389 
    return
1596 ankur.sing 2390 
 
3064 chandransh 2391 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2392 
    """
3064 chandransh 2393 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2394 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2395 
 
3064 chandransh 2396 
    Parameters:
2397 
     - providerId
2398 
     - undeliveredOrders
1627 ankur.sing 2399 
    """
3064 chandransh 2400 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2401 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2402 
 
3064 chandransh 2403 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2404 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2405 
    args = updateNonDeliveryReason_args()
2406 
    args.providerId = providerId
2407 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2408 
    args.write(self._oprot)
2409 
    self._oprot.writeMessageEnd()
2410 
    self._oprot.trans.flush()
2411 
 
3064 chandransh 2412 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2413 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2414 
    if mtype == TMessageType.EXCEPTION:
2415 
      x = TApplicationException()
2416 
      x.read(self._iprot)
2417 
      self._iprot.readMessageEnd()
2418 
      raise x
3064 chandransh 2419 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2420 
    result.read(self._iprot)
2421 
    self._iprot.readMessageEnd()
4581 phani.kuma 2422 
    if result.success is not None:
2423 
      return result.success
3431 rajveer 2424 
    if result.ex is not None:
3064 chandransh 2425 
      raise result.ex
4581 phani.kuma 2426 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2427 
 
3064 chandransh 2428 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2429 
    """
3064 chandransh 2430 
    Returns the list of orders whose delivery time has passed but have not been
2431 
    delivered yet for the given provider and warehouse. To get a complete list of
2432 
    undelivered orders, pass them as -1.
2433 
    Returns an empty list if no such orders exist.
3431 rajveer 2434 
 
1886 ankur.sing 2435 
    Parameters:
3064 chandransh 2436 
     - providerId
2437 
     - warehouseId
1886 ankur.sing 2438 
    """
3064 chandransh 2439 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2440 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2441 
 
3064 chandransh 2442 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2443 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2444 
    args = getUndeliveredOrders_args()
2445 
    args.providerId = providerId
2446 
    args.warehouseId = warehouseId
1886 ankur.sing 2447 
    args.write(self._oprot)
2448 
    self._oprot.writeMessageEnd()
2449 
    self._oprot.trans.flush()
2450 
 
3064 chandransh 2451 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2452 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2453 
    if mtype == TMessageType.EXCEPTION:
2454 
      x = TApplicationException()
2455 
      x.read(self._iprot)
2456 
      self._iprot.readMessageEnd()
2457 
      raise x
3064 chandransh 2458 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2459 
    result.read(self._iprot)
2460 
    self._iprot.readMessageEnd()
3431 rajveer 2461 
    if result.success is not None:
1886 ankur.sing 2462 
      return result.success
3064 chandransh 2463 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2464 
 
2536 chandransh 2465 
  def toggleDOAFlag(self, orderId):
2466 
    """
2467 
    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.
2468 
    Returns the final flag status.
2469 
    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 2470 
 
2536 chandransh 2471 
    Parameters:
2472 
     - orderId
2473 
    """
2474 
    self.send_toggleDOAFlag(orderId)
2475 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2476 
 
2536 chandransh 2477 
  def send_toggleDOAFlag(self, orderId):
2478 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2479 
    args = toggleDOAFlag_args()
2480 
    args.orderId = orderId
2481 
    args.write(self._oprot)
2482 
    self._oprot.writeMessageEnd()
2483 
    self._oprot.trans.flush()
2484 
 
2485 
  def recv_toggleDOAFlag(self, ):
2486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2487 
    if mtype == TMessageType.EXCEPTION:
2488 
      x = TApplicationException()
2489 
      x.read(self._iprot)
2490 
      self._iprot.readMessageEnd()
2491 
      raise x
2492 
    result = toggleDOAFlag_result()
2493 
    result.read(self._iprot)
2494 
    self._iprot.readMessageEnd()
3431 rajveer 2495 
    if result.success is not None:
2536 chandransh 2496 
      return result.success
3431 rajveer 2497 
    if result.ex is not None:
2536 chandransh 2498 
      raise result.ex
2499 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2500 
 
4712 rajveer 2501 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2502 
    """
2503 
    Parameters:
2504 
     - orderId
2505 
     - deliveryTimestamp
2506 
     - receiver
2507 
    """
2508 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2509 
    self.recv_markOrderAsDelivered()
2510 
 
2511 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2512 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2513 
    args = markOrderAsDelivered_args()
2514 
    args.orderId = orderId
2515 
    args.deliveryTimestamp = deliveryTimestamp
2516 
    args.receiver = receiver
2517 
    args.write(self._oprot)
2518 
    self._oprot.writeMessageEnd()
2519 
    self._oprot.trans.flush()
2520 
 
2521 
  def recv_markOrderAsDelivered(self, ):
2522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2523 
    if mtype == TMessageType.EXCEPTION:
2524 
      x = TApplicationException()
2525 
      x.read(self._iprot)
2526 
      self._iprot.readMessageEnd()
2527 
      raise x
2528 
    result = markOrderAsDelivered_result()
2529 
    result.read(self._iprot)
2530 
    self._iprot.readMessageEnd()
2531 
    if result.ex is not None:
2532 
      raise result.ex
2533 
    return
2534 
 
4454 rajveer 2535 
  def markOrderDoaRequestReceived(self, orderId):
2536 
    """
2537 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2538 
 
2539 
    Parameters:
2540 
     - orderId
2541 
    """
2542 
    self.send_markOrderDoaRequestReceived(orderId)
2543 
    return self.recv_markOrderDoaRequestReceived()
2544 
 
2545 
  def send_markOrderDoaRequestReceived(self, orderId):
2546 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2547 
    args = markOrderDoaRequestReceived_args()
2548 
    args.orderId = orderId
2549 
    args.write(self._oprot)
2550 
    self._oprot.writeMessageEnd()
2551 
    self._oprot.trans.flush()
2552 
 
2553 
  def recv_markOrderDoaRequestReceived(self, ):
2554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2555 
    if mtype == TMessageType.EXCEPTION:
2556 
      x = TApplicationException()
2557 
      x.read(self._iprot)
2558 
      self._iprot.readMessageEnd()
2559 
      raise x
2560 
    result = markOrderDoaRequestReceived_result()
2561 
    result.read(self._iprot)
2562 
    self._iprot.readMessageEnd()
2563 
    if result.success is not None:
2564 
      return result.success
2565 
    if result.ex is not None:
2566 
      raise result.ex
2567 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2568 
 
2569 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2570 
    """
2571 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2572 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2573 
 
2574 
    Parameters:
2575 
     - orderId
2576 
     - isAuthorized
2577 
    """
2578 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2579 
    return self.recv_markOrderDoaRequestAuthorized()
2580 
 
2581 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2582 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2583 
    args = markOrderDoaRequestAuthorized_args()
2584 
    args.orderId = orderId
2585 
    args.isAuthorized = isAuthorized
2586 
    args.write(self._oprot)
2587 
    self._oprot.writeMessageEnd()
2588 
    self._oprot.trans.flush()
2589 
 
2590 
  def recv_markOrderDoaRequestAuthorized(self, ):
2591 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2592 
    if mtype == TMessageType.EXCEPTION:
2593 
      x = TApplicationException()
2594 
      x.read(self._iprot)
2595 
      self._iprot.readMessageEnd()
2596 
      raise x
2597 
    result = markOrderDoaRequestAuthorized_result()
2598 
    result.read(self._iprot)
2599 
    self._iprot.readMessageEnd()
2600 
    if result.success is not None:
2601 
      return result.success
2602 
    if result.ex is not None:
2603 
      raise result.ex
2604 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2605 
 
4488 rajveer 2606 
  def markOrderReturnRequestReceived(self, orderId):
2607 
    """
2608 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2609 
 
2610 
    Parameters:
2611 
     - orderId
2612 
    """
2613 
    self.send_markOrderReturnRequestReceived(orderId)
2614 
    return self.recv_markOrderReturnRequestReceived()
2615 
 
2616 
  def send_markOrderReturnRequestReceived(self, orderId):
2617 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2618 
    args = markOrderReturnRequestReceived_args()
2619 
    args.orderId = orderId
2620 
    args.write(self._oprot)
2621 
    self._oprot.writeMessageEnd()
2622 
    self._oprot.trans.flush()
2623 
 
2624 
  def recv_markOrderReturnRequestReceived(self, ):
2625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2626 
    if mtype == TMessageType.EXCEPTION:
2627 
      x = TApplicationException()
2628 
      x.read(self._iprot)
2629 
      self._iprot.readMessageEnd()
2630 
      raise x
2631 
    result = markOrderReturnRequestReceived_result()
2632 
    result.read(self._iprot)
2633 
    self._iprot.readMessageEnd()
2634 
    if result.success is not None:
2635 
      return result.success
2636 
    if result.ex is not None:
2637 
      raise result.ex
2638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2639 
 
2640 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2641 
    """
2642 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2643 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2644 
 
2645 
    Parameters:
2646 
     - orderId
2647 
     - isAuthorized
2648 
    """
2649 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2650 
    return self.recv_markOrderReturnRequestAuthorized()
2651 
 
2652 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2653 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2654 
    args = markOrderReturnRequestAuthorized_args()
2655 
    args.orderId = orderId
2656 
    args.isAuthorized = isAuthorized
2657 
    args.write(self._oprot)
2658 
    self._oprot.writeMessageEnd()
2659 
    self._oprot.trans.flush()
2660 
 
2661 
  def recv_markOrderReturnRequestAuthorized(self, ):
2662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2663 
    if mtype == TMessageType.EXCEPTION:
2664 
      x = TApplicationException()
2665 
      x.read(self._iprot)
2666 
      self._iprot.readMessageEnd()
2667 
      raise x
2668 
    result = markOrderReturnRequestAuthorized_result()
2669 
    result.read(self._iprot)
2670 
    self._iprot.readMessageEnd()
2671 
    if result.success is not None:
2672 
      return result.success
2673 
    if result.ex is not None:
2674 
      raise result.ex
2675 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2676 
 
4579 rajveer 2677 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2678 
    """
2679 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2680 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2681 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2682 
    For any other status, it returns false.
2683 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2684 
 
2536 chandransh 2685 
    Parameters:
2686 
     - orderId
4579 rajveer 2687 
     - providerId
2536 chandransh 2688 
    """
4579 rajveer 2689 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2690 
    return self.recv_requestPickupNumber()
2691 
 
4579 rajveer 2692 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2693 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2694 
    args = requestPickupNumber_args()
2695 
    args.orderId = orderId
4579 rajveer 2696 
    args.providerId = providerId
2536 chandransh 2697 
    args.write(self._oprot)
2698 
    self._oprot.writeMessageEnd()
2699 
    self._oprot.trans.flush()
2700 
 
2701 
  def recv_requestPickupNumber(self, ):
2702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2703 
    if mtype == TMessageType.EXCEPTION:
2704 
      x = TApplicationException()
2705 
      x.read(self._iprot)
2706 
      self._iprot.readMessageEnd()
2707 
      raise x
2708 
    result = requestPickupNumber_result()
2709 
    result.read(self._iprot)
2710 
    self._iprot.readMessageEnd()
3431 rajveer 2711 
    if result.success is not None:
2536 chandransh 2712 
      return result.success
3431 rajveer 2713 
    if result.ex is not None:
2536 chandransh 2714 
      raise result.ex
2715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2716 
 
4602 rajveer 2717 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2718 
    """
4452 rajveer 2719 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2720 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2721 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2722 
    	3. Returns true
2591 chandransh 2723 
    If the order is in any other status, it returns false.
2536 chandransh 2724 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2725 
 
2536 chandransh 2726 
    Parameters:
2727 
     - orderId
2728 
     - pickupNumber
4602 rajveer 2729 
     - providerId
2536 chandransh 2730 
    """
4602 rajveer 2731 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 2732 
    return self.recv_authorizePickup()
2733 
 
4602 rajveer 2734 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2735 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2736 
    args = authorizePickup_args()
2737 
    args.orderId = orderId
2738 
    args.pickupNumber = pickupNumber
4602 rajveer 2739 
    args.providerId = providerId
2536 chandransh 2740 
    args.write(self._oprot)
2741 
    self._oprot.writeMessageEnd()
2742 
    self._oprot.trans.flush()
2743 
 
2744 
  def recv_authorizePickup(self, ):
2745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2746 
    if mtype == TMessageType.EXCEPTION:
2747 
      x = TApplicationException()
2748 
      x.read(self._iprot)
2749 
      self._iprot.readMessageEnd()
2750 
      raise x
2751 
    result = authorizePickup_result()
2752 
    result.read(self._iprot)
2753 
    self._iprot.readMessageEnd()
3431 rajveer 2754 
    if result.success is not None:
2536 chandransh 2755 
      return result.success
3431 rajveer 2756 
    if result.ex is not None:
2536 chandransh 2757 
      raise result.ex
2758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2759 
 
2764 chandransh 2760 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2761 
    """
2762 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2763 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2764 
 
2764 chandransh 2765 
    Parameters:
2766 
     - providerId
2767 
     - pickupDetails
2768 
    """
2769 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2770 
    return self.recv_markDoasAsPickedUp()
2771 
 
2772 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2773 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2774 
    args = markDoasAsPickedUp_args()
2775 
    args.providerId = providerId
2776 
    args.pickupDetails = pickupDetails
2777 
    args.write(self._oprot)
2778 
    self._oprot.writeMessageEnd()
2779 
    self._oprot.trans.flush()
2780 
 
2781 
  def recv_markDoasAsPickedUp(self, ):
2782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2783 
    if mtype == TMessageType.EXCEPTION:
2784 
      x = TApplicationException()
2785 
      x.read(self._iprot)
2786 
      self._iprot.readMessageEnd()
2787 
      raise x
2788 
    result = markDoasAsPickedUp_result()
2789 
    result.read(self._iprot)
2790 
    self._iprot.readMessageEnd()
3431 rajveer 2791 
    if result.success is not None:
2764 chandransh 2792 
      return result.success
2793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2794 
 
4479 rajveer 2795 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2796 
    """
4452 rajveer 2797 
    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 2798 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2799 
    If the order is in any other state, it returns false.
2800 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2801 
 
2591 chandransh 2802 
    Parameters:
2803 
     - orderId
4479 rajveer 2804 
     - receiveCondition
2591 chandransh 2805 
    """
4479 rajveer 2806 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2807 
    return self.recv_receiveReturn()
2536 chandransh 2808 
 
4479 rajveer 2809 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2810 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2811 
    args = receiveReturn_args()
2591 chandransh 2812 
    args.orderId = orderId
4479 rajveer 2813 
    args.receiveCondition = receiveCondition
2591 chandransh 2814 
    args.write(self._oprot)
2815 
    self._oprot.writeMessageEnd()
2816 
    self._oprot.trans.flush()
2817 
 
2616 chandransh 2818 
  def recv_receiveReturn(self, ):
2591 chandransh 2819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2820 
    if mtype == TMessageType.EXCEPTION:
2821 
      x = TApplicationException()
2822 
      x.read(self._iprot)
2823 
      self._iprot.readMessageEnd()
2824 
      raise x
2616 chandransh 2825 
    result = receiveReturn_result()
2591 chandransh 2826 
    result.read(self._iprot)
2827 
    self._iprot.readMessageEnd()
3431 rajveer 2828 
    if result.success is not None:
2591 chandransh 2829 
      return result.success
3431 rajveer 2830 
    if result.ex is not None:
2591 chandransh 2831 
      raise result.ex
2616 chandransh 2832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2833 
 
2834 
  def validateDoa(self, orderId, isValid):
2835 
    """
4452 rajveer 2836 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2837 
    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 2838 
    If the order is in any other state, it returns false.
2839 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2840 
 
2591 chandransh 2841 
    Parameters:
2842 
     - orderId
2843 
     - isValid
2844 
    """
2845 
    self.send_validateDoa(orderId, isValid)
2846 
    return self.recv_validateDoa()
2847 
 
2848 
  def send_validateDoa(self, orderId, isValid):
2849 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2850 
    args = validateDoa_args()
2851 
    args.orderId = orderId
2852 
    args.isValid = isValid
2853 
    args.write(self._oprot)
2854 
    self._oprot.writeMessageEnd()
2855 
    self._oprot.trans.flush()
2856 
 
2857 
  def recv_validateDoa(self, ):
2858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2859 
    if mtype == TMessageType.EXCEPTION:
2860 
      x = TApplicationException()
2861 
      x.read(self._iprot)
2862 
      self._iprot.readMessageEnd()
2863 
      raise x
2864 
    result = validateDoa_result()
2865 
    result.read(self._iprot)
2866 
    self._iprot.readMessageEnd()
3431 rajveer 2867 
    if result.success is not None:
2591 chandransh 2868 
      return result.success
3431 rajveer 2869 
    if result.ex is not None:
2591 chandransh 2870 
      raise result.ex
2871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2872 
 
4495 rajveer 2873 
  def validateReturnProduct(self, orderId, isUsable):
2874 
    """
2875 
    Parameters:
2876 
     - orderId
2877 
     - isUsable
2878 
    """
2879 
    self.send_validateReturnProduct(orderId, isUsable)
2880 
    return self.recv_validateReturnProduct()
2881 
 
2882 
  def send_validateReturnProduct(self, orderId, isUsable):
2883 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2884 
    args = validateReturnProduct_args()
2885 
    args.orderId = orderId
2886 
    args.isUsable = isUsable
2887 
    args.write(self._oprot)
2888 
    self._oprot.writeMessageEnd()
2889 
    self._oprot.trans.flush()
2890 
 
2891 
  def recv_validateReturnProduct(self, ):
2892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2893 
    if mtype == TMessageType.EXCEPTION:
2894 
      x = TApplicationException()
2895 
      x.read(self._iprot)
2896 
      self._iprot.readMessageEnd()
2897 
      raise x
2898 
    result = validateReturnProduct_result()
2899 
    result.read(self._iprot)
2900 
    self._iprot.readMessageEnd()
2901 
    if result.success is not None:
2902 
      return result.success
2903 
    if result.ex is not None:
2904 
      raise result.ex
2905 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
2906 
 
2616 chandransh 2907 
  def reshipOrder(self, orderId):
2908 
    """
4484 rajveer 2909 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2910 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2911 
    	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 2912 
 
2913 
    If the order is in DOA_CERT_VALID state, it does the following:
2914 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2915 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2916 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2917 
 
2616 chandransh 2918 
    Returns the id of the newly created order.
3431 rajveer 2919 
 
2616 chandransh 2920 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2921 
 
2616 chandransh 2922 
    Parameters:
2923 
     - orderId
2924 
    """
2925 
    self.send_reshipOrder(orderId)
2926 
    return self.recv_reshipOrder()
2591 chandransh 2927 
 
2616 chandransh 2928 
  def send_reshipOrder(self, orderId):
2929 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2930 
    args = reshipOrder_args()
2931 
    args.orderId = orderId
2932 
    args.write(self._oprot)
2933 
    self._oprot.writeMessageEnd()
2934 
    self._oprot.trans.flush()
2935 
 
2936 
  def recv_reshipOrder(self, ):
2937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2938 
    if mtype == TMessageType.EXCEPTION:
2939 
      x = TApplicationException()
2940 
      x.read(self._iprot)
2941 
      self._iprot.readMessageEnd()
2942 
      raise x
2943 
    result = reshipOrder_result()
2944 
    result.read(self._iprot)
2945 
    self._iprot.readMessageEnd()
3431 rajveer 2946 
    if result.success is not None:
2616 chandransh 2947 
      return result.success
3431 rajveer 2948 
    if result.ex is not None:
2616 chandransh 2949 
      raise result.ex
2950 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2951 
 
3226 chandransh 2952 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2953 
    """
4484 rajveer 2954 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2955 
    	1. Creates a refund request for batch processing.
2956 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 2957 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2958 
 
2616 chandransh 2959 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2960 
    	1. Creates a refund request for batch processing.
3226 chandransh 2961 
    	2. Cancels the reservation of the item in the warehouse.
2962 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2963 
 
3226 chandransh 2964 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2965 
    	1. Cancels the reservation of the item in the warehouse.
2966 
    	2. Marks the current order as CANCELED.
2967 
 
2968 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2969 
 
2616 chandransh 2970 
    Returns True if it is successful, False otherwise.
3431 rajveer 2971 
 
2616 chandransh 2972 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2973 
 
2616 chandransh 2974 
    Parameters:
2975 
     - orderId
3226 chandransh 2976 
     - refundedBy
2977 
     - reason
2616 chandransh 2978 
    """
3226 chandransh 2979 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2980 
    return self.recv_refundOrder()
2981 
 
3226 chandransh 2982 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2983 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2984 
    args = refundOrder_args()
2985 
    args.orderId = orderId
3226 chandransh 2986 
    args.refundedBy = refundedBy
2987 
    args.reason = reason
2616 chandransh 2988 
    args.write(self._oprot)
2989 
    self._oprot.writeMessageEnd()
2990 
    self._oprot.trans.flush()
2991 
 
2992 
  def recv_refundOrder(self, ):
2993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2994 
    if mtype == TMessageType.EXCEPTION:
2995 
      x = TApplicationException()
2996 
      x.read(self._iprot)
2997 
      self._iprot.readMessageEnd()
2998 
      raise x
2999 
    result = refundOrder_result()
3000 
    result.read(self._iprot)
3001 
    self._iprot.readMessageEnd()
3431 rajveer 3002 
    if result.success is not None:
2616 chandransh 3003 
      return result.success
3431 rajveer 3004 
    if result.ex is not None:
2616 chandransh 3005 
      raise result.ex
3006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3007 
 
2690 chandransh 3008 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3009 
    """
3010 
    Get all return orders created between the from and to dates for the given warehouse.
3011 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3012 
 
2690 chandransh 3013 
    Parameters:
3014 
     - warehouseId
3015 
     - fromDate
3016 
     - toDate
3017 
    """
3018 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3019 
    return self.recv_getReturnOrders()
2616 chandransh 3020 
 
2690 chandransh 3021 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3022 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3023 
    args = getReturnOrders_args()
3024 
    args.warehouseId = warehouseId
3025 
    args.fromDate = fromDate
3026 
    args.toDate = toDate
3027 
    args.write(self._oprot)
3028 
    self._oprot.writeMessageEnd()
3029 
    self._oprot.trans.flush()
3030 
 
3031 
  def recv_getReturnOrders(self, ):
3032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3033 
    if mtype == TMessageType.EXCEPTION:
3034 
      x = TApplicationException()
3035 
      x.read(self._iprot)
3036 
      self._iprot.readMessageEnd()
3037 
      raise x
3038 
    result = getReturnOrders_result()
3039 
    result.read(self._iprot)
3040 
    self._iprot.readMessageEnd()
3431 rajveer 3041 
    if result.success is not None:
2690 chandransh 3042 
      return result.success
3043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3044 
 
2700 chandransh 3045 
  def getReturnOrder(self, id):
3046 
    """
3047 
    Returns the ReturnOrder corresponding to the given id.
3048 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3049 
 
2700 chandransh 3050 
    Parameters:
3051 
     - id
3052 
    """
3053 
    self.send_getReturnOrder(id)
3054 
    return self.recv_getReturnOrder()
3055 
 
3056 
  def send_getReturnOrder(self, id):
3057 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3058 
    args = getReturnOrder_args()
3059 
    args.id = id
3060 
    args.write(self._oprot)
3061 
    self._oprot.writeMessageEnd()
3062 
    self._oprot.trans.flush()
3063 
 
3064 
  def recv_getReturnOrder(self, ):
3065 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3066 
    if mtype == TMessageType.EXCEPTION:
3067 
      x = TApplicationException()
3068 
      x.read(self._iprot)
3069 
      self._iprot.readMessageEnd()
3070 
      raise x
3071 
    result = getReturnOrder_result()
3072 
    result.read(self._iprot)
3073 
    self._iprot.readMessageEnd()
3431 rajveer 3074 
    if result.success is not None:
2700 chandransh 3075 
      return result.success
3431 rajveer 3076 
    if result.ex is not None:
2700 chandransh 3077 
      raise result.ex
3078 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3079 
 
2690 chandransh 3080 
  def processReturn(self, returnOrderId):
3081 
    """
3082 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3083 
 
2690 chandransh 3084 
    Parameters:
3085 
     - returnOrderId
3086 
    """
3087 
    self.send_processReturn(returnOrderId)
3088 
    self.recv_processReturn()
3089 
 
3090 
  def send_processReturn(self, returnOrderId):
3091 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3092 
    args = processReturn_args()
3093 
    args.returnOrderId = returnOrderId
3094 
    args.write(self._oprot)
3095 
    self._oprot.writeMessageEnd()
3096 
    self._oprot.trans.flush()
3097 
 
3098 
  def recv_processReturn(self, ):
3099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3100 
    if mtype == TMessageType.EXCEPTION:
3101 
      x = TApplicationException()
3102 
      x.read(self._iprot)
3103 
      self._iprot.readMessageEnd()
3104 
      raise x
3105 
    result = processReturn_result()
3106 
    result.read(self._iprot)
3107 
    self._iprot.readMessageEnd()
3431 rajveer 3108 
    if result.ex is not None:
2690 chandransh 3109 
      raise result.ex
3110 
    return
3111 
 
2819 chandransh 3112 
  def createPurchaseOrder(self, warehouseId):
3113 
    """
4586 mandeep.dh 3114 
    Creates purchase orders corresponding to all the pending orders of the given warehouse.
3115 
    Returns the list of PO no. of the newly created purchase order.
3116 
    Returns null if no new purchase order had to be created.
3431 rajveer 3117 
 
2819 chandransh 3118 
    Parameters:
3119 
     - warehouseId
3120 
    """
3121 
    self.send_createPurchaseOrder(warehouseId)
3122 
    return self.recv_createPurchaseOrder()
2690 chandransh 3123 
 
2819 chandransh 3124 
  def send_createPurchaseOrder(self, warehouseId):
3125 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
3126 
    args = createPurchaseOrder_args()
3127 
    args.warehouseId = warehouseId
3128 
    args.write(self._oprot)
3129 
    self._oprot.writeMessageEnd()
3130 
    self._oprot.trans.flush()
3131 
 
3132 
  def recv_createPurchaseOrder(self, ):
3133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3134 
    if mtype == TMessageType.EXCEPTION:
3135 
      x = TApplicationException()
3136 
      x.read(self._iprot)
3137 
      self._iprot.readMessageEnd()
3138 
      raise x
3139 
    result = createPurchaseOrder_result()
3140 
    result.read(self._iprot)
3141 
    self._iprot.readMessageEnd()
3431 rajveer 3142 
    if result.success is not None:
2819 chandransh 3143 
      return result.success
3431 rajveer 3144 
    if result.ex is not None:
2819 chandransh 3145 
      raise result.ex
3146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
3147 
 
3451 chandransh 3148 
  def updateWeight(self, orderId, weight):
3149 
    """
3150 
    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 3151 
 
3451 chandransh 3152 
    Parameters:
3153 
     - orderId
3154 
     - weight
3155 
    """
3156 
    self.send_updateWeight(orderId, weight)
3157 
    return self.recv_updateWeight()
3158 
 
3159 
  def send_updateWeight(self, orderId, weight):
3160 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3161 
    args = updateWeight_args()
3162 
    args.orderId = orderId
3163 
    args.weight = weight
3164 
    args.write(self._oprot)
3165 
    self._oprot.writeMessageEnd()
3166 
    self._oprot.trans.flush()
3167 
 
3168 
  def recv_updateWeight(self, ):
3169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3170 
    if mtype == TMessageType.EXCEPTION:
3171 
      x = TApplicationException()
3172 
      x.read(self._iprot)
3173 
      self._iprot.readMessageEnd()
3174 
      raise x
3175 
    result = updateWeight_result()
3176 
    result.read(self._iprot)
3177 
    self._iprot.readMessageEnd()
3178 
    if result.success is not None:
3179 
      return result.success
3180 
    if result.ex is not None:
3181 
      raise result.ex
3182 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3183 
 
3469 chandransh 3184 
  def changeItem(self, orderId, itemId):
3185 
    """
3186 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3187 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3188 
 
3469 chandransh 3189 
    Parameters:
3190 
     - orderId
3191 
     - itemId
3192 
    """
3193 
    self.send_changeItem(orderId, itemId)
3194 
    return self.recv_changeItem()
3195 
 
3196 
  def send_changeItem(self, orderId, itemId):
3197 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3198 
    args = changeItem_args()
3199 
    args.orderId = orderId
3200 
    args.itemId = itemId
3201 
    args.write(self._oprot)
3202 
    self._oprot.writeMessageEnd()
3203 
    self._oprot.trans.flush()
3204 
 
3205 
  def recv_changeItem(self, ):
3206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3207 
    if mtype == TMessageType.EXCEPTION:
3208 
      x = TApplicationException()
3209 
      x.read(self._iprot)
3210 
      self._iprot.readMessageEnd()
3211 
      raise x
3212 
    result = changeItem_result()
3213 
    result.read(self._iprot)
3214 
    self._iprot.readMessageEnd()
3215 
    if result.success is not None:
3216 
      return result.success
3217 
    if result.ex is not None:
3218 
      raise result.ex
3219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3220 
 
3221 
  def shiftToWarehouse(self, orderId, warehouseId):
3222 
    """
3223 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3224 
 
3225 
    Parameters:
3226 
     - orderId
3227 
     - warehouseId
3228 
    """
3229 
    self.send_shiftToWarehouse(orderId, warehouseId)
3230 
    return self.recv_shiftToWarehouse()
3231 
 
3232 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3233 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3234 
    args = shiftToWarehouse_args()
3235 
    args.orderId = orderId
3236 
    args.warehouseId = warehouseId
3237 
    args.write(self._oprot)
3238 
    self._oprot.writeMessageEnd()
3239 
    self._oprot.trans.flush()
3240 
 
3241 
  def recv_shiftToWarehouse(self, ):
3242 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3243 
    if mtype == TMessageType.EXCEPTION:
3244 
      x = TApplicationException()
3245 
      x.read(self._iprot)
3246 
      self._iprot.readMessageEnd()
3247 
      raise x
3248 
    result = shiftToWarehouse_result()
3249 
    result.read(self._iprot)
3250 
    self._iprot.readMessageEnd()
3251 
    if result.success is not None:
3252 
      return result.success
3253 
    if result.ex is not None:
3254 
      raise result.ex
3255 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3256 
 
4647 rajveer 3257 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3258 
    """
3259 
    Adds the given delay reason to the given order.
3986 chandransh 3260 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3261 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3262 
 
3553 chandransh 3263 
    Parameters:
3264 
     - orderId
3265 
     - delayReason
3986 chandransh 3266 
     - furtherDelay
4647 rajveer 3267 
     - delayReasonText
3553 chandransh 3268 
    """
4647 rajveer 3269 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3270 
    return self.recv_addDelayReason()
3271 
 
4647 rajveer 3272 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3273 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3274 
    args = addDelayReason_args()
3275 
    args.orderId = orderId
3276 
    args.delayReason = delayReason
3986 chandransh 3277 
    args.furtherDelay = furtherDelay
4647 rajveer 3278 
    args.delayReasonText = delayReasonText
3553 chandransh 3279 
    args.write(self._oprot)
3280 
    self._oprot.writeMessageEnd()
3281 
    self._oprot.trans.flush()
3282 
 
3283 
  def recv_addDelayReason(self, ):
3284 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3285 
    if mtype == TMessageType.EXCEPTION:
3286 
      x = TApplicationException()
3287 
      x.read(self._iprot)
3288 
      self._iprot.readMessageEnd()
3289 
      raise x
3290 
    result = addDelayReason_result()
3291 
    result.read(self._iprot)
3292 
    self._iprot.readMessageEnd()
3293 
    if result.success is not None:
3294 
      return result.success
3295 
    if result.ex is not None:
3296 
      raise result.ex
3297 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3298 
 
3956 chandransh 3299 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3300 
    """
3301 
    Marks the COD orders with given AWB nos. as having been processed.
3302 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3303 
 
3956 chandransh 3304 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3305 
    1. There is no order corresponding to an AWB number.
3306 
    2. The captured amount for a payment exceeds the total payment.
3307 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3308 
 
3309 
    Parameters:
3310 
     - collectedAmountMap
3311 
     - xferBy
3312 
     - xferTxnId
3313 
     - xferDate
3314 
    """
3315 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3316 
    return self.recv_reconcileCodCollection()
3317 
 
3318 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3319 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3320 
    args = reconcileCodCollection_args()
3321 
    args.collectedAmountMap = collectedAmountMap
3322 
    args.xferBy = xferBy
3323 
    args.xferTxnId = xferTxnId
3324 
    args.xferDate = xferDate
3325 
    args.write(self._oprot)
3326 
    self._oprot.writeMessageEnd()
3327 
    self._oprot.trans.flush()
3328 
 
3329 
  def recv_reconcileCodCollection(self, ):
3330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3331 
    if mtype == TMessageType.EXCEPTION:
3332 
      x = TApplicationException()
3333 
      x.read(self._iprot)
3334 
      self._iprot.readMessageEnd()
3335 
      raise x
3336 
    result = reconcileCodCollection_result()
3337 
    result.read(self._iprot)
3338 
    self._iprot.readMessageEnd()
3339 
    if result.success is not None:
3340 
      return result.success
3341 
    if result.ex is not None:
3342 
      raise result.ex
3343 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3344 
 
4008 mandeep.dh 3345 
  def getTransactionsRequiringExtraProcessing(self, category):
3346 
    """
4065 mandeep.dh 3347 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3348 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3349 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3350 
 
4008 mandeep.dh 3351 
    Parameters:
3352 
     - category
3353 
    """
3354 
    self.send_getTransactionsRequiringExtraProcessing(category)
3355 
    return self.recv_getTransactionsRequiringExtraProcessing()
3356 
 
3357 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3358 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3359 
    args = getTransactionsRequiringExtraProcessing_args()
3360 
    args.category = category
3361 
    args.write(self._oprot)
3362 
    self._oprot.writeMessageEnd()
3363 
    self._oprot.trans.flush()
3364 
 
3365 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3367 
    if mtype == TMessageType.EXCEPTION:
3368 
      x = TApplicationException()
3369 
      x.read(self._iprot)
3370 
      self._iprot.readMessageEnd()
3371 
      raise x
3372 
    result = getTransactionsRequiringExtraProcessing_result()
3373 
    result.read(self._iprot)
3374 
    self._iprot.readMessageEnd()
3375 
    if result.success is not None:
3376 
      return result.success
3377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3378 
 
3379 
  def markTransactionAsProcessed(self, transactionId, category):
3380 
    """
3381 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3382 
    It essentially deletes the transaction id record for a particular
3383 
    processing type category (if present) from DB.
3384 
    This is currently used by CRM application.
4008 mandeep.dh 3385 
 
3386 
    Parameters:
3387 
     - transactionId
3388 
     - category
3389 
    """
3390 
    self.send_markTransactionAsProcessed(transactionId, category)
3391 
    self.recv_markTransactionAsProcessed()
3392 
 
3393 
  def send_markTransactionAsProcessed(self, transactionId, category):
3394 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3395 
    args = markTransactionAsProcessed_args()
3396 
    args.transactionId = transactionId
3397 
    args.category = category
3398 
    args.write(self._oprot)
3399 
    self._oprot.writeMessageEnd()
3400 
    self._oprot.trans.flush()
3401 
 
3402 
  def recv_markTransactionAsProcessed(self, ):
3403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3404 
    if mtype == TMessageType.EXCEPTION:
3405 
      x = TApplicationException()
3406 
      x.read(self._iprot)
3407 
      self._iprot.readMessageEnd()
3408 
      raise x
3409 
    result = markTransactionAsProcessed_result()
3410 
    result.read(self._iprot)
3411 
    self._iprot.readMessageEnd()
3412 
    return
3413 
 
4018 chandransh 3414 
  def getItemWiseRiskyOrdersCount(self, ):
3415 
    """
3416 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3417 
    is defined as one whose shipping date is about to expire.
3418 
    """
3419 
    self.send_getItemWiseRiskyOrdersCount()
3420 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3421 
 
4018 chandransh 3422 
  def send_getItemWiseRiskyOrdersCount(self, ):
3423 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3424 
    args = getItemWiseRiskyOrdersCount_args()
3425 
    args.write(self._oprot)
3426 
    self._oprot.writeMessageEnd()
3427 
    self._oprot.trans.flush()
3428 
 
3429 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3430 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3431 
    if mtype == TMessageType.EXCEPTION:
3432 
      x = TApplicationException()
3433 
      x.read(self._iprot)
3434 
      self._iprot.readMessageEnd()
3435 
      raise x
3436 
    result = getItemWiseRiskyOrdersCount_result()
3437 
    result.read(self._iprot)
3438 
    self._iprot.readMessageEnd()
3439 
    if result.success is not None:
3440 
      return result.success
3441 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3442 
 
4295 varun.gupt 3443 
  def getOrdersForItemIds(self, itemIds):
3444 
    """
3445 
    Returns a list of all orders which have items with given id
3446 
 
3447 
    Parameters:
3448 
     - itemIds
3449 
    """
3450 
    self.send_getOrdersForItemIds(itemIds)
3451 
    return self.recv_getOrdersForItemIds()
3452 
 
3453 
  def send_getOrdersForItemIds(self, itemIds):
3454 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3455 
    args = getOrdersForItemIds_args()
3456 
    args.itemIds = itemIds
3457 
    args.write(self._oprot)
3458 
    self._oprot.writeMessageEnd()
3459 
    self._oprot.trans.flush()
3460 
 
3461 
  def recv_getOrdersForItemIds(self, ):
3462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3463 
    if mtype == TMessageType.EXCEPTION:
3464 
      x = TApplicationException()
3465 
      x.read(self._iprot)
3466 
      self._iprot.readMessageEnd()
3467 
      raise x
3468 
    result = getOrdersForItemIds_result()
3469 
    result.read(self._iprot)
3470 
    self._iprot.readMessageEnd()
3471 
    if result.success is not None:
3472 
      return result.success
3473 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3474 
 
4247 rajveer 3475 
  def markOrderCancellationRequestReceived(self, orderId):
3476 
    """
3477 
    Mark order as cancellation request received. If customer sends request of cancellation of
3478 
    a particular order, this method will be called. It will just change status of the order
3479 
    depending on its current status. It also records the previous status, so that we can move
3480 
    back to that status if cancellation request is denied.
4018 chandransh 3481 
 
4247 rajveer 3482 
    Parameters:
3483 
     - orderId
3484 
    """
3485 
    self.send_markOrderCancellationRequestReceived(orderId)
3486 
    self.recv_markOrderCancellationRequestReceived()
3487 
 
3488 
  def send_markOrderCancellationRequestReceived(self, orderId):
3489 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3490 
    args = markOrderCancellationRequestReceived_args()
3491 
    args.orderId = orderId
3492 
    args.write(self._oprot)
3493 
    self._oprot.writeMessageEnd()
3494 
    self._oprot.trans.flush()
3495 
 
3496 
  def recv_markOrderCancellationRequestReceived(self, ):
3497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3498 
    if mtype == TMessageType.EXCEPTION:
3499 
      x = TApplicationException()
3500 
      x.read(self._iprot)
3501 
      self._iprot.readMessageEnd()
3502 
      raise x
3503 
    result = markOrderCancellationRequestReceived_result()
3504 
    result.read(self._iprot)
3505 
    self._iprot.readMessageEnd()
3506 
    if result.ex is not None:
3507 
      raise result.ex
3508 
    return
3509 
 
3510 
  def markOrderCancellationRequestConfirmed(self, orderId):
3511 
    """
3512 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3513 
    cancellation request confirmed. After this OM will be able to cancel the order.
3514 
 
3515 
    Parameters:
3516 
     - orderId
3517 
    """
3518 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3519 
    self.recv_markOrderCancellationRequestConfirmed()
3520 
 
3521 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3522 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3523 
    args = markOrderCancellationRequestConfirmed_args()
3524 
    args.orderId = orderId
3525 
    args.write(self._oprot)
3526 
    self._oprot.writeMessageEnd()
3527 
    self._oprot.trans.flush()
3528 
 
3529 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3531 
    if mtype == TMessageType.EXCEPTION:
3532 
      x = TApplicationException()
3533 
      x.read(self._iprot)
3534 
      self._iprot.readMessageEnd()
3535 
      raise x
3536 
    result = markOrderCancellationRequestConfirmed_result()
3537 
    result.read(self._iprot)
3538 
    self._iprot.readMessageEnd()
3539 
    if result.ex is not None:
3540 
      raise result.ex
3541 
    return
3542 
 
3543 
  def markOrderCancellationRequestDenied(self, orderId):
3544 
    """
3545 
    If we decide to not to cancel order, we will move the order ro previous status.
3546 
 
3547 
    Parameters:
3548 
     - orderId
3549 
    """
3550 
    self.send_markOrderCancellationRequestDenied(orderId)
3551 
    self.recv_markOrderCancellationRequestDenied()
3552 
 
3553 
  def send_markOrderCancellationRequestDenied(self, orderId):
3554 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3555 
    args = markOrderCancellationRequestDenied_args()
3556 
    args.orderId = orderId
3557 
    args.write(self._oprot)
3558 
    self._oprot.writeMessageEnd()
3559 
    self._oprot.trans.flush()
3560 
 
3561 
  def recv_markOrderCancellationRequestDenied(self, ):
3562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3563 
    if mtype == TMessageType.EXCEPTION:
3564 
      x = TApplicationException()
3565 
      x.read(self._iprot)
3566 
      self._iprot.readMessageEnd()
3567 
      raise x
3568 
    result = markOrderCancellationRequestDenied_result()
3569 
    result.read(self._iprot)
3570 
    self._iprot.readMessageEnd()
3571 
    if result.ex is not None:
3572 
      raise result.ex
3573 
    return
3574 
 
4258 rajveer 3575 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3576 
    """
4258 rajveer 3577 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3578 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3579 
 
3580 
    Parameters:
4258 rajveer 3581 
     - transactionId
4247 rajveer 3582 
    """
4258 rajveer 3583 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3584 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3585 
 
4258 rajveer 3586 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3587 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3588 
    args = markTransactionAsPaymentFlagRemoved_args()
3589 
    args.transactionId = transactionId
4247 rajveer 3590 
    args.write(self._oprot)
3591 
    self._oprot.writeMessageEnd()
3592 
    self._oprot.trans.flush()
3593 
 
4258 rajveer 3594 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3596 
    if mtype == TMessageType.EXCEPTION:
3597 
      x = TApplicationException()
3598 
      x.read(self._iprot)
3599 
      self._iprot.readMessageEnd()
3600 
      raise x
4258 rajveer 3601 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3602 
    result.read(self._iprot)
3603 
    self._iprot.readMessageEnd()
3604 
    if result.ex is not None:
3605 
      raise result.ex
3606 
    return
3607 
 
4259 anupam.sin 3608 
  def refundTransaction(self, transactionId, refundedBy, reason):
3609 
    """
3610 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3611 
    need to be cancelled
4247 rajveer 3612 
 
4259 anupam.sin 3613 
    Parameters:
3614 
     - transactionId
3615 
     - refundedBy
3616 
     - reason
3617 
    """
3618 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3619 
    self.recv_refundTransaction()
3620 
 
3621 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3622 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3623 
    args = refundTransaction_args()
3624 
    args.transactionId = transactionId
3625 
    args.refundedBy = refundedBy
3626 
    args.reason = reason
3627 
    args.write(self._oprot)
3628 
    self._oprot.writeMessageEnd()
3629 
    self._oprot.trans.flush()
3630 
 
3631 
  def recv_refundTransaction(self, ):
3632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3633 
    if mtype == TMessageType.EXCEPTION:
3634 
      x = TApplicationException()
3635 
      x.read(self._iprot)
3636 
      self._iprot.readMessageEnd()
3637 
      raise x
3638 
    result = refundTransaction_result()
3639 
    result.read(self._iprot)
3640 
    self._iprot.readMessageEnd()
3641 
    if result.ex is not None:
3642 
      raise result.ex
3643 
    return
3644 
 
4324 mandeep.dh 3645 
  def updateShipmentAddress(self, orderId, addressId):
3646 
    """
3647 
    Updates shipment address of an order. Delivery and shipping date estimates
3648 
    etc. are also updated here.
3649 
 
3650 
    Throws TransactionServiceException in case address change is not
3651 
    possible due to certain reasons such as new pincode in address is
3652 
    not serviceable etc.
3653 
 
3654 
    Parameters:
3655 
     - orderId
3656 
     - addressId
3657 
    """
3658 
    self.send_updateShipmentAddress(orderId, addressId)
3659 
    self.recv_updateShipmentAddress()
3660 
 
3661 
  def send_updateShipmentAddress(self, orderId, addressId):
3662 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3663 
    args = updateShipmentAddress_args()
3664 
    args.orderId = orderId
3665 
    args.addressId = addressId
3666 
    args.write(self._oprot)
3667 
    self._oprot.writeMessageEnd()
3668 
    self._oprot.trans.flush()
3669 
 
3670 
  def recv_updateShipmentAddress(self, ):
3671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3672 
    if mtype == TMessageType.EXCEPTION:
3673 
      x = TApplicationException()
3674 
      x.read(self._iprot)
3675 
      self._iprot.readMessageEnd()
3676 
      raise x
3677 
    result = updateShipmentAddress_result()
3678 
    result.read(self._iprot)
3679 
    self._iprot.readMessageEnd()
3680 
    if result.ex is not None:
3681 
      raise result.ex
3682 
    return
3683 
 
4285 rajveer 3684 
  def acceptOrdersForItemId(self, itemId, inventory):
3685 
    """
3686 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3687 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3688 
 
4285 rajveer 3689 
    Parameters:
3690 
     - itemId
3691 
     - inventory
3692 
    """
3693 
    self.send_acceptOrdersForItemId(itemId, inventory)
3694 
    return self.recv_acceptOrdersForItemId()
3695 
 
3696 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3697 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3698 
    args = acceptOrdersForItemId_args()
3699 
    args.itemId = itemId
3700 
    args.inventory = inventory
3701 
    args.write(self._oprot)
3702 
    self._oprot.writeMessageEnd()
3703 
    self._oprot.trans.flush()
3704 
 
3705 
  def recv_acceptOrdersForItemId(self, ):
3706 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3707 
    if mtype == TMessageType.EXCEPTION:
3708 
      x = TApplicationException()
3709 
      x.read(self._iprot)
3710 
      self._iprot.readMessageEnd()
3711 
      raise x
3712 
    result = acceptOrdersForItemId_result()
3713 
    result.read(self._iprot)
3714 
    self._iprot.readMessageEnd()
3715 
    if result.success is not None:
3716 
      return result.success
3717 
    if result.ex is not None:
3718 
      raise result.ex
3719 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3720 
 
4369 rajveer 3721 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3722 
    """
3723 
    Parameters:
3724 
     - vendorId
3725 
     - itemId
3726 
     - quantity
3727 
     - estimate
4369 rajveer 3728 
     - isReminder
4303 rajveer 3729 
    """
4369 rajveer 3730 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3731 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3732 
 
4369 rajveer 3733 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3734 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3735 
    args = markOrdersAsPORaised_args()
3736 
    args.vendorId = vendorId
3737 
    args.itemId = itemId
3738 
    args.quantity = quantity
3739 
    args.estimate = estimate
4369 rajveer 3740 
    args.isReminder = isReminder
4303 rajveer 3741 
    args.write(self._oprot)
3742 
    self._oprot.writeMessageEnd()
3743 
    self._oprot.trans.flush()
3744 
 
3745 
  def recv_markOrdersAsPORaised(self, ):
3746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3747 
    if mtype == TMessageType.EXCEPTION:
3748 
      x = TApplicationException()
3749 
      x.read(self._iprot)
3750 
      self._iprot.readMessageEnd()
3751 
      raise x
3752 
    result = markOrdersAsPORaised_result()
3753 
    result.read(self._iprot)
3754 
    self._iprot.readMessageEnd()
3755 
    if result.ex is not None:
3756 
      raise result.ex
3757 
    return
3758 
 
4369 rajveer 3759 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3760 
    """
3761 
    Parameters:
3762 
     - vendorId
3763 
     - itemId
3764 
     - quantity
3765 
     - estimate
4369 rajveer 3766 
     - isReminder
4303 rajveer 3767 
    """
4369 rajveer 3768 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3769 
    self.recv_markOrdersAsReversalInitiated()
3770 
 
4369 rajveer 3771 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3772 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3773 
    args = markOrdersAsReversalInitiated_args()
3774 
    args.vendorId = vendorId
3775 
    args.itemId = itemId
3776 
    args.quantity = quantity
3777 
    args.estimate = estimate
4369 rajveer 3778 
    args.isReminder = isReminder
4303 rajveer 3779 
    args.write(self._oprot)
3780 
    self._oprot.writeMessageEnd()
3781 
    self._oprot.trans.flush()
3782 
 
3783 
  def recv_markOrdersAsReversalInitiated(self, ):
3784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3785 
    if mtype == TMessageType.EXCEPTION:
3786 
      x = TApplicationException()
3787 
      x.read(self._iprot)
3788 
      self._iprot.readMessageEnd()
3789 
      raise x
3790 
    result = markOrdersAsReversalInitiated_result()
3791 
    result.read(self._iprot)
3792 
    self._iprot.readMessageEnd()
3793 
    if result.ex is not None:
3794 
      raise result.ex
3795 
    return
3796 
 
4369 rajveer 3797 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3798 
    """
3799 
    Parameters:
3800 
     - vendorId
3801 
     - itemId
3802 
     - quantity
3803 
     - estimate
4369 rajveer 3804 
     - isReminder
4303 rajveer 3805 
    """
4369 rajveer 3806 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3807 
    self.recv_markOrdersAsNotAvailabke()
3808 
 
4369 rajveer 3809 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3810 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3811 
    args = markOrdersAsNotAvailabke_args()
3812 
    args.vendorId = vendorId
3813 
    args.itemId = itemId
3814 
    args.quantity = quantity
3815 
    args.estimate = estimate
4369 rajveer 3816 
    args.isReminder = isReminder
4303 rajveer 3817 
    args.write(self._oprot)
3818 
    self._oprot.writeMessageEnd()
3819 
    self._oprot.trans.flush()
3820 
 
3821 
  def recv_markOrdersAsNotAvailabke(self, ):
3822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3823 
    if mtype == TMessageType.EXCEPTION:
3824 
      x = TApplicationException()
3825 
      x.read(self._iprot)
3826 
      self._iprot.readMessageEnd()
3827 
      raise x
3828 
    result = markOrdersAsNotAvailabke_result()
3829 
    result.read(self._iprot)
3830 
    self._iprot.readMessageEnd()
3831 
    if result.ex is not None:
3832 
      raise result.ex
3833 
    return
3834 
 
4369 rajveer 3835 
  def markOrdersAsTimeout(self, vendorId):
3836 
    """
3837 
    Parameters:
3838 
     - vendorId
3839 
    """
3840 
    self.send_markOrdersAsTimeout(vendorId)
3841 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3842 
 
4369 rajveer 3843 
  def send_markOrdersAsTimeout(self, vendorId):
3844 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3845 
    args = markOrdersAsTimeout_args()
3846 
    args.vendorId = vendorId
3847 
    args.write(self._oprot)
3848 
    self._oprot.writeMessageEnd()
3849 
    self._oprot.trans.flush()
3850 
 
3851 
  def recv_markOrdersAsTimeout(self, ):
3852 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3853 
    if mtype == TMessageType.EXCEPTION:
3854 
      x = TApplicationException()
3855 
      x.read(self._iprot)
3856 
      self._iprot.readMessageEnd()
3857 
      raise x
3858 
    result = markOrdersAsTimeout_result()
3859 
    result.read(self._iprot)
3860 
    self._iprot.readMessageEnd()
3861 
    if result.success is not None:
3862 
      return result.success
3863 
    if result.ex is not None:
3864 
      raise result.ex
3865 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3866 
 
4662 rajveer 3867 
  def markOrderAsLostInTransit(self, orderId):
3868 
    """
3869 
    Mark order as LOST_IN_TRANSIT
3870 
 
3871 
    Parameters:
3872 
     - orderId
3873 
    """
3874 
    self.send_markOrderAsLostInTransit(orderId)
3875 
    return self.recv_markOrderAsLostInTransit()
3876 
 
3877 
  def send_markOrderAsLostInTransit(self, orderId):
3878 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
3879 
    args = markOrderAsLostInTransit_args()
3880 
    args.orderId = orderId
3881 
    args.write(self._oprot)
3882 
    self._oprot.writeMessageEnd()
3883 
    self._oprot.trans.flush()
3884 
 
3885 
  def recv_markOrderAsLostInTransit(self, ):
3886 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3887 
    if mtype == TMessageType.EXCEPTION:
3888 
      x = TApplicationException()
3889 
      x.read(self._iprot)
3890 
      self._iprot.readMessageEnd()
3891 
      raise x
3892 
    result = markOrderAsLostInTransit_result()
3893 
    result.read(self._iprot)
3894 
    self._iprot.readMessageEnd()
3895 
    if result.success is not None:
3896 
      return result.success
3897 
    if result.ex is not None:
3898 
      raise result.ex
3899 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
3900 
 
4386 anupam.sin 3901 
  def getOrderForAwb(self, awb):
3902 
    """
3903 
    Returns the order corresponding to an AWB number
4369 rajveer 3904 
 
4386 anupam.sin 3905 
    Parameters:
3906 
     - awb
3907 
    """
3908 
    self.send_getOrderForAwb(awb)
3909 
    return self.recv_getOrderForAwb()
3910 
 
3911 
  def send_getOrderForAwb(self, awb):
3912 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3913 
    args = getOrderForAwb_args()
3914 
    args.awb = awb
3915 
    args.write(self._oprot)
3916 
    self._oprot.writeMessageEnd()
3917 
    self._oprot.trans.flush()
3918 
 
3919 
  def recv_getOrderForAwb(self, ):
3920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3921 
    if mtype == TMessageType.EXCEPTION:
3922 
      x = TApplicationException()
3923 
      x.read(self._iprot)
3924 
      self._iprot.readMessageEnd()
3925 
      raise x
3926 
    result = getOrderForAwb_result()
3927 
    result.read(self._iprot)
3928 
    self._iprot.readMessageEnd()
3929 
    if result.success is not None:
3930 
      return result.success
3931 
    if result.ex is not None:
3932 
      raise result.ex
3933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3934 
 
4506 phani.kuma 3935 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3936 
    """
3937 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3938 
 
4506 phani.kuma 3939 
    Parameters:
3940 
     - logistics_provider_id
3941 
     - order_status
3942 
    """
3943 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
3944 
    return self.recv_getOrdersForProviderForStatus()
3945 
 
3946 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3947 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
3948 
    args = getOrdersForProviderForStatus_args()
3949 
    args.logistics_provider_id = logistics_provider_id
3950 
    args.order_status = order_status
3951 
    args.write(self._oprot)
3952 
    self._oprot.writeMessageEnd()
3953 
    self._oprot.trans.flush()
3954 
 
3955 
  def recv_getOrdersForProviderForStatus(self, ):
3956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3957 
    if mtype == TMessageType.EXCEPTION:
3958 
      x = TApplicationException()
3959 
      x.read(self._iprot)
3960 
      self._iprot.readMessageEnd()
3961 
      raise x
3962 
    result = getOrdersForProviderForStatus_result()
3963 
    result.read(self._iprot)
3964 
    self._iprot.readMessageEnd()
3965 
    if result.success is not None:
3966 
      return result.success
3967 
    if result.ex is not None:
3968 
      raise result.ex
3969 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
3970 
 
4600 varun.gupt 3971 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3972 
    """
3973 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 3974 
 
4600 varun.gupt 3975 
    Parameters:
3976 
     - vendorId
3977 
     - billingDateFrom
3978 
     - billingDateTo
3979 
    """
3980 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
3981 
    return self.recv_getBilledOrdersForVendor()
3982 
 
3983 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
3984 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
3985 
    args = getBilledOrdersForVendor_args()
3986 
    args.vendorId = vendorId
3987 
    args.billingDateFrom = billingDateFrom
3988 
    args.billingDateTo = billingDateTo
3989 
    args.write(self._oprot)
3990 
    self._oprot.writeMessageEnd()
3991 
    self._oprot.trans.flush()
3992 
 
3993 
  def recv_getBilledOrdersForVendor(self, ):
3994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3995 
    if mtype == TMessageType.EXCEPTION:
3996 
      x = TApplicationException()
3997 
      x.read(self._iprot)
3998 
      self._iprot.readMessageEnd()
3999 
      raise x
4000 
    result = getBilledOrdersForVendor_result()
4001 
    result.read(self._iprot)
4002 
    self._iprot.readMessageEnd()
4003 
    if result.success is not None:
4004 
      return result.success
4005 
    if result.ex is not None:
4006 
      raise result.ex
4007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4008 
 
4607 rajveer 4009 
  def getSlippedSippingDateOrders(self, ):
4010 
    self.send_getSlippedSippingDateOrders()
4011 
    return self.recv_getSlippedSippingDateOrders()
4012 
 
4013 
  def send_getSlippedSippingDateOrders(self, ):
4014 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4015 
    args = getSlippedSippingDateOrders_args()
4016 
    args.write(self._oprot)
4017 
    self._oprot.writeMessageEnd()
4018 
    self._oprot.trans.flush()
4019 
 
4020 
  def recv_getSlippedSippingDateOrders(self, ):
4021 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4022 
    if mtype == TMessageType.EXCEPTION:
4023 
      x = TApplicationException()
4024 
      x.read(self._iprot)
4025 
      self._iprot.readMessageEnd()
4026 
      raise x
4027 
    result = getSlippedSippingDateOrders_result()
4028 
    result.read(self._iprot)
4029 
    self._iprot.readMessageEnd()
4030 
    if result.success is not None:
4031 
      return result.success
4032 
    if result.ex is not None:
4033 
      raise result.ex
4034 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4035 
 
4709 rajveer 4036 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4037 
    """
4038 
    Parameters:
4039 
     - cancelDateFrom
4040 
     - cancelDateTo
4041 
    """
4042 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4043 
    return self.recv_getCancelledOrders()
4044 
 
4045 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4046 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4047 
    args = getCancelledOrders_args()
4048 
    args.cancelDateFrom = cancelDateFrom
4049 
    args.cancelDateTo = cancelDateTo
4050 
    args.write(self._oprot)
4051 
    self._oprot.writeMessageEnd()
4052 
    self._oprot.trans.flush()
4053 
 
4054 
  def recv_getCancelledOrders(self, ):
4055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4056 
    if mtype == TMessageType.EXCEPTION:
4057 
      x = TApplicationException()
4058 
      x.read(self._iprot)
4059 
      self._iprot.readMessageEnd()
4060 
      raise x
4061 
    result = getCancelledOrders_result()
4062 
    result.read(self._iprot)
4063 
    self._iprot.readMessageEnd()
4064 
    if result.success is not None:
4065 
      return result.success
4066 
    if result.ex is not None:
4067 
      raise result.ex
4068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4069 
 
4600 varun.gupt 4070 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4071 
    """
4072 
    Parameters:
4073 
     - mapAWBAndAmount
4074 
    """
4075 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4076 
    self.recv_saveBluedartSettlements()
4077 
 
4078 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4079 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4080 
    args = saveBluedartSettlements_args()
4081 
    args.mapAWBAndAmount = mapAWBAndAmount
4082 
    args.write(self._oprot)
4083 
    self._oprot.writeMessageEnd()
4084 
    self._oprot.trans.flush()
4085 
 
4086 
  def recv_saveBluedartSettlements(self, ):
4087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4088 
    if mtype == TMessageType.EXCEPTION:
4089 
      x = TApplicationException()
4090 
      x.read(self._iprot)
4091 
      self._iprot.readMessageEnd()
4092 
      raise x
4093 
    result = saveBluedartSettlements_result()
4094 
    result.read(self._iprot)
4095 
    self._iprot.readMessageEnd()
4096 
    if result.ex is not None:
4097 
      raise result.ex
4098 
    return
4099 
 
4100 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4101 
    """
4102 
    Parameters:
4103 
     - settlementDate
4104 
     - paymentGatewayId
4105 
     - paymentId
4106 
     - serviceTax
4107 
     - otherCharges
4108 
     - netCollection
4109 
    """
4110 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection)
4111 
    self.recv_savePaymentSettlements()
4112 
 
4113 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4114 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4115 
    args = savePaymentSettlements_args()
4116 
    args.settlementDate = settlementDate
4117 
    args.paymentGatewayId = paymentGatewayId
4118 
    args.paymentId = paymentId
4119 
    args.serviceTax = serviceTax
4120 
    args.otherCharges = otherCharges
4121 
    args.netCollection = netCollection
4122 
    args.write(self._oprot)
4123 
    self._oprot.writeMessageEnd()
4124 
    self._oprot.trans.flush()
4125 
 
4126 
  def recv_savePaymentSettlements(self, ):
4127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4128 
    if mtype == TMessageType.EXCEPTION:
4129 
      x = TApplicationException()
4130 
      x.read(self._iprot)
4131 
      self._iprot.readMessageEnd()
4132 
      raise x
4133 
    result = savePaymentSettlements_result()
4134 
    result.read(self._iprot)
4135 
    self._iprot.readMessageEnd()
4136 
    if result.ex is not None:
4137 
      raise result.ex
4138 
    return
4139 
 
4140 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4141 
    """
4142 
    Parameters:
4143 
     - settlementId
4144 
     - settlementDate
4145 
     - transactionDateFrom
4146 
     - transactionDateTo
4147 
     - amount
4148 
    """
4149 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4150 
    self.recv_saveEBSSettlementSummary()
4151 
 
4152 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4153 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4154 
    args = saveEBSSettlementSummary_args()
4155 
    args.settlementId = settlementId
4156 
    args.settlementDate = settlementDate
4157 
    args.transactionDateFrom = transactionDateFrom
4158 
    args.transactionDateTo = transactionDateTo
4159 
    args.amount = amount
4160 
    args.write(self._oprot)
4161 
    self._oprot.writeMessageEnd()
4162 
    self._oprot.trans.flush()
4163 
 
4164 
  def recv_saveEBSSettlementSummary(self, ):
4165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4166 
    if mtype == TMessageType.EXCEPTION:
4167 
      x = TApplicationException()
4168 
      x.read(self._iprot)
4169 
      self._iprot.readMessageEnd()
4170 
      raise x
4171 
    result = saveEBSSettlementSummary_result()
4172 
    result.read(self._iprot)
4173 
    self._iprot.readMessageEnd()
4174 
    if result.ex is not None:
4175 
      raise result.ex
4176 
    return
4177 
 
4178 
  def getSettlementForPaymentId(self, paymentId):
4179 
    """
4180 
    Parameters:
4181 
     - paymentId
4182 
    """
4183 
    self.send_getSettlementForPaymentId(paymentId)
4184 
    return self.recv_getSettlementForPaymentId()
4185 
 
4186 
  def send_getSettlementForPaymentId(self, paymentId):
4187 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4188 
    args = getSettlementForPaymentId_args()
4189 
    args.paymentId = paymentId
4190 
    args.write(self._oprot)
4191 
    self._oprot.writeMessageEnd()
4192 
    self._oprot.trans.flush()
4193 
 
4194 
  def recv_getSettlementForPaymentId(self, ):
4195 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4196 
    if mtype == TMessageType.EXCEPTION:
4197 
      x = TApplicationException()
4198 
      x.read(self._iprot)
4199 
      self._iprot.readMessageEnd()
4200 
      raise x
4201 
    result = getSettlementForPaymentId_result()
4202 
    result.read(self._iprot)
4203 
    self._iprot.readMessageEnd()
4204 
    if result.success is not None:
4205 
      return result.success
4206 
    if result.ex is not None:
4207 
      raise result.ex
4208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4209 
 
4210 
  def getEBSSettlementSummaries(self, ):
4211 
    self.send_getEBSSettlementSummaries()
4212 
    return self.recv_getEBSSettlementSummaries()
4213 
 
4214 
  def send_getEBSSettlementSummaries(self, ):
4215 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4216 
    args = getEBSSettlementSummaries_args()
4217 
    args.write(self._oprot)
4218 
    self._oprot.writeMessageEnd()
4219 
    self._oprot.trans.flush()
4220 
 
4221 
  def recv_getEBSSettlementSummaries(self, ):
4222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4223 
    if mtype == TMessageType.EXCEPTION:
4224 
      x = TApplicationException()
4225 
      x.read(self._iprot)
4226 
      self._iprot.readMessageEnd()
4227 
      raise x
4228 
    result = getEBSSettlementSummaries_result()
4229 
    result.read(self._iprot)
4230 
    self._iprot.readMessageEnd()
4231 
    if result.success is not None:
4232 
      return result.success
4233 
    if result.ex is not None:
4234 
      raise result.ex
4235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4236 
 
4237 
  def markEBSSettlementUploaded(self, settlementId):
4238 
    """
4239 
    Parameters:
4240 
     - settlementId
4241 
    """
4242 
    self.send_markEBSSettlementUploaded(settlementId)
4243 
    self.recv_markEBSSettlementUploaded()
4244 
 
4245 
  def send_markEBSSettlementUploaded(self, settlementId):
4246 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4247 
    args = markEBSSettlementUploaded_args()
4248 
    args.settlementId = settlementId
4249 
    args.write(self._oprot)
4250 
    self._oprot.writeMessageEnd()
4251 
    self._oprot.trans.flush()
4252 
 
4253 
  def recv_markEBSSettlementUploaded(self, ):
4254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4255 
    if mtype == TMessageType.EXCEPTION:
4256 
      x = TApplicationException()
4257 
      x.read(self._iprot)
4258 
      self._iprot.readMessageEnd()
4259 
      raise x
4260 
    result = markEBSSettlementUploaded_result()
4261 
    result.read(self._iprot)
4262 
    self._iprot.readMessageEnd()
4263 
    if result.ex is not None:
4264 
      raise result.ex
4265 
    return
4266 
 
4267 
  def getEBSSettlementDate(self, settlementId):
4268 
    """
4269 
    Parameters:
4270 
     - settlementId
4271 
    """
4272 
    self.send_getEBSSettlementDate(settlementId)
4273 
    return self.recv_getEBSSettlementDate()
4274 
 
4275 
  def send_getEBSSettlementDate(self, settlementId):
4276 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4277 
    args = getEBSSettlementDate_args()
4278 
    args.settlementId = settlementId
4279 
    args.write(self._oprot)
4280 
    self._oprot.writeMessageEnd()
4281 
    self._oprot.trans.flush()
4282 
 
4283 
  def recv_getEBSSettlementDate(self, ):
4284 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4285 
    if mtype == TMessageType.EXCEPTION:
4286 
      x = TApplicationException()
4287 
      x.read(self._iprot)
4288 
      self._iprot.readMessageEnd()
4289 
      raise x
4290 
    result = getEBSSettlementDate_result()
4291 
    result.read(self._iprot)
4292 
    self._iprot.readMessageEnd()
4293 
    if result.success is not None:
4294 
      return result.success
4295 
    if result.ex is not None:
4296 
      raise result.ex
4297 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4298 
 
4715 varun.gupt 4299 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4300 
    """
4301 
    Parameters:
4302 
     - settlementDateFrom
4303 
     - settlementDateTo
4304 
     - isRefund
4305 
    """
4306 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4307 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4308 
 
4715 varun.gupt 4309 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4310 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4311 
    args = getSettlementsByDate_args()
4312 
    args.settlementDateFrom = settlementDateFrom
4313 
    args.settlementDateTo = settlementDateTo
4314 
    args.isRefund = isRefund
4315 
    args.write(self._oprot)
4316 
    self._oprot.writeMessageEnd()
4317 
    self._oprot.trans.flush()
4318 
 
4319 
  def recv_getSettlementsByDate(self, ):
4320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4321 
    if mtype == TMessageType.EXCEPTION:
4322 
      x = TApplicationException()
4323 
      x.read(self._iprot)
4324 
      self._iprot.readMessageEnd()
4325 
      raise x
4326 
    result = getSettlementsByDate_result()
4327 
    result.read(self._iprot)
4328 
    self._iprot.readMessageEnd()
4329 
    if result.success is not None:
4330 
      return result.success
4331 
    if result.ex is not None:
4332 
      raise result.ex
4333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4334 
 
4335 
  def getReshippedOrderIds(self, orderIds):
4336 
    """
4337 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4338 
 
4339 
    Parameters:
4340 
     - orderIds
4341 
    """
4342 
    self.send_getReshippedOrderIds(orderIds)
4343 
    return self.recv_getReshippedOrderIds()
4344 
 
4345 
  def send_getReshippedOrderIds(self, orderIds):
4346 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4347 
    args = getReshippedOrderIds_args()
4348 
    args.orderIds = orderIds
4349 
    args.write(self._oprot)
4350 
    self._oprot.writeMessageEnd()
4351 
    self._oprot.trans.flush()
4352 
 
4353 
  def recv_getReshippedOrderIds(self, ):
4354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4355 
    if mtype == TMessageType.EXCEPTION:
4356 
      x = TApplicationException()
4357 
      x.read(self._iprot)
4358 
      self._iprot.readMessageEnd()
4359 
      raise x
4360 
    result = getReshippedOrderIds_result()
4361 
    result.read(self._iprot)
4362 
    self._iprot.readMessageEnd()
4363 
    if result.success is not None:
4364 
      return result.success
4365 
    if result.ex is not None:
4366 
      raise result.ex
4367 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4368 
 
4369 
 
3376 rajveer 4370 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4371 
  def __init__(self, handler):
3376 rajveer 4372 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4373 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4374 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4375 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4376 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4377 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4378 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4379 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4380 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4381 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4382 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4383 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4384 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4385 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4386 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4387 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4388 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4389 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4390 
    self._processMap["createOrder"] = Processor.process_createOrder
4391 
    self._processMap["getOrder"] = Processor.process_getOrder
4392 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4393 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4394 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4395 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4396 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4397 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4398 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4399 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4400 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4401 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4402 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4403 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4404 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4405 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4406 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 4407 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 4408 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4409 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 4410 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 4411 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 4412 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 4413 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 4414 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 4415 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 4416 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4417 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4418 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4419 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4420 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4421 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4422 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 4423 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4424 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4425 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4426 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4427 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4428 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4429 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4430 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 4431 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 4432 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4433 
    self._processMap["changeItem"] = Processor.process_changeItem
4434 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4435 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4436 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4437 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4438 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4439 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4440 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4441 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4442 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4443 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4444 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4445 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4446 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4447 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4448 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4449 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4450 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4451 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 4452 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 4453 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4454 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4455 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4456 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 4457 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 4458 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4459 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4460 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4461 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4462 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4463 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4464 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 4465 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
4466 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
94 ashish 4467 
 
4468 
  def process(self, iprot, oprot):
4469 
    (name, type, seqid) = iprot.readMessageBegin()
4470 
    if name not in self._processMap:
4471 
      iprot.skip(TType.STRUCT)
4472 
      iprot.readMessageEnd()
4473 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4474 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4475 
      x.write(oprot)
4476 
      oprot.writeMessageEnd()
4477 
      oprot.trans.flush()
4478 
      return
4479 
    else:
4480 
      self._processMap[name](self, seqid, iprot, oprot)
4481 
    return True
4482 
 
4483 
  def process_createTransaction(self, seqid, iprot, oprot):
4484 
    args = createTransaction_args()
4485 
    args.read(iprot)
4486 
    iprot.readMessageEnd()
4487 
    result = createTransaction_result()
4488 
    try:
132 ashish 4489 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4490 
    except TransactionServiceException, ex:
4491 
      result.ex = ex
4492 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4493 
    result.write(oprot)
4494 
    oprot.writeMessageEnd()
4495 
    oprot.trans.flush()
4496 
 
4497 
  def process_getTransaction(self, seqid, iprot, oprot):
4498 
    args = getTransaction_args()
4499 
    args.read(iprot)
4500 
    iprot.readMessageEnd()
4501 
    result = getTransaction_result()
4502 
    try:
4503 
      result.success = self._handler.getTransaction(args.id)
4504 
    except TransactionServiceException, ex:
4505 
      result.ex = ex
4506 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4507 
    result.write(oprot)
4508 
    oprot.writeMessageEnd()
4509 
    oprot.trans.flush()
4510 
 
4511 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4512 
    args = getTransactionsForCustomer_args()
4513 
    args.read(iprot)
4514 
    iprot.readMessageEnd()
4515 
    result = getTransactionsForCustomer_result()
4516 
    try:
4517 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4518 
    except TransactionServiceException, ex:
4519 
      result.ex = ex
4520 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4521 
    result.write(oprot)
4522 
    oprot.writeMessageEnd()
4523 
    oprot.trans.flush()
4524 
 
132 ashish 4525 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4526 
    args = getTransactionsForShoppingCartId_args()
4527 
    args.read(iprot)
4528 
    iprot.readMessageEnd()
4529 
    result = getTransactionsForShoppingCartId_result()
4530 
    try:
4531 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4532 
    except TransactionServiceException, ex:
4533 
      result.ex = ex
4534 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4535 
    result.write(oprot)
4536 
    oprot.writeMessageEnd()
4537 
    oprot.trans.flush()
4538 
 
94 ashish 4539 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4540 
    args = getTransactionStatus_args()
4541 
    args.read(iprot)
4542 
    iprot.readMessageEnd()
4543 
    result = getTransactionStatus_result()
4544 
    try:
4545 
      result.success = self._handler.getTransactionStatus(args.transactionId)
4546 
    except TransactionServiceException, ex:
4547 
      result.ex = ex
4548 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
4549 
    result.write(oprot)
4550 
    oprot.writeMessageEnd()
4551 
    oprot.trans.flush()
4552 
 
4553 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
4554 
    args = changeTransactionStatus_args()
4555 
    args.read(iprot)
4556 
    iprot.readMessageEnd()
4557 
    result = changeTransactionStatus_result()
4558 
    try:
4559 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
4560 
    except TransactionServiceException, ex:
4561 
      result.ex = ex
4562 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
4563 
    result.write(oprot)
4564 
    oprot.writeMessageEnd()
4565 
    oprot.trans.flush()
4566 
 
1398 varun.gupt 4567 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
4568 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 4569 
    args.read(iprot)
4570 
    iprot.readMessageEnd()
1398 varun.gupt 4571 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 4572 
    try:
1398 varun.gupt 4573 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 4574 
    except TransactionServiceException, ex:
4575 
      result.ex = ex
1398 varun.gupt 4576 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 4577 
    result.write(oprot)
4578 
    oprot.writeMessageEnd()
4579 
    oprot.trans.flush()
4580 
 
483 rajveer 4581 
  def process_getAllOrders(self, seqid, iprot, oprot):
4582 
    args = getAllOrders_args()
94 ashish 4583 
    args.read(iprot)
4584 
    iprot.readMessageEnd()
483 rajveer 4585 
    result = getAllOrders_result()
94 ashish 4586 
    try:
483 rajveer 4587 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 4588 
    except TransactionServiceException, ex:
4589 
      result.ex = ex
483 rajveer 4590 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 4591 
    result.write(oprot)
4592 
    oprot.writeMessageEnd()
4593 
    oprot.trans.flush()
4594 
 
4133 chandransh 4595 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
4596 
    args = getOrdersInBatch_args()
4597 
    args.read(iprot)
4598 
    iprot.readMessageEnd()
4599 
    result = getOrdersInBatch_result()
4600 
    try:
4601 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4602 
    except TransactionServiceException, ex:
4603 
      result.ex = ex
4604 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4605 
    result.write(oprot)
4606 
    oprot.writeMessageEnd()
4607 
    oprot.trans.flush()
4608 
 
4609 
  def process_getOrderCount(self, seqid, iprot, oprot):
4610 
    args = getOrderCount_args()
4611 
    args.read(iprot)
4612 
    iprot.readMessageEnd()
4613 
    result = getOrderCount_result()
4614 
    try:
4615 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4616 
    except TransactionServiceException, ex:
4617 
      result.ex = ex
4618 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4619 
    result.write(oprot)
4620 
    oprot.writeMessageEnd()
4621 
    oprot.trans.flush()
4622 
 
999 varun.gupt 4623 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4624 
    args = getOrdersByBillingDate_args()
4625 
    args.read(iprot)
4626 
    iprot.readMessageEnd()
4627 
    result = getOrdersByBillingDate_result()
4628 
    try:
4629 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4630 
    except TransactionServiceException, ex:
4631 
      result.ex = ex
4632 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4633 
    result.write(oprot)
4634 
    oprot.writeMessageEnd()
4635 
    oprot.trans.flush()
4636 
 
3427 chandransh 4637 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4638 
    args = getOrdersByShippingDate_args()
4639 
    args.read(iprot)
4640 
    iprot.readMessageEnd()
4641 
    result = getOrdersByShippingDate_result()
4642 
    try:
3451 chandransh 4643 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4644 
    except TransactionServiceException, ex:
4645 
      result.ex = ex
4646 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4647 
    result.write(oprot)
4648 
    oprot.writeMessageEnd()
4649 
    oprot.trans.flush()
4650 
 
1382 varun.gupt 4651 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4652 
    args = getReturnableOrdersForCustomer_args()
4653 
    args.read(iprot)
4654 
    iprot.readMessageEnd()
4655 
    result = getReturnableOrdersForCustomer_result()
4656 
    try:
4657 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4658 
    except TransactionServiceException, ex:
4659 
      result.ex = ex
4660 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4661 
    result.write(oprot)
4662 
    oprot.writeMessageEnd()
4663 
    oprot.trans.flush()
4664 
 
4665 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4666 
    args = getCancellableOrdersForCustomer_args()
4667 
    args.read(iprot)
4668 
    iprot.readMessageEnd()
4669 
    result = getCancellableOrdersForCustomer_result()
4670 
    try:
4671 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4672 
    except TransactionServiceException, ex:
4673 
      result.ex = ex
4674 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4675 
    result.write(oprot)
4676 
    oprot.writeMessageEnd()
4677 
    oprot.trans.flush()
4678 
 
483 rajveer 4679 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4680 
    args = changeOrderStatus_args()
94 ashish 4681 
    args.read(iprot)
4682 
    iprot.readMessageEnd()
483 rajveer 4683 
    result = changeOrderStatus_result()
94 ashish 4684 
    try:
483 rajveer 4685 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4686 
    except TransactionServiceException, ex:
4687 
      result.ex = ex
483 rajveer 4688 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4689 
    result.write(oprot)
4690 
    oprot.writeMessageEnd()
4691 
    oprot.trans.flush()
4692 
 
483 rajveer 4693 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4694 
    args = getOrdersForTransaction_args()
94 ashish 4695 
    args.read(iprot)
4696 
    iprot.readMessageEnd()
483 rajveer 4697 
    result = getOrdersForTransaction_result()
94 ashish 4698 
    try:
1528 ankur.sing 4699 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4700 
    except TransactionServiceException, ex:
4701 
      result.ex = ex
483 rajveer 4702 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4703 
    result.write(oprot)
4704 
    oprot.writeMessageEnd()
4705 
    oprot.trans.flush()
4706 
 
483 rajveer 4707 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4708 
    args = getOrdersForCustomer_args()
94 ashish 4709 
    args.read(iprot)
4710 
    iprot.readMessageEnd()
483 rajveer 4711 
    result = getOrdersForCustomer_result()
94 ashish 4712 
    try:
3014 chandransh 4713 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4714 
    except TransactionServiceException, ex:
4715 
      result.ex = ex
483 rajveer 4716 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4717 
    result.write(oprot)
4718 
    oprot.writeMessageEnd()
4719 
    oprot.trans.flush()
4720 
 
483 rajveer 4721 
  def process_createOrder(self, seqid, iprot, oprot):
4722 
    args = createOrder_args()
94 ashish 4723 
    args.read(iprot)
4724 
    iprot.readMessageEnd()
483 rajveer 4725 
    result = createOrder_result()
94 ashish 4726 
    try:
483 rajveer 4727 
      result.success = self._handler.createOrder(args.order)
94 ashish 4728 
    except TransactionServiceException, ex:
4729 
      result.ex = ex
483 rajveer 4730 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4731 
    result.write(oprot)
4732 
    oprot.writeMessageEnd()
4733 
    oprot.trans.flush()
4734 
 
483 rajveer 4735 
  def process_getOrder(self, seqid, iprot, oprot):
4736 
    args = getOrder_args()
94 ashish 4737 
    args.read(iprot)
4738 
    iprot.readMessageEnd()
483 rajveer 4739 
    result = getOrder_result()
94 ashish 4740 
    try:
483 rajveer 4741 
      result.success = self._handler.getOrder(args.id)
94 ashish 4742 
    except TransactionServiceException, ex:
4743 
      result.ex = ex
483 rajveer 4744 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4745 
    result.write(oprot)
4746 
    oprot.writeMessageEnd()
4747 
    oprot.trans.flush()
4748 
 
483 rajveer 4749 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4750 
    args = getLineItemsForOrder_args()
94 ashish 4751 
    args.read(iprot)
4752 
    iprot.readMessageEnd()
483 rajveer 4753 
    result = getLineItemsForOrder_result()
94 ashish 4754 
    try:
483 rajveer 4755 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4756 
    except TransactionServiceException, ex:
4757 
      result.ex = ex
483 rajveer 4758 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4759 
    result.write(oprot)
4760 
    oprot.writeMessageEnd()
4761 
    oprot.trans.flush()
4762 
 
1528 ankur.sing 4763 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4764 
    args = getOrderForCustomer_args()
4765 
    args.read(iprot)
4766 
    iprot.readMessageEnd()
4767 
    result = getOrderForCustomer_result()
4768 
    try:
4769 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4770 
    except TransactionServiceException, ex:
4771 
      result.ex = ex
4772 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4773 
    result.write(oprot)
4774 
    oprot.writeMessageEnd()
4775 
    oprot.trans.flush()
4776 
 
3064 chandransh 4777 
  def process_getAlerts(self, seqid, iprot, oprot):
4778 
    args = getAlerts_args()
4779 
    args.read(iprot)
4780 
    iprot.readMessageEnd()
4781 
    result = getAlerts_result()
4444 rajveer 4782 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4783 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4784 
    result.write(oprot)
4785 
    oprot.writeMessageEnd()
4786 
    oprot.trans.flush()
4787 
 
4394 rajveer 4788 
  def process_addAlert(self, seqid, iprot, oprot):
4789 
    args = addAlert_args()
3064 chandransh 4790 
    args.read(iprot)
4791 
    iprot.readMessageEnd()
4394 rajveer 4792 
    result = addAlert_result()
4444 rajveer 4793 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4794 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4795 
    result.write(oprot)
4796 
    oprot.writeMessageEnd()
4797 
    oprot.trans.flush()
4798 
 
4444 rajveer 4799 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4800 
    args = markAlertsAsSeen_args()
4801 
    args.read(iprot)
4802 
    iprot.readMessageEnd()
4803 
    result = markAlertsAsSeen_result()
4804 
    self._handler.markAlertsAsSeen(args.warehouseId)
4805 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4806 
    result.write(oprot)
4807 
    oprot.writeMessageEnd()
4808 
    oprot.trans.flush()
4809 
 
3064 chandransh 4810 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4811 
    args = getValidOrderCount_args()
4812 
    args.read(iprot)
4813 
    iprot.readMessageEnd()
4814 
    result = getValidOrderCount_result()
4815 
    result.success = self._handler.getValidOrderCount()
4816 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4817 
    result.write(oprot)
4818 
    oprot.writeMessageEnd()
4819 
    oprot.trans.flush()
4820 
 
4821 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4822 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4823 
    args.read(iprot)
4824 
    iprot.readMessageEnd()
4825 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4826 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4827 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4828 
    result.write(oprot)
4829 
    oprot.writeMessageEnd()
4830 
    oprot.trans.flush()
4831 
 
4832 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4833 
    args = getValidOrdersAmountRange_args()
4834 
    args.read(iprot)
4835 
    iprot.readMessageEnd()
4836 
    result = getValidOrdersAmountRange_result()
4837 
    result.success = self._handler.getValidOrdersAmountRange()
4838 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4839 
    result.write(oprot)
4840 
    oprot.writeMessageEnd()
4841 
    oprot.trans.flush()
4842 
 
4843 
  def process_getValidOrders(self, seqid, iprot, oprot):
4844 
    args = getValidOrders_args()
4845 
    args.read(iprot)
4846 
    iprot.readMessageEnd()
4847 
    result = getValidOrders_result()
4848 
    result.success = self._handler.getValidOrders(args.limit)
4849 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4850 
    result.write(oprot)
4851 
    oprot.writeMessageEnd()
4852 
    oprot.trans.flush()
4853 
 
1220 chandransh 4854 
  def process_batchOrders(self, seqid, iprot, oprot):
4855 
    args = batchOrders_args()
4856 
    args.read(iprot)
4857 
    iprot.readMessageEnd()
4858 
    result = batchOrders_result()
4859 
    try:
4860 
      result.success = self._handler.batchOrders(args.warehouseId)
4861 
    except TransactionServiceException, ex:
4862 
      result.ex = ex
4863 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4864 
    result.write(oprot)
4865 
    oprot.writeMessageEnd()
4866 
    oprot.trans.flush()
4867 
 
1208 chandransh 4868 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4869 
    args = markOrderAsOutOfStock_args()
4870 
    args.read(iprot)
4871 
    iprot.readMessageEnd()
4872 
    result = markOrderAsOutOfStock_result()
4873 
    try:
4874 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4875 
    except TransactionServiceException, ex:
4876 
      result.ex = ex
4877 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4878 
    result.write(oprot)
4879 
    oprot.writeMessageEnd()
4880 
    oprot.trans.flush()
4881 
 
3064 chandransh 4882 
  def process_verifyOrder(self, seqid, iprot, oprot):
4883 
    args = verifyOrder_args()
759 chandransh 4884 
    args.read(iprot)
4885 
    iprot.readMessageEnd()
3064 chandransh 4886 
    result = verifyOrder_result()
759 chandransh 4887 
    try:
3064 chandransh 4888 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4889 
    except TransactionServiceException, ex:
4890 
      result.ex = ex
3064 chandransh 4891 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4892 
    result.write(oprot)
4893 
    oprot.writeMessageEnd()
4894 
    oprot.trans.flush()
4895 
 
3064 chandransh 4896 
  def process_acceptOrder(self, seqid, iprot, oprot):
4897 
    args = acceptOrder_args()
1113 chandransh 4898 
    args.read(iprot)
4899 
    iprot.readMessageEnd()
3064 chandransh 4900 
    result = acceptOrder_result()
1113 chandransh 4901 
    try:
3064 chandransh 4902 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4903 
    except TransactionServiceException, ex:
4904 
      result.ex = ex
3064 chandransh 4905 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4906 
    result.write(oprot)
4907 
    oprot.writeMessageEnd()
4908 
    oprot.trans.flush()
4909 
 
3064 chandransh 4910 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4911 
    args = addBillingDetails_args()
1135 chandransh 4912 
    args.read(iprot)
4913 
    iprot.readMessageEnd()
3064 chandransh 4914 
    result = addBillingDetails_result()
1135 chandransh 4915 
    try:
4658 mandeep.dh 4916 
      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 4917 
    except TransactionServiceException, ex:
4918 
      result.ex = ex
3064 chandransh 4919 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4920 
    result.write(oprot)
4921 
    oprot.writeMessageEnd()
4922 
    oprot.trans.flush()
4923 
 
4579 rajveer 4924 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
4925 
    args = addInvoiceNumber_args()
4926 
    args.read(iprot)
4927 
    iprot.readMessageEnd()
4928 
    result = addInvoiceNumber_result()
4929 
    try:
4930 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber)
4931 
    except TransactionServiceException, ex:
4932 
      result.ex = ex
4933 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
4934 
    result.write(oprot)
4935 
    oprot.writeMessageEnd()
4936 
    oprot.trans.flush()
4937 
 
3064 chandransh 4938 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4939 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4940 
    args.read(iprot)
4941 
    iprot.readMessageEnd()
3064 chandransh 4942 
    result = markOrdersAsManifested_result()
4943 
    try:
4944 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4945 
    except TransactionServiceException, ex:
4946 
      result.ex = ex
4947 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4948 
    result.write(oprot)
4949 
    oprot.writeMessageEnd()
4950 
    oprot.trans.flush()
4951 
 
4410 rajveer 4952 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4953 
    args = markOrdersAsShippedFromWarehouse_args()
4954 
    args.read(iprot)
4955 
    iprot.readMessageEnd()
4956 
    result = markOrdersAsShippedFromWarehouse_result()
4957 
    try:
4958 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4959 
    except TransactionServiceException, ex:
4960 
      result.ex = ex
4961 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4962 
    result.write(oprot)
4963 
    oprot.writeMessageEnd()
4964 
    oprot.trans.flush()
4965 
 
3064 chandransh 4966 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4967 
    args = markOrdersAsPickedUp_args()
304 ashish 4968 
    args.read(iprot)
4969 
    iprot.readMessageEnd()
3064 chandransh 4970 
    result = markOrdersAsPickedUp_result()
4971 
    try:
4972 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4973 
    except TransactionServiceException, ex:
4974 
      result.ex = ex
4975 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4976 
    result.write(oprot)
4977 
    oprot.writeMessageEnd()
4978 
    oprot.trans.flush()
94 ashish 4979 
 
3064 chandransh 4980 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4981 
    args = markOrdersAsDelivered_args()
304 ashish 4982 
    args.read(iprot)
4983 
    iprot.readMessageEnd()
3064 chandransh 4984 
    result = markOrdersAsDelivered_result()
4985 
    try:
4986 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4987 
    except TransactionServiceException, ex:
4988 
      result.ex = ex
4989 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4990 
    result.write(oprot)
4991 
    oprot.writeMessageEnd()
4992 
    oprot.trans.flush()
4993 
 
3064 chandransh 4994 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4995 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4996 
    args.read(iprot)
4997 
    iprot.readMessageEnd()
3064 chandransh 4998 
    result = markOrdersAsFailed_result()
4999 
    try:
5000 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
5001 
    except TransactionServiceException, ex:
5002 
      result.ex = ex
5003 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 5004 
    result.write(oprot)
5005 
    oprot.writeMessageEnd()
5006 
    oprot.trans.flush()
304 ashish 5007 
 
3064 chandransh 5008 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5009 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5010 
    args.read(iprot)
5011 
    iprot.readMessageEnd()
3064 chandransh 5012 
    result = updateNonDeliveryReason_result()
5013 
    try:
4581 phani.kuma 5014 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5015 
    except TransactionServiceException, ex:
5016 
      result.ex = ex
5017 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5018 
    result.write(oprot)
5019 
    oprot.writeMessageEnd()
5020 
    oprot.trans.flush()
1596 ankur.sing 5021 
 
3064 chandransh 5022 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5023 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5024 
    args.read(iprot)
5025 
    iprot.readMessageEnd()
3064 chandransh 5026 
    result = getUndeliveredOrders_result()
5027 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5028 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5029 
    result.write(oprot)
5030 
    oprot.writeMessageEnd()
5031 
    oprot.trans.flush()
5032 
 
2536 chandransh 5033 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5034 
    args = toggleDOAFlag_args()
5035 
    args.read(iprot)
5036 
    iprot.readMessageEnd()
5037 
    result = toggleDOAFlag_result()
5038 
    try:
5039 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5040 
    except TransactionServiceException, ex:
5041 
      result.ex = ex
5042 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5043 
    result.write(oprot)
5044 
    oprot.writeMessageEnd()
5045 
    oprot.trans.flush()
1886 ankur.sing 5046 
 
4712 rajveer 5047 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5048 
    args = markOrderAsDelivered_args()
5049 
    args.read(iprot)
5050 
    iprot.readMessageEnd()
5051 
    result = markOrderAsDelivered_result()
5052 
    try:
5053 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5054 
    except TransactionServiceException, ex:
5055 
      result.ex = ex
5056 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5057 
    result.write(oprot)
5058 
    oprot.writeMessageEnd()
5059 
    oprot.trans.flush()
5060 
 
4454 rajveer 5061 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5062 
    args = markOrderDoaRequestReceived_args()
5063 
    args.read(iprot)
5064 
    iprot.readMessageEnd()
5065 
    result = markOrderDoaRequestReceived_result()
5066 
    try:
5067 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5068 
    except TransactionServiceException, ex:
5069 
      result.ex = ex
5070 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5071 
    result.write(oprot)
5072 
    oprot.writeMessageEnd()
5073 
    oprot.trans.flush()
5074 
 
5075 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5076 
    args = markOrderDoaRequestAuthorized_args()
5077 
    args.read(iprot)
5078 
    iprot.readMessageEnd()
5079 
    result = markOrderDoaRequestAuthorized_result()
5080 
    try:
5081 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5082 
    except TransactionServiceException, ex:
5083 
      result.ex = ex
5084 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5085 
    result.write(oprot)
5086 
    oprot.writeMessageEnd()
5087 
    oprot.trans.flush()
5088 
 
4488 rajveer 5089 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5090 
    args = markOrderReturnRequestReceived_args()
5091 
    args.read(iprot)
5092 
    iprot.readMessageEnd()
5093 
    result = markOrderReturnRequestReceived_result()
5094 
    try:
5095 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5096 
    except TransactionServiceException, ex:
5097 
      result.ex = ex
5098 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5099 
    result.write(oprot)
5100 
    oprot.writeMessageEnd()
5101 
    oprot.trans.flush()
5102 
 
5103 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5104 
    args = markOrderReturnRequestAuthorized_args()
5105 
    args.read(iprot)
5106 
    iprot.readMessageEnd()
5107 
    result = markOrderReturnRequestAuthorized_result()
5108 
    try:
5109 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5110 
    except TransactionServiceException, ex:
5111 
      result.ex = ex
5112 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5113 
    result.write(oprot)
5114 
    oprot.writeMessageEnd()
5115 
    oprot.trans.flush()
5116 
 
2536 chandransh 5117 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5118 
    args = requestPickupNumber_args()
5119 
    args.read(iprot)
5120 
    iprot.readMessageEnd()
5121 
    result = requestPickupNumber_result()
5122 
    try:
4579 rajveer 5123 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5124 
    except TransactionServiceException, ex:
5125 
      result.ex = ex
5126 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5127 
    result.write(oprot)
5128 
    oprot.writeMessageEnd()
5129 
    oprot.trans.flush()
5130 
 
5131 
  def process_authorizePickup(self, seqid, iprot, oprot):
5132 
    args = authorizePickup_args()
5133 
    args.read(iprot)
5134 
    iprot.readMessageEnd()
5135 
    result = authorizePickup_result()
5136 
    try:
4602 rajveer 5137 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5138 
    except TransactionServiceException, ex:
5139 
      result.ex = ex
5140 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5141 
    result.write(oprot)
5142 
    oprot.writeMessageEnd()
5143 
    oprot.trans.flush()
5144 
 
2764 chandransh 5145 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5146 
    args = markDoasAsPickedUp_args()
5147 
    args.read(iprot)
5148 
    iprot.readMessageEnd()
5149 
    result = markDoasAsPickedUp_result()
5150 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
5151 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5152 
    result.write(oprot)
5153 
    oprot.writeMessageEnd()
5154 
    oprot.trans.flush()
5155 
 
2616 chandransh 5156 
  def process_receiveReturn(self, seqid, iprot, oprot):
5157 
    args = receiveReturn_args()
2591 chandransh 5158 
    args.read(iprot)
5159 
    iprot.readMessageEnd()
2616 chandransh 5160 
    result = receiveReturn_result()
2591 chandransh 5161 
    try:
4479 rajveer 5162 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5163 
    except TransactionServiceException, ex:
5164 
      result.ex = ex
2616 chandransh 5165 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5166 
    result.write(oprot)
5167 
    oprot.writeMessageEnd()
5168 
    oprot.trans.flush()
2536 chandransh 5169 
 
2591 chandransh 5170 
  def process_validateDoa(self, seqid, iprot, oprot):
5171 
    args = validateDoa_args()
5172 
    args.read(iprot)
5173 
    iprot.readMessageEnd()
5174 
    result = validateDoa_result()
5175 
    try:
5176 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5177 
    except TransactionServiceException, ex:
5178 
      result.ex = ex
5179 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5180 
    result.write(oprot)
5181 
    oprot.writeMessageEnd()
5182 
    oprot.trans.flush()
5183 
 
4495 rajveer 5184 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5185 
    args = validateReturnProduct_args()
5186 
    args.read(iprot)
5187 
    iprot.readMessageEnd()
5188 
    result = validateReturnProduct_result()
5189 
    try:
5190 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5191 
    except TransactionServiceException, ex:
5192 
      result.ex = ex
5193 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5194 
    result.write(oprot)
5195 
    oprot.writeMessageEnd()
5196 
    oprot.trans.flush()
5197 
 
2616 chandransh 5198 
  def process_reshipOrder(self, seqid, iprot, oprot):
5199 
    args = reshipOrder_args()
5200 
    args.read(iprot)
5201 
    iprot.readMessageEnd()
5202 
    result = reshipOrder_result()
5203 
    try:
5204 
      result.success = self._handler.reshipOrder(args.orderId)
5205 
    except TransactionServiceException, ex:
5206 
      result.ex = ex
5207 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5208 
    result.write(oprot)
5209 
    oprot.writeMessageEnd()
5210 
    oprot.trans.flush()
2591 chandransh 5211 
 
2616 chandransh 5212 
  def process_refundOrder(self, seqid, iprot, oprot):
5213 
    args = refundOrder_args()
5214 
    args.read(iprot)
5215 
    iprot.readMessageEnd()
5216 
    result = refundOrder_result()
5217 
    try:
3226 chandransh 5218 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5219 
    except TransactionServiceException, ex:
5220 
      result.ex = ex
5221 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5222 
    result.write(oprot)
5223 
    oprot.writeMessageEnd()
5224 
    oprot.trans.flush()
5225 
 
2690 chandransh 5226 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5227 
    args = getReturnOrders_args()
5228 
    args.read(iprot)
5229 
    iprot.readMessageEnd()
5230 
    result = getReturnOrders_result()
5231 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5232 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5233 
    result.write(oprot)
5234 
    oprot.writeMessageEnd()
5235 
    oprot.trans.flush()
2616 chandransh 5236 
 
2700 chandransh 5237 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5238 
    args = getReturnOrder_args()
5239 
    args.read(iprot)
5240 
    iprot.readMessageEnd()
5241 
    result = getReturnOrder_result()
5242 
    try:
5243 
      result.success = self._handler.getReturnOrder(args.id)
5244 
    except TransactionServiceException, ex:
5245 
      result.ex = ex
5246 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5247 
    result.write(oprot)
5248 
    oprot.writeMessageEnd()
5249 
    oprot.trans.flush()
5250 
 
2690 chandransh 5251 
  def process_processReturn(self, seqid, iprot, oprot):
5252 
    args = processReturn_args()
5253 
    args.read(iprot)
5254 
    iprot.readMessageEnd()
5255 
    result = processReturn_result()
5256 
    try:
5257 
      self._handler.processReturn(args.returnOrderId)
5258 
    except TransactionServiceException, ex:
5259 
      result.ex = ex
5260 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5261 
    result.write(oprot)
5262 
    oprot.writeMessageEnd()
5263 
    oprot.trans.flush()
5264 
 
2819 chandransh 5265 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
5266 
    args = createPurchaseOrder_args()
5267 
    args.read(iprot)
5268 
    iprot.readMessageEnd()
5269 
    result = createPurchaseOrder_result()
5270 
    try:
5271 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
5272 
    except TransactionServiceException, ex:
5273 
      result.ex = ex
5274 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
5275 
    result.write(oprot)
5276 
    oprot.writeMessageEnd()
5277 
    oprot.trans.flush()
2690 chandransh 5278 
 
3451 chandransh 5279 
  def process_updateWeight(self, seqid, iprot, oprot):
5280 
    args = updateWeight_args()
5281 
    args.read(iprot)
5282 
    iprot.readMessageEnd()
5283 
    result = updateWeight_result()
5284 
    try:
5285 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5286 
    except TransactionServiceException, ex:
5287 
      result.ex = ex
5288 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5289 
    result.write(oprot)
5290 
    oprot.writeMessageEnd()
5291 
    oprot.trans.flush()
2819 chandransh 5292 
 
3469 chandransh 5293 
  def process_changeItem(self, seqid, iprot, oprot):
5294 
    args = changeItem_args()
5295 
    args.read(iprot)
5296 
    iprot.readMessageEnd()
5297 
    result = changeItem_result()
5298 
    try:
5299 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5300 
    except TransactionServiceException, ex:
5301 
      result.ex = ex
5302 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5303 
    result.write(oprot)
5304 
    oprot.writeMessageEnd()
5305 
    oprot.trans.flush()
3451 chandransh 5306 
 
3469 chandransh 5307 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5308 
    args = shiftToWarehouse_args()
5309 
    args.read(iprot)
5310 
    iprot.readMessageEnd()
5311 
    result = shiftToWarehouse_result()
5312 
    try:
5313 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5314 
    except TransactionServiceException, ex:
5315 
      result.ex = ex
5316 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5317 
    result.write(oprot)
5318 
    oprot.writeMessageEnd()
5319 
    oprot.trans.flush()
5320 
 
3553 chandransh 5321 
  def process_addDelayReason(self, seqid, iprot, oprot):
5322 
    args = addDelayReason_args()
5323 
    args.read(iprot)
5324 
    iprot.readMessageEnd()
5325 
    result = addDelayReason_result()
5326 
    try:
4647 rajveer 5327 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 5328 
    except TransactionServiceException, ex:
5329 
      result.ex = ex
5330 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5331 
    result.write(oprot)
5332 
    oprot.writeMessageEnd()
5333 
    oprot.trans.flush()
3469 chandransh 5334 
 
3956 chandransh 5335 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5336 
    args = reconcileCodCollection_args()
5337 
    args.read(iprot)
5338 
    iprot.readMessageEnd()
5339 
    result = reconcileCodCollection_result()
5340 
    try:
5341 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5342 
    except TransactionServiceException, ex:
5343 
      result.ex = ex
5344 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5345 
    result.write(oprot)
5346 
    oprot.writeMessageEnd()
5347 
    oprot.trans.flush()
3553 chandransh 5348 
 
4008 mandeep.dh 5349 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5350 
    args = getTransactionsRequiringExtraProcessing_args()
5351 
    args.read(iprot)
5352 
    iprot.readMessageEnd()
5353 
    result = getTransactionsRequiringExtraProcessing_result()
5354 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5355 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5356 
    result.write(oprot)
5357 
    oprot.writeMessageEnd()
5358 
    oprot.trans.flush()
3956 chandransh 5359 
 
4008 mandeep.dh 5360 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5361 
    args = markTransactionAsProcessed_args()
5362 
    args.read(iprot)
5363 
    iprot.readMessageEnd()
5364 
    result = markTransactionAsProcessed_result()
5365 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5366 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5367 
    result.write(oprot)
5368 
    oprot.writeMessageEnd()
5369 
    oprot.trans.flush()
5370 
 
4018 chandransh 5371 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5372 
    args = getItemWiseRiskyOrdersCount_args()
5373 
    args.read(iprot)
5374 
    iprot.readMessageEnd()
5375 
    result = getItemWiseRiskyOrdersCount_result()
5376 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5377 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5378 
    result.write(oprot)
5379 
    oprot.writeMessageEnd()
5380 
    oprot.trans.flush()
4008 mandeep.dh 5381 
 
4295 varun.gupt 5382 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5383 
    args = getOrdersForItemIds_args()
5384 
    args.read(iprot)
5385 
    iprot.readMessageEnd()
5386 
    result = getOrdersForItemIds_result()
5387 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5388 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5389 
    result.write(oprot)
5390 
    oprot.writeMessageEnd()
5391 
    oprot.trans.flush()
5392 
 
4247 rajveer 5393 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5394 
    args = markOrderCancellationRequestReceived_args()
5395 
    args.read(iprot)
5396 
    iprot.readMessageEnd()
5397 
    result = markOrderCancellationRequestReceived_result()
5398 
    try:
5399 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5400 
    except TransactionServiceException, ex:
5401 
      result.ex = ex
5402 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5403 
    result.write(oprot)
5404 
    oprot.writeMessageEnd()
5405 
    oprot.trans.flush()
4018 chandransh 5406 
 
4247 rajveer 5407 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5408 
    args = markOrderCancellationRequestConfirmed_args()
5409 
    args.read(iprot)
5410 
    iprot.readMessageEnd()
5411 
    result = markOrderCancellationRequestConfirmed_result()
5412 
    try:
5413 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5414 
    except TransactionServiceException, ex:
5415 
      result.ex = ex
5416 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5417 
    result.write(oprot)
5418 
    oprot.writeMessageEnd()
5419 
    oprot.trans.flush()
5420 
 
5421 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5422 
    args = markOrderCancellationRequestDenied_args()
5423 
    args.read(iprot)
5424 
    iprot.readMessageEnd()
5425 
    result = markOrderCancellationRequestDenied_result()
5426 
    try:
5427 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5428 
    except TransactionServiceException, ex:
5429 
      result.ex = ex
5430 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5431 
    result.write(oprot)
5432 
    oprot.writeMessageEnd()
5433 
    oprot.trans.flush()
5434 
 
4258 rajveer 5435 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5436 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5437 
    args.read(iprot)
5438 
    iprot.readMessageEnd()
4258 rajveer 5439 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5440 
    try:
4258 rajveer 5441 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 5442 
    except TransactionServiceException, ex:
5443 
      result.ex = ex
4258 rajveer 5444 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 5445 
    result.write(oprot)
5446 
    oprot.writeMessageEnd()
5447 
    oprot.trans.flush()
5448 
 
4259 anupam.sin 5449 
  def process_refundTransaction(self, seqid, iprot, oprot):
5450 
    args = refundTransaction_args()
5451 
    args.read(iprot)
5452 
    iprot.readMessageEnd()
5453 
    result = refundTransaction_result()
5454 
    try:
5455 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
5456 
    except TransactionServiceException, ex:
5457 
      result.ex = ex
5458 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
5459 
    result.write(oprot)
5460 
    oprot.writeMessageEnd()
5461 
    oprot.trans.flush()
4247 rajveer 5462 
 
4324 mandeep.dh 5463 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
5464 
    args = updateShipmentAddress_args()
5465 
    args.read(iprot)
5466 
    iprot.readMessageEnd()
5467 
    result = updateShipmentAddress_result()
5468 
    try:
5469 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
5470 
    except TransactionServiceException, ex:
5471 
      result.ex = ex
5472 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
5473 
    result.write(oprot)
5474 
    oprot.writeMessageEnd()
5475 
    oprot.trans.flush()
5476 
 
4285 rajveer 5477 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
5478 
    args = acceptOrdersForItemId_args()
5479 
    args.read(iprot)
5480 
    iprot.readMessageEnd()
5481 
    result = acceptOrdersForItemId_result()
5482 
    try:
5483 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
5484 
    except TransactionServiceException, ex:
5485 
      result.ex = ex
5486 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
5487 
    result.write(oprot)
5488 
    oprot.writeMessageEnd()
5489 
    oprot.trans.flush()
4259 anupam.sin 5490 
 
4303 rajveer 5491 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
5492 
    args = markOrdersAsPORaised_args()
5493 
    args.read(iprot)
5494 
    iprot.readMessageEnd()
5495 
    result = markOrdersAsPORaised_result()
5496 
    try:
4369 rajveer 5497 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5498 
    except TransactionServiceException, ex:
5499 
      result.ex = ex
5500 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
5501 
    result.write(oprot)
5502 
    oprot.writeMessageEnd()
5503 
    oprot.trans.flush()
4285 rajveer 5504 
 
4303 rajveer 5505 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
5506 
    args = markOrdersAsReversalInitiated_args()
5507 
    args.read(iprot)
5508 
    iprot.readMessageEnd()
5509 
    result = markOrdersAsReversalInitiated_result()
5510 
    try:
4369 rajveer 5511 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5512 
    except TransactionServiceException, ex:
5513 
      result.ex = ex
5514 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
5515 
    result.write(oprot)
5516 
    oprot.writeMessageEnd()
5517 
    oprot.trans.flush()
5518 
 
5519 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
5520 
    args = markOrdersAsNotAvailabke_args()
5521 
    args.read(iprot)
5522 
    iprot.readMessageEnd()
5523 
    result = markOrdersAsNotAvailabke_result()
5524 
    try:
4369 rajveer 5525 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5526 
    except TransactionServiceException, ex:
5527 
      result.ex = ex
5528 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
5529 
    result.write(oprot)
5530 
    oprot.writeMessageEnd()
5531 
    oprot.trans.flush()
5532 
 
4369 rajveer 5533 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
5534 
    args = markOrdersAsTimeout_args()
5535 
    args.read(iprot)
5536 
    iprot.readMessageEnd()
5537 
    result = markOrdersAsTimeout_result()
5538 
    try:
5539 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
5540 
    except TransactionServiceException, ex:
5541 
      result.ex = ex
5542 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
5543 
    result.write(oprot)
5544 
    oprot.writeMessageEnd()
5545 
    oprot.trans.flush()
4303 rajveer 5546 
 
4662 rajveer 5547 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
5548 
    args = markOrderAsLostInTransit_args()
5549 
    args.read(iprot)
5550 
    iprot.readMessageEnd()
5551 
    result = markOrderAsLostInTransit_result()
5552 
    try:
5553 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
5554 
    except TransactionServiceException, ex:
5555 
      result.ex = ex
5556 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
5557 
    result.write(oprot)
5558 
    oprot.writeMessageEnd()
5559 
    oprot.trans.flush()
5560 
 
4386 anupam.sin 5561 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
5562 
    args = getOrderForAwb_args()
5563 
    args.read(iprot)
5564 
    iprot.readMessageEnd()
5565 
    result = getOrderForAwb_result()
5566 
    try:
5567 
      result.success = self._handler.getOrderForAwb(args.awb)
5568 
    except TransactionServiceException, ex:
5569 
      result.ex = ex
5570 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
5571 
    result.write(oprot)
5572 
    oprot.writeMessageEnd()
5573 
    oprot.trans.flush()
4369 rajveer 5574 
 
4506 phani.kuma 5575 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
5576 
    args = getOrdersForProviderForStatus_args()
5577 
    args.read(iprot)
5578 
    iprot.readMessageEnd()
5579 
    result = getOrdersForProviderForStatus_result()
5580 
    try:
5581 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
5582 
    except TransactionServiceException, ex:
5583 
      result.ex = ex
5584 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
5585 
    result.write(oprot)
5586 
    oprot.writeMessageEnd()
5587 
    oprot.trans.flush()
4386 anupam.sin 5588 
 
4600 varun.gupt 5589 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
5590 
    args = getBilledOrdersForVendor_args()
5591 
    args.read(iprot)
5592 
    iprot.readMessageEnd()
5593 
    result = getBilledOrdersForVendor_result()
5594 
    try:
5595 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
5596 
    except TransactionServiceException, ex:
5597 
      result.ex = ex
5598 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
5599 
    result.write(oprot)
5600 
    oprot.writeMessageEnd()
5601 
    oprot.trans.flush()
4506 phani.kuma 5602 
 
4607 rajveer 5603 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
5604 
    args = getSlippedSippingDateOrders_args()
5605 
    args.read(iprot)
5606 
    iprot.readMessageEnd()
5607 
    result = getSlippedSippingDateOrders_result()
5608 
    try:
5609 
      result.success = self._handler.getSlippedSippingDateOrders()
5610 
    except TransactionServiceException, ex:
5611 
      result.ex = ex
5612 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
5613 
    result.write(oprot)
5614 
    oprot.writeMessageEnd()
5615 
    oprot.trans.flush()
5616 
 
4709 rajveer 5617 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
5618 
    args = getCancelledOrders_args()
5619 
    args.read(iprot)
5620 
    iprot.readMessageEnd()
5621 
    result = getCancelledOrders_result()
5622 
    try:
5623 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
5624 
    except TransactionServiceException, ex:
5625 
      result.ex = ex
5626 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
5627 
    result.write(oprot)
5628 
    oprot.writeMessageEnd()
5629 
    oprot.trans.flush()
5630 
 
4600 varun.gupt 5631 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
5632 
    args = saveBluedartSettlements_args()
5633 
    args.read(iprot)
5634 
    iprot.readMessageEnd()
5635 
    result = saveBluedartSettlements_result()
5636 
    try:
5637 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
5638 
    except TransactionServiceException, ex:
5639 
      result.ex = ex
5640 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
5641 
    result.write(oprot)
5642 
    oprot.writeMessageEnd()
5643 
    oprot.trans.flush()
5644 
 
5645 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
5646 
    args = savePaymentSettlements_args()
5647 
    args.read(iprot)
5648 
    iprot.readMessageEnd()
5649 
    result = savePaymentSettlements_result()
5650 
    try:
5651 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.paymentId, args.serviceTax, args.otherCharges, args.netCollection)
5652 
    except TransactionServiceException, ex:
5653 
      result.ex = ex
5654 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
5655 
    result.write(oprot)
5656 
    oprot.writeMessageEnd()
5657 
    oprot.trans.flush()
5658 
 
5659 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
5660 
    args = saveEBSSettlementSummary_args()
5661 
    args.read(iprot)
5662 
    iprot.readMessageEnd()
5663 
    result = saveEBSSettlementSummary_result()
5664 
    try:
5665 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
5666 
    except TransactionServiceException, ex:
5667 
      result.ex = ex
5668 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
5669 
    result.write(oprot)
5670 
    oprot.writeMessageEnd()
5671 
    oprot.trans.flush()
5672 
 
5673 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
5674 
    args = getSettlementForPaymentId_args()
5675 
    args.read(iprot)
5676 
    iprot.readMessageEnd()
5677 
    result = getSettlementForPaymentId_result()
5678 
    try:
5679 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
5680 
    except TransactionServiceException, ex:
5681 
      result.ex = ex
5682 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
5683 
    result.write(oprot)
5684 
    oprot.writeMessageEnd()
5685 
    oprot.trans.flush()
5686 
 
5687 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
5688 
    args = getEBSSettlementSummaries_args()
5689 
    args.read(iprot)
5690 
    iprot.readMessageEnd()
5691 
    result = getEBSSettlementSummaries_result()
5692 
    try:
5693 
      result.success = self._handler.getEBSSettlementSummaries()
5694 
    except TransactionServiceException, ex:
5695 
      result.ex = ex
5696 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
5697 
    result.write(oprot)
5698 
    oprot.writeMessageEnd()
5699 
    oprot.trans.flush()
5700 
 
5701 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
5702 
    args = markEBSSettlementUploaded_args()
5703 
    args.read(iprot)
5704 
    iprot.readMessageEnd()
5705 
    result = markEBSSettlementUploaded_result()
5706 
    try:
5707 
      self._handler.markEBSSettlementUploaded(args.settlementId)
5708 
    except TransactionServiceException, ex:
5709 
      result.ex = ex
5710 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
5711 
    result.write(oprot)
5712 
    oprot.writeMessageEnd()
5713 
    oprot.trans.flush()
5714 
 
5715 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
5716 
    args = getEBSSettlementDate_args()
5717 
    args.read(iprot)
5718 
    iprot.readMessageEnd()
5719 
    result = getEBSSettlementDate_result()
5720 
    try:
5721 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
5722 
    except TransactionServiceException, ex:
5723 
      result.ex = ex
5724 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
5725 
    result.write(oprot)
5726 
    oprot.writeMessageEnd()
5727 
    oprot.trans.flush()
5728 
 
4715 varun.gupt 5729 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
5730 
    args = getSettlementsByDate_args()
5731 
    args.read(iprot)
5732 
    iprot.readMessageEnd()
5733 
    result = getSettlementsByDate_result()
5734 
    try:
5735 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
5736 
    except TransactionServiceException, ex:
5737 
      result.ex = ex
5738 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
5739 
    result.write(oprot)
5740 
    oprot.writeMessageEnd()
5741 
    oprot.trans.flush()
4600 varun.gupt 5742 
 
4715 varun.gupt 5743 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
5744 
    args = getReshippedOrderIds_args()
5745 
    args.read(iprot)
5746 
    iprot.readMessageEnd()
5747 
    result = getReshippedOrderIds_result()
5748 
    try:
5749 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
5750 
    except TransactionServiceException, ex:
5751 
      result.ex = ex
5752 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
5753 
    result.write(oprot)
5754 
    oprot.writeMessageEnd()
5755 
    oprot.trans.flush()
5756 
 
5757 
 
94 ashish 5758 
# HELPER FUNCTIONS AND STRUCTURES
5759 
 
5760 
class createTransaction_args:
5761 
  """
5762 
  Attributes:
5763 
   - transaction
5764 
  """
5765 
 
5766 
  thrift_spec = (
5767 
    None, # 0
5768 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
5769 
  )
5770 
 
5771 
  def __init__(self, transaction=None,):
5772 
    self.transaction = transaction
5773 
 
5774 
  def read(self, iprot):
5775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5777 
      return
5778 
    iprot.readStructBegin()
5779 
    while True:
5780 
      (fname, ftype, fid) = iprot.readFieldBegin()
5781 
      if ftype == TType.STOP:
5782 
        break
5783 
      if fid == 1:
5784 
        if ftype == TType.STRUCT:
5785 
          self.transaction = Transaction()
5786 
          self.transaction.read(iprot)
5787 
        else:
5788 
          iprot.skip(ftype)
5789 
      else:
5790 
        iprot.skip(ftype)
5791 
      iprot.readFieldEnd()
5792 
    iprot.readStructEnd()
5793 
 
5794 
  def write(self, oprot):
5795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5797 
      return
5798 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 5799 
    if self.transaction is not None:
94 ashish 5800 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5801 
      self.transaction.write(oprot)
5802 
      oprot.writeFieldEnd()
5803 
    oprot.writeFieldStop()
5804 
    oprot.writeStructEnd()
5805 
 
3431 rajveer 5806 
  def validate(self):
5807 
    return
5808 
 
5809 
 
94 ashish 5810 
  def __repr__(self):
5811 
    L = ['%s=%r' % (key, value)
5812 
      for key, value in self.__dict__.iteritems()]
5813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5814 
 
5815 
  def __eq__(self, other):
5816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5817 
 
5818 
  def __ne__(self, other):
5819 
    return not (self == other)
5820 
 
5821 
class createTransaction_result:
5822 
  """
5823 
  Attributes:
132 ashish 5824 
   - success
94 ashish 5825 
   - ex
5826 
  """
5827 
 
5828 
  thrift_spec = (
132 ashish 5829 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5830 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5831 
  )
5832 
 
132 ashish 5833 
  def __init__(self, success=None, ex=None,):
5834 
    self.success = success
94 ashish 5835 
    self.ex = ex
5836 
 
5837 
  def read(self, iprot):
5838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5840 
      return
5841 
    iprot.readStructBegin()
5842 
    while True:
5843 
      (fname, ftype, fid) = iprot.readFieldBegin()
5844 
      if ftype == TType.STOP:
5845 
        break
132 ashish 5846 
      if fid == 0:
5847 
        if ftype == TType.I64:
5848 
          self.success = iprot.readI64();
5849 
        else:
5850 
          iprot.skip(ftype)
5851 
      elif fid == 1:
94 ashish 5852 
        if ftype == TType.STRUCT:
5853 
          self.ex = TransactionServiceException()
5854 
          self.ex.read(iprot)
5855 
        else:
5856 
          iprot.skip(ftype)
5857 
      else:
5858 
        iprot.skip(ftype)
5859 
      iprot.readFieldEnd()
5860 
    iprot.readStructEnd()
5861 
 
5862 
  def write(self, oprot):
5863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5865 
      return
5866 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5867 
    if self.success is not None:
132 ashish 5868 
      oprot.writeFieldBegin('success', TType.I64, 0)
5869 
      oprot.writeI64(self.success)
5870 
      oprot.writeFieldEnd()
3431 rajveer 5871 
    if self.ex is not None:
94 ashish 5872 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5873 
      self.ex.write(oprot)
5874 
      oprot.writeFieldEnd()
5875 
    oprot.writeFieldStop()
5876 
    oprot.writeStructEnd()
5877 
 
3431 rajveer 5878 
  def validate(self):
5879 
    return
5880 
 
5881 
 
94 ashish 5882 
  def __repr__(self):
5883 
    L = ['%s=%r' % (key, value)
5884 
      for key, value in self.__dict__.iteritems()]
5885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5886 
 
5887 
  def __eq__(self, other):
5888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5889 
 
5890 
  def __ne__(self, other):
5891 
    return not (self == other)
5892 
 
5893 
class getTransaction_args:
5894 
  """
5895 
  Attributes:
5896 
   - id
5897 
  """
5898 
 
5899 
  thrift_spec = (
5900 
    None, # 0
5901 
    (1, TType.I64, 'id', None, None, ), # 1
5902 
  )
5903 
 
5904 
  def __init__(self, id=None,):
5905 
    self.id = id
5906 
 
5907 
  def read(self, iprot):
5908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5910 
      return
5911 
    iprot.readStructBegin()
5912 
    while True:
5913 
      (fname, ftype, fid) = iprot.readFieldBegin()
5914 
      if ftype == TType.STOP:
5915 
        break
5916 
      if fid == 1:
5917 
        if ftype == TType.I64:
5918 
          self.id = iprot.readI64();
5919 
        else:
5920 
          iprot.skip(ftype)
5921 
      else:
5922 
        iprot.skip(ftype)
5923 
      iprot.readFieldEnd()
5924 
    iprot.readStructEnd()
5925 
 
5926 
  def write(self, oprot):
5927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5929 
      return
5930 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 5931 
    if self.id is not None:
94 ashish 5932 
      oprot.writeFieldBegin('id', TType.I64, 1)
5933 
      oprot.writeI64(self.id)
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_result:
5954 
  """
5955 
  Attributes:
5956 
   - success
5957 
   - ex
5958 
  """
5959 
 
5960 
  thrift_spec = (
5961 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
5962 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5963 
  )
5964 
 
5965 
  def __init__(self, success=None, ex=None,):
5966 
    self.success = success
5967 
    self.ex = ex
5968 
 
5969 
  def read(self, iprot):
5970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5972 
      return
5973 
    iprot.readStructBegin()
5974 
    while True:
5975 
      (fname, ftype, fid) = iprot.readFieldBegin()
5976 
      if ftype == TType.STOP:
5977 
        break
5978 
      if fid == 0:
5979 
        if ftype == TType.STRUCT:
5980 
          self.success = Transaction()
5981 
          self.success.read(iprot)
5982 
        else:
5983 
          iprot.skip(ftype)
5984 
      elif fid == 1:
5985 
        if ftype == TType.STRUCT:
5986 
          self.ex = TransactionServiceException()
5987 
          self.ex.read(iprot)
5988 
        else:
5989 
          iprot.skip(ftype)
5990 
      else:
5991 
        iprot.skip(ftype)
5992 
      iprot.readFieldEnd()
5993 
    iprot.readStructEnd()
5994 
 
5995 
  def write(self, oprot):
5996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5998 
      return
5999 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6000 
    if self.success is not None:
94 ashish 6001 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6002 
      self.success.write(oprot)
6003 
      oprot.writeFieldEnd()
3431 rajveer 6004 
    if self.ex is not None:
94 ashish 6005 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6006 
      self.ex.write(oprot)
6007 
      oprot.writeFieldEnd()
6008 
    oprot.writeFieldStop()
6009 
    oprot.writeStructEnd()
6010 
 
3431 rajveer 6011 
  def validate(self):
6012 
    return
6013 
 
6014 
 
94 ashish 6015 
  def __repr__(self):
6016 
    L = ['%s=%r' % (key, value)
6017 
      for key, value in self.__dict__.iteritems()]
6018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6019 
 
6020 
  def __eq__(self, other):
6021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6022 
 
6023 
  def __ne__(self, other):
6024 
    return not (self == other)
6025 
 
6026 
class getTransactionsForCustomer_args:
6027 
  """
6028 
  Attributes:
6029 
   - customerId
6030 
   - from_date
6031 
   - to_date
6032 
   - status
6033 
  """
6034 
 
6035 
  thrift_spec = (
6036 
    None, # 0
6037 
    (1, TType.I64, 'customerId', None, None, ), # 1
6038 
    (2, TType.I64, 'from_date', None, None, ), # 2
6039 
    (3, TType.I64, 'to_date', None, None, ), # 3
6040 
    (4, TType.I32, 'status', None, None, ), # 4
6041 
  )
6042 
 
6043 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6044 
    self.customerId = customerId
6045 
    self.from_date = from_date
6046 
    self.to_date = to_date
6047 
    self.status = status
6048 
 
6049 
  def read(self, iprot):
6050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6052 
      return
6053 
    iprot.readStructBegin()
6054 
    while True:
6055 
      (fname, ftype, fid) = iprot.readFieldBegin()
6056 
      if ftype == TType.STOP:
6057 
        break
6058 
      if fid == 1:
6059 
        if ftype == TType.I64:
6060 
          self.customerId = iprot.readI64();
6061 
        else:
6062 
          iprot.skip(ftype)
6063 
      elif fid == 2:
6064 
        if ftype == TType.I64:
6065 
          self.from_date = iprot.readI64();
6066 
        else:
6067 
          iprot.skip(ftype)
6068 
      elif fid == 3:
6069 
        if ftype == TType.I64:
6070 
          self.to_date = iprot.readI64();
6071 
        else:
6072 
          iprot.skip(ftype)
6073 
      elif fid == 4:
6074 
        if ftype == TType.I32:
6075 
          self.status = iprot.readI32();
6076 
        else:
6077 
          iprot.skip(ftype)
6078 
      else:
6079 
        iprot.skip(ftype)
6080 
      iprot.readFieldEnd()
6081 
    iprot.readStructEnd()
6082 
 
6083 
  def write(self, oprot):
6084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6086 
      return
6087 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6088 
    if self.customerId is not None:
94 ashish 6089 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6090 
      oprot.writeI64(self.customerId)
6091 
      oprot.writeFieldEnd()
3431 rajveer 6092 
    if self.from_date is not None:
94 ashish 6093 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6094 
      oprot.writeI64(self.from_date)
6095 
      oprot.writeFieldEnd()
3431 rajveer 6096 
    if self.to_date is not None:
94 ashish 6097 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6098 
      oprot.writeI64(self.to_date)
6099 
      oprot.writeFieldEnd()
3431 rajveer 6100 
    if self.status is not None:
94 ashish 6101 
      oprot.writeFieldBegin('status', TType.I32, 4)
6102 
      oprot.writeI32(self.status)
6103 
      oprot.writeFieldEnd()
6104 
    oprot.writeFieldStop()
6105 
    oprot.writeStructEnd()
6106 
 
3431 rajveer 6107 
  def validate(self):
6108 
    return
6109 
 
6110 
 
94 ashish 6111 
  def __repr__(self):
6112 
    L = ['%s=%r' % (key, value)
6113 
      for key, value in self.__dict__.iteritems()]
6114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6115 
 
6116 
  def __eq__(self, other):
6117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6118 
 
6119 
  def __ne__(self, other):
6120 
    return not (self == other)
6121 
 
6122 
class getTransactionsForCustomer_result:
6123 
  """
6124 
  Attributes:
6125 
   - success
6126 
   - ex
6127 
  """
6128 
 
6129 
  thrift_spec = (
6130 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6131 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6132 
  )
6133 
 
6134 
  def __init__(self, success=None, ex=None,):
6135 
    self.success = success
6136 
    self.ex = ex
6137 
 
6138 
  def read(self, iprot):
6139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6141 
      return
6142 
    iprot.readStructBegin()
6143 
    while True:
6144 
      (fname, ftype, fid) = iprot.readFieldBegin()
6145 
      if ftype == TType.STOP:
6146 
        break
6147 
      if fid == 0:
6148 
        if ftype == TType.LIST:
6149 
          self.success = []
685 chandransh 6150 
          (_etype17, _size14) = iprot.readListBegin()
6151 
          for _i18 in xrange(_size14):
6152 
            _elem19 = Transaction()
6153 
            _elem19.read(iprot)
6154 
            self.success.append(_elem19)
94 ashish 6155 
          iprot.readListEnd()
6156 
        else:
6157 
          iprot.skip(ftype)
6158 
      elif fid == 1:
6159 
        if ftype == TType.STRUCT:
6160 
          self.ex = TransactionServiceException()
6161 
          self.ex.read(iprot)
6162 
        else:
6163 
          iprot.skip(ftype)
6164 
      else:
6165 
        iprot.skip(ftype)
6166 
      iprot.readFieldEnd()
6167 
    iprot.readStructEnd()
6168 
 
6169 
  def write(self, oprot):
6170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6172 
      return
6173 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6174 
    if self.success is not None:
94 ashish 6175 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6176 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6177 
      for iter20 in self.success:
6178 
        iter20.write(oprot)
94 ashish 6179 
      oprot.writeListEnd()
6180 
      oprot.writeFieldEnd()
3431 rajveer 6181 
    if self.ex is not None:
94 ashish 6182 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6183 
      self.ex.write(oprot)
6184 
      oprot.writeFieldEnd()
6185 
    oprot.writeFieldStop()
6186 
    oprot.writeStructEnd()
6187 
 
3431 rajveer 6188 
  def validate(self):
6189 
    return
6190 
 
6191 
 
94 ashish 6192 
  def __repr__(self):
6193 
    L = ['%s=%r' % (key, value)
6194 
      for key, value in self.__dict__.iteritems()]
6195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6196 
 
6197 
  def __eq__(self, other):
6198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6199 
 
6200 
  def __ne__(self, other):
6201 
    return not (self == other)
6202 
 
132 ashish 6203 
class getTransactionsForShoppingCartId_args:
6204 
  """
6205 
  Attributes:
6206 
   - shoppingCartId
6207 
  """
6208 
 
6209 
  thrift_spec = (
6210 
    None, # 0
6211 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
6212 
  )
6213 
 
6214 
  def __init__(self, shoppingCartId=None,):
6215 
    self.shoppingCartId = shoppingCartId
6216 
 
6217 
  def read(self, iprot):
6218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6220 
      return
6221 
    iprot.readStructBegin()
6222 
    while True:
6223 
      (fname, ftype, fid) = iprot.readFieldBegin()
6224 
      if ftype == TType.STOP:
6225 
        break
6226 
      if fid == 1:
6227 
        if ftype == TType.I64:
6228 
          self.shoppingCartId = iprot.readI64();
6229 
        else:
6230 
          iprot.skip(ftype)
6231 
      else:
6232 
        iprot.skip(ftype)
6233 
      iprot.readFieldEnd()
6234 
    iprot.readStructEnd()
6235 
 
6236 
  def write(self, oprot):
6237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6239 
      return
6240 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 6241 
    if self.shoppingCartId is not None:
132 ashish 6242 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
6243 
      oprot.writeI64(self.shoppingCartId)
6244 
      oprot.writeFieldEnd()
6245 
    oprot.writeFieldStop()
6246 
    oprot.writeStructEnd()
6247 
 
3431 rajveer 6248 
  def validate(self):
6249 
    return
6250 
 
6251 
 
132 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 
 
6263 
class getTransactionsForShoppingCartId_result:
6264 
  """
6265 
  Attributes:
6266 
   - success
6267 
   - ex
6268 
  """
6269 
 
6270 
  thrift_spec = (
6271 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6272 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6273 
  )
6274 
 
6275 
  def __init__(self, success=None, ex=None,):
6276 
    self.success = success
6277 
    self.ex = ex
6278 
 
6279 
  def read(self, iprot):
6280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6282 
      return
6283 
    iprot.readStructBegin()
6284 
    while True:
6285 
      (fname, ftype, fid) = iprot.readFieldBegin()
6286 
      if ftype == TType.STOP:
6287 
        break
6288 
      if fid == 0:
6289 
        if ftype == TType.LIST:
6290 
          self.success = []
685 chandransh 6291 
          (_etype24, _size21) = iprot.readListBegin()
6292 
          for _i25 in xrange(_size21):
6293 
            _elem26 = Transaction()
6294 
            _elem26.read(iprot)
6295 
            self.success.append(_elem26)
132 ashish 6296 
          iprot.readListEnd()
6297 
        else:
6298 
          iprot.skip(ftype)
6299 
      elif fid == 1:
6300 
        if ftype == TType.STRUCT:
6301 
          self.ex = TransactionServiceException()
6302 
          self.ex.read(iprot)
6303 
        else:
6304 
          iprot.skip(ftype)
6305 
      else:
6306 
        iprot.skip(ftype)
6307 
      iprot.readFieldEnd()
6308 
    iprot.readStructEnd()
6309 
 
6310 
  def write(self, oprot):
6311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6313 
      return
6314 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 6315 
    if self.success is not None:
132 ashish 6316 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6317 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6318 
      for iter27 in self.success:
6319 
        iter27.write(oprot)
132 ashish 6320 
      oprot.writeListEnd()
6321 
      oprot.writeFieldEnd()
3431 rajveer 6322 
    if self.ex is not None:
132 ashish 6323 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6324 
      self.ex.write(oprot)
6325 
      oprot.writeFieldEnd()
6326 
    oprot.writeFieldStop()
6327 
    oprot.writeStructEnd()
6328 
 
3431 rajveer 6329 
  def validate(self):
6330 
    return
6331 
 
6332 
 
132 ashish 6333 
  def __repr__(self):
6334 
    L = ['%s=%r' % (key, value)
6335 
      for key, value in self.__dict__.iteritems()]
6336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6337 
 
6338 
  def __eq__(self, other):
6339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6340 
 
6341 
  def __ne__(self, other):
6342 
    return not (self == other)
6343 
 
94 ashish 6344 
class getTransactionStatus_args:
6345 
  """
6346 
  Attributes:
6347 
   - transactionId
6348 
  """
6349 
 
6350 
  thrift_spec = (
6351 
    None, # 0
6352 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6353 
  )
6354 
 
6355 
  def __init__(self, transactionId=None,):
6356 
    self.transactionId = transactionId
6357 
 
6358 
  def read(self, iprot):
6359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6361 
      return
6362 
    iprot.readStructBegin()
6363 
    while True:
6364 
      (fname, ftype, fid) = iprot.readFieldBegin()
6365 
      if ftype == TType.STOP:
6366 
        break
6367 
      if fid == 1:
6368 
        if ftype == TType.I64:
6369 
          self.transactionId = iprot.readI64();
6370 
        else:
6371 
          iprot.skip(ftype)
6372 
      else:
6373 
        iprot.skip(ftype)
6374 
      iprot.readFieldEnd()
6375 
    iprot.readStructEnd()
6376 
 
6377 
  def write(self, oprot):
6378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6380 
      return
6381 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6382 
    if self.transactionId is not None:
94 ashish 6383 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6384 
      oprot.writeI64(self.transactionId)
6385 
      oprot.writeFieldEnd()
6386 
    oprot.writeFieldStop()
6387 
    oprot.writeStructEnd()
6388 
 
3431 rajveer 6389 
  def validate(self):
6390 
    return
6391 
 
6392 
 
94 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 
 
6404 
class getTransactionStatus_result:
6405 
  """
6406 
  Attributes:
6407 
   - success
6408 
   - ex
6409 
  """
6410 
 
6411 
  thrift_spec = (
6412 
    (0, TType.I32, 'success', None, None, ), # 0
6413 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6414 
  )
6415 
 
6416 
  def __init__(self, success=None, ex=None,):
6417 
    self.success = success
6418 
    self.ex = ex
6419 
 
6420 
  def read(self, iprot):
6421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6423 
      return
6424 
    iprot.readStructBegin()
6425 
    while True:
6426 
      (fname, ftype, fid) = iprot.readFieldBegin()
6427 
      if ftype == TType.STOP:
6428 
        break
6429 
      if fid == 0:
6430 
        if ftype == TType.I32:
6431 
          self.success = iprot.readI32();
6432 
        else:
6433 
          iprot.skip(ftype)
6434 
      elif fid == 1:
6435 
        if ftype == TType.STRUCT:
6436 
          self.ex = TransactionServiceException()
6437 
          self.ex.read(iprot)
6438 
        else:
6439 
          iprot.skip(ftype)
6440 
      else:
6441 
        iprot.skip(ftype)
6442 
      iprot.readFieldEnd()
6443 
    iprot.readStructEnd()
6444 
 
6445 
  def write(self, oprot):
6446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6448 
      return
6449 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 6450 
    if self.success is not None:
94 ashish 6451 
      oprot.writeFieldBegin('success', TType.I32, 0)
6452 
      oprot.writeI32(self.success)
6453 
      oprot.writeFieldEnd()
3431 rajveer 6454 
    if self.ex is not None:
94 ashish 6455 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6456 
      self.ex.write(oprot)
6457 
      oprot.writeFieldEnd()
6458 
    oprot.writeFieldStop()
6459 
    oprot.writeStructEnd()
6460 
 
3431 rajveer 6461 
  def validate(self):
6462 
    return
6463 
 
6464 
 
94 ashish 6465 
  def __repr__(self):
6466 
    L = ['%s=%r' % (key, value)
6467 
      for key, value in self.__dict__.iteritems()]
6468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6469 
 
6470 
  def __eq__(self, other):
6471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6472 
 
6473 
  def __ne__(self, other):
6474 
    return not (self == other)
6475 
 
6476 
class changeTransactionStatus_args:
6477 
  """
6478 
  Attributes:
6479 
   - transactionId
6480 
   - status
6481 
   - description
6482 
  """
6483 
 
6484 
  thrift_spec = (
6485 
    None, # 0
6486 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6487 
    (2, TType.I32, 'status', None, None, ), # 2
6488 
    (3, TType.STRING, 'description', None, None, ), # 3
6489 
  )
6490 
 
6491 
  def __init__(self, transactionId=None, status=None, description=None,):
6492 
    self.transactionId = transactionId
6493 
    self.status = status
6494 
    self.description = description
6495 
 
6496 
  def read(self, iprot):
6497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6499 
      return
6500 
    iprot.readStructBegin()
6501 
    while True:
6502 
      (fname, ftype, fid) = iprot.readFieldBegin()
6503 
      if ftype == TType.STOP:
6504 
        break
6505 
      if fid == 1:
6506 
        if ftype == TType.I64:
6507 
          self.transactionId = iprot.readI64();
6508 
        else:
6509 
          iprot.skip(ftype)
6510 
      elif fid == 2:
6511 
        if ftype == TType.I32:
6512 
          self.status = iprot.readI32();
6513 
        else:
6514 
          iprot.skip(ftype)
6515 
      elif fid == 3:
6516 
        if ftype == TType.STRING:
6517 
          self.description = iprot.readString();
6518 
        else:
6519 
          iprot.skip(ftype)
6520 
      else:
6521 
        iprot.skip(ftype)
6522 
      iprot.readFieldEnd()
6523 
    iprot.readStructEnd()
6524 
 
6525 
  def write(self, oprot):
6526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6528 
      return
6529 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 6530 
    if self.transactionId is not None:
94 ashish 6531 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6532 
      oprot.writeI64(self.transactionId)
6533 
      oprot.writeFieldEnd()
3431 rajveer 6534 
    if self.status is not None:
94 ashish 6535 
      oprot.writeFieldBegin('status', TType.I32, 2)
6536 
      oprot.writeI32(self.status)
6537 
      oprot.writeFieldEnd()
3431 rajveer 6538 
    if self.description is not None:
94 ashish 6539 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6540 
      oprot.writeString(self.description)
6541 
      oprot.writeFieldEnd()
6542 
    oprot.writeFieldStop()
6543 
    oprot.writeStructEnd()
6544 
 
3431 rajveer 6545 
  def validate(self):
6546 
    return
6547 
 
6548 
 
94 ashish 6549 
  def __repr__(self):
6550 
    L = ['%s=%r' % (key, value)
6551 
      for key, value in self.__dict__.iteritems()]
6552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6553 
 
6554 
  def __eq__(self, other):
6555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6556 
 
6557 
  def __ne__(self, other):
6558 
    return not (self == other)
6559 
 
6560 
class changeTransactionStatus_result:
6561 
  """
6562 
  Attributes:
6563 
   - success
6564 
   - ex
6565 
  """
6566 
 
6567 
  thrift_spec = (
6568 
    (0, TType.BOOL, 'success', None, None, ), # 0
6569 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6570 
  )
6571 
 
6572 
  def __init__(self, success=None, ex=None,):
6573 
    self.success = success
6574 
    self.ex = ex
6575 
 
6576 
  def read(self, iprot):
6577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6579 
      return
6580 
    iprot.readStructBegin()
6581 
    while True:
6582 
      (fname, ftype, fid) = iprot.readFieldBegin()
6583 
      if ftype == TType.STOP:
6584 
        break
6585 
      if fid == 0:
6586 
        if ftype == TType.BOOL:
6587 
          self.success = iprot.readBool();
6588 
        else:
6589 
          iprot.skip(ftype)
6590 
      elif fid == 1:
6591 
        if ftype == TType.STRUCT:
6592 
          self.ex = TransactionServiceException()
6593 
          self.ex.read(iprot)
6594 
        else:
6595 
          iprot.skip(ftype)
6596 
      else:
6597 
        iprot.skip(ftype)
6598 
      iprot.readFieldEnd()
6599 
    iprot.readStructEnd()
6600 
 
6601 
  def write(self, oprot):
6602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6604 
      return
6605 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 6606 
    if self.success is not None:
94 ashish 6607 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6608 
      oprot.writeBool(self.success)
6609 
      oprot.writeFieldEnd()
3431 rajveer 6610 
    if self.ex is not None:
94 ashish 6611 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6612 
      self.ex.write(oprot)
6613 
      oprot.writeFieldEnd()
6614 
    oprot.writeFieldStop()
6615 
    oprot.writeStructEnd()
6616 
 
3431 rajveer 6617 
  def validate(self):
6618 
    return
6619 
 
6620 
 
94 ashish 6621 
  def __repr__(self):
6622 
    L = ['%s=%r' % (key, value)
6623 
      for key, value in self.__dict__.iteritems()]
6624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6625 
 
6626 
  def __eq__(self, other):
6627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6628 
 
6629 
  def __ne__(self, other):
6630 
    return not (self == other)
6631 
 
1398 varun.gupt 6632 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 6633 
  """
6634 
  Attributes:
6635 
   - transactionId
6636 
  """
6637 
 
6638 
  thrift_spec = (
6639 
    None, # 0
6640 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6641 
  )
6642 
 
6643 
  def __init__(self, transactionId=None,):
6644 
    self.transactionId = transactionId
6645 
 
6646 
  def read(self, iprot):
6647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6649 
      return
6650 
    iprot.readStructBegin()
6651 
    while True:
6652 
      (fname, ftype, fid) = iprot.readFieldBegin()
6653 
      if ftype == TType.STOP:
6654 
        break
6655 
      if fid == 1:
6656 
        if ftype == TType.I64:
6657 
          self.transactionId = iprot.readI64();
6658 
        else:
6659 
          iprot.skip(ftype)
6660 
      else:
6661 
        iprot.skip(ftype)
6662 
      iprot.readFieldEnd()
6663 
    iprot.readStructEnd()
6664 
 
6665 
  def write(self, oprot):
6666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6668 
      return
1398 varun.gupt 6669 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 6670 
    if self.transactionId is not None:
1382 varun.gupt 6671 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6672 
      oprot.writeI64(self.transactionId)
6673 
      oprot.writeFieldEnd()
6674 
    oprot.writeFieldStop()
6675 
    oprot.writeStructEnd()
6676 
 
3431 rajveer 6677 
  def validate(self):
6678 
    return
6679 
 
6680 
 
1382 varun.gupt 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_result:
1382 varun.gupt 6693 
  """
6694 
  Attributes:
6695 
   - success
6696 
   - ex
6697 
  """
6698 
 
6699 
  thrift_spec = (
6700 
    (0, TType.BOOL, 'success', None, None, ), # 0
6701 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6702 
  )
6703 
 
6704 
  def __init__(self, success=None, ex=None,):
6705 
    self.success = success
6706 
    self.ex = ex
6707 
 
6708 
  def read(self, iprot):
6709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6711 
      return
6712 
    iprot.readStructBegin()
6713 
    while True:
6714 
      (fname, ftype, fid) = iprot.readFieldBegin()
6715 
      if ftype == TType.STOP:
6716 
        break
6717 
      if fid == 0:
6718 
        if ftype == TType.BOOL:
6719 
          self.success = iprot.readBool();
6720 
        else:
6721 
          iprot.skip(ftype)
6722 
      elif fid == 1:
6723 
        if ftype == TType.STRUCT:
6724 
          self.ex = TransactionServiceException()
6725 
          self.ex.read(iprot)
6726 
        else:
6727 
          iprot.skip(ftype)
6728 
      else:
6729 
        iprot.skip(ftype)
6730 
      iprot.readFieldEnd()
6731 
    iprot.readStructEnd()
6732 
 
6733 
  def write(self, oprot):
6734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6736 
      return
1398 varun.gupt 6737 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 6738 
    if self.success is not None:
1382 varun.gupt 6739 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6740 
      oprot.writeBool(self.success)
6741 
      oprot.writeFieldEnd()
3431 rajveer 6742 
    if self.ex is not None:
1382 varun.gupt 6743 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6744 
      self.ex.write(oprot)
6745 
      oprot.writeFieldEnd()
6746 
    oprot.writeFieldStop()
6747 
    oprot.writeStructEnd()
6748 
 
3431 rajveer 6749 
  def validate(self):
6750 
    return
6751 
 
6752 
 
1382 varun.gupt 6753 
  def __repr__(self):
6754 
    L = ['%s=%r' % (key, value)
6755 
      for key, value in self.__dict__.iteritems()]
6756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6757 
 
6758 
  def __eq__(self, other):
6759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6760 
 
6761 
  def __ne__(self, other):
6762 
    return not (self == other)
6763 
 
483 rajveer 6764 
class getAllOrders_args:
94 ashish 6765 
  """
6766 
  Attributes:
483 rajveer 6767 
   - status
6768 
   - from_date
6769 
   - to_date
6770 
   - warehouse_id
94 ashish 6771 
  """
6772 
 
6773 
  thrift_spec = (
6774 
    None, # 0
483 rajveer 6775 
    (1, TType.I32, 'status', None, None, ), # 1
6776 
    (2, TType.I64, 'from_date', None, None, ), # 2
6777 
    (3, TType.I64, 'to_date', None, None, ), # 3
6778 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 6779 
  )
6780 
 
483 rajveer 6781 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
6782 
    self.status = status
6783 
    self.from_date = from_date
6784 
    self.to_date = to_date
6785 
    self.warehouse_id = warehouse_id
94 ashish 6786 
 
6787 
  def read(self, iprot):
6788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6790 
      return
6791 
    iprot.readStructBegin()
6792 
    while True:
6793 
      (fname, ftype, fid) = iprot.readFieldBegin()
6794 
      if ftype == TType.STOP:
6795 
        break
6796 
      if fid == 1:
483 rajveer 6797 
        if ftype == TType.I32:
6798 
          self.status = iprot.readI32();
94 ashish 6799 
        else:
6800 
          iprot.skip(ftype)
483 rajveer 6801 
      elif fid == 2:
6802 
        if ftype == TType.I64:
6803 
          self.from_date = iprot.readI64();
94 ashish 6804 
        else:
6805 
          iprot.skip(ftype)
483 rajveer 6806 
      elif fid == 3:
6807 
        if ftype == TType.I64:
6808 
          self.to_date = iprot.readI64();
94 ashish 6809 
        else:
6810 
          iprot.skip(ftype)
483 rajveer 6811 
      elif fid == 4:
94 ashish 6812 
        if ftype == TType.I64:
483 rajveer 6813 
          self.warehouse_id = iprot.readI64();
94 ashish 6814 
        else:
6815 
          iprot.skip(ftype)
6816 
      else:
6817 
        iprot.skip(ftype)
6818 
      iprot.readFieldEnd()
6819 
    iprot.readStructEnd()
6820 
 
6821 
  def write(self, oprot):
6822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6824 
      return
483 rajveer 6825 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 6826 
    if self.status is not None:
483 rajveer 6827 
      oprot.writeFieldBegin('status', TType.I32, 1)
6828 
      oprot.writeI32(self.status)
94 ashish 6829 
      oprot.writeFieldEnd()
3431 rajveer 6830 
    if self.from_date is not None:
483 rajveer 6831 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6832 
      oprot.writeI64(self.from_date)
94 ashish 6833 
      oprot.writeFieldEnd()
3431 rajveer 6834 
    if self.to_date is not None:
483 rajveer 6835 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6836 
      oprot.writeI64(self.to_date)
94 ashish 6837 
      oprot.writeFieldEnd()
3431 rajveer 6838 
    if self.warehouse_id is not None:
483 rajveer 6839 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6840 
      oprot.writeI64(self.warehouse_id)
94 ashish 6841 
      oprot.writeFieldEnd()
6842 
    oprot.writeFieldStop()
6843 
    oprot.writeStructEnd()
6844 
 
3431 rajveer 6845 
  def validate(self):
6846 
    return
6847 
 
6848 
 
94 ashish 6849 
  def __repr__(self):
6850 
    L = ['%s=%r' % (key, value)
6851 
      for key, value in self.__dict__.iteritems()]
6852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6853 
 
6854 
  def __eq__(self, other):
6855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6856 
 
6857 
  def __ne__(self, other):
6858 
    return not (self == other)
6859 
 
483 rajveer 6860 
class getAllOrders_result:
94 ashish 6861 
  """
6862 
  Attributes:
6863 
   - success
6864 
   - ex
6865 
  """
6866 
 
6867 
  thrift_spec = (
483 rajveer 6868 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6869 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6870 
  )
6871 
 
6872 
  def __init__(self, success=None, ex=None,):
6873 
    self.success = success
6874 
    self.ex = ex
6875 
 
6876 
  def read(self, iprot):
6877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6879 
      return
6880 
    iprot.readStructBegin()
6881 
    while True:
6882 
      (fname, ftype, fid) = iprot.readFieldBegin()
6883 
      if ftype == TType.STOP:
6884 
        break
6885 
      if fid == 0:
483 rajveer 6886 
        if ftype == TType.LIST:
6887 
          self.success = []
685 chandransh 6888 
          (_etype31, _size28) = iprot.readListBegin()
6889 
          for _i32 in xrange(_size28):
6890 
            _elem33 = Order()
6891 
            _elem33.read(iprot)
6892 
            self.success.append(_elem33)
483 rajveer 6893 
          iprot.readListEnd()
94 ashish 6894 
        else:
6895 
          iprot.skip(ftype)
6896 
      elif fid == 1:
6897 
        if ftype == TType.STRUCT:
6898 
          self.ex = TransactionServiceException()
6899 
          self.ex.read(iprot)
6900 
        else:
6901 
          iprot.skip(ftype)
6902 
      else:
6903 
        iprot.skip(ftype)
6904 
      iprot.readFieldEnd()
6905 
    iprot.readStructEnd()
6906 
 
6907 
  def write(self, oprot):
6908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6910 
      return
483 rajveer 6911 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 6912 
    if self.success is not None:
483 rajveer 6913 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6914 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6915 
      for iter34 in self.success:
6916 
        iter34.write(oprot)
483 rajveer 6917 
      oprot.writeListEnd()
94 ashish 6918 
      oprot.writeFieldEnd()
3431 rajveer 6919 
    if self.ex is not None:
94 ashish 6920 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6921 
      self.ex.write(oprot)
6922 
      oprot.writeFieldEnd()
6923 
    oprot.writeFieldStop()
6924 
    oprot.writeStructEnd()
6925 
 
3431 rajveer 6926 
  def validate(self):
6927 
    return
6928 
 
6929 
 
94 ashish 6930 
  def __repr__(self):
6931 
    L = ['%s=%r' % (key, value)
6932 
      for key, value in self.__dict__.iteritems()]
6933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6934 
 
6935 
  def __eq__(self, other):
6936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6937 
 
6938 
  def __ne__(self, other):
6939 
    return not (self == other)
6940 
 
4133 chandransh 6941 
class getOrdersInBatch_args:
6942 
  """
6943 
  Attributes:
6944 
   - statuses
6945 
   - offset
6946 
   - limit
6947 
   - warehouse_id
6948 
  """
6949 
 
6950 
  thrift_spec = (
6951 
    None, # 0
6952 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6953 
    (2, TType.I64, 'offset', None, None, ), # 2
6954 
    (3, TType.I64, 'limit', None, None, ), # 3
6955 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6956 
  )
6957 
 
6958 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
6959 
    self.statuses = statuses
6960 
    self.offset = offset
6961 
    self.limit = limit
6962 
    self.warehouse_id = warehouse_id
6963 
 
6964 
  def read(self, iprot):
6965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6967 
      return
6968 
    iprot.readStructBegin()
6969 
    while True:
6970 
      (fname, ftype, fid) = iprot.readFieldBegin()
6971 
      if ftype == TType.STOP:
6972 
        break
6973 
      if fid == 1:
6974 
        if ftype == TType.LIST:
6975 
          self.statuses = []
6976 
          (_etype38, _size35) = iprot.readListBegin()
6977 
          for _i39 in xrange(_size35):
6978 
            _elem40 = iprot.readI32();
6979 
            self.statuses.append(_elem40)
6980 
          iprot.readListEnd()
6981 
        else:
6982 
          iprot.skip(ftype)
6983 
      elif fid == 2:
6984 
        if ftype == TType.I64:
6985 
          self.offset = iprot.readI64();
6986 
        else:
6987 
          iprot.skip(ftype)
6988 
      elif fid == 3:
6989 
        if ftype == TType.I64:
6990 
          self.limit = iprot.readI64();
6991 
        else:
6992 
          iprot.skip(ftype)
6993 
      elif fid == 4:
6994 
        if ftype == TType.I64:
6995 
          self.warehouse_id = iprot.readI64();
6996 
        else:
6997 
          iprot.skip(ftype)
6998 
      else:
6999 
        iprot.skip(ftype)
7000 
      iprot.readFieldEnd()
7001 
    iprot.readStructEnd()
7002 
 
7003 
  def write(self, oprot):
7004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7006 
      return
7007 
    oprot.writeStructBegin('getOrdersInBatch_args')
7008 
    if self.statuses is not None:
7009 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7010 
      oprot.writeListBegin(TType.I32, len(self.statuses))
7011 
      for iter41 in self.statuses:
7012 
        oprot.writeI32(iter41)
7013 
      oprot.writeListEnd()
7014 
      oprot.writeFieldEnd()
7015 
    if self.offset is not None:
7016 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7017 
      oprot.writeI64(self.offset)
7018 
      oprot.writeFieldEnd()
7019 
    if self.limit is not None:
7020 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7021 
      oprot.writeI64(self.limit)
7022 
      oprot.writeFieldEnd()
7023 
    if self.warehouse_id is not None:
7024 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7025 
      oprot.writeI64(self.warehouse_id)
7026 
      oprot.writeFieldEnd()
7027 
    oprot.writeFieldStop()
7028 
    oprot.writeStructEnd()
7029 
 
7030 
  def validate(self):
7031 
    return
7032 
 
7033 
 
7034 
  def __repr__(self):
7035 
    L = ['%s=%r' % (key, value)
7036 
      for key, value in self.__dict__.iteritems()]
7037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7038 
 
7039 
  def __eq__(self, other):
7040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7041 
 
7042 
  def __ne__(self, other):
7043 
    return not (self == other)
7044 
 
7045 
class getOrdersInBatch_result:
7046 
  """
7047 
  Attributes:
7048 
   - success
7049 
   - ex
7050 
  """
7051 
 
7052 
  thrift_spec = (
7053 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7054 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7055 
  )
7056 
 
7057 
  def __init__(self, success=None, ex=None,):
7058 
    self.success = success
7059 
    self.ex = ex
7060 
 
7061 
  def read(self, iprot):
7062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7064 
      return
7065 
    iprot.readStructBegin()
7066 
    while True:
7067 
      (fname, ftype, fid) = iprot.readFieldBegin()
7068 
      if ftype == TType.STOP:
7069 
        break
7070 
      if fid == 0:
7071 
        if ftype == TType.LIST:
7072 
          self.success = []
7073 
          (_etype45, _size42) = iprot.readListBegin()
7074 
          for _i46 in xrange(_size42):
7075 
            _elem47 = Order()
7076 
            _elem47.read(iprot)
7077 
            self.success.append(_elem47)
7078 
          iprot.readListEnd()
7079 
        else:
7080 
          iprot.skip(ftype)
7081 
      elif fid == 1:
7082 
        if ftype == TType.STRUCT:
7083 
          self.ex = TransactionServiceException()
7084 
          self.ex.read(iprot)
7085 
        else:
7086 
          iprot.skip(ftype)
7087 
      else:
7088 
        iprot.skip(ftype)
7089 
      iprot.readFieldEnd()
7090 
    iprot.readStructEnd()
7091 
 
7092 
  def write(self, oprot):
7093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7095 
      return
7096 
    oprot.writeStructBegin('getOrdersInBatch_result')
7097 
    if self.success is not None:
7098 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7099 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7100 
      for iter48 in self.success:
7101 
        iter48.write(oprot)
7102 
      oprot.writeListEnd()
7103 
      oprot.writeFieldEnd()
7104 
    if self.ex is not None:
7105 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7106 
      self.ex.write(oprot)
7107 
      oprot.writeFieldEnd()
7108 
    oprot.writeFieldStop()
7109 
    oprot.writeStructEnd()
7110 
 
7111 
  def validate(self):
7112 
    return
7113 
 
7114 
 
7115 
  def __repr__(self):
7116 
    L = ['%s=%r' % (key, value)
7117 
      for key, value in self.__dict__.iteritems()]
7118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7119 
 
7120 
  def __eq__(self, other):
7121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7122 
 
7123 
  def __ne__(self, other):
7124 
    return not (self == other)
7125 
 
7126 
class getOrderCount_args:
7127 
  """
7128 
  Attributes:
7129 
   - statuses
7130 
   - warehouseId
7131 
  """
7132 
 
7133 
  thrift_spec = (
7134 
    None, # 0
7135 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7136 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7137 
  )
7138 
 
7139 
  def __init__(self, statuses=None, warehouseId=None,):
7140 
    self.statuses = statuses
7141 
    self.warehouseId = warehouseId
7142 
 
7143 
  def read(self, iprot):
7144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7146 
      return
7147 
    iprot.readStructBegin()
7148 
    while True:
7149 
      (fname, ftype, fid) = iprot.readFieldBegin()
7150 
      if ftype == TType.STOP:
7151 
        break
7152 
      if fid == 1:
7153 
        if ftype == TType.LIST:
7154 
          self.statuses = []
7155 
          (_etype52, _size49) = iprot.readListBegin()
7156 
          for _i53 in xrange(_size49):
7157 
            _elem54 = iprot.readI32();
7158 
            self.statuses.append(_elem54)
7159 
          iprot.readListEnd()
7160 
        else:
7161 
          iprot.skip(ftype)
7162 
      elif fid == 2:
7163 
        if ftype == TType.I64:
7164 
          self.warehouseId = iprot.readI64();
7165 
        else:
7166 
          iprot.skip(ftype)
7167 
      else:
7168 
        iprot.skip(ftype)
7169 
      iprot.readFieldEnd()
7170 
    iprot.readStructEnd()
7171 
 
7172 
  def write(self, oprot):
7173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7175 
      return
7176 
    oprot.writeStructBegin('getOrderCount_args')
7177 
    if self.statuses is not None:
7178 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7179 
      oprot.writeListBegin(TType.I32, len(self.statuses))
7180 
      for iter55 in self.statuses:
7181 
        oprot.writeI32(iter55)
7182 
      oprot.writeListEnd()
7183 
      oprot.writeFieldEnd()
7184 
    if self.warehouseId is not None:
7185 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7186 
      oprot.writeI64(self.warehouseId)
7187 
      oprot.writeFieldEnd()
7188 
    oprot.writeFieldStop()
7189 
    oprot.writeStructEnd()
7190 
 
7191 
  def validate(self):
7192 
    return
7193 
 
7194 
 
7195 
  def __repr__(self):
7196 
    L = ['%s=%r' % (key, value)
7197 
      for key, value in self.__dict__.iteritems()]
7198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7199 
 
7200 
  def __eq__(self, other):
7201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7202 
 
7203 
  def __ne__(self, other):
7204 
    return not (self == other)
7205 
 
7206 
class getOrderCount_result:
7207 
  """
7208 
  Attributes:
7209 
   - success
7210 
   - ex
7211 
  """
7212 
 
7213 
  thrift_spec = (
7214 
    (0, TType.I32, 'success', None, None, ), # 0
7215 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7216 
  )
7217 
 
7218 
  def __init__(self, success=None, ex=None,):
7219 
    self.success = success
7220 
    self.ex = ex
7221 
 
7222 
  def read(self, iprot):
7223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7225 
      return
7226 
    iprot.readStructBegin()
7227 
    while True:
7228 
      (fname, ftype, fid) = iprot.readFieldBegin()
7229 
      if ftype == TType.STOP:
7230 
        break
7231 
      if fid == 0:
7232 
        if ftype == TType.I32:
7233 
          self.success = iprot.readI32();
7234 
        else:
7235 
          iprot.skip(ftype)
7236 
      elif fid == 1:
7237 
        if ftype == TType.STRUCT:
7238 
          self.ex = TransactionServiceException()
7239 
          self.ex.read(iprot)
7240 
        else:
7241 
          iprot.skip(ftype)
7242 
      else:
7243 
        iprot.skip(ftype)
7244 
      iprot.readFieldEnd()
7245 
    iprot.readStructEnd()
7246 
 
7247 
  def write(self, oprot):
7248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7250 
      return
7251 
    oprot.writeStructBegin('getOrderCount_result')
7252 
    if self.success is not None:
7253 
      oprot.writeFieldBegin('success', TType.I32, 0)
7254 
      oprot.writeI32(self.success)
7255 
      oprot.writeFieldEnd()
7256 
    if self.ex is not None:
7257 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7258 
      self.ex.write(oprot)
7259 
      oprot.writeFieldEnd()
7260 
    oprot.writeFieldStop()
7261 
    oprot.writeStructEnd()
7262 
 
7263 
  def validate(self):
7264 
    return
7265 
 
7266 
 
7267 
  def __repr__(self):
7268 
    L = ['%s=%r' % (key, value)
7269 
      for key, value in self.__dict__.iteritems()]
7270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7271 
 
7272 
  def __eq__(self, other):
7273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7274 
 
7275 
  def __ne__(self, other):
7276 
    return not (self == other)
7277 
 
999 varun.gupt 7278 
class getOrdersByBillingDate_args:
7279 
  """
7280 
  Attributes:
7281 
   - status
7282 
   - start_billing_date
7283 
   - end_billing_date
7284 
   - warehouse_id
7285 
  """
7286 
 
7287 
  thrift_spec = (
7288 
    None, # 0
7289 
    (1, TType.I32, 'status', None, None, ), # 1
7290 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
7291 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
7292 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7293 
  )
7294 
 
7295 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7296 
    self.status = status
7297 
    self.start_billing_date = start_billing_date
7298 
    self.end_billing_date = end_billing_date
7299 
    self.warehouse_id = warehouse_id
7300 
 
7301 
  def read(self, iprot):
7302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7304 
      return
7305 
    iprot.readStructBegin()
7306 
    while True:
7307 
      (fname, ftype, fid) = iprot.readFieldBegin()
7308 
      if ftype == TType.STOP:
7309 
        break
7310 
      if fid == 1:
7311 
        if ftype == TType.I32:
7312 
          self.status = iprot.readI32();
7313 
        else:
7314 
          iprot.skip(ftype)
7315 
      elif fid == 2:
7316 
        if ftype == TType.I64:
7317 
          self.start_billing_date = iprot.readI64();
7318 
        else:
7319 
          iprot.skip(ftype)
7320 
      elif fid == 3:
7321 
        if ftype == TType.I64:
7322 
          self.end_billing_date = iprot.readI64();
7323 
        else:
7324 
          iprot.skip(ftype)
7325 
      elif fid == 4:
7326 
        if ftype == TType.I64:
7327 
          self.warehouse_id = iprot.readI64();
7328 
        else:
7329 
          iprot.skip(ftype)
7330 
      else:
7331 
        iprot.skip(ftype)
7332 
      iprot.readFieldEnd()
7333 
    iprot.readStructEnd()
7334 
 
7335 
  def write(self, oprot):
7336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7338 
      return
7339 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7340 
    if self.status is not None:
999 varun.gupt 7341 
      oprot.writeFieldBegin('status', TType.I32, 1)
7342 
      oprot.writeI32(self.status)
7343 
      oprot.writeFieldEnd()
3431 rajveer 7344 
    if self.start_billing_date is not None:
999 varun.gupt 7345 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7346 
      oprot.writeI64(self.start_billing_date)
7347 
      oprot.writeFieldEnd()
3431 rajveer 7348 
    if self.end_billing_date is not None:
999 varun.gupt 7349 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7350 
      oprot.writeI64(self.end_billing_date)
7351 
      oprot.writeFieldEnd()
3431 rajveer 7352 
    if self.warehouse_id is not None:
999 varun.gupt 7353 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7354 
      oprot.writeI64(self.warehouse_id)
7355 
      oprot.writeFieldEnd()
7356 
    oprot.writeFieldStop()
7357 
    oprot.writeStructEnd()
7358 
 
3431 rajveer 7359 
  def validate(self):
7360 
    return
7361 
 
7362 
 
999 varun.gupt 7363 
  def __repr__(self):
7364 
    L = ['%s=%r' % (key, value)
7365 
      for key, value in self.__dict__.iteritems()]
7366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7367 
 
7368 
  def __eq__(self, other):
7369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7370 
 
7371 
  def __ne__(self, other):
7372 
    return not (self == other)
7373 
 
7374 
class getOrdersByBillingDate_result:
7375 
  """
7376 
  Attributes:
7377 
   - success
7378 
   - ex
7379 
  """
7380 
 
7381 
  thrift_spec = (
7382 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7383 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7384 
  )
7385 
 
7386 
  def __init__(self, success=None, ex=None,):
7387 
    self.success = success
7388 
    self.ex = ex
7389 
 
7390 
  def read(self, iprot):
7391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7393 
      return
7394 
    iprot.readStructBegin()
7395 
    while True:
7396 
      (fname, ftype, fid) = iprot.readFieldBegin()
7397 
      if ftype == TType.STOP:
7398 
        break
7399 
      if fid == 0:
7400 
        if ftype == TType.LIST:
7401 
          self.success = []
4133 chandransh 7402 
          (_etype59, _size56) = iprot.readListBegin()
7403 
          for _i60 in xrange(_size56):
7404 
            _elem61 = Order()
7405 
            _elem61.read(iprot)
7406 
            self.success.append(_elem61)
999 varun.gupt 7407 
          iprot.readListEnd()
7408 
        else:
7409 
          iprot.skip(ftype)
7410 
      elif fid == 1:
7411 
        if ftype == TType.STRUCT:
7412 
          self.ex = TransactionServiceException()
7413 
          self.ex.read(iprot)
7414 
        else:
7415 
          iprot.skip(ftype)
7416 
      else:
7417 
        iprot.skip(ftype)
7418 
      iprot.readFieldEnd()
7419 
    iprot.readStructEnd()
7420 
 
7421 
  def write(self, oprot):
7422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7424 
      return
7425 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 7426 
    if self.success is not None:
999 varun.gupt 7427 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7428 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7429 
      for iter62 in self.success:
7430 
        iter62.write(oprot)
999 varun.gupt 7431 
      oprot.writeListEnd()
7432 
      oprot.writeFieldEnd()
3431 rajveer 7433 
    if self.ex is not None:
999 varun.gupt 7434 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7435 
      self.ex.write(oprot)
7436 
      oprot.writeFieldEnd()
7437 
    oprot.writeFieldStop()
7438 
    oprot.writeStructEnd()
7439 
 
3431 rajveer 7440 
  def validate(self):
7441 
    return
7442 
 
7443 
 
999 varun.gupt 7444 
  def __repr__(self):
7445 
    L = ['%s=%r' % (key, value)
7446 
      for key, value in self.__dict__.iteritems()]
7447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7448 
 
7449 
  def __eq__(self, other):
7450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7451 
 
7452 
  def __ne__(self, other):
7453 
    return not (self == other)
7454 
 
3427 chandransh 7455 
class getOrdersByShippingDate_args:
7456 
  """
7457 
  Attributes:
7458 
   - fromShippingDate
7459 
   - toShippingDate
7460 
   - providerId
7461 
   - warehouseId
3451 chandransh 7462 
   - cod
3427 chandransh 7463 
  """
7464 
 
7465 
  thrift_spec = (
7466 
    None, # 0
7467 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
7468 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
7469 
    (3, TType.I64, 'providerId', None, None, ), # 3
7470 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 7471 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 7472 
  )
7473 
 
3451 chandransh 7474 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 7475 
    self.fromShippingDate = fromShippingDate
7476 
    self.toShippingDate = toShippingDate
7477 
    self.providerId = providerId
7478 
    self.warehouseId = warehouseId
3451 chandransh 7479 
    self.cod = cod
3427 chandransh 7480 
 
7481 
  def read(self, iprot):
7482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7484 
      return
7485 
    iprot.readStructBegin()
7486 
    while True:
7487 
      (fname, ftype, fid) = iprot.readFieldBegin()
7488 
      if ftype == TType.STOP:
7489 
        break
7490 
      if fid == 1:
7491 
        if ftype == TType.I64:
7492 
          self.fromShippingDate = iprot.readI64();
7493 
        else:
7494 
          iprot.skip(ftype)
7495 
      elif fid == 2:
7496 
        if ftype == TType.I64:
7497 
          self.toShippingDate = iprot.readI64();
7498 
        else:
7499 
          iprot.skip(ftype)
7500 
      elif fid == 3:
7501 
        if ftype == TType.I64:
7502 
          self.providerId = iprot.readI64();
7503 
        else:
7504 
          iprot.skip(ftype)
7505 
      elif fid == 4:
7506 
        if ftype == TType.I64:
7507 
          self.warehouseId = iprot.readI64();
7508 
        else:
7509 
          iprot.skip(ftype)
3451 chandransh 7510 
      elif fid == 5:
7511 
        if ftype == TType.BOOL:
7512 
          self.cod = iprot.readBool();
7513 
        else:
7514 
          iprot.skip(ftype)
3427 chandransh 7515 
      else:
7516 
        iprot.skip(ftype)
7517 
      iprot.readFieldEnd()
7518 
    iprot.readStructEnd()
7519 
 
7520 
  def write(self, oprot):
7521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7523 
      return
7524 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 7525 
    if self.fromShippingDate is not None:
3427 chandransh 7526 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
7527 
      oprot.writeI64(self.fromShippingDate)
7528 
      oprot.writeFieldEnd()
3431 rajveer 7529 
    if self.toShippingDate is not None:
3427 chandransh 7530 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
7531 
      oprot.writeI64(self.toShippingDate)
7532 
      oprot.writeFieldEnd()
3431 rajveer 7533 
    if self.providerId is not None:
3427 chandransh 7534 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
7535 
      oprot.writeI64(self.providerId)
7536 
      oprot.writeFieldEnd()
3431 rajveer 7537 
    if self.warehouseId is not None:
3427 chandransh 7538 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
7539 
      oprot.writeI64(self.warehouseId)
7540 
      oprot.writeFieldEnd()
3451 chandransh 7541 
    if self.cod is not None:
7542 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
7543 
      oprot.writeBool(self.cod)
7544 
      oprot.writeFieldEnd()
3427 chandransh 7545 
    oprot.writeFieldStop()
7546 
    oprot.writeStructEnd()
7547 
 
3431 rajveer 7548 
  def validate(self):
7549 
    return
7550 
 
7551 
 
3427 chandransh 7552 
  def __repr__(self):
7553 
    L = ['%s=%r' % (key, value)
7554 
      for key, value in self.__dict__.iteritems()]
7555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7556 
 
7557 
  def __eq__(self, other):
7558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7559 
 
7560 
  def __ne__(self, other):
7561 
    return not (self == other)
7562 
 
7563 
class getOrdersByShippingDate_result:
7564 
  """
7565 
  Attributes:
7566 
   - success
7567 
   - ex
7568 
  """
7569 
 
7570 
  thrift_spec = (
7571 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7572 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7573 
  )
7574 
 
7575 
  def __init__(self, success=None, ex=None,):
7576 
    self.success = success
7577 
    self.ex = ex
7578 
 
7579 
  def read(self, iprot):
7580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7582 
      return
7583 
    iprot.readStructBegin()
7584 
    while True:
7585 
      (fname, ftype, fid) = iprot.readFieldBegin()
7586 
      if ftype == TType.STOP:
7587 
        break
7588 
      if fid == 0:
7589 
        if ftype == TType.LIST:
7590 
          self.success = []
4133 chandransh 7591 
          (_etype66, _size63) = iprot.readListBegin()
7592 
          for _i67 in xrange(_size63):
7593 
            _elem68 = Order()
7594 
            _elem68.read(iprot)
7595 
            self.success.append(_elem68)
3427 chandransh 7596 
          iprot.readListEnd()
7597 
        else:
7598 
          iprot.skip(ftype)
7599 
      elif fid == 1:
7600 
        if ftype == TType.STRUCT:
7601 
          self.ex = TransactionServiceException()
7602 
          self.ex.read(iprot)
7603 
        else:
7604 
          iprot.skip(ftype)
7605 
      else:
7606 
        iprot.skip(ftype)
7607 
      iprot.readFieldEnd()
7608 
    iprot.readStructEnd()
7609 
 
7610 
  def write(self, oprot):
7611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7613 
      return
7614 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 7615 
    if self.success is not None:
3427 chandransh 7616 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7617 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7618 
      for iter69 in self.success:
7619 
        iter69.write(oprot)
3427 chandransh 7620 
      oprot.writeListEnd()
7621 
      oprot.writeFieldEnd()
3431 rajveer 7622 
    if self.ex is not None:
3427 chandransh 7623 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7624 
      self.ex.write(oprot)
7625 
      oprot.writeFieldEnd()
7626 
    oprot.writeFieldStop()
7627 
    oprot.writeStructEnd()
7628 
 
3431 rajveer 7629 
  def validate(self):
7630 
    return
7631 
 
7632 
 
3427 chandransh 7633 
  def __repr__(self):
7634 
    L = ['%s=%r' % (key, value)
7635 
      for key, value in self.__dict__.iteritems()]
7636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7637 
 
7638 
  def __eq__(self, other):
7639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7640 
 
7641 
  def __ne__(self, other):
7642 
    return not (self == other)
7643 
 
1382 varun.gupt 7644 
class getReturnableOrdersForCustomer_args:
7645 
  """
7646 
  Attributes:
7647 
   - customer_id
7648 
   - limit
7649 
  """
7650 
 
7651 
  thrift_spec = (
7652 
    None, # 0
7653 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7654 
    (2, TType.I64, 'limit', None, None, ), # 2
7655 
  )
7656 
 
7657 
  def __init__(self, customer_id=None, limit=None,):
7658 
    self.customer_id = customer_id
7659 
    self.limit = limit
7660 
 
7661 
  def read(self, iprot):
7662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7664 
      return
7665 
    iprot.readStructBegin()
7666 
    while True:
7667 
      (fname, ftype, fid) = iprot.readFieldBegin()
7668 
      if ftype == TType.STOP:
7669 
        break
7670 
      if fid == 1:
7671 
        if ftype == TType.I64:
7672 
          self.customer_id = iprot.readI64();
7673 
        else:
7674 
          iprot.skip(ftype)
7675 
      elif fid == 2:
7676 
        if ftype == TType.I64:
7677 
          self.limit = iprot.readI64();
7678 
        else:
7679 
          iprot.skip(ftype)
7680 
      else:
7681 
        iprot.skip(ftype)
7682 
      iprot.readFieldEnd()
7683 
    iprot.readStructEnd()
7684 
 
7685 
  def write(self, oprot):
7686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7688 
      return
7689 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 7690 
    if self.customer_id is not None:
1382 varun.gupt 7691 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7692 
      oprot.writeI64(self.customer_id)
7693 
      oprot.writeFieldEnd()
3431 rajveer 7694 
    if self.limit is not None:
1382 varun.gupt 7695 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7696 
      oprot.writeI64(self.limit)
7697 
      oprot.writeFieldEnd()
7698 
    oprot.writeFieldStop()
7699 
    oprot.writeStructEnd()
7700 
 
3431 rajveer 7701 
  def validate(self):
7702 
    return
7703 
 
7704 
 
1382 varun.gupt 7705 
  def __repr__(self):
7706 
    L = ['%s=%r' % (key, value)
7707 
      for key, value in self.__dict__.iteritems()]
7708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7709 
 
7710 
  def __eq__(self, other):
7711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7712 
 
7713 
  def __ne__(self, other):
7714 
    return not (self == other)
7715 
 
7716 
class getReturnableOrdersForCustomer_result:
7717 
  """
7718 
  Attributes:
7719 
   - success
7720 
   - ex
7721 
  """
7722 
 
7723 
  thrift_spec = (
7724 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7725 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7726 
  )
7727 
 
7728 
  def __init__(self, success=None, ex=None,):
7729 
    self.success = success
7730 
    self.ex = ex
7731 
 
7732 
  def read(self, iprot):
7733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7735 
      return
7736 
    iprot.readStructBegin()
7737 
    while True:
7738 
      (fname, ftype, fid) = iprot.readFieldBegin()
7739 
      if ftype == TType.STOP:
7740 
        break
7741 
      if fid == 0:
7742 
        if ftype == TType.LIST:
7743 
          self.success = []
4133 chandransh 7744 
          (_etype73, _size70) = iprot.readListBegin()
7745 
          for _i74 in xrange(_size70):
7746 
            _elem75 = iprot.readI64();
7747 
            self.success.append(_elem75)
1382 varun.gupt 7748 
          iprot.readListEnd()
7749 
        else:
7750 
          iprot.skip(ftype)
7751 
      elif fid == 1:
7752 
        if ftype == TType.STRUCT:
7753 
          self.ex = TransactionServiceException()
7754 
          self.ex.read(iprot)
7755 
        else:
7756 
          iprot.skip(ftype)
7757 
      else:
7758 
        iprot.skip(ftype)
7759 
      iprot.readFieldEnd()
7760 
    iprot.readStructEnd()
7761 
 
7762 
  def write(self, oprot):
7763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7765 
      return
7766 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 7767 
    if self.success is not None:
1382 varun.gupt 7768 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7769 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7770 
      for iter76 in self.success:
7771 
        oprot.writeI64(iter76)
1382 varun.gupt 7772 
      oprot.writeListEnd()
7773 
      oprot.writeFieldEnd()
3431 rajveer 7774 
    if self.ex is not None:
1382 varun.gupt 7775 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7776 
      self.ex.write(oprot)
7777 
      oprot.writeFieldEnd()
7778 
    oprot.writeFieldStop()
7779 
    oprot.writeStructEnd()
7780 
 
3431 rajveer 7781 
  def validate(self):
7782 
    return
7783 
 
7784 
 
1382 varun.gupt 7785 
  def __repr__(self):
7786 
    L = ['%s=%r' % (key, value)
7787 
      for key, value in self.__dict__.iteritems()]
7788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7789 
 
7790 
  def __eq__(self, other):
7791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7792 
 
7793 
  def __ne__(self, other):
7794 
    return not (self == other)
7795 
 
7796 
class getCancellableOrdersForCustomer_args:
7797 
  """
7798 
  Attributes:
7799 
   - customer_id
7800 
   - limit
7801 
  """
7802 
 
7803 
  thrift_spec = (
7804 
    None, # 0
7805 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7806 
    (2, TType.I64, 'limit', None, None, ), # 2
7807 
  )
7808 
 
7809 
  def __init__(self, customer_id=None, limit=None,):
7810 
    self.customer_id = customer_id
7811 
    self.limit = limit
7812 
 
7813 
  def read(self, iprot):
7814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7816 
      return
7817 
    iprot.readStructBegin()
7818 
    while True:
7819 
      (fname, ftype, fid) = iprot.readFieldBegin()
7820 
      if ftype == TType.STOP:
7821 
        break
7822 
      if fid == 1:
7823 
        if ftype == TType.I64:
7824 
          self.customer_id = iprot.readI64();
7825 
        else:
7826 
          iprot.skip(ftype)
7827 
      elif fid == 2:
7828 
        if ftype == TType.I64:
7829 
          self.limit = iprot.readI64();
7830 
        else:
7831 
          iprot.skip(ftype)
7832 
      else:
7833 
        iprot.skip(ftype)
7834 
      iprot.readFieldEnd()
7835 
    iprot.readStructEnd()
7836 
 
7837 
  def write(self, oprot):
7838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7840 
      return
7841 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7842 
    if self.customer_id is not None:
1382 varun.gupt 7843 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7844 
      oprot.writeI64(self.customer_id)
7845 
      oprot.writeFieldEnd()
3431 rajveer 7846 
    if self.limit is not None:
1382 varun.gupt 7847 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7848 
      oprot.writeI64(self.limit)
7849 
      oprot.writeFieldEnd()
7850 
    oprot.writeFieldStop()
7851 
    oprot.writeStructEnd()
7852 
 
3431 rajveer 7853 
  def validate(self):
7854 
    return
7855 
 
7856 
 
1382 varun.gupt 7857 
  def __repr__(self):
7858 
    L = ['%s=%r' % (key, value)
7859 
      for key, value in self.__dict__.iteritems()]
7860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7861 
 
7862 
  def __eq__(self, other):
7863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7864 
 
7865 
  def __ne__(self, other):
7866 
    return not (self == other)
7867 
 
7868 
class getCancellableOrdersForCustomer_result:
7869 
  """
7870 
  Attributes:
7871 
   - success
7872 
   - ex
7873 
  """
7874 
 
7875 
  thrift_spec = (
7876 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7877 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7878 
  )
7879 
 
7880 
  def __init__(self, success=None, ex=None,):
7881 
    self.success = success
7882 
    self.ex = ex
7883 
 
7884 
  def read(self, iprot):
7885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7887 
      return
7888 
    iprot.readStructBegin()
7889 
    while True:
7890 
      (fname, ftype, fid) = iprot.readFieldBegin()
7891 
      if ftype == TType.STOP:
7892 
        break
7893 
      if fid == 0:
7894 
        if ftype == TType.LIST:
7895 
          self.success = []
4133 chandransh 7896 
          (_etype80, _size77) = iprot.readListBegin()
7897 
          for _i81 in xrange(_size77):
7898 
            _elem82 = iprot.readI64();
7899 
            self.success.append(_elem82)
1382 varun.gupt 7900 
          iprot.readListEnd()
7901 
        else:
7902 
          iprot.skip(ftype)
7903 
      elif fid == 1:
7904 
        if ftype == TType.STRUCT:
7905 
          self.ex = TransactionServiceException()
7906 
          self.ex.read(iprot)
7907 
        else:
7908 
          iprot.skip(ftype)
7909 
      else:
7910 
        iprot.skip(ftype)
7911 
      iprot.readFieldEnd()
7912 
    iprot.readStructEnd()
7913 
 
7914 
  def write(self, oprot):
7915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7917 
      return
7918 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 7919 
    if self.success is not None:
1382 varun.gupt 7920 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7921 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7922 
      for iter83 in self.success:
7923 
        oprot.writeI64(iter83)
1382 varun.gupt 7924 
      oprot.writeListEnd()
7925 
      oprot.writeFieldEnd()
3431 rajveer 7926 
    if self.ex is not None:
1382 varun.gupt 7927 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7928 
      self.ex.write(oprot)
7929 
      oprot.writeFieldEnd()
7930 
    oprot.writeFieldStop()
7931 
    oprot.writeStructEnd()
7932 
 
3431 rajveer 7933 
  def validate(self):
7934 
    return
7935 
 
7936 
 
1382 varun.gupt 7937 
  def __repr__(self):
7938 
    L = ['%s=%r' % (key, value)
7939 
      for key, value in self.__dict__.iteritems()]
7940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7941 
 
7942 
  def __eq__(self, other):
7943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7944 
 
7945 
  def __ne__(self, other):
7946 
    return not (self == other)
7947 
 
483 rajveer 7948 
class changeOrderStatus_args:
94 ashish 7949 
  """
7950 
  Attributes:
483 rajveer 7951 
   - orderId
7952 
   - status
7953 
   - description
94 ashish 7954 
  """
7955 
 
7956 
  thrift_spec = (
7957 
    None, # 0
483 rajveer 7958 
    (1, TType.I64, 'orderId', None, None, ), # 1
7959 
    (2, TType.I32, 'status', None, None, ), # 2
7960 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 7961 
  )
7962 
 
483 rajveer 7963 
  def __init__(self, orderId=None, status=None, description=None,):
7964 
    self.orderId = orderId
7965 
    self.status = status
7966 
    self.description = description
94 ashish 7967 
 
7968 
  def read(self, iprot):
7969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7971 
      return
7972 
    iprot.readStructBegin()
7973 
    while True:
7974 
      (fname, ftype, fid) = iprot.readFieldBegin()
7975 
      if ftype == TType.STOP:
7976 
        break
7977 
      if fid == 1:
7978 
        if ftype == TType.I64:
483 rajveer 7979 
          self.orderId = iprot.readI64();
94 ashish 7980 
        else:
7981 
          iprot.skip(ftype)
7982 
      elif fid == 2:
483 rajveer 7983 
        if ftype == TType.I32:
7984 
          self.status = iprot.readI32();
94 ashish 7985 
        else:
7986 
          iprot.skip(ftype)
483 rajveer 7987 
      elif fid == 3:
7988 
        if ftype == TType.STRING:
7989 
          self.description = iprot.readString();
7990 
        else:
7991 
          iprot.skip(ftype)
94 ashish 7992 
      else:
7993 
        iprot.skip(ftype)
7994 
      iprot.readFieldEnd()
7995 
    iprot.readStructEnd()
7996 
 
7997 
  def write(self, oprot):
7998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8000 
      return
483 rajveer 8001 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8002 
    if self.orderId is not None:
483 rajveer 8003 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8004 
      oprot.writeI64(self.orderId)
94 ashish 8005 
      oprot.writeFieldEnd()
3431 rajveer 8006 
    if self.status is not None:
483 rajveer 8007 
      oprot.writeFieldBegin('status', TType.I32, 2)
8008 
      oprot.writeI32(self.status)
94 ashish 8009 
      oprot.writeFieldEnd()
3431 rajveer 8010 
    if self.description is not None:
483 rajveer 8011 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8012 
      oprot.writeString(self.description)
8013 
      oprot.writeFieldEnd()
94 ashish 8014 
    oprot.writeFieldStop()
8015 
    oprot.writeStructEnd()
8016 
 
3431 rajveer 8017 
  def validate(self):
8018 
    return
8019 
 
8020 
 
94 ashish 8021 
  def __repr__(self):
8022 
    L = ['%s=%r' % (key, value)
8023 
      for key, value in self.__dict__.iteritems()]
8024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8025 
 
8026 
  def __eq__(self, other):
8027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8028 
 
8029 
  def __ne__(self, other):
8030 
    return not (self == other)
8031 
 
483 rajveer 8032 
class changeOrderStatus_result:
94 ashish 8033 
  """
8034 
  Attributes:
8035 
   - success
8036 
   - ex
8037 
  """
8038 
 
8039 
  thrift_spec = (
8040 
    (0, TType.BOOL, 'success', None, None, ), # 0
8041 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8042 
  )
8043 
 
8044 
  def __init__(self, success=None, ex=None,):
8045 
    self.success = success
8046 
    self.ex = ex
8047 
 
8048 
  def read(self, iprot):
8049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8051 
      return
8052 
    iprot.readStructBegin()
8053 
    while True:
8054 
      (fname, ftype, fid) = iprot.readFieldBegin()
8055 
      if ftype == TType.STOP:
8056 
        break
8057 
      if fid == 0:
8058 
        if ftype == TType.BOOL:
8059 
          self.success = iprot.readBool();
8060 
        else:
8061 
          iprot.skip(ftype)
8062 
      elif fid == 1:
8063 
        if ftype == TType.STRUCT:
8064 
          self.ex = TransactionServiceException()
8065 
          self.ex.read(iprot)
8066 
        else:
8067 
          iprot.skip(ftype)
8068 
      else:
8069 
        iprot.skip(ftype)
8070 
      iprot.readFieldEnd()
8071 
    iprot.readStructEnd()
8072 
 
8073 
  def write(self, oprot):
8074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8076 
      return
483 rajveer 8077 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8078 
    if self.success is not None:
94 ashish 8079 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8080 
      oprot.writeBool(self.success)
8081 
      oprot.writeFieldEnd()
3431 rajveer 8082 
    if self.ex is not None:
94 ashish 8083 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8084 
      self.ex.write(oprot)
8085 
      oprot.writeFieldEnd()
8086 
    oprot.writeFieldStop()
8087 
    oprot.writeStructEnd()
8088 
 
3431 rajveer 8089 
  def validate(self):
8090 
    return
8091 
 
8092 
 
94 ashish 8093 
  def __repr__(self):
8094 
    L = ['%s=%r' % (key, value)
8095 
      for key, value in self.__dict__.iteritems()]
8096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8097 
 
8098 
  def __eq__(self, other):
8099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8100 
 
8101 
  def __ne__(self, other):
8102 
    return not (self == other)
8103 
 
3064 chandransh 8104 
class getOrdersForTransaction_args:
494 rajveer 8105 
  """
8106 
  Attributes:
3064 chandransh 8107 
   - transactionId
8108 
   - customerId
494 rajveer 8109 
  """
8110 
 
8111 
  thrift_spec = (
8112 
    None, # 0
3064 chandransh 8113 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8114 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8115 
  )
8116 
 
3064 chandransh 8117 
  def __init__(self, transactionId=None, customerId=None,):
8118 
    self.transactionId = transactionId
8119 
    self.customerId = customerId
494 rajveer 8120 
 
8121 
  def read(self, iprot):
8122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8124 
      return
8125 
    iprot.readStructBegin()
8126 
    while True:
8127 
      (fname, ftype, fid) = iprot.readFieldBegin()
8128 
      if ftype == TType.STOP:
8129 
        break
8130 
      if fid == 1:
8131 
        if ftype == TType.I64:
3064 chandransh 8132 
          self.transactionId = iprot.readI64();
494 rajveer 8133 
        else:
8134 
          iprot.skip(ftype)
8135 
      elif fid == 2:
3064 chandransh 8136 
        if ftype == TType.I64:
8137 
          self.customerId = iprot.readI64();
494 rajveer 8138 
        else:
8139 
          iprot.skip(ftype)
8140 
      else:
8141 
        iprot.skip(ftype)
8142 
      iprot.readFieldEnd()
8143 
    iprot.readStructEnd()
8144 
 
8145 
  def write(self, oprot):
8146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8148 
      return
3064 chandransh 8149 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8150 
    if self.transactionId is not None:
3064 chandransh 8151 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8152 
      oprot.writeI64(self.transactionId)
494 rajveer 8153 
      oprot.writeFieldEnd()
3431 rajveer 8154 
    if self.customerId is not None:
3064 chandransh 8155 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8156 
      oprot.writeI64(self.customerId)
494 rajveer 8157 
      oprot.writeFieldEnd()
8158 
    oprot.writeFieldStop()
8159 
    oprot.writeStructEnd()
8160 
 
3431 rajveer 8161 
  def validate(self):
8162 
    return
8163 
 
8164 
 
494 rajveer 8165 
  def __repr__(self):
8166 
    L = ['%s=%r' % (key, value)
8167 
      for key, value in self.__dict__.iteritems()]
8168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8169 
 
8170 
  def __eq__(self, other):
8171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8172 
 
8173 
  def __ne__(self, other):
8174 
    return not (self == other)
8175 
 
3064 chandransh 8176 
class getOrdersForTransaction_result:
494 rajveer 8177 
  """
8178 
  Attributes:
8179 
   - success
8180 
   - ex
8181 
  """
8182 
 
8183 
  thrift_spec = (
3064 chandransh 8184 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8186 
  )
8187 
 
8188 
  def __init__(self, success=None, ex=None,):
8189 
    self.success = success
8190 
    self.ex = ex
8191 
 
8192 
  def read(self, iprot):
8193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8195 
      return
8196 
    iprot.readStructBegin()
8197 
    while True:
8198 
      (fname, ftype, fid) = iprot.readFieldBegin()
8199 
      if ftype == TType.STOP:
8200 
        break
8201 
      if fid == 0:
3064 chandransh 8202 
        if ftype == TType.LIST:
8203 
          self.success = []
4133 chandransh 8204 
          (_etype87, _size84) = iprot.readListBegin()
8205 
          for _i88 in xrange(_size84):
8206 
            _elem89 = Order()
8207 
            _elem89.read(iprot)
8208 
            self.success.append(_elem89)
3064 chandransh 8209 
          iprot.readListEnd()
494 rajveer 8210 
        else:
8211 
          iprot.skip(ftype)
8212 
      elif fid == 1:
8213 
        if ftype == TType.STRUCT:
8214 
          self.ex = TransactionServiceException()
8215 
          self.ex.read(iprot)
8216 
        else:
8217 
          iprot.skip(ftype)
8218 
      else:
8219 
        iprot.skip(ftype)
8220 
      iprot.readFieldEnd()
8221 
    iprot.readStructEnd()
8222 
 
8223 
  def write(self, oprot):
8224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8226 
      return
3064 chandransh 8227 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 8228 
    if self.success is not None:
3064 chandransh 8229 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8230 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8231 
      for iter90 in self.success:
8232 
        iter90.write(oprot)
3064 chandransh 8233 
      oprot.writeListEnd()
494 rajveer 8234 
      oprot.writeFieldEnd()
3431 rajveer 8235 
    if self.ex is not None:
494 rajveer 8236 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8237 
      self.ex.write(oprot)
8238 
      oprot.writeFieldEnd()
8239 
    oprot.writeFieldStop()
8240 
    oprot.writeStructEnd()
8241 
 
3431 rajveer 8242 
  def validate(self):
8243 
    return
8244 
 
8245 
 
494 rajveer 8246 
  def __repr__(self):
8247 
    L = ['%s=%r' % (key, value)
8248 
      for key, value in self.__dict__.iteritems()]
8249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8250 
 
8251 
  def __eq__(self, other):
8252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8253 
 
8254 
  def __ne__(self, other):
8255 
    return not (self == other)
8256 
 
3064 chandransh 8257 
class getOrdersForCustomer_args:
1149 chandransh 8258 
  """
8259 
  Attributes:
3064 chandransh 8260 
   - customerId
8261 
   - from_date
8262 
   - to_date
8263 
   - statuses
1149 chandransh 8264 
  """
8265 
 
8266 
  thrift_spec = (
8267 
    None, # 0
3064 chandransh 8268 
    (1, TType.I64, 'customerId', None, None, ), # 1
8269 
    (2, TType.I64, 'from_date', None, None, ), # 2
8270 
    (3, TType.I64, 'to_date', None, None, ), # 3
8271 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 8272 
  )
8273 
 
3064 chandransh 8274 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
8275 
    self.customerId = customerId
8276 
    self.from_date = from_date
8277 
    self.to_date = to_date
8278 
    self.statuses = statuses
1149 chandransh 8279 
 
8280 
  def read(self, iprot):
8281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8283 
      return
8284 
    iprot.readStructBegin()
8285 
    while True:
8286 
      (fname, ftype, fid) = iprot.readFieldBegin()
8287 
      if ftype == TType.STOP:
8288 
        break
8289 
      if fid == 1:
8290 
        if ftype == TType.I64:
3064 chandransh 8291 
          self.customerId = iprot.readI64();
1149 chandransh 8292 
        else:
8293 
          iprot.skip(ftype)
8294 
      elif fid == 2:
8295 
        if ftype == TType.I64:
3064 chandransh 8296 
          self.from_date = iprot.readI64();
1149 chandransh 8297 
        else:
8298 
          iprot.skip(ftype)
2783 chandransh 8299 
      elif fid == 3:
8300 
        if ftype == TType.I64:
3064 chandransh 8301 
          self.to_date = iprot.readI64();
2783 chandransh 8302 
        else:
8303 
          iprot.skip(ftype)
8304 
      elif fid == 4:
3064 chandransh 8305 
        if ftype == TType.LIST:
8306 
          self.statuses = []
4133 chandransh 8307 
          (_etype94, _size91) = iprot.readListBegin()
8308 
          for _i95 in xrange(_size91):
8309 
            _elem96 = iprot.readI32();
8310 
            self.statuses.append(_elem96)
3064 chandransh 8311 
          iprot.readListEnd()
2783 chandransh 8312 
        else:
8313 
          iprot.skip(ftype)
1149 chandransh 8314 
      else:
8315 
        iprot.skip(ftype)
8316 
      iprot.readFieldEnd()
8317 
    iprot.readStructEnd()
8318 
 
8319 
  def write(self, oprot):
8320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8322 
      return
3064 chandransh 8323 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 8324 
    if self.customerId is not None:
3064 chandransh 8325 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8326 
      oprot.writeI64(self.customerId)
1149 chandransh 8327 
      oprot.writeFieldEnd()
3431 rajveer 8328 
    if self.from_date is not None:
3064 chandransh 8329 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8330 
      oprot.writeI64(self.from_date)
1149 chandransh 8331 
      oprot.writeFieldEnd()
3431 rajveer 8332 
    if self.to_date is not None:
3064 chandransh 8333 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8334 
      oprot.writeI64(self.to_date)
2783 chandransh 8335 
      oprot.writeFieldEnd()
3431 rajveer 8336 
    if self.statuses is not None:
3064 chandransh 8337 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
8338 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 8339 
      for iter97 in self.statuses:
8340 
        oprot.writeI32(iter97)
3064 chandransh 8341 
      oprot.writeListEnd()
2783 chandransh 8342 
      oprot.writeFieldEnd()
1149 chandransh 8343 
    oprot.writeFieldStop()
8344 
    oprot.writeStructEnd()
8345 
 
3431 rajveer 8346 
  def validate(self):
8347 
    return
8348 
 
8349 
 
1149 chandransh 8350 
  def __repr__(self):
8351 
    L = ['%s=%r' % (key, value)
8352 
      for key, value in self.__dict__.iteritems()]
8353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8354 
 
8355 
  def __eq__(self, other):
8356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8357 
 
8358 
  def __ne__(self, other):
8359 
    return not (self == other)
8360 
 
3064 chandransh 8361 
class getOrdersForCustomer_result:
1149 chandransh 8362 
  """
8363 
  Attributes:
8364 
   - success
8365 
   - ex
8366 
  """
8367 
 
8368 
  thrift_spec = (
3064 chandransh 8369 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8370 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8371 
  )
8372 
 
8373 
  def __init__(self, success=None, ex=None,):
8374 
    self.success = success
8375 
    self.ex = ex
8376 
 
8377 
  def read(self, iprot):
8378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8380 
      return
8381 
    iprot.readStructBegin()
8382 
    while True:
8383 
      (fname, ftype, fid) = iprot.readFieldBegin()
8384 
      if ftype == TType.STOP:
8385 
        break
8386 
      if fid == 0:
3064 chandransh 8387 
        if ftype == TType.LIST:
8388 
          self.success = []
4133 chandransh 8389 
          (_etype101, _size98) = iprot.readListBegin()
8390 
          for _i102 in xrange(_size98):
8391 
            _elem103 = Order()
8392 
            _elem103.read(iprot)
8393 
            self.success.append(_elem103)
3064 chandransh 8394 
          iprot.readListEnd()
1149 chandransh 8395 
        else:
8396 
          iprot.skip(ftype)
8397 
      elif fid == 1:
8398 
        if ftype == TType.STRUCT:
8399 
          self.ex = TransactionServiceException()
8400 
          self.ex.read(iprot)
8401 
        else:
8402 
          iprot.skip(ftype)
8403 
      else:
8404 
        iprot.skip(ftype)
8405 
      iprot.readFieldEnd()
8406 
    iprot.readStructEnd()
8407 
 
8408 
  def write(self, oprot):
8409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8411 
      return
3064 chandransh 8412 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 8413 
    if self.success is not None:
3064 chandransh 8414 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8415 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8416 
      for iter104 in self.success:
8417 
        iter104.write(oprot)
3064 chandransh 8418 
      oprot.writeListEnd()
1149 chandransh 8419 
      oprot.writeFieldEnd()
3431 rajveer 8420 
    if self.ex is not None:
1149 chandransh 8421 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8422 
      self.ex.write(oprot)
8423 
      oprot.writeFieldEnd()
8424 
    oprot.writeFieldStop()
8425 
    oprot.writeStructEnd()
8426 
 
3431 rajveer 8427 
  def validate(self):
8428 
    return
8429 
 
8430 
 
1149 chandransh 8431 
  def __repr__(self):
8432 
    L = ['%s=%r' % (key, value)
8433 
      for key, value in self.__dict__.iteritems()]
8434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8435 
 
8436 
  def __eq__(self, other):
8437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8438 
 
8439 
  def __ne__(self, other):
8440 
    return not (self == other)
8441 
 
3064 chandransh 8442 
class createOrder_args:
921 rajveer 8443 
  """
8444 
  Attributes:
3064 chandransh 8445 
   - order
921 rajveer 8446 
  """
8447 
 
8448 
  thrift_spec = (
8449 
    None, # 0
3064 chandransh 8450 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 8451 
  )
8452 
 
3064 chandransh 8453 
  def __init__(self, order=None,):
8454 
    self.order = order
921 rajveer 8455 
 
8456 
  def read(self, iprot):
8457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8459 
      return
8460 
    iprot.readStructBegin()
8461 
    while True:
8462 
      (fname, ftype, fid) = iprot.readFieldBegin()
8463 
      if ftype == TType.STOP:
8464 
        break
8465 
      if fid == 1:
3064 chandransh 8466 
        if ftype == TType.STRUCT:
8467 
          self.order = Order()
8468 
          self.order.read(iprot)
921 rajveer 8469 
        else:
8470 
          iprot.skip(ftype)
8471 
      else:
8472 
        iprot.skip(ftype)
8473 
      iprot.readFieldEnd()
8474 
    iprot.readStructEnd()
8475 
 
8476 
  def write(self, oprot):
8477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8479 
      return
3064 chandransh 8480 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 8481 
    if self.order is not None:
3064 chandransh 8482 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
8483 
      self.order.write(oprot)
921 rajveer 8484 
      oprot.writeFieldEnd()
8485 
    oprot.writeFieldStop()
8486 
    oprot.writeStructEnd()
8487 
 
3431 rajveer 8488 
  def validate(self):
8489 
    return
8490 
 
8491 
 
921 rajveer 8492 
  def __repr__(self):
8493 
    L = ['%s=%r' % (key, value)
8494 
      for key, value in self.__dict__.iteritems()]
8495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8496 
 
8497 
  def __eq__(self, other):
8498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8499 
 
8500 
  def __ne__(self, other):
8501 
    return not (self == other)
8502 
 
3064 chandransh 8503 
class createOrder_result:
921 rajveer 8504 
  """
8505 
  Attributes:
8506 
   - success
8507 
   - ex
8508 
  """
8509 
 
8510 
  thrift_spec = (
3064 chandransh 8511 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 8512 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8513 
  )
8514 
 
8515 
  def __init__(self, success=None, ex=None,):
8516 
    self.success = success
8517 
    self.ex = ex
8518 
 
8519 
  def read(self, iprot):
8520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8522 
      return
8523 
    iprot.readStructBegin()
8524 
    while True:
8525 
      (fname, ftype, fid) = iprot.readFieldBegin()
8526 
      if ftype == TType.STOP:
8527 
        break
8528 
      if fid == 0:
3064 chandransh 8529 
        if ftype == TType.I64:
8530 
          self.success = iprot.readI64();
921 rajveer 8531 
        else:
8532 
          iprot.skip(ftype)
8533 
      elif fid == 1:
8534 
        if ftype == TType.STRUCT:
8535 
          self.ex = TransactionServiceException()
8536 
          self.ex.read(iprot)
8537 
        else:
8538 
          iprot.skip(ftype)
8539 
      else:
8540 
        iprot.skip(ftype)
8541 
      iprot.readFieldEnd()
8542 
    iprot.readStructEnd()
8543 
 
8544 
  def write(self, oprot):
8545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8547 
      return
3064 chandransh 8548 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 8549 
    if self.success is not None:
3064 chandransh 8550 
      oprot.writeFieldBegin('success', TType.I64, 0)
8551 
      oprot.writeI64(self.success)
921 rajveer 8552 
      oprot.writeFieldEnd()
3431 rajveer 8553 
    if self.ex is not None:
921 rajveer 8554 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8555 
      self.ex.write(oprot)
8556 
      oprot.writeFieldEnd()
8557 
    oprot.writeFieldStop()
8558 
    oprot.writeStructEnd()
8559 
 
3431 rajveer 8560 
  def validate(self):
8561 
    return
8562 
 
8563 
 
921 rajveer 8564 
  def __repr__(self):
8565 
    L = ['%s=%r' % (key, value)
8566 
      for key, value in self.__dict__.iteritems()]
8567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8568 
 
8569 
  def __eq__(self, other):
8570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8571 
 
8572 
  def __ne__(self, other):
8573 
    return not (self == other)
8574 
 
3064 chandransh 8575 
class getOrder_args:
921 rajveer 8576 
  """
8577 
  Attributes:
3064 chandransh 8578 
   - id
921 rajveer 8579 
  """
8580 
 
8581 
  thrift_spec = (
8582 
    None, # 0
3064 chandransh 8583 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 8584 
  )
8585 
 
3064 chandransh 8586 
  def __init__(self, id=None,):
8587 
    self.id = id
921 rajveer 8588 
 
8589 
  def read(self, iprot):
8590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8592 
      return
8593 
    iprot.readStructBegin()
8594 
    while True:
8595 
      (fname, ftype, fid) = iprot.readFieldBegin()
8596 
      if ftype == TType.STOP:
8597 
        break
8598 
      if fid == 1:
8599 
        if ftype == TType.I64:
3064 chandransh 8600 
          self.id = iprot.readI64();
921 rajveer 8601 
        else:
8602 
          iprot.skip(ftype)
8603 
      else:
8604 
        iprot.skip(ftype)
8605 
      iprot.readFieldEnd()
8606 
    iprot.readStructEnd()
8607 
 
8608 
  def write(self, oprot):
8609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8611 
      return
3064 chandransh 8612 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 8613 
    if self.id is not None:
3064 chandransh 8614 
      oprot.writeFieldBegin('id', TType.I64, 1)
8615 
      oprot.writeI64(self.id)
921 rajveer 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_result:
921 rajveer 8636 
  """
8637 
  Attributes:
8638 
   - success
8639 
   - ex
8640 
  """
8641 
 
8642 
  thrift_spec = (
3064 chandransh 8643 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 8644 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8645 
  )
8646 
 
8647 
  def __init__(self, success=None, ex=None,):
8648 
    self.success = success
8649 
    self.ex = ex
8650 
 
8651 
  def read(self, iprot):
8652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8654 
      return
8655 
    iprot.readStructBegin()
8656 
    while True:
8657 
      (fname, ftype, fid) = iprot.readFieldBegin()
8658 
      if ftype == TType.STOP:
8659 
        break
8660 
      if fid == 0:
3064 chandransh 8661 
        if ftype == TType.STRUCT:
8662 
          self.success = Order()
8663 
          self.success.read(iprot)
921 rajveer 8664 
        else:
8665 
          iprot.skip(ftype)
8666 
      elif fid == 1:
8667 
        if ftype == TType.STRUCT:
8668 
          self.ex = TransactionServiceException()
8669 
          self.ex.read(iprot)
8670 
        else:
8671 
          iprot.skip(ftype)
8672 
      else:
8673 
        iprot.skip(ftype)
8674 
      iprot.readFieldEnd()
8675 
    iprot.readStructEnd()
8676 
 
8677 
  def write(self, oprot):
8678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8680 
      return
3064 chandransh 8681 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 8682 
    if self.success is not None:
3064 chandransh 8683 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8684 
      self.success.write(oprot)
921 rajveer 8685 
      oprot.writeFieldEnd()
3431 rajveer 8686 
    if self.ex is not None:
921 rajveer 8687 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8688 
      self.ex.write(oprot)
8689 
      oprot.writeFieldEnd()
8690 
    oprot.writeFieldStop()
8691 
    oprot.writeStructEnd()
8692 
 
3431 rajveer 8693 
  def validate(self):
8694 
    return
8695 
 
8696 
 
921 rajveer 8697 
  def __repr__(self):
8698 
    L = ['%s=%r' % (key, value)
8699 
      for key, value in self.__dict__.iteritems()]
8700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8701 
 
8702 
  def __eq__(self, other):
8703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8704 
 
8705 
  def __ne__(self, other):
8706 
    return not (self == other)
8707 
 
3064 chandransh 8708 
class getLineItemsForOrder_args:
94 ashish 8709 
  """
8710 
  Attributes:
3064 chandransh 8711 
   - orderId
94 ashish 8712 
  """
8713 
 
8714 
  thrift_spec = (
8715 
    None, # 0
3064 chandransh 8716 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 8717 
  )
8718 
 
3064 chandransh 8719 
  def __init__(self, orderId=None,):
8720 
    self.orderId = orderId
94 ashish 8721 
 
8722 
  def read(self, iprot):
8723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8725 
      return
8726 
    iprot.readStructBegin()
8727 
    while True:
8728 
      (fname, ftype, fid) = iprot.readFieldBegin()
8729 
      if ftype == TType.STOP:
8730 
        break
8731 
      if fid == 1:
8732 
        if ftype == TType.I64:
3064 chandransh 8733 
          self.orderId = iprot.readI64();
94 ashish 8734 
        else:
8735 
          iprot.skip(ftype)
8736 
      else:
8737 
        iprot.skip(ftype)
8738 
      iprot.readFieldEnd()
8739 
    iprot.readStructEnd()
8740 
 
8741 
  def write(self, oprot):
8742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8744 
      return
3064 chandransh 8745 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 8746 
    if self.orderId is not None:
3064 chandransh 8747 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8748 
      oprot.writeI64(self.orderId)
94 ashish 8749 
      oprot.writeFieldEnd()
8750 
    oprot.writeFieldStop()
8751 
    oprot.writeStructEnd()
8752 
 
3431 rajveer 8753 
  def validate(self):
8754 
    return
8755 
 
8756 
 
94 ashish 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_result:
94 ashish 8769 
  """
8770 
  Attributes:
8771 
   - success
8772 
   - ex
8773 
  """
8774 
 
8775 
  thrift_spec = (
3064 chandransh 8776 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 8777 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8778 
  )
8779 
 
8780 
  def __init__(self, success=None, ex=None,):
8781 
    self.success = success
8782 
    self.ex = ex
8783 
 
8784 
  def read(self, iprot):
8785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8787 
      return
8788 
    iprot.readStructBegin()
8789 
    while True:
8790 
      (fname, ftype, fid) = iprot.readFieldBegin()
8791 
      if ftype == TType.STOP:
8792 
        break
8793 
      if fid == 0:
483 rajveer 8794 
        if ftype == TType.LIST:
8795 
          self.success = []
4133 chandransh 8796 
          (_etype108, _size105) = iprot.readListBegin()
8797 
          for _i109 in xrange(_size105):
8798 
            _elem110 = LineItem()
8799 
            _elem110.read(iprot)
8800 
            self.success.append(_elem110)
483 rajveer 8801 
          iprot.readListEnd()
94 ashish 8802 
        else:
8803 
          iprot.skip(ftype)
8804 
      elif fid == 1:
8805 
        if ftype == TType.STRUCT:
8806 
          self.ex = TransactionServiceException()
8807 
          self.ex.read(iprot)
8808 
        else:
8809 
          iprot.skip(ftype)
8810 
      else:
8811 
        iprot.skip(ftype)
8812 
      iprot.readFieldEnd()
8813 
    iprot.readStructEnd()
8814 
 
8815 
  def write(self, oprot):
8816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8818 
      return
3064 chandransh 8819 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8820 
    if self.success is not None:
483 rajveer 8821 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8822 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8823 
      for iter111 in self.success:
8824 
        iter111.write(oprot)
483 rajveer 8825 
      oprot.writeListEnd()
94 ashish 8826 
      oprot.writeFieldEnd()
3431 rajveer 8827 
    if self.ex is not None:
94 ashish 8828 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8829 
      self.ex.write(oprot)
8830 
      oprot.writeFieldEnd()
8831 
    oprot.writeFieldStop()
8832 
    oprot.writeStructEnd()
8833 
 
3431 rajveer 8834 
  def validate(self):
8835 
    return
8836 
 
8837 
 
94 ashish 8838 
  def __repr__(self):
8839 
    L = ['%s=%r' % (key, value)
8840 
      for key, value in self.__dict__.iteritems()]
8841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8842 
 
8843 
  def __eq__(self, other):
8844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8845 
 
8846 
  def __ne__(self, other):
8847 
    return not (self == other)
8848 
 
3064 chandransh 8849 
class getOrderForCustomer_args:
94 ashish 8850 
  """
8851 
  Attributes:
3064 chandransh 8852 
   - orderId
483 rajveer 8853 
   - customerId
94 ashish 8854 
  """
8855 
 
8856 
  thrift_spec = (
8857 
    None, # 0
3064 chandransh 8858 
    (1, TType.I64, 'orderId', None, None, ), # 1
8859 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8860 
  )
8861 
 
3064 chandransh 8862 
  def __init__(self, orderId=None, customerId=None,):
8863 
    self.orderId = orderId
483 rajveer 8864 
    self.customerId = customerId
94 ashish 8865 
 
8866 
  def read(self, iprot):
8867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8869 
      return
8870 
    iprot.readStructBegin()
8871 
    while True:
8872 
      (fname, ftype, fid) = iprot.readFieldBegin()
8873 
      if ftype == TType.STOP:
8874 
        break
8875 
      if fid == 1:
8876 
        if ftype == TType.I64:
3064 chandransh 8877 
          self.orderId = iprot.readI64();
94 ashish 8878 
        else:
8879 
          iprot.skip(ftype)
8880 
      elif fid == 2:
8881 
        if ftype == TType.I64:
3064 chandransh 8882 
          self.customerId = iprot.readI64();
94 ashish 8883 
        else:
8884 
          iprot.skip(ftype)
8885 
      else:
8886 
        iprot.skip(ftype)
8887 
      iprot.readFieldEnd()
8888 
    iprot.readStructEnd()
8889 
 
8890 
  def write(self, oprot):
8891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8893 
      return
3064 chandransh 8894 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 8895 
    if self.orderId is not None:
3064 chandransh 8896 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8897 
      oprot.writeI64(self.orderId)
8898 
      oprot.writeFieldEnd()
3431 rajveer 8899 
    if self.customerId is not None:
3064 chandransh 8900 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 8901 
      oprot.writeI64(self.customerId)
94 ashish 8902 
      oprot.writeFieldEnd()
8903 
    oprot.writeFieldStop()
8904 
    oprot.writeStructEnd()
8905 
 
3431 rajveer 8906 
  def validate(self):
8907 
    return
8908 
 
8909 
 
94 ashish 8910 
  def __repr__(self):
8911 
    L = ['%s=%r' % (key, value)
8912 
      for key, value in self.__dict__.iteritems()]
8913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8914 
 
8915 
  def __eq__(self, other):
8916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8917 
 
8918 
  def __ne__(self, other):
8919 
    return not (self == other)
8920 
 
3064 chandransh 8921 
class getOrderForCustomer_result:
94 ashish 8922 
  """
8923 
  Attributes:
8924 
   - success
8925 
   - ex
8926 
  """
8927 
 
8928 
  thrift_spec = (
3064 chandransh 8929 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 8930 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8931 
  )
8932 
 
8933 
  def __init__(self, success=None, ex=None,):
8934 
    self.success = success
8935 
    self.ex = ex
8936 
 
8937 
  def read(self, iprot):
8938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8940 
      return
8941 
    iprot.readStructBegin()
8942 
    while True:
8943 
      (fname, ftype, fid) = iprot.readFieldBegin()
8944 
      if ftype == TType.STOP:
8945 
        break
8946 
      if fid == 0:
3064 chandransh 8947 
        if ftype == TType.STRUCT:
8948 
          self.success = Order()
8949 
          self.success.read(iprot)
94 ashish 8950 
        else:
8951 
          iprot.skip(ftype)
8952 
      elif fid == 1:
8953 
        if ftype == TType.STRUCT:
8954 
          self.ex = TransactionServiceException()
8955 
          self.ex.read(iprot)
8956 
        else:
8957 
          iprot.skip(ftype)
8958 
      else:
8959 
        iprot.skip(ftype)
8960 
      iprot.readFieldEnd()
8961 
    iprot.readStructEnd()
8962 
 
8963 
  def write(self, oprot):
8964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8966 
      return
3064 chandransh 8967 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 8968 
    if self.success is not None:
3064 chandransh 8969 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8970 
      self.success.write(oprot)
94 ashish 8971 
      oprot.writeFieldEnd()
3431 rajveer 8972 
    if self.ex is not None:
94 ashish 8973 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8974 
      self.ex.write(oprot)
8975 
      oprot.writeFieldEnd()
8976 
    oprot.writeFieldStop()
8977 
    oprot.writeStructEnd()
8978 
 
3431 rajveer 8979 
  def validate(self):
8980 
    return
8981 
 
8982 
 
94 ashish 8983 
  def __repr__(self):
8984 
    L = ['%s=%r' % (key, value)
8985 
      for key, value in self.__dict__.iteritems()]
8986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8987 
 
8988 
  def __eq__(self, other):
8989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8990 
 
8991 
  def __ne__(self, other):
8992 
    return not (self == other)
8993 
 
3064 chandransh 8994 
class getAlerts_args:
94 ashish 8995 
  """
8996 
  Attributes:
4394 rajveer 8997 
   - type
4444 rajveer 8998 
   - warehouseId
4394 rajveer 8999 
   - status
9000 
   - timestamp
94 ashish 9001 
  """
9002 
 
9003 
  thrift_spec = (
9004 
    None, # 0
4394 rajveer 9005 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9006 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9007 
    (3, TType.I64, 'status', None, None, ), # 3
9008 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 9009 
  )
9010 
 
4444 rajveer 9011 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 9012 
    self.type = type
4444 rajveer 9013 
    self.warehouseId = warehouseId
4394 rajveer 9014 
    self.status = status
9015 
    self.timestamp = timestamp
94 ashish 9016 
 
9017 
  def read(self, iprot):
9018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9020 
      return
9021 
    iprot.readStructBegin()
9022 
    while True:
9023 
      (fname, ftype, fid) = iprot.readFieldBegin()
9024 
      if ftype == TType.STOP:
9025 
        break
9026 
      if fid == 1:
3064 chandransh 9027 
        if ftype == TType.I64:
4394 rajveer 9028 
          self.type = iprot.readI64();
94 ashish 9029 
        else:
9030 
          iprot.skip(ftype)
3064 chandransh 9031 
      elif fid == 2:
4394 rajveer 9032 
        if ftype == TType.I64:
4444 rajveer 9033 
          self.warehouseId = iprot.readI64();
3064 chandransh 9034 
        else:
9035 
          iprot.skip(ftype)
4394 rajveer 9036 
      elif fid == 3:
9037 
        if ftype == TType.I64:
4444 rajveer 9038 
          self.status = iprot.readI64();
9039 
        else:
9040 
          iprot.skip(ftype)
9041 
      elif fid == 4:
9042 
        if ftype == TType.I64:
4394 rajveer 9043 
          self.timestamp = iprot.readI64();
9044 
        else:
9045 
          iprot.skip(ftype)
94 ashish 9046 
      else:
9047 
        iprot.skip(ftype)
9048 
      iprot.readFieldEnd()
9049 
    iprot.readStructEnd()
9050 
 
9051 
  def write(self, oprot):
9052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9054 
      return
3064 chandransh 9055 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 9056 
    if self.type is not None:
9057 
      oprot.writeFieldBegin('type', TType.I64, 1)
9058 
      oprot.writeI64(self.type)
94 ashish 9059 
      oprot.writeFieldEnd()
4444 rajveer 9060 
    if self.warehouseId is not None:
9061 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9062 
      oprot.writeI64(self.warehouseId)
9063 
      oprot.writeFieldEnd()
4394 rajveer 9064 
    if self.status is not None:
4444 rajveer 9065 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 9066 
      oprot.writeI64(self.status)
3064 chandransh 9067 
      oprot.writeFieldEnd()
4394 rajveer 9068 
    if self.timestamp is not None:
4444 rajveer 9069 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 9070 
      oprot.writeI64(self.timestamp)
9071 
      oprot.writeFieldEnd()
94 ashish 9072 
    oprot.writeFieldStop()
9073 
    oprot.writeStructEnd()
9074 
 
3431 rajveer 9075 
  def validate(self):
9076 
    return
9077 
 
9078 
 
94 ashish 9079 
  def __repr__(self):
9080 
    L = ['%s=%r' % (key, value)
9081 
      for key, value in self.__dict__.iteritems()]
9082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9083 
 
9084 
  def __eq__(self, other):
9085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9086 
 
9087 
  def __ne__(self, other):
9088 
    return not (self == other)
9089 
 
3064 chandransh 9090 
class getAlerts_result:
94 ashish 9091 
  """
9092 
  Attributes:
9093 
   - success
9094 
  """
9095 
 
9096 
  thrift_spec = (
3064 chandransh 9097 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 9098 
  )
9099 
 
3064 chandransh 9100 
  def __init__(self, success=None,):
94 ashish 9101 
    self.success = success
9102 
 
9103 
  def read(self, iprot):
9104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9106 
      return
9107 
    iprot.readStructBegin()
9108 
    while True:
9109 
      (fname, ftype, fid) = iprot.readFieldBegin()
9110 
      if ftype == TType.STOP:
9111 
        break
9112 
      if fid == 0:
3064 chandransh 9113 
        if ftype == TType.LIST:
9114 
          self.success = []
4133 chandransh 9115 
          (_etype115, _size112) = iprot.readListBegin()
9116 
          for _i116 in xrange(_size112):
9117 
            _elem117 = Alert()
9118 
            _elem117.read(iprot)
9119 
            self.success.append(_elem117)
3064 chandransh 9120 
          iprot.readListEnd()
94 ashish 9121 
        else:
9122 
          iprot.skip(ftype)
9123 
      else:
9124 
        iprot.skip(ftype)
9125 
      iprot.readFieldEnd()
9126 
    iprot.readStructEnd()
9127 
 
9128 
  def write(self, oprot):
9129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9131 
      return
3064 chandransh 9132 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 9133 
    if self.success is not None:
3064 chandransh 9134 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9135 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9136 
      for iter118 in self.success:
9137 
        iter118.write(oprot)
3064 chandransh 9138 
      oprot.writeListEnd()
94 ashish 9139 
      oprot.writeFieldEnd()
9140 
    oprot.writeFieldStop()
9141 
    oprot.writeStructEnd()
9142 
 
3431 rajveer 9143 
  def validate(self):
9144 
    return
9145 
 
9146 
 
94 ashish 9147 
  def __repr__(self):
9148 
    L = ['%s=%r' % (key, value)
9149 
      for key, value in self.__dict__.iteritems()]
9150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9151 
 
9152 
  def __eq__(self, other):
9153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9154 
 
9155 
  def __ne__(self, other):
9156 
    return not (self == other)
9157 
 
4394 rajveer 9158 
class addAlert_args:
94 ashish 9159 
  """
9160 
  Attributes:
3064 chandransh 9161 
   - type
4444 rajveer 9162 
   - warehouseId
4394 rajveer 9163 
   - description
94 ashish 9164 
  """
9165 
 
9166 
  thrift_spec = (
9167 
    None, # 0
4394 rajveer 9168 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9169 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9170 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9171 
  )
9172 
 
4444 rajveer 9173 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 9174 
    self.type = type
4444 rajveer 9175 
    self.warehouseId = warehouseId
4394 rajveer 9176 
    self.description = description
94 ashish 9177 
 
9178 
  def read(self, iprot):
9179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9181 
      return
9182 
    iprot.readStructBegin()
9183 
    while True:
9184 
      (fname, ftype, fid) = iprot.readFieldBegin()
9185 
      if ftype == TType.STOP:
9186 
        break
9187 
      if fid == 1:
9188 
        if ftype == TType.I64:
4394 rajveer 9189 
          self.type = iprot.readI64();
94 ashish 9190 
        else:
9191 
          iprot.skip(ftype)
3064 chandransh 9192 
      elif fid == 2:
4444 rajveer 9193 
        if ftype == TType.I64:
9194 
          self.warehouseId = iprot.readI64();
9195 
        else:
9196 
          iprot.skip(ftype)
9197 
      elif fid == 3:
3064 chandransh 9198 
        if ftype == TType.STRING:
4394 rajveer 9199 
          self.description = iprot.readString();
3064 chandransh 9200 
        else:
9201 
          iprot.skip(ftype)
94 ashish 9202 
      else:
9203 
        iprot.skip(ftype)
9204 
      iprot.readFieldEnd()
9205 
    iprot.readStructEnd()
9206 
 
9207 
  def write(self, oprot):
9208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9210 
      return
4394 rajveer 9211 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 9212 
    if self.type is not None:
4394 rajveer 9213 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 9214 
      oprot.writeI64(self.type)
9215 
      oprot.writeFieldEnd()
4444 rajveer 9216 
    if self.warehouseId is not None:
9217 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9218 
      oprot.writeI64(self.warehouseId)
9219 
      oprot.writeFieldEnd()
4394 rajveer 9220 
    if self.description is not None:
4444 rajveer 9221 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 9222 
      oprot.writeString(self.description)
3064 chandransh 9223 
      oprot.writeFieldEnd()
94 ashish 9224 
    oprot.writeFieldStop()
9225 
    oprot.writeStructEnd()
9226 
 
3431 rajveer 9227 
  def validate(self):
9228 
    return
9229 
 
9230 
 
94 ashish 9231 
  def __repr__(self):
9232 
    L = ['%s=%r' % (key, value)
9233 
      for key, value in self.__dict__.iteritems()]
9234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9235 
 
9236 
  def __eq__(self, other):
9237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9238 
 
9239 
  def __ne__(self, other):
9240 
    return not (self == other)
9241 
 
4394 rajveer 9242 
class addAlert_result:
3064 chandransh 9243 
 
9244 
  thrift_spec = (
9245 
  )
9246 
 
9247 
  def read(self, iprot):
9248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9250 
      return
9251 
    iprot.readStructBegin()
9252 
    while True:
9253 
      (fname, ftype, fid) = iprot.readFieldBegin()
9254 
      if ftype == TType.STOP:
9255 
        break
9256 
      else:
9257 
        iprot.skip(ftype)
9258 
      iprot.readFieldEnd()
9259 
    iprot.readStructEnd()
9260 
 
9261 
  def write(self, oprot):
9262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9264 
      return
4394 rajveer 9265 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 9266 
    oprot.writeFieldStop()
9267 
    oprot.writeStructEnd()
9268 
 
3431 rajveer 9269 
  def validate(self):
9270 
    return
9271 
 
9272 
 
3064 chandransh 9273 
  def __repr__(self):
9274 
    L = ['%s=%r' % (key, value)
9275 
      for key, value in self.__dict__.iteritems()]
9276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9277 
 
9278 
  def __eq__(self, other):
9279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9280 
 
9281 
  def __ne__(self, other):
9282 
    return not (self == other)
9283 
 
4444 rajveer 9284 
class markAlertsAsSeen_args:
9285 
  """
9286 
  Attributes:
9287 
   - warehouseId
9288 
  """
9289 
 
9290 
  thrift_spec = (
9291 
    None, # 0
9292 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9293 
  )
9294 
 
9295 
  def __init__(self, warehouseId=None,):
9296 
    self.warehouseId = warehouseId
9297 
 
9298 
  def read(self, iprot):
9299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9301 
      return
9302 
    iprot.readStructBegin()
9303 
    while True:
9304 
      (fname, ftype, fid) = iprot.readFieldBegin()
9305 
      if ftype == TType.STOP:
9306 
        break
9307 
      if fid == 1:
9308 
        if ftype == TType.I64:
9309 
          self.warehouseId = iprot.readI64();
9310 
        else:
9311 
          iprot.skip(ftype)
9312 
      else:
9313 
        iprot.skip(ftype)
9314 
      iprot.readFieldEnd()
9315 
    iprot.readStructEnd()
9316 
 
9317 
  def write(self, oprot):
9318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9320 
      return
9321 
    oprot.writeStructBegin('markAlertsAsSeen_args')
9322 
    if self.warehouseId is not None:
9323 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9324 
      oprot.writeI64(self.warehouseId)
9325 
      oprot.writeFieldEnd()
9326 
    oprot.writeFieldStop()
9327 
    oprot.writeStructEnd()
9328 
 
9329 
  def validate(self):
9330 
    return
9331 
 
9332 
 
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 
 
9344 
class markAlertsAsSeen_result:
9345 
 
9346 
  thrift_spec = (
9347 
  )
9348 
 
9349 
  def read(self, iprot):
9350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9352 
      return
9353 
    iprot.readStructBegin()
9354 
    while True:
9355 
      (fname, ftype, fid) = iprot.readFieldBegin()
9356 
      if ftype == TType.STOP:
9357 
        break
9358 
      else:
9359 
        iprot.skip(ftype)
9360 
      iprot.readFieldEnd()
9361 
    iprot.readStructEnd()
9362 
 
9363 
  def write(self, oprot):
9364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9366 
      return
9367 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9368 
    oprot.writeFieldStop()
9369 
    oprot.writeStructEnd()
9370 
 
9371 
  def validate(self):
9372 
    return
9373 
 
9374 
 
9375 
  def __repr__(self):
9376 
    L = ['%s=%r' % (key, value)
9377 
      for key, value in self.__dict__.iteritems()]
9378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9379 
 
9380 
  def __eq__(self, other):
9381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9382 
 
9383 
  def __ne__(self, other):
9384 
    return not (self == other)
9385 
 
3064 chandransh 9386 
class getValidOrderCount_args:
9387 
 
9388 
  thrift_spec = (
9389 
  )
9390 
 
9391 
  def read(self, iprot):
9392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9394 
      return
9395 
    iprot.readStructBegin()
9396 
    while True:
9397 
      (fname, ftype, fid) = iprot.readFieldBegin()
9398 
      if ftype == TType.STOP:
9399 
        break
9400 
      else:
9401 
        iprot.skip(ftype)
9402 
      iprot.readFieldEnd()
9403 
    iprot.readStructEnd()
9404 
 
9405 
  def write(self, oprot):
9406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9408 
      return
9409 
    oprot.writeStructBegin('getValidOrderCount_args')
9410 
    oprot.writeFieldStop()
9411 
    oprot.writeStructEnd()
9412 
 
3431 rajveer 9413 
  def validate(self):
9414 
    return
9415 
 
9416 
 
3064 chandransh 9417 
  def __repr__(self):
9418 
    L = ['%s=%r' % (key, value)
9419 
      for key, value in self.__dict__.iteritems()]
9420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9421 
 
9422 
  def __eq__(self, other):
9423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9424 
 
9425 
  def __ne__(self, other):
9426 
    return not (self == other)
9427 
 
9428 
class getValidOrderCount_result:
94 ashish 9429 
  """
9430 
  Attributes:
9431 
   - success
9432 
  """
9433 
 
9434 
  thrift_spec = (
3064 chandransh 9435 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9436 
  )
9437 
 
3064 chandransh 9438 
  def __init__(self, success=None,):
94 ashish 9439 
    self.success = success
9440 
 
9441 
  def read(self, iprot):
9442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9444 
      return
9445 
    iprot.readStructBegin()
9446 
    while True:
9447 
      (fname, ftype, fid) = iprot.readFieldBegin()
9448 
      if ftype == TType.STOP:
9449 
        break
9450 
      if fid == 0:
3064 chandransh 9451 
        if ftype == TType.I64:
9452 
          self.success = iprot.readI64();
94 ashish 9453 
        else:
9454 
          iprot.skip(ftype)
9455 
      else:
9456 
        iprot.skip(ftype)
9457 
      iprot.readFieldEnd()
9458 
    iprot.readStructEnd()
9459 
 
9460 
  def write(self, oprot):
9461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9463 
      return
3064 chandransh 9464 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 9465 
    if self.success is not None:
3064 chandransh 9466 
      oprot.writeFieldBegin('success', TType.I64, 0)
9467 
      oprot.writeI64(self.success)
94 ashish 9468 
      oprot.writeFieldEnd()
9469 
    oprot.writeFieldStop()
9470 
    oprot.writeStructEnd()
9471 
 
3431 rajveer 9472 
  def validate(self):
9473 
    return
9474 
 
9475 
 
94 ashish 9476 
  def __repr__(self):
9477 
    L = ['%s=%r' % (key, value)
9478 
      for key, value in self.__dict__.iteritems()]
9479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9480 
 
9481 
  def __eq__(self, other):
9482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9483 
 
9484 
  def __ne__(self, other):
9485 
    return not (self == other)
9486 
 
3064 chandransh 9487 
class getNoOfCustomersWithSuccessfulTransaction_args:
9488 
 
9489 
  thrift_spec = (
9490 
  )
9491 
 
9492 
  def read(self, iprot):
9493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9495 
      return
9496 
    iprot.readStructBegin()
9497 
    while True:
9498 
      (fname, ftype, fid) = iprot.readFieldBegin()
9499 
      if ftype == TType.STOP:
9500 
        break
9501 
      else:
9502 
        iprot.skip(ftype)
9503 
      iprot.readFieldEnd()
9504 
    iprot.readStructEnd()
9505 
 
9506 
  def write(self, oprot):
9507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9509 
      return
9510 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
9511 
    oprot.writeFieldStop()
9512 
    oprot.writeStructEnd()
9513 
 
3431 rajveer 9514 
  def validate(self):
9515 
    return
9516 
 
9517 
 
3064 chandransh 9518 
  def __repr__(self):
9519 
    L = ['%s=%r' % (key, value)
9520 
      for key, value in self.__dict__.iteritems()]
9521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9522 
 
9523 
  def __eq__(self, other):
9524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9525 
 
9526 
  def __ne__(self, other):
9527 
    return not (self == other)
9528 
 
9529 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 9530 
  """
9531 
  Attributes:
3064 chandransh 9532 
   - success
94 ashish 9533 
  """
9534 
 
9535 
  thrift_spec = (
3064 chandransh 9536 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9537 
  )
9538 
 
3064 chandransh 9539 
  def __init__(self, success=None,):
9540 
    self.success = success
94 ashish 9541 
 
9542 
  def read(self, iprot):
9543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9545 
      return
9546 
    iprot.readStructBegin()
9547 
    while True:
9548 
      (fname, ftype, fid) = iprot.readFieldBegin()
9549 
      if ftype == TType.STOP:
9550 
        break
3064 chandransh 9551 
      if fid == 0:
94 ashish 9552 
        if ftype == TType.I64:
3064 chandransh 9553 
          self.success = iprot.readI64();
94 ashish 9554 
        else:
9555 
          iprot.skip(ftype)
9556 
      else:
9557 
        iprot.skip(ftype)
9558 
      iprot.readFieldEnd()
9559 
    iprot.readStructEnd()
9560 
 
9561 
  def write(self, oprot):
9562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9564 
      return
3064 chandransh 9565 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 9566 
    if self.success is not None:
3064 chandransh 9567 
      oprot.writeFieldBegin('success', TType.I64, 0)
9568 
      oprot.writeI64(self.success)
94 ashish 9569 
      oprot.writeFieldEnd()
9570 
    oprot.writeFieldStop()
9571 
    oprot.writeStructEnd()
9572 
 
3431 rajveer 9573 
  def validate(self):
9574 
    return
9575 
 
9576 
 
94 ashish 9577 
  def __repr__(self):
9578 
    L = ['%s=%r' % (key, value)
9579 
      for key, value in self.__dict__.iteritems()]
9580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9581 
 
9582 
  def __eq__(self, other):
9583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9584 
 
9585 
  def __ne__(self, other):
9586 
    return not (self == other)
9587 
 
3064 chandransh 9588 
class getValidOrdersAmountRange_args:
9589 
 
9590 
  thrift_spec = (
9591 
  )
9592 
 
9593 
  def read(self, iprot):
9594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9596 
      return
9597 
    iprot.readStructBegin()
9598 
    while True:
9599 
      (fname, ftype, fid) = iprot.readFieldBegin()
9600 
      if ftype == TType.STOP:
9601 
        break
9602 
      else:
9603 
        iprot.skip(ftype)
9604 
      iprot.readFieldEnd()
9605 
    iprot.readStructEnd()
9606 
 
9607 
  def write(self, oprot):
9608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9610 
      return
9611 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
9612 
    oprot.writeFieldStop()
9613 
    oprot.writeStructEnd()
9614 
 
3431 rajveer 9615 
  def validate(self):
9616 
    return
9617 
 
9618 
 
3064 chandransh 9619 
  def __repr__(self):
9620 
    L = ['%s=%r' % (key, value)
9621 
      for key, value in self.__dict__.iteritems()]
9622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9623 
 
9624 
  def __eq__(self, other):
9625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9626 
 
9627 
  def __ne__(self, other):
9628 
    return not (self == other)
9629 
 
9630 
class getValidOrdersAmountRange_result:
94 ashish 9631 
  """
9632 
  Attributes:
9633 
   - success
9634 
  """
9635 
 
9636 
  thrift_spec = (
3064 chandransh 9637 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 9638 
  )
9639 
 
3064 chandransh 9640 
  def __init__(self, success=None,):
94 ashish 9641 
    self.success = success
9642 
 
9643 
  def read(self, iprot):
9644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9646 
      return
9647 
    iprot.readStructBegin()
9648 
    while True:
9649 
      (fname, ftype, fid) = iprot.readFieldBegin()
9650 
      if ftype == TType.STOP:
9651 
        break
9652 
      if fid == 0:
483 rajveer 9653 
        if ftype == TType.LIST:
9654 
          self.success = []
4133 chandransh 9655 
          (_etype122, _size119) = iprot.readListBegin()
9656 
          for _i123 in xrange(_size119):
9657 
            _elem124 = iprot.readDouble();
9658 
            self.success.append(_elem124)
483 rajveer 9659 
          iprot.readListEnd()
94 ashish 9660 
        else:
9661 
          iprot.skip(ftype)
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
3064 chandransh 9671 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 9672 
    if self.success is not None:
483 rajveer 9673 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 9674 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 9675 
      for iter125 in self.success:
9676 
        oprot.writeDouble(iter125)
483 rajveer 9677 
      oprot.writeListEnd()
94 ashish 9678 
      oprot.writeFieldEnd()
9679 
    oprot.writeFieldStop()
9680 
    oprot.writeStructEnd()
9681 
 
3431 rajveer 9682 
  def validate(self):
9683 
    return
9684 
 
9685 
 
94 ashish 9686 
  def __repr__(self):
9687 
    L = ['%s=%r' % (key, value)
9688 
      for key, value in self.__dict__.iteritems()]
9689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9690 
 
9691 
  def __eq__(self, other):
9692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9693 
 
9694 
  def __ne__(self, other):
9695 
    return not (self == other)
9696 
 
3064 chandransh 9697 
class getValidOrders_args:
1528 ankur.sing 9698 
  """
9699 
  Attributes:
3064 chandransh 9700 
   - limit
1528 ankur.sing 9701 
  """
9702 
 
9703 
  thrift_spec = (
9704 
    None, # 0
3064 chandransh 9705 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 9706 
  )
9707 
 
3064 chandransh 9708 
  def __init__(self, limit=None,):
9709 
    self.limit = limit
1528 ankur.sing 9710 
 
9711 
  def read(self, iprot):
9712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9714 
      return
9715 
    iprot.readStructBegin()
9716 
    while True:
9717 
      (fname, ftype, fid) = iprot.readFieldBegin()
9718 
      if ftype == TType.STOP:
9719 
        break
9720 
      if fid == 1:
9721 
        if ftype == TType.I64:
3064 chandransh 9722 
          self.limit = iprot.readI64();
1528 ankur.sing 9723 
        else:
9724 
          iprot.skip(ftype)
9725 
      else:
9726 
        iprot.skip(ftype)
9727 
      iprot.readFieldEnd()
9728 
    iprot.readStructEnd()
9729 
 
9730 
  def write(self, oprot):
9731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9733 
      return
3064 chandransh 9734 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 9735 
    if self.limit is not None:
3064 chandransh 9736 
      oprot.writeFieldBegin('limit', TType.I64, 1)
9737 
      oprot.writeI64(self.limit)
1528 ankur.sing 9738 
      oprot.writeFieldEnd()
9739 
    oprot.writeFieldStop()
9740 
    oprot.writeStructEnd()
9741 
 
3431 rajveer 9742 
  def validate(self):
9743 
    return
9744 
 
9745 
 
1528 ankur.sing 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_result:
1528 ankur.sing 9758 
  """
9759 
  Attributes:
9760 
   - success
9761 
  """
9762 
 
9763 
  thrift_spec = (
3064 chandransh 9764 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 9765 
  )
9766 
 
3064 chandransh 9767 
  def __init__(self, success=None,):
1528 ankur.sing 9768 
    self.success = success
9769 
 
9770 
  def read(self, iprot):
9771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9773 
      return
9774 
    iprot.readStructBegin()
9775 
    while True:
9776 
      (fname, ftype, fid) = iprot.readFieldBegin()
9777 
      if ftype == TType.STOP:
9778 
        break
9779 
      if fid == 0:
3064 chandransh 9780 
        if ftype == TType.LIST:
9781 
          self.success = []
4133 chandransh 9782 
          (_etype129, _size126) = iprot.readListBegin()
9783 
          for _i130 in xrange(_size126):
9784 
            _elem131 = Order()
9785 
            _elem131.read(iprot)
9786 
            self.success.append(_elem131)
3064 chandransh 9787 
          iprot.readListEnd()
1528 ankur.sing 9788 
        else:
9789 
          iprot.skip(ftype)
9790 
      else:
9791 
        iprot.skip(ftype)
9792 
      iprot.readFieldEnd()
9793 
    iprot.readStructEnd()
9794 
 
9795 
  def write(self, oprot):
9796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9798 
      return
3064 chandransh 9799 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9800 
    if self.success is not None:
3064 chandransh 9801 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9802 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9803 
      for iter132 in self.success:
9804 
        iter132.write(oprot)
3064 chandransh 9805 
      oprot.writeListEnd()
1528 ankur.sing 9806 
      oprot.writeFieldEnd()
9807 
    oprot.writeFieldStop()
9808 
    oprot.writeStructEnd()
9809 
 
3431 rajveer 9810 
  def validate(self):
9811 
    return
9812 
 
9813 
 
1528 ankur.sing 9814 
  def __repr__(self):
9815 
    L = ['%s=%r' % (key, value)
9816 
      for key, value in self.__dict__.iteritems()]
9817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9818 
 
9819 
  def __eq__(self, other):
9820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9821 
 
9822 
  def __ne__(self, other):
9823 
    return not (self == other)
9824 
 
1220 chandransh 9825 
class batchOrders_args:
9826 
  """
9827 
  Attributes:
9828 
   - warehouseId
9829 
  """
9830 
 
9831 
  thrift_spec = (
9832 
    None, # 0
9833 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9834 
  )
9835 
 
9836 
  def __init__(self, warehouseId=None,):
9837 
    self.warehouseId = warehouseId
9838 
 
9839 
  def read(self, iprot):
9840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9842 
      return
9843 
    iprot.readStructBegin()
9844 
    while True:
9845 
      (fname, ftype, fid) = iprot.readFieldBegin()
9846 
      if ftype == TType.STOP:
9847 
        break
9848 
      if fid == 1:
9849 
        if ftype == TType.I64:
9850 
          self.warehouseId = iprot.readI64();
9851 
        else:
9852 
          iprot.skip(ftype)
9853 
      else:
9854 
        iprot.skip(ftype)
9855 
      iprot.readFieldEnd()
9856 
    iprot.readStructEnd()
9857 
 
9858 
  def write(self, oprot):
9859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9861 
      return
9862 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9863 
    if self.warehouseId is not None:
1220 chandransh 9864 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9865 
      oprot.writeI64(self.warehouseId)
9866 
      oprot.writeFieldEnd()
9867 
    oprot.writeFieldStop()
9868 
    oprot.writeStructEnd()
9869 
 
3431 rajveer 9870 
  def validate(self):
9871 
    return
9872 
 
9873 
 
1220 chandransh 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 
 
9885 
class batchOrders_result:
9886 
  """
9887 
  Attributes:
9888 
   - success
9889 
   - ex
9890 
  """
9891 
 
9892 
  thrift_spec = (
9893 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9894 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9895 
  )
9896 
 
9897 
  def __init__(self, success=None, ex=None,):
9898 
    self.success = success
9899 
    self.ex = ex
9900 
 
9901 
  def read(self, iprot):
9902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9904 
      return
9905 
    iprot.readStructBegin()
9906 
    while True:
9907 
      (fname, ftype, fid) = iprot.readFieldBegin()
9908 
      if ftype == TType.STOP:
9909 
        break
9910 
      if fid == 0:
9911 
        if ftype == TType.LIST:
9912 
          self.success = []
4133 chandransh 9913 
          (_etype136, _size133) = iprot.readListBegin()
9914 
          for _i137 in xrange(_size133):
9915 
            _elem138 = Order()
9916 
            _elem138.read(iprot)
9917 
            self.success.append(_elem138)
1220 chandransh 9918 
          iprot.readListEnd()
9919 
        else:
9920 
          iprot.skip(ftype)
9921 
      elif fid == 1:
9922 
        if ftype == TType.STRUCT:
9923 
          self.ex = TransactionServiceException()
9924 
          self.ex.read(iprot)
9925 
        else:
9926 
          iprot.skip(ftype)
9927 
      else:
9928 
        iprot.skip(ftype)
9929 
      iprot.readFieldEnd()
9930 
    iprot.readStructEnd()
9931 
 
9932 
  def write(self, oprot):
9933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9935 
      return
9936 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 9937 
    if self.success is not None:
1220 chandransh 9938 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9939 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9940 
      for iter139 in self.success:
9941 
        iter139.write(oprot)
1220 chandransh 9942 
      oprot.writeListEnd()
9943 
      oprot.writeFieldEnd()
3431 rajveer 9944 
    if self.ex is not None:
1220 chandransh 9945 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9946 
      self.ex.write(oprot)
9947 
      oprot.writeFieldEnd()
9948 
    oprot.writeFieldStop()
9949 
    oprot.writeStructEnd()
9950 
 
3431 rajveer 9951 
  def validate(self):
9952 
    return
9953 
 
9954 
 
1220 chandransh 9955 
  def __repr__(self):
9956 
    L = ['%s=%r' % (key, value)
9957 
      for key, value in self.__dict__.iteritems()]
9958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9959 
 
9960 
  def __eq__(self, other):
9961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9962 
 
9963 
  def __ne__(self, other):
9964 
    return not (self == other)
9965 
 
1208 chandransh 9966 
class markOrderAsOutOfStock_args:
9967 
  """
9968 
  Attributes:
9969 
   - orderId
9970 
  """
9971 
 
9972 
  thrift_spec = (
9973 
    None, # 0
9974 
    (1, TType.I64, 'orderId', None, None, ), # 1
9975 
  )
9976 
 
9977 
  def __init__(self, orderId=None,):
9978 
    self.orderId = orderId
9979 
 
9980 
  def read(self, iprot):
9981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9983 
      return
9984 
    iprot.readStructBegin()
9985 
    while True:
9986 
      (fname, ftype, fid) = iprot.readFieldBegin()
9987 
      if ftype == TType.STOP:
9988 
        break
9989 
      if fid == 1:
9990 
        if ftype == TType.I64:
9991 
          self.orderId = iprot.readI64();
9992 
        else:
9993 
          iprot.skip(ftype)
9994 
      else:
9995 
        iprot.skip(ftype)
9996 
      iprot.readFieldEnd()
9997 
    iprot.readStructEnd()
9998 
 
9999 
  def write(self, oprot):
10000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10002 
      return
10003 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 10004 
    if self.orderId is not None:
1208 chandransh 10005 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10006 
      oprot.writeI64(self.orderId)
10007 
      oprot.writeFieldEnd()
10008 
    oprot.writeFieldStop()
10009 
    oprot.writeStructEnd()
10010 
 
3431 rajveer 10011 
  def validate(self):
10012 
    return
10013 
 
10014 
 
1208 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 
 
10026 
class markOrderAsOutOfStock_result:
10027 
  """
10028 
  Attributes:
10029 
   - success
10030 
   - ex
10031 
  """
10032 
 
10033 
  thrift_spec = (
10034 
    (0, TType.BOOL, 'success', None, None, ), # 0
10035 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10036 
  )
10037 
 
10038 
  def __init__(self, success=None, ex=None,):
10039 
    self.success = success
10040 
    self.ex = ex
10041 
 
10042 
  def read(self, iprot):
10043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10045 
      return
10046 
    iprot.readStructBegin()
10047 
    while True:
10048 
      (fname, ftype, fid) = iprot.readFieldBegin()
10049 
      if ftype == TType.STOP:
10050 
        break
10051 
      if fid == 0:
10052 
        if ftype == TType.BOOL:
10053 
          self.success = iprot.readBool();
10054 
        else:
10055 
          iprot.skip(ftype)
10056 
      elif fid == 1:
10057 
        if ftype == TType.STRUCT:
10058 
          self.ex = TransactionServiceException()
10059 
          self.ex.read(iprot)
10060 
        else:
10061 
          iprot.skip(ftype)
10062 
      else:
10063 
        iprot.skip(ftype)
10064 
      iprot.readFieldEnd()
10065 
    iprot.readStructEnd()
10066 
 
10067 
  def write(self, oprot):
10068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10070 
      return
10071 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 10072 
    if self.success is not None:
1208 chandransh 10073 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10074 
      oprot.writeBool(self.success)
10075 
      oprot.writeFieldEnd()
3431 rajveer 10076 
    if self.ex is not None:
1208 chandransh 10077 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10078 
      self.ex.write(oprot)
10079 
      oprot.writeFieldEnd()
10080 
    oprot.writeFieldStop()
10081 
    oprot.writeStructEnd()
10082 
 
3431 rajveer 10083 
  def validate(self):
10084 
    return
10085 
 
10086 
 
1208 chandransh 10087 
  def __repr__(self):
10088 
    L = ['%s=%r' % (key, value)
10089 
      for key, value in self.__dict__.iteritems()]
10090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10091 
 
10092 
  def __eq__(self, other):
10093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10094 
 
10095 
  def __ne__(self, other):
10096 
    return not (self == other)
10097 
 
3064 chandransh 10098 
class verifyOrder_args:
759 chandransh 10099 
  """
10100 
  Attributes:
3064 chandransh 10101 
   - orderId
759 chandransh 10102 
  """
10103 
 
10104 
  thrift_spec = (
10105 
    None, # 0
3064 chandransh 10106 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 10107 
  )
10108 
 
3064 chandransh 10109 
  def __init__(self, orderId=None,):
10110 
    self.orderId = orderId
759 chandransh 10111 
 
10112 
  def read(self, iprot):
10113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10115 
      return
10116 
    iprot.readStructBegin()
10117 
    while True:
10118 
      (fname, ftype, fid) = iprot.readFieldBegin()
10119 
      if ftype == TType.STOP:
10120 
        break
10121 
      if fid == 1:
10122 
        if ftype == TType.I64:
3064 chandransh 10123 
          self.orderId = iprot.readI64();
759 chandransh 10124 
        else:
10125 
          iprot.skip(ftype)
10126 
      else:
10127 
        iprot.skip(ftype)
10128 
      iprot.readFieldEnd()
10129 
    iprot.readStructEnd()
10130 
 
10131 
  def write(self, oprot):
10132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10134 
      return
3064 chandransh 10135 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 10136 
    if self.orderId is not None:
3064 chandransh 10137 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10138 
      oprot.writeI64(self.orderId)
759 chandransh 10139 
      oprot.writeFieldEnd()
10140 
    oprot.writeFieldStop()
10141 
    oprot.writeStructEnd()
10142 
 
3431 rajveer 10143 
  def validate(self):
10144 
    return
10145 
 
10146 
 
759 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_result:
759 chandransh 10159 
  """
10160 
  Attributes:
10161 
   - success
10162 
   - ex
10163 
  """
10164 
 
10165 
  thrift_spec = (
10166 
    (0, TType.BOOL, 'success', None, None, ), # 0
10167 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10168 
  )
10169 
 
10170 
  def __init__(self, success=None, ex=None,):
10171 
    self.success = success
10172 
    self.ex = ex
10173 
 
10174 
  def read(self, iprot):
10175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10177 
      return
10178 
    iprot.readStructBegin()
10179 
    while True:
10180 
      (fname, ftype, fid) = iprot.readFieldBegin()
10181 
      if ftype == TType.STOP:
10182 
        break
10183 
      if fid == 0:
10184 
        if ftype == TType.BOOL:
10185 
          self.success = iprot.readBool();
10186 
        else:
10187 
          iprot.skip(ftype)
10188 
      elif fid == 1:
10189 
        if ftype == TType.STRUCT:
10190 
          self.ex = TransactionServiceException()
10191 
          self.ex.read(iprot)
10192 
        else:
10193 
          iprot.skip(ftype)
10194 
      else:
10195 
        iprot.skip(ftype)
10196 
      iprot.readFieldEnd()
10197 
    iprot.readStructEnd()
10198 
 
10199 
  def write(self, oprot):
10200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10202 
      return
3064 chandransh 10203 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 10204 
    if self.success is not None:
759 chandransh 10205 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10206 
      oprot.writeBool(self.success)
10207 
      oprot.writeFieldEnd()
3431 rajveer 10208 
    if self.ex is not None:
759 chandransh 10209 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10210 
      self.ex.write(oprot)
10211 
      oprot.writeFieldEnd()
10212 
    oprot.writeFieldStop()
10213 
    oprot.writeStructEnd()
10214 
 
3431 rajveer 10215 
  def validate(self):
10216 
    return
10217 
 
10218 
 
759 chandransh 10219 
  def __repr__(self):
10220 
    L = ['%s=%r' % (key, value)
10221 
      for key, value in self.__dict__.iteritems()]
10222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10223 
 
10224 
  def __eq__(self, other):
10225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10226 
 
10227 
  def __ne__(self, other):
10228 
    return not (self == other)
10229 
 
3064 chandransh 10230 
class acceptOrder_args:
1113 chandransh 10231 
  """
10232 
  Attributes:
3064 chandransh 10233 
   - orderId
1113 chandransh 10234 
  """
10235 
 
10236 
  thrift_spec = (
10237 
    None, # 0
3064 chandransh 10238 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 10239 
  )
10240 
 
3064 chandransh 10241 
  def __init__(self, orderId=None,):
10242 
    self.orderId = orderId
1113 chandransh 10243 
 
10244 
  def read(self, iprot):
10245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10247 
      return
10248 
    iprot.readStructBegin()
10249 
    while True:
10250 
      (fname, ftype, fid) = iprot.readFieldBegin()
10251 
      if ftype == TType.STOP:
10252 
        break
10253 
      if fid == 1:
10254 
        if ftype == TType.I64:
3064 chandransh 10255 
          self.orderId = iprot.readI64();
1113 chandransh 10256 
        else:
10257 
          iprot.skip(ftype)
10258 
      else:
10259 
        iprot.skip(ftype)
10260 
      iprot.readFieldEnd()
10261 
    iprot.readStructEnd()
10262 
 
10263 
  def write(self, oprot):
10264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10266 
      return
3064 chandransh 10267 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 10268 
    if self.orderId is not None:
3064 chandransh 10269 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10270 
      oprot.writeI64(self.orderId)
1113 chandransh 10271 
      oprot.writeFieldEnd()
10272 
    oprot.writeFieldStop()
10273 
    oprot.writeStructEnd()
10274 
 
3431 rajveer 10275 
  def validate(self):
10276 
    return
10277 
 
10278 
 
1113 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_result:
1113 chandransh 10291 
  """
10292 
  Attributes:
10293 
   - success
10294 
   - ex
10295 
  """
10296 
 
10297 
  thrift_spec = (
3064 chandransh 10298 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 10299 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10300 
  )
10301 
 
10302 
  def __init__(self, success=None, ex=None,):
10303 
    self.success = success
10304 
    self.ex = ex
10305 
 
10306 
  def read(self, iprot):
10307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10309 
      return
10310 
    iprot.readStructBegin()
10311 
    while True:
10312 
      (fname, ftype, fid) = iprot.readFieldBegin()
10313 
      if ftype == TType.STOP:
10314 
        break
10315 
      if fid == 0:
3064 chandransh 10316 
        if ftype == TType.BOOL:
10317 
          self.success = iprot.readBool();
1113 chandransh 10318 
        else:
10319 
          iprot.skip(ftype)
10320 
      elif fid == 1:
10321 
        if ftype == TType.STRUCT:
10322 
          self.ex = TransactionServiceException()
10323 
          self.ex.read(iprot)
10324 
        else:
10325 
          iprot.skip(ftype)
10326 
      else:
10327 
        iprot.skip(ftype)
10328 
      iprot.readFieldEnd()
10329 
    iprot.readStructEnd()
10330 
 
10331 
  def write(self, oprot):
10332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10334 
      return
3064 chandransh 10335 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 10336 
    if self.success is not None:
3064 chandransh 10337 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10338 
      oprot.writeBool(self.success)
1113 chandransh 10339 
      oprot.writeFieldEnd()
3431 rajveer 10340 
    if self.ex is not None:
1113 chandransh 10341 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10342 
      self.ex.write(oprot)
10343 
      oprot.writeFieldEnd()
10344 
    oprot.writeFieldStop()
10345 
    oprot.writeStructEnd()
10346 
 
3431 rajveer 10347 
  def validate(self):
10348 
    return
10349 
 
10350 
 
1113 chandransh 10351 
  def __repr__(self):
10352 
    L = ['%s=%r' % (key, value)
10353 
      for key, value in self.__dict__.iteritems()]
10354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10355 
 
10356 
  def __eq__(self, other):
10357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10358 
 
10359 
  def __ne__(self, other):
10360 
    return not (self == other)
10361 
 
3064 chandransh 10362 
class addBillingDetails_args:
1135 chandransh 10363 
  """
10364 
  Attributes:
3064 chandransh 10365 
   - orderId
10366 
   - invoice_number
4658 mandeep.dh 10367 
   - serialNumber
4283 anupam.sin 10368 
   - itemNumber
3064 chandransh 10369 
   - billed_by
4264 rajveer 10370 
   - jacketNumber
4283 anupam.sin 10371 
   - billingType
10372 
   - vendorId
1135 chandransh 10373 
  """
10374 
 
10375 
  thrift_spec = (
10376 
    None, # 0
3064 chandransh 10377 
    (1, TType.I64, 'orderId', None, None, ), # 1
10378 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 10379 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 10380 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10381 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10382 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10383 
    (7, TType.I64, 'billingType', None, None, ), # 7
10384 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 10385 
  )
10386 
 
4658 mandeep.dh 10387 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 10388 
    self.orderId = orderId
10389 
    self.invoice_number = invoice_number
4658 mandeep.dh 10390 
    self.serialNumber = serialNumber
4283 anupam.sin 10391 
    self.itemNumber = itemNumber
3064 chandransh 10392 
    self.billed_by = billed_by
4264 rajveer 10393 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10394 
    self.billingType = billingType
10395 
    self.vendorId = vendorId
1135 chandransh 10396 
 
10397 
  def read(self, iprot):
10398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10400 
      return
10401 
    iprot.readStructBegin()
10402 
    while True:
10403 
      (fname, ftype, fid) = iprot.readFieldBegin()
10404 
      if ftype == TType.STOP:
10405 
        break
10406 
      if fid == 1:
10407 
        if ftype == TType.I64:
3064 chandransh 10408 
          self.orderId = iprot.readI64();
1135 chandransh 10409 
        else:
10410 
          iprot.skip(ftype)
10411 
      elif fid == 2:
3064 chandransh 10412 
        if ftype == TType.STRING:
10413 
          self.invoice_number = iprot.readString();
1135 chandransh 10414 
        else:
10415 
          iprot.skip(ftype)
3064 chandransh 10416 
      elif fid == 3:
4658 mandeep.dh 10417 
        if ftype == TType.STRING:
10418 
          self.serialNumber = iprot.readString();
3064 chandransh 10419 
        else:
10420 
          iprot.skip(ftype)
10421 
      elif fid == 4:
10422 
        if ftype == TType.STRING:
10423 
          self.itemNumber = iprot.readString();
10424 
        else:
10425 
          iprot.skip(ftype)
10426 
      elif fid == 5:
10427 
        if ftype == TType.STRING:
4283 anupam.sin 10428 
          self.billed_by = iprot.readString();
3064 chandransh 10429 
        else:
10430 
          iprot.skip(ftype)
10431 
      elif fid == 6:
10432 
        if ftype == TType.I64:
4283 anupam.sin 10433 
          self.jacketNumber = iprot.readI64();
10434 
        else:
10435 
          iprot.skip(ftype)
10436 
      elif fid == 7:
10437 
        if ftype == TType.I64:
3064 chandransh 10438 
          self.billingType = iprot.readI64();
10439 
        else:
10440 
          iprot.skip(ftype)
4283 anupam.sin 10441 
      elif fid == 8:
10442 
        if ftype == TType.I64:
10443 
          self.vendorId = iprot.readI64();
10444 
        else:
10445 
          iprot.skip(ftype)
1246 chandransh 10446 
      else:
10447 
        iprot.skip(ftype)
10448 
      iprot.readFieldEnd()
10449 
    iprot.readStructEnd()
10450 
 
10451 
  def write(self, oprot):
10452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10454 
      return
4283 anupam.sin 10455 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 10456 
    if self.orderId is not None:
3064 chandransh 10457 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10458 
      oprot.writeI64(self.orderId)
1246 chandransh 10459 
      oprot.writeFieldEnd()
4283 anupam.sin 10460 
    if self.invoice_number is not None:
10461 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
10462 
      oprot.writeString(self.invoice_number)
1246 chandransh 10463 
      oprot.writeFieldEnd()
4658 mandeep.dh 10464 
    if self.serialNumber is not None:
10465 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
10466 
      oprot.writeString(self.serialNumber)
3064 chandransh 10467 
      oprot.writeFieldEnd()
3431 rajveer 10468 
    if self.itemNumber is not None:
3064 chandransh 10469 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
10470 
      oprot.writeString(self.itemNumber)
10471 
      oprot.writeFieldEnd()
4283 anupam.sin 10472 
    if self.billed_by is not None:
10473 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
10474 
      oprot.writeString(self.billed_by)
3064 chandransh 10475 
      oprot.writeFieldEnd()
4283 anupam.sin 10476 
    if self.jacketNumber is not None:
10477 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
10478 
      oprot.writeI64(self.jacketNumber)
10479 
      oprot.writeFieldEnd()
3431 rajveer 10480 
    if self.billingType is not None:
4283 anupam.sin 10481 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 10482 
      oprot.writeI64(self.billingType)
10483 
      oprot.writeFieldEnd()
4283 anupam.sin 10484 
    if self.vendorId is not None:
10485 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
10486 
      oprot.writeI64(self.vendorId)
10487 
      oprot.writeFieldEnd()
1246 chandransh 10488 
    oprot.writeFieldStop()
10489 
    oprot.writeStructEnd()
10490 
 
3431 rajveer 10491 
  def validate(self):
10492 
    return
10493 
 
10494 
 
1246 chandransh 10495 
  def __repr__(self):
10496 
    L = ['%s=%r' % (key, value)
10497 
      for key, value in self.__dict__.iteritems()]
10498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10499 
 
10500 
  def __eq__(self, other):
10501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10502 
 
10503 
  def __ne__(self, other):
10504 
    return not (self == other)
10505 
 
4283 anupam.sin 10506 
class addBillingDetails_result:
1246 chandransh 10507 
  """
10508 
  Attributes:
3064 chandransh 10509 
   - success
1246 chandransh 10510 
   - ex
10511 
  """
10512 
 
10513 
  thrift_spec = (
3064 chandransh 10514 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 10515 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10516 
  )
10517 
 
3064 chandransh 10518 
  def __init__(self, success=None, ex=None,):
10519 
    self.success = success
1246 chandransh 10520 
    self.ex = ex
10521 
 
10522 
  def read(self, iprot):
10523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10525 
      return
10526 
    iprot.readStructBegin()
10527 
    while True:
10528 
      (fname, ftype, fid) = iprot.readFieldBegin()
10529 
      if ftype == TType.STOP:
10530 
        break
3064 chandransh 10531 
      if fid == 0:
10532 
        if ftype == TType.BOOL:
10533 
          self.success = iprot.readBool();
10534 
        else:
10535 
          iprot.skip(ftype)
10536 
      elif fid == 1:
1246 chandransh 10537 
        if ftype == TType.STRUCT:
10538 
          self.ex = TransactionServiceException()
10539 
          self.ex.read(iprot)
10540 
        else:
10541 
          iprot.skip(ftype)
10542 
      else:
10543 
        iprot.skip(ftype)
10544 
      iprot.readFieldEnd()
10545 
    iprot.readStructEnd()
10546 
 
10547 
  def write(self, oprot):
10548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10550 
      return
4283 anupam.sin 10551 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 10552 
    if self.success is not None:
3064 chandransh 10553 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10554 
      oprot.writeBool(self.success)
10555 
      oprot.writeFieldEnd()
3431 rajveer 10556 
    if self.ex is not None:
1246 chandransh 10557 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10558 
      self.ex.write(oprot)
10559 
      oprot.writeFieldEnd()
10560 
    oprot.writeFieldStop()
10561 
    oprot.writeStructEnd()
10562 
 
3431 rajveer 10563 
  def validate(self):
10564 
    return
10565 
 
10566 
 
1246 chandransh 10567 
  def __repr__(self):
10568 
    L = ['%s=%r' % (key, value)
10569 
      for key, value in self.__dict__.iteritems()]
10570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10571 
 
10572 
  def __eq__(self, other):
10573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10574 
 
10575 
  def __ne__(self, other):
10576 
    return not (self == other)
10577 
 
4579 rajveer 10578 
class addInvoiceNumber_args:
10579 
  """
10580 
  Attributes:
10581 
   - orderId
10582 
   - invoiceNumber
10583 
  """
10584 
 
10585 
  thrift_spec = (
10586 
    None, # 0
10587 
    (1, TType.I64, 'orderId', None, None, ), # 1
10588 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
10589 
  )
10590 
 
10591 
  def __init__(self, orderId=None, invoiceNumber=None,):
10592 
    self.orderId = orderId
10593 
    self.invoiceNumber = invoiceNumber
10594 
 
10595 
  def read(self, iprot):
10596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10598 
      return
10599 
    iprot.readStructBegin()
10600 
    while True:
10601 
      (fname, ftype, fid) = iprot.readFieldBegin()
10602 
      if ftype == TType.STOP:
10603 
        break
10604 
      if fid == 1:
10605 
        if ftype == TType.I64:
10606 
          self.orderId = iprot.readI64();
10607 
        else:
10608 
          iprot.skip(ftype)
10609 
      elif fid == 2:
10610 
        if ftype == TType.STRING:
10611 
          self.invoiceNumber = iprot.readString();
10612 
        else:
10613 
          iprot.skip(ftype)
10614 
      else:
10615 
        iprot.skip(ftype)
10616 
      iprot.readFieldEnd()
10617 
    iprot.readStructEnd()
10618 
 
10619 
  def write(self, oprot):
10620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10622 
      return
10623 
    oprot.writeStructBegin('addInvoiceNumber_args')
10624 
    if self.orderId is not None:
10625 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10626 
      oprot.writeI64(self.orderId)
10627 
      oprot.writeFieldEnd()
10628 
    if self.invoiceNumber is not None:
10629 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
10630 
      oprot.writeString(self.invoiceNumber)
10631 
      oprot.writeFieldEnd()
10632 
    oprot.writeFieldStop()
10633 
    oprot.writeStructEnd()
10634 
 
10635 
  def validate(self):
10636 
    return
10637 
 
10638 
 
10639 
  def __repr__(self):
10640 
    L = ['%s=%r' % (key, value)
10641 
      for key, value in self.__dict__.iteritems()]
10642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10643 
 
10644 
  def __eq__(self, other):
10645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10646 
 
10647 
  def __ne__(self, other):
10648 
    return not (self == other)
10649 
 
10650 
class addInvoiceNumber_result:
10651 
  """
10652 
  Attributes:
10653 
   - ex
10654 
  """
10655 
 
10656 
  thrift_spec = (
10657 
    None, # 0
10658 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10659 
  )
10660 
 
10661 
  def __init__(self, ex=None,):
10662 
    self.ex = ex
10663 
 
10664 
  def read(self, iprot):
10665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10667 
      return
10668 
    iprot.readStructBegin()
10669 
    while True:
10670 
      (fname, ftype, fid) = iprot.readFieldBegin()
10671 
      if ftype == TType.STOP:
10672 
        break
10673 
      if fid == 1:
10674 
        if ftype == TType.STRUCT:
10675 
          self.ex = TransactionServiceException()
10676 
          self.ex.read(iprot)
10677 
        else:
10678 
          iprot.skip(ftype)
10679 
      else:
10680 
        iprot.skip(ftype)
10681 
      iprot.readFieldEnd()
10682 
    iprot.readStructEnd()
10683 
 
10684 
  def write(self, oprot):
10685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10687 
      return
10688 
    oprot.writeStructBegin('addInvoiceNumber_result')
10689 
    if self.ex is not None:
10690 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10691 
      self.ex.write(oprot)
10692 
      oprot.writeFieldEnd()
10693 
    oprot.writeFieldStop()
10694 
    oprot.writeStructEnd()
10695 
 
10696 
  def validate(self):
10697 
    return
10698 
 
10699 
 
10700 
  def __repr__(self):
10701 
    L = ['%s=%r' % (key, value)
10702 
      for key, value in self.__dict__.iteritems()]
10703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10704 
 
10705 
  def __eq__(self, other):
10706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10707 
 
10708 
  def __ne__(self, other):
10709 
    return not (self == other)
10710 
 
3064 chandransh 10711 
class markOrdersAsManifested_args:
1408 ankur.sing 10712 
  """
10713 
  Attributes:
3064 chandransh 10714 
   - warehouseId
1408 ankur.sing 10715 
   - providerId
3064 chandransh 10716 
   - cod
1408 ankur.sing 10717 
  """
10718 
 
10719 
  thrift_spec = (
10720 
    None, # 0
3064 chandransh 10721 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10722 
    (2, TType.I64, 'providerId', None, None, ), # 2
10723 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 10724 
  )
10725 
 
3064 chandransh 10726 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10727 
    self.warehouseId = warehouseId
1408 ankur.sing 10728 
    self.providerId = providerId
3064 chandransh 10729 
    self.cod = cod
1408 ankur.sing 10730 
 
10731 
  def read(self, iprot):
10732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10734 
      return
10735 
    iprot.readStructBegin()
10736 
    while True:
10737 
      (fname, ftype, fid) = iprot.readFieldBegin()
10738 
      if ftype == TType.STOP:
10739 
        break
10740 
      if fid == 1:
10741 
        if ftype == TType.I64:
3064 chandransh 10742 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 10743 
        else:
10744 
          iprot.skip(ftype)
10745 
      elif fid == 2:
10746 
        if ftype == TType.I64:
3064 chandransh 10747 
          self.providerId = iprot.readI64();
1408 ankur.sing 10748 
        else:
10749 
          iprot.skip(ftype)
3064 chandransh 10750 
      elif fid == 3:
10751 
        if ftype == TType.BOOL:
10752 
          self.cod = iprot.readBool();
10753 
        else:
10754 
          iprot.skip(ftype)
1408 ankur.sing 10755 
      else:
10756 
        iprot.skip(ftype)
10757 
      iprot.readFieldEnd()
10758 
    iprot.readStructEnd()
10759 
 
10760 
  def write(self, oprot):
10761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10763 
      return
3064 chandransh 10764 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 10765 
    if self.warehouseId is not None:
3064 chandransh 10766 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10767 
      oprot.writeI64(self.warehouseId)
10768 
      oprot.writeFieldEnd()
3431 rajveer 10769 
    if self.providerId is not None:
3064 chandransh 10770 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 10771 
      oprot.writeI64(self.providerId)
10772 
      oprot.writeFieldEnd()
3431 rajveer 10773 
    if self.cod is not None:
3064 chandransh 10774 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10775 
      oprot.writeBool(self.cod)
1408 ankur.sing 10776 
      oprot.writeFieldEnd()
10777 
    oprot.writeFieldStop()
10778 
    oprot.writeStructEnd()
10779 
 
3431 rajveer 10780 
  def validate(self):
10781 
    return
10782 
 
10783 
 
1408 ankur.sing 10784 
  def __repr__(self):
10785 
    L = ['%s=%r' % (key, value)
10786 
      for key, value in self.__dict__.iteritems()]
10787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10788 
 
10789 
  def __eq__(self, other):
10790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10791 
 
10792 
  def __ne__(self, other):
10793 
    return not (self == other)
10794 
 
3064 chandransh 10795 
class markOrdersAsManifested_result:
1408 ankur.sing 10796 
  """
10797 
  Attributes:
10798 
   - success
3064 chandransh 10799 
   - ex
1408 ankur.sing 10800 
  """
10801 
 
10802 
  thrift_spec = (
3064 chandransh 10803 
    (0, TType.BOOL, 'success', None, None, ), # 0
10804 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10805 
  )
10806 
 
3064 chandransh 10807 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10808 
    self.success = success
3064 chandransh 10809 
    self.ex = ex
1408 ankur.sing 10810 
 
10811 
  def read(self, iprot):
10812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10814 
      return
10815 
    iprot.readStructBegin()
10816 
    while True:
10817 
      (fname, ftype, fid) = iprot.readFieldBegin()
10818 
      if ftype == TType.STOP:
10819 
        break
10820 
      if fid == 0:
3064 chandransh 10821 
        if ftype == TType.BOOL:
10822 
          self.success = iprot.readBool();
1408 ankur.sing 10823 
        else:
10824 
          iprot.skip(ftype)
3064 chandransh 10825 
      elif fid == 1:
10826 
        if ftype == TType.STRUCT:
10827 
          self.ex = TransactionServiceException()
10828 
          self.ex.read(iprot)
10829 
        else:
10830 
          iprot.skip(ftype)
1408 ankur.sing 10831 
      else:
10832 
        iprot.skip(ftype)
10833 
      iprot.readFieldEnd()
10834 
    iprot.readStructEnd()
10835 
 
10836 
  def write(self, oprot):
10837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10839 
      return
3064 chandransh 10840 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10841 
    if self.success is not None:
3064 chandransh 10842 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10843 
      oprot.writeBool(self.success)
1408 ankur.sing 10844 
      oprot.writeFieldEnd()
3431 rajveer 10845 
    if self.ex is not None:
3064 chandransh 10846 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10847 
      self.ex.write(oprot)
10848 
      oprot.writeFieldEnd()
1408 ankur.sing 10849 
    oprot.writeFieldStop()
10850 
    oprot.writeStructEnd()
10851 
 
3431 rajveer 10852 
  def validate(self):
10853 
    return
10854 
 
10855 
 
1408 ankur.sing 10856 
  def __repr__(self):
10857 
    L = ['%s=%r' % (key, value)
10858 
      for key, value in self.__dict__.iteritems()]
10859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10860 
 
10861 
  def __eq__(self, other):
10862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10863 
 
10864 
  def __ne__(self, other):
10865 
    return not (self == other)
10866 
 
4410 rajveer 10867 
class markOrdersAsShippedFromWarehouse_args:
10868 
  """
10869 
  Attributes:
10870 
   - warehouseId
10871 
   - providerId
10872 
   - cod
10873 
  """
10874 
 
10875 
  thrift_spec = (
10876 
    None, # 0
10877 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10878 
    (2, TType.I64, 'providerId', None, None, ), # 2
10879 
    (3, TType.BOOL, 'cod', None, None, ), # 3
10880 
  )
10881 
 
10882 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10883 
    self.warehouseId = warehouseId
10884 
    self.providerId = providerId
10885 
    self.cod = cod
10886 
 
10887 
  def read(self, iprot):
10888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10890 
      return
10891 
    iprot.readStructBegin()
10892 
    while True:
10893 
      (fname, ftype, fid) = iprot.readFieldBegin()
10894 
      if ftype == TType.STOP:
10895 
        break
10896 
      if fid == 1:
10897 
        if ftype == TType.I64:
10898 
          self.warehouseId = iprot.readI64();
10899 
        else:
10900 
          iprot.skip(ftype)
10901 
      elif fid == 2:
10902 
        if ftype == TType.I64:
10903 
          self.providerId = iprot.readI64();
10904 
        else:
10905 
          iprot.skip(ftype)
10906 
      elif fid == 3:
10907 
        if ftype == TType.BOOL:
10908 
          self.cod = iprot.readBool();
10909 
        else:
10910 
          iprot.skip(ftype)
10911 
      else:
10912 
        iprot.skip(ftype)
10913 
      iprot.readFieldEnd()
10914 
    iprot.readStructEnd()
10915 
 
10916 
  def write(self, oprot):
10917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10919 
      return
10920 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
10921 
    if self.warehouseId is not None:
10922 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10923 
      oprot.writeI64(self.warehouseId)
10924 
      oprot.writeFieldEnd()
10925 
    if self.providerId is not None:
10926 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
10927 
      oprot.writeI64(self.providerId)
10928 
      oprot.writeFieldEnd()
10929 
    if self.cod is not None:
10930 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10931 
      oprot.writeBool(self.cod)
10932 
      oprot.writeFieldEnd()
10933 
    oprot.writeFieldStop()
10934 
    oprot.writeStructEnd()
10935 
 
10936 
  def validate(self):
10937 
    return
10938 
 
10939 
 
10940 
  def __repr__(self):
10941 
    L = ['%s=%r' % (key, value)
10942 
      for key, value in self.__dict__.iteritems()]
10943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10944 
 
10945 
  def __eq__(self, other):
10946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10947 
 
10948 
  def __ne__(self, other):
10949 
    return not (self == other)
10950 
 
10951 
class markOrdersAsShippedFromWarehouse_result:
10952 
  """
10953 
  Attributes:
10954 
   - success
10955 
   - ex
10956 
  """
10957 
 
10958 
  thrift_spec = (
10959 
    (0, TType.BOOL, 'success', None, None, ), # 0
10960 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10961 
  )
10962 
 
10963 
  def __init__(self, success=None, ex=None,):
10964 
    self.success = success
10965 
    self.ex = ex
10966 
 
10967 
  def read(self, iprot):
10968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10970 
      return
10971 
    iprot.readStructBegin()
10972 
    while True:
10973 
      (fname, ftype, fid) = iprot.readFieldBegin()
10974 
      if ftype == TType.STOP:
10975 
        break
10976 
      if fid == 0:
10977 
        if ftype == TType.BOOL:
10978 
          self.success = iprot.readBool();
10979 
        else:
10980 
          iprot.skip(ftype)
10981 
      elif fid == 1:
10982 
        if ftype == TType.STRUCT:
10983 
          self.ex = TransactionServiceException()
10984 
          self.ex.read(iprot)
10985 
        else:
10986 
          iprot.skip(ftype)
10987 
      else:
10988 
        iprot.skip(ftype)
10989 
      iprot.readFieldEnd()
10990 
    iprot.readStructEnd()
10991 
 
10992 
  def write(self, oprot):
10993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10995 
      return
10996 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
10997 
    if self.success is not None:
10998 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10999 
      oprot.writeBool(self.success)
11000 
      oprot.writeFieldEnd()
11001 
    if self.ex is not None:
11002 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11003 
      self.ex.write(oprot)
11004 
      oprot.writeFieldEnd()
11005 
    oprot.writeFieldStop()
11006 
    oprot.writeStructEnd()
11007 
 
11008 
  def validate(self):
11009 
    return
11010 
 
11011 
 
11012 
  def __repr__(self):
11013 
    L = ['%s=%r' % (key, value)
11014 
      for key, value in self.__dict__.iteritems()]
11015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11016 
 
11017 
  def __eq__(self, other):
11018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11019 
 
11020 
  def __ne__(self, other):
11021 
    return not (self == other)
11022 
 
3064 chandransh 11023 
class markOrdersAsPickedUp_args:
304 ashish 11024 
  """
11025 
  Attributes:
3064 chandransh 11026 
   - providerId
11027 
   - pickupDetails
304 ashish 11028 
  """
94 ashish 11029 
 
304 ashish 11030 
  thrift_spec = (
11031 
    None, # 0
3064 chandransh 11032 
    (1, TType.I64, 'providerId', None, None, ), # 1
11033 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11034 
  )
11035 
 
3064 chandransh 11036 
  def __init__(self, providerId=None, pickupDetails=None,):
11037 
    self.providerId = providerId
11038 
    self.pickupDetails = pickupDetails
304 ashish 11039 
 
11040 
  def read(self, iprot):
11041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11043 
      return
11044 
    iprot.readStructBegin()
11045 
    while True:
11046 
      (fname, ftype, fid) = iprot.readFieldBegin()
11047 
      if ftype == TType.STOP:
11048 
        break
11049 
      if fid == 1:
11050 
        if ftype == TType.I64:
3064 chandransh 11051 
          self.providerId = iprot.readI64();
304 ashish 11052 
        else:
11053 
          iprot.skip(ftype)
11054 
      elif fid == 2:
3064 chandransh 11055 
        if ftype == TType.MAP:
11056 
          self.pickupDetails = {}
4133 chandransh 11057 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
11058 
          for _i144 in xrange(_size140):
11059 
            _key145 = iprot.readString();
11060 
            _val146 = iprot.readString();
11061 
            self.pickupDetails[_key145] = _val146
3064 chandransh 11062 
          iprot.readMapEnd()
304 ashish 11063 
        else:
11064 
          iprot.skip(ftype)
11065 
      else:
11066 
        iprot.skip(ftype)
11067 
      iprot.readFieldEnd()
11068 
    iprot.readStructEnd()
11069 
 
11070 
  def write(self, oprot):
11071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11073 
      return
3064 chandransh 11074 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 11075 
    if self.providerId is not None:
3064 chandransh 11076 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11077 
      oprot.writeI64(self.providerId)
304 ashish 11078 
      oprot.writeFieldEnd()
3431 rajveer 11079 
    if self.pickupDetails is not None:
3064 chandransh 11080 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11081 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 11082 
      for kiter147,viter148 in self.pickupDetails.items():
11083 
        oprot.writeString(kiter147)
11084 
        oprot.writeString(viter148)
3064 chandransh 11085 
      oprot.writeMapEnd()
304 ashish 11086 
      oprot.writeFieldEnd()
11087 
    oprot.writeFieldStop()
11088 
    oprot.writeStructEnd()
11089 
 
3431 rajveer 11090 
  def validate(self):
11091 
    return
11092 
 
11093 
 
304 ashish 11094 
  def __repr__(self):
11095 
    L = ['%s=%r' % (key, value)
11096 
      for key, value in self.__dict__.iteritems()]
11097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11098 
 
11099 
  def __eq__(self, other):
11100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11101 
 
11102 
  def __ne__(self, other):
11103 
    return not (self == other)
11104 
 
3064 chandransh 11105 
class markOrdersAsPickedUp_result:
304 ashish 11106 
  """
11107 
  Attributes:
11108 
   - success
3064 chandransh 11109 
   - ex
304 ashish 11110 
  """
11111 
 
11112 
  thrift_spec = (
3064 chandransh 11113 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11114 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11115 
  )
11116 
 
3064 chandransh 11117 
  def __init__(self, success=None, ex=None,):
304 ashish 11118 
    self.success = success
3064 chandransh 11119 
    self.ex = ex
304 ashish 11120 
 
11121 
  def read(self, iprot):
11122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11124 
      return
11125 
    iprot.readStructBegin()
11126 
    while True:
11127 
      (fname, ftype, fid) = iprot.readFieldBegin()
11128 
      if ftype == TType.STOP:
11129 
        break
11130 
      if fid == 0:
11131 
        if ftype == TType.LIST:
11132 
          self.success = []
4133 chandransh 11133 
          (_etype152, _size149) = iprot.readListBegin()
11134 
          for _i153 in xrange(_size149):
11135 
            _elem154 = Order()
11136 
            _elem154.read(iprot)
11137 
            self.success.append(_elem154)
304 ashish 11138 
          iprot.readListEnd()
11139 
        else:
11140 
          iprot.skip(ftype)
3064 chandransh 11141 
      elif fid == 1:
11142 
        if ftype == TType.STRUCT:
11143 
          self.ex = TransactionServiceException()
11144 
          self.ex.read(iprot)
11145 
        else:
11146 
          iprot.skip(ftype)
304 ashish 11147 
      else:
11148 
        iprot.skip(ftype)
11149 
      iprot.readFieldEnd()
11150 
    iprot.readStructEnd()
11151 
 
11152 
  def write(self, oprot):
11153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11155 
      return
3064 chandransh 11156 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 11157 
    if self.success is not None:
304 ashish 11158 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11159 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11160 
      for iter155 in self.success:
11161 
        iter155.write(oprot)
304 ashish 11162 
      oprot.writeListEnd()
11163 
      oprot.writeFieldEnd()
3431 rajveer 11164 
    if self.ex is not None:
3064 chandransh 11165 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11166 
      self.ex.write(oprot)
11167 
      oprot.writeFieldEnd()
304 ashish 11168 
    oprot.writeFieldStop()
11169 
    oprot.writeStructEnd()
11170 
 
3431 rajveer 11171 
  def validate(self):
11172 
    return
11173 
 
11174 
 
304 ashish 11175 
  def __repr__(self):
11176 
    L = ['%s=%r' % (key, value)
11177 
      for key, value in self.__dict__.iteritems()]
11178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11179 
 
11180 
  def __eq__(self, other):
11181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11182 
 
11183 
  def __ne__(self, other):
11184 
    return not (self == other)
11185 
 
3064 chandransh 11186 
class markOrdersAsDelivered_args:
304 ashish 11187 
  """
11188 
  Attributes:
3064 chandransh 11189 
   - providerId
11190 
   - deliveredOrders
304 ashish 11191 
  """
11192 
 
11193 
  thrift_spec = (
11194 
    None, # 0
3064 chandransh 11195 
    (1, TType.I64, 'providerId', None, None, ), # 1
11196 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11197 
  )
11198 
 
3064 chandransh 11199 
  def __init__(self, providerId=None, deliveredOrders=None,):
11200 
    self.providerId = providerId
11201 
    self.deliveredOrders = deliveredOrders
304 ashish 11202 
 
11203 
  def read(self, iprot):
11204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11206 
      return
11207 
    iprot.readStructBegin()
11208 
    while True:
11209 
      (fname, ftype, fid) = iprot.readFieldBegin()
11210 
      if ftype == TType.STOP:
11211 
        break
11212 
      if fid == 1:
11213 
        if ftype == TType.I64:
3064 chandransh 11214 
          self.providerId = iprot.readI64();
304 ashish 11215 
        else:
11216 
          iprot.skip(ftype)
11217 
      elif fid == 2:
3064 chandransh 11218 
        if ftype == TType.MAP:
11219 
          self.deliveredOrders = {}
4133 chandransh 11220 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
11221 
          for _i160 in xrange(_size156):
11222 
            _key161 = iprot.readString();
11223 
            _val162 = iprot.readString();
11224 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 11225 
          iprot.readMapEnd()
304 ashish 11226 
        else:
11227 
          iprot.skip(ftype)
11228 
      else:
11229 
        iprot.skip(ftype)
11230 
      iprot.readFieldEnd()
11231 
    iprot.readStructEnd()
11232 
 
11233 
  def write(self, oprot):
11234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11236 
      return
3064 chandransh 11237 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 11238 
    if self.providerId is not None:
3064 chandransh 11239 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11240 
      oprot.writeI64(self.providerId)
304 ashish 11241 
      oprot.writeFieldEnd()
3431 rajveer 11242 
    if self.deliveredOrders is not None:
3064 chandransh 11243 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
11244 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 11245 
      for kiter163,viter164 in self.deliveredOrders.items():
11246 
        oprot.writeString(kiter163)
11247 
        oprot.writeString(viter164)
3064 chandransh 11248 
      oprot.writeMapEnd()
304 ashish 11249 
      oprot.writeFieldEnd()
11250 
    oprot.writeFieldStop()
11251 
    oprot.writeStructEnd()
11252 
 
3431 rajveer 11253 
  def validate(self):
11254 
    return
11255 
 
11256 
 
304 ashish 11257 
  def __repr__(self):
11258 
    L = ['%s=%r' % (key, value)
11259 
      for key, value in self.__dict__.iteritems()]
11260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11261 
 
11262 
  def __eq__(self, other):
11263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11264 
 
11265 
  def __ne__(self, other):
11266 
    return not (self == other)
11267 
 
3064 chandransh 11268 
class markOrdersAsDelivered_result:
11269 
  """
11270 
  Attributes:
11271 
   - ex
11272 
  """
304 ashish 11273 
 
11274 
  thrift_spec = (
3064 chandransh 11275 
    None, # 0
11276 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11277 
  )
11278 
 
3064 chandransh 11279 
  def __init__(self, ex=None,):
11280 
    self.ex = ex
304 ashish 11281 
 
1596 ankur.sing 11282 
  def read(self, iprot):
11283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11285 
      return
11286 
    iprot.readStructBegin()
11287 
    while True:
11288 
      (fname, ftype, fid) = iprot.readFieldBegin()
11289 
      if ftype == TType.STOP:
11290 
        break
3064 chandransh 11291 
      if fid == 1:
11292 
        if ftype == TType.STRUCT:
11293 
          self.ex = TransactionServiceException()
11294 
          self.ex.read(iprot)
11295 
        else:
11296 
          iprot.skip(ftype)
1596 ankur.sing 11297 
      else:
11298 
        iprot.skip(ftype)
11299 
      iprot.readFieldEnd()
11300 
    iprot.readStructEnd()
11301 
 
11302 
  def write(self, oprot):
11303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11305 
      return
3064 chandransh 11306 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 11307 
    if self.ex is not None:
3064 chandransh 11308 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11309 
      self.ex.write(oprot)
11310 
      oprot.writeFieldEnd()
1596 ankur.sing 11311 
    oprot.writeFieldStop()
11312 
    oprot.writeStructEnd()
11313 
 
3431 rajveer 11314 
  def validate(self):
11315 
    return
11316 
 
11317 
 
1596 ankur.sing 11318 
  def __repr__(self):
11319 
    L = ['%s=%r' % (key, value)
11320 
      for key, value in self.__dict__.iteritems()]
11321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11322 
 
11323 
  def __eq__(self, other):
11324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11325 
 
11326 
  def __ne__(self, other):
11327 
    return not (self == other)
11328 
 
3064 chandransh 11329 
class markOrdersAsFailed_args:
1596 ankur.sing 11330 
  """
11331 
  Attributes:
3064 chandransh 11332 
   - providerId
11333 
   - returnedOrders
1596 ankur.sing 11334 
  """
11335 
 
11336 
  thrift_spec = (
3064 chandransh 11337 
    None, # 0
11338 
    (1, TType.I64, 'providerId', None, None, ), # 1
11339 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 11340 
  )
11341 
 
3064 chandransh 11342 
  def __init__(self, providerId=None, returnedOrders=None,):
11343 
    self.providerId = providerId
11344 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11345 
 
11346 
  def read(self, iprot):
11347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11349 
      return
11350 
    iprot.readStructBegin()
11351 
    while True:
11352 
      (fname, ftype, fid) = iprot.readFieldBegin()
11353 
      if ftype == TType.STOP:
11354 
        break
3064 chandransh 11355 
      if fid == 1:
1596 ankur.sing 11356 
        if ftype == TType.I64:
3064 chandransh 11357 
          self.providerId = iprot.readI64();
1596 ankur.sing 11358 
        else:
11359 
          iprot.skip(ftype)
3064 chandransh 11360 
      elif fid == 2:
11361 
        if ftype == TType.MAP:
11362 
          self.returnedOrders = {}
4133 chandransh 11363 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
11364 
          for _i169 in xrange(_size165):
11365 
            _key170 = iprot.readString();
11366 
            _val171 = iprot.readString();
11367 
            self.returnedOrders[_key170] = _val171
3064 chandransh 11368 
          iprot.readMapEnd()
11369 
        else:
11370 
          iprot.skip(ftype)
1596 ankur.sing 11371 
      else:
11372 
        iprot.skip(ftype)
11373 
      iprot.readFieldEnd()
11374 
    iprot.readStructEnd()
11375 
 
11376 
  def write(self, oprot):
11377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11379 
      return
3064 chandransh 11380 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 11381 
    if self.providerId is not None:
3064 chandransh 11382 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11383 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11384 
      oprot.writeFieldEnd()
3431 rajveer 11385 
    if self.returnedOrders is not None:
3064 chandransh 11386 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11387 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 11388 
      for kiter172,viter173 in self.returnedOrders.items():
11389 
        oprot.writeString(kiter172)
11390 
        oprot.writeString(viter173)
3064 chandransh 11391 
      oprot.writeMapEnd()
11392 
      oprot.writeFieldEnd()
1596 ankur.sing 11393 
    oprot.writeFieldStop()
11394 
    oprot.writeStructEnd()
11395 
 
3431 rajveer 11396 
  def validate(self):
11397 
    return
11398 
 
11399 
 
1596 ankur.sing 11400 
  def __repr__(self):
11401 
    L = ['%s=%r' % (key, value)
11402 
      for key, value in self.__dict__.iteritems()]
11403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11404 
 
11405 
  def __eq__(self, other):
11406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11407 
 
11408 
  def __ne__(self, other):
11409 
    return not (self == other)
11410 
 
3064 chandransh 11411 
class markOrdersAsFailed_result:
11412 
  """
11413 
  Attributes:
11414 
   - ex
11415 
  """
1596 ankur.sing 11416 
 
1627 ankur.sing 11417 
  thrift_spec = (
3064 chandransh 11418 
    None, # 0
11419 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11420 
  )
11421 
 
3064 chandransh 11422 
  def __init__(self, ex=None,):
11423 
    self.ex = ex
11424 
 
1627 ankur.sing 11425 
  def read(self, iprot):
11426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11428 
      return
11429 
    iprot.readStructBegin()
11430 
    while True:
11431 
      (fname, ftype, fid) = iprot.readFieldBegin()
11432 
      if ftype == TType.STOP:
11433 
        break
3064 chandransh 11434 
      if fid == 1:
11435 
        if ftype == TType.STRUCT:
11436 
          self.ex = TransactionServiceException()
11437 
          self.ex.read(iprot)
11438 
        else:
11439 
          iprot.skip(ftype)
1627 ankur.sing 11440 
      else:
11441 
        iprot.skip(ftype)
11442 
      iprot.readFieldEnd()
11443 
    iprot.readStructEnd()
11444 
 
11445 
  def write(self, oprot):
11446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11448 
      return
3064 chandransh 11449 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 11450 
    if self.ex is not None:
3064 chandransh 11451 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11452 
      self.ex.write(oprot)
11453 
      oprot.writeFieldEnd()
1627 ankur.sing 11454 
    oprot.writeFieldStop()
11455 
    oprot.writeStructEnd()
11456 
 
3431 rajveer 11457 
  def validate(self):
11458 
    return
11459 
 
11460 
 
1627 ankur.sing 11461 
  def __repr__(self):
11462 
    L = ['%s=%r' % (key, value)
11463 
      for key, value in self.__dict__.iteritems()]
11464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11465 
 
11466 
  def __eq__(self, other):
11467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11468 
 
11469 
  def __ne__(self, other):
11470 
    return not (self == other)
11471 
 
3064 chandransh 11472 
class updateNonDeliveryReason_args:
1627 ankur.sing 11473 
  """
11474 
  Attributes:
3064 chandransh 11475 
   - providerId
11476 
   - undeliveredOrders
1627 ankur.sing 11477 
  """
11478 
 
11479 
  thrift_spec = (
3064 chandransh 11480 
    None, # 0
11481 
    (1, TType.I64, 'providerId', None, None, ), # 1
11482 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 11483 
  )
11484 
 
3064 chandransh 11485 
  def __init__(self, providerId=None, undeliveredOrders=None,):
11486 
    self.providerId = providerId
11487 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 11488 
 
11489 
  def read(self, iprot):
11490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11492 
      return
11493 
    iprot.readStructBegin()
11494 
    while True:
11495 
      (fname, ftype, fid) = iprot.readFieldBegin()
11496 
      if ftype == TType.STOP:
11497 
        break
3064 chandransh 11498 
      if fid == 1:
1627 ankur.sing 11499 
        if ftype == TType.I64:
3064 chandransh 11500 
          self.providerId = iprot.readI64();
1627 ankur.sing 11501 
        else:
11502 
          iprot.skip(ftype)
3064 chandransh 11503 
      elif fid == 2:
11504 
        if ftype == TType.MAP:
11505 
          self.undeliveredOrders = {}
4133 chandransh 11506 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
11507 
          for _i178 in xrange(_size174):
11508 
            _key179 = iprot.readString();
11509 
            _val180 = iprot.readString();
11510 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 11511 
          iprot.readMapEnd()
11512 
        else:
11513 
          iprot.skip(ftype)
1627 ankur.sing 11514 
      else:
11515 
        iprot.skip(ftype)
11516 
      iprot.readFieldEnd()
11517 
    iprot.readStructEnd()
11518 
 
11519 
  def write(self, oprot):
11520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11522 
      return
3064 chandransh 11523 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 11524 
    if self.providerId is not None:
3064 chandransh 11525 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11526 
      oprot.writeI64(self.providerId)
1627 ankur.sing 11527 
      oprot.writeFieldEnd()
3431 rajveer 11528 
    if self.undeliveredOrders is not None:
3064 chandransh 11529 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
11530 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 11531 
      for kiter181,viter182 in self.undeliveredOrders.items():
11532 
        oprot.writeString(kiter181)
11533 
        oprot.writeString(viter182)
3064 chandransh 11534 
      oprot.writeMapEnd()
11535 
      oprot.writeFieldEnd()
1627 ankur.sing 11536 
    oprot.writeFieldStop()
11537 
    oprot.writeStructEnd()
11538 
 
3431 rajveer 11539 
  def validate(self):
11540 
    return
11541 
 
11542 
 
1627 ankur.sing 11543 
  def __repr__(self):
11544 
    L = ['%s=%r' % (key, value)
11545 
      for key, value in self.__dict__.iteritems()]
11546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11547 
 
11548 
  def __eq__(self, other):
11549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11550 
 
11551 
  def __ne__(self, other):
11552 
    return not (self == other)
11553 
 
3064 chandransh 11554 
class updateNonDeliveryReason_result:
1627 ankur.sing 11555 
  """
11556 
  Attributes:
4581 phani.kuma 11557 
   - success
3064 chandransh 11558 
   - ex
1627 ankur.sing 11559 
  """
11560 
 
11561 
  thrift_spec = (
4581 phani.kuma 11562 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 11563 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11564 
  )
11565 
 
4581 phani.kuma 11566 
  def __init__(self, success=None, ex=None,):
11567 
    self.success = success
3064 chandransh 11568 
    self.ex = ex
1627 ankur.sing 11569 
 
11570 
  def read(self, iprot):
11571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11573 
      return
11574 
    iprot.readStructBegin()
11575 
    while True:
11576 
      (fname, ftype, fid) = iprot.readFieldBegin()
11577 
      if ftype == TType.STOP:
11578 
        break
4581 phani.kuma 11579 
      if fid == 0:
11580 
        if ftype == TType.LIST:
11581 
          self.success = []
11582 
          (_etype186, _size183) = iprot.readListBegin()
11583 
          for _i187 in xrange(_size183):
11584 
            _elem188 = Order()
11585 
            _elem188.read(iprot)
11586 
            self.success.append(_elem188)
11587 
          iprot.readListEnd()
11588 
        else:
11589 
          iprot.skip(ftype)
11590 
      elif fid == 1:
3064 chandransh 11591 
        if ftype == TType.STRUCT:
11592 
          self.ex = TransactionServiceException()
11593 
          self.ex.read(iprot)
1627 ankur.sing 11594 
        else:
11595 
          iprot.skip(ftype)
11596 
      else:
11597 
        iprot.skip(ftype)
11598 
      iprot.readFieldEnd()
11599 
    iprot.readStructEnd()
11600 
 
11601 
  def write(self, oprot):
11602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11604 
      return
3064 chandransh 11605 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 11606 
    if self.success is not None:
11607 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11608 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11609 
      for iter189 in self.success:
11610 
        iter189.write(oprot)
11611 
      oprot.writeListEnd()
11612 
      oprot.writeFieldEnd()
3431 rajveer 11613 
    if self.ex is not None:
3064 chandransh 11614 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11615 
      self.ex.write(oprot)
1627 ankur.sing 11616 
      oprot.writeFieldEnd()
11617 
    oprot.writeFieldStop()
11618 
    oprot.writeStructEnd()
11619 
 
3431 rajveer 11620 
  def validate(self):
11621 
    return
11622 
 
11623 
 
1627 ankur.sing 11624 
  def __repr__(self):
11625 
    L = ['%s=%r' % (key, value)
11626 
      for key, value in self.__dict__.iteritems()]
11627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11628 
 
11629 
  def __eq__(self, other):
11630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11631 
 
11632 
  def __ne__(self, other):
11633 
    return not (self == other)
11634 
 
3064 chandransh 11635 
class getUndeliveredOrders_args:
1886 ankur.sing 11636 
  """
11637 
  Attributes:
3064 chandransh 11638 
   - providerId
11639 
   - warehouseId
1886 ankur.sing 11640 
  """
1627 ankur.sing 11641 
 
1886 ankur.sing 11642 
  thrift_spec = (
11643 
    None, # 0
3064 chandransh 11644 
    (1, TType.I64, 'providerId', None, None, ), # 1
11645 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 11646 
  )
11647 
 
3064 chandransh 11648 
  def __init__(self, providerId=None, warehouseId=None,):
11649 
    self.providerId = providerId
11650 
    self.warehouseId = warehouseId
1886 ankur.sing 11651 
 
11652 
  def read(self, iprot):
11653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11655 
      return
11656 
    iprot.readStructBegin()
11657 
    while True:
11658 
      (fname, ftype, fid) = iprot.readFieldBegin()
11659 
      if ftype == TType.STOP:
11660 
        break
11661 
      if fid == 1:
11662 
        if ftype == TType.I64:
3064 chandransh 11663 
          self.providerId = iprot.readI64();
1886 ankur.sing 11664 
        else:
11665 
          iprot.skip(ftype)
3064 chandransh 11666 
      elif fid == 2:
11667 
        if ftype == TType.I64:
11668 
          self.warehouseId = iprot.readI64();
11669 
        else:
11670 
          iprot.skip(ftype)
1886 ankur.sing 11671 
      else:
11672 
        iprot.skip(ftype)
11673 
      iprot.readFieldEnd()
11674 
    iprot.readStructEnd()
11675 
 
11676 
  def write(self, oprot):
11677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11679 
      return
3064 chandransh 11680 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 11681 
    if self.providerId is not None:
3064 chandransh 11682 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11683 
      oprot.writeI64(self.providerId)
1886 ankur.sing 11684 
      oprot.writeFieldEnd()
3431 rajveer 11685 
    if self.warehouseId is not None:
3064 chandransh 11686 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11687 
      oprot.writeI64(self.warehouseId)
11688 
      oprot.writeFieldEnd()
1886 ankur.sing 11689 
    oprot.writeFieldStop()
11690 
    oprot.writeStructEnd()
11691 
 
3431 rajveer 11692 
  def validate(self):
11693 
    return
11694 
 
11695 
 
1886 ankur.sing 11696 
  def __repr__(self):
11697 
    L = ['%s=%r' % (key, value)
11698 
      for key, value in self.__dict__.iteritems()]
11699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11700 
 
11701 
  def __eq__(self, other):
11702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11703 
 
11704 
  def __ne__(self, other):
11705 
    return not (self == other)
11706 
 
3064 chandransh 11707 
class getUndeliveredOrders_result:
1886 ankur.sing 11708 
  """
11709 
  Attributes:
11710 
   - success
11711 
  """
11712 
 
11713 
  thrift_spec = (
11714 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11715 
  )
11716 
 
11717 
  def __init__(self, success=None,):
11718 
    self.success = success
11719 
 
11720 
  def read(self, iprot):
11721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11723 
      return
11724 
    iprot.readStructBegin()
11725 
    while True:
11726 
      (fname, ftype, fid) = iprot.readFieldBegin()
11727 
      if ftype == TType.STOP:
11728 
        break
11729 
      if fid == 0:
11730 
        if ftype == TType.LIST:
11731 
          self.success = []
4581 phani.kuma 11732 
          (_etype193, _size190) = iprot.readListBegin()
11733 
          for _i194 in xrange(_size190):
11734 
            _elem195 = Order()
11735 
            _elem195.read(iprot)
11736 
            self.success.append(_elem195)
1886 ankur.sing 11737 
          iprot.readListEnd()
11738 
        else:
11739 
          iprot.skip(ftype)
11740 
      else:
11741 
        iprot.skip(ftype)
11742 
      iprot.readFieldEnd()
11743 
    iprot.readStructEnd()
11744 
 
11745 
  def write(self, oprot):
11746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11748 
      return
3064 chandransh 11749 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 11750 
    if self.success is not None:
1886 ankur.sing 11751 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11752 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 11753 
      for iter196 in self.success:
11754 
        iter196.write(oprot)
1886 ankur.sing 11755 
      oprot.writeListEnd()
11756 
      oprot.writeFieldEnd()
11757 
    oprot.writeFieldStop()
11758 
    oprot.writeStructEnd()
11759 
 
3431 rajveer 11760 
  def validate(self):
11761 
    return
11762 
 
11763 
 
1886 ankur.sing 11764 
  def __repr__(self):
11765 
    L = ['%s=%r' % (key, value)
11766 
      for key, value in self.__dict__.iteritems()]
11767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11768 
 
11769 
  def __eq__(self, other):
11770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11771 
 
11772 
  def __ne__(self, other):
11773 
    return not (self == other)
11774 
 
2536 chandransh 11775 
class toggleDOAFlag_args:
11776 
  """
11777 
  Attributes:
11778 
   - orderId
11779 
  """
1886 ankur.sing 11780 
 
2536 chandransh 11781 
  thrift_spec = (
11782 
    None, # 0
11783 
    (1, TType.I64, 'orderId', None, None, ), # 1
11784 
  )
11785 
 
11786 
  def __init__(self, orderId=None,):
11787 
    self.orderId = orderId
11788 
 
11789 
  def read(self, iprot):
11790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11792 
      return
11793 
    iprot.readStructBegin()
11794 
    while True:
11795 
      (fname, ftype, fid) = iprot.readFieldBegin()
11796 
      if ftype == TType.STOP:
11797 
        break
11798 
      if fid == 1:
11799 
        if ftype == TType.I64:
11800 
          self.orderId = iprot.readI64();
11801 
        else:
11802 
          iprot.skip(ftype)
11803 
      else:
11804 
        iprot.skip(ftype)
11805 
      iprot.readFieldEnd()
11806 
    iprot.readStructEnd()
11807 
 
11808 
  def write(self, oprot):
11809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11811 
      return
11812 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 11813 
    if self.orderId is not None:
2536 chandransh 11814 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11815 
      oprot.writeI64(self.orderId)
11816 
      oprot.writeFieldEnd()
11817 
    oprot.writeFieldStop()
11818 
    oprot.writeStructEnd()
11819 
 
3431 rajveer 11820 
  def validate(self):
11821 
    return
11822 
 
11823 
 
2536 chandransh 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 
 
11835 
class toggleDOAFlag_result:
11836 
  """
11837 
  Attributes:
11838 
   - success
11839 
   - ex
11840 
  """
11841 
 
11842 
  thrift_spec = (
11843 
    (0, TType.BOOL, 'success', None, None, ), # 0
11844 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11845 
  )
11846 
 
11847 
  def __init__(self, success=None, ex=None,):
11848 
    self.success = success
11849 
    self.ex = ex
11850 
 
11851 
  def read(self, iprot):
11852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11854 
      return
11855 
    iprot.readStructBegin()
11856 
    while True:
11857 
      (fname, ftype, fid) = iprot.readFieldBegin()
11858 
      if ftype == TType.STOP:
11859 
        break
11860 
      if fid == 0:
11861 
        if ftype == TType.BOOL:
11862 
          self.success = iprot.readBool();
11863 
        else:
11864 
          iprot.skip(ftype)
11865 
      elif fid == 1:
11866 
        if ftype == TType.STRUCT:
11867 
          self.ex = TransactionServiceException()
11868 
          self.ex.read(iprot)
11869 
        else:
11870 
          iprot.skip(ftype)
11871 
      else:
11872 
        iprot.skip(ftype)
11873 
      iprot.readFieldEnd()
11874 
    iprot.readStructEnd()
11875 
 
11876 
  def write(self, oprot):
11877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11879 
      return
11880 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 11881 
    if self.success is not None:
2536 chandransh 11882 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11883 
      oprot.writeBool(self.success)
11884 
      oprot.writeFieldEnd()
3431 rajveer 11885 
    if self.ex is not None:
2536 chandransh 11886 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11887 
      self.ex.write(oprot)
11888 
      oprot.writeFieldEnd()
11889 
    oprot.writeFieldStop()
11890 
    oprot.writeStructEnd()
11891 
 
3431 rajveer 11892 
  def validate(self):
11893 
    return
11894 
 
11895 
 
2536 chandransh 11896 
  def __repr__(self):
11897 
    L = ['%s=%r' % (key, value)
11898 
      for key, value in self.__dict__.iteritems()]
11899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11900 
 
11901 
  def __eq__(self, other):
11902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11903 
 
11904 
  def __ne__(self, other):
11905 
    return not (self == other)
11906 
 
4712 rajveer 11907 
class markOrderAsDelivered_args:
11908 
  """
11909 
  Attributes:
11910 
   - orderId
11911 
   - deliveryTimestamp
11912 
   - receiver
11913 
  """
11914 
 
11915 
  thrift_spec = None
11916 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
11917 
    self.orderId = orderId
11918 
    self.deliveryTimestamp = deliveryTimestamp
11919 
    self.receiver = receiver
11920 
 
11921 
  def read(self, iprot):
11922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11924 
      return
11925 
    iprot.readStructBegin()
11926 
    while True:
11927 
      (fname, ftype, fid) = iprot.readFieldBegin()
11928 
      if ftype == TType.STOP:
11929 
        break
11930 
      if fid == 1:
11931 
        if ftype == TType.I64:
11932 
          self.orderId = iprot.readI64();
11933 
        else:
11934 
          iprot.skip(ftype)
11935 
      elif fid == 2:
11936 
        if ftype == TType.I64:
11937 
          self.deliveryTimestamp = iprot.readI64();
11938 
        else:
11939 
          iprot.skip(ftype)
11940 
      elif fid == -1:
11941 
        if ftype == TType.STRING:
11942 
          self.receiver = iprot.readString();
11943 
        else:
11944 
          iprot.skip(ftype)
11945 
      else:
11946 
        iprot.skip(ftype)
11947 
      iprot.readFieldEnd()
11948 
    iprot.readStructEnd()
11949 
 
11950 
  def write(self, oprot):
11951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11953 
      return
11954 
    oprot.writeStructBegin('markOrderAsDelivered_args')
11955 
    if self.receiver is not None:
11956 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
11957 
      oprot.writeString(self.receiver)
11958 
      oprot.writeFieldEnd()
11959 
    if self.orderId is not None:
11960 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11961 
      oprot.writeI64(self.orderId)
11962 
      oprot.writeFieldEnd()
11963 
    if self.deliveryTimestamp is not None:
11964 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
11965 
      oprot.writeI64(self.deliveryTimestamp)
11966 
      oprot.writeFieldEnd()
11967 
    oprot.writeFieldStop()
11968 
    oprot.writeStructEnd()
11969 
 
11970 
  def validate(self):
11971 
    return
11972 
 
11973 
 
11974 
  def __repr__(self):
11975 
    L = ['%s=%r' % (key, value)
11976 
      for key, value in self.__dict__.iteritems()]
11977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11978 
 
11979 
  def __eq__(self, other):
11980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11981 
 
11982 
  def __ne__(self, other):
11983 
    return not (self == other)
11984 
 
11985 
class markOrderAsDelivered_result:
11986 
  """
11987 
  Attributes:
11988 
   - ex
11989 
  """
11990 
 
11991 
  thrift_spec = (
11992 
    None, # 0
11993 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11994 
  )
11995 
 
11996 
  def __init__(self, ex=None,):
11997 
    self.ex = ex
11998 
 
11999 
  def read(self, iprot):
12000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12002 
      return
12003 
    iprot.readStructBegin()
12004 
    while True:
12005 
      (fname, ftype, fid) = iprot.readFieldBegin()
12006 
      if ftype == TType.STOP:
12007 
        break
12008 
      if fid == 1:
12009 
        if ftype == TType.STRUCT:
12010 
          self.ex = TransactionServiceException()
12011 
          self.ex.read(iprot)
12012 
        else:
12013 
          iprot.skip(ftype)
12014 
      else:
12015 
        iprot.skip(ftype)
12016 
      iprot.readFieldEnd()
12017 
    iprot.readStructEnd()
12018 
 
12019 
  def write(self, oprot):
12020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12022 
      return
12023 
    oprot.writeStructBegin('markOrderAsDelivered_result')
12024 
    if self.ex is not None:
12025 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12026 
      self.ex.write(oprot)
12027 
      oprot.writeFieldEnd()
12028 
    oprot.writeFieldStop()
12029 
    oprot.writeStructEnd()
12030 
 
12031 
  def validate(self):
12032 
    return
12033 
 
12034 
 
12035 
  def __repr__(self):
12036 
    L = ['%s=%r' % (key, value)
12037 
      for key, value in self.__dict__.iteritems()]
12038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12039 
 
12040 
  def __eq__(self, other):
12041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12042 
 
12043 
  def __ne__(self, other):
12044 
    return not (self == other)
12045 
 
4454 rajveer 12046 
class markOrderDoaRequestReceived_args:
12047 
  """
12048 
  Attributes:
12049 
   - orderId
12050 
  """
12051 
 
12052 
  thrift_spec = (
12053 
    None, # 0
12054 
    (1, TType.I64, 'orderId', None, None, ), # 1
12055 
  )
12056 
 
12057 
  def __init__(self, orderId=None,):
12058 
    self.orderId = orderId
12059 
 
12060 
  def read(self, iprot):
12061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12063 
      return
12064 
    iprot.readStructBegin()
12065 
    while True:
12066 
      (fname, ftype, fid) = iprot.readFieldBegin()
12067 
      if ftype == TType.STOP:
12068 
        break
12069 
      if fid == 1:
12070 
        if ftype == TType.I64:
12071 
          self.orderId = iprot.readI64();
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('markOrderDoaRequestReceived_args')
12084 
    if self.orderId is not None:
12085 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12086 
      oprot.writeI64(self.orderId)
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 
 
12106 
class markOrderDoaRequestReceived_result:
12107 
  """
12108 
  Attributes:
12109 
   - success
12110 
   - ex
12111 
  """
12112 
 
12113 
  thrift_spec = (
12114 
    (0, TType.BOOL, 'success', None, None, ), # 0
12115 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12116 
  )
12117 
 
12118 
  def __init__(self, success=None, ex=None,):
12119 
    self.success = success
12120 
    self.ex = ex
12121 
 
12122 
  def read(self, iprot):
12123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12125 
      return
12126 
    iprot.readStructBegin()
12127 
    while True:
12128 
      (fname, ftype, fid) = iprot.readFieldBegin()
12129 
      if ftype == TType.STOP:
12130 
        break
12131 
      if fid == 0:
12132 
        if ftype == TType.BOOL:
12133 
          self.success = iprot.readBool();
12134 
        else:
12135 
          iprot.skip(ftype)
12136 
      elif fid == 1:
12137 
        if ftype == TType.STRUCT:
12138 
          self.ex = TransactionServiceException()
12139 
          self.ex.read(iprot)
12140 
        else:
12141 
          iprot.skip(ftype)
12142 
      else:
12143 
        iprot.skip(ftype)
12144 
      iprot.readFieldEnd()
12145 
    iprot.readStructEnd()
12146 
 
12147 
  def write(self, oprot):
12148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12150 
      return
12151 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
12152 
    if self.success is not None:
12153 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12154 
      oprot.writeBool(self.success)
12155 
      oprot.writeFieldEnd()
12156 
    if self.ex is not None:
12157 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12158 
      self.ex.write(oprot)
12159 
      oprot.writeFieldEnd()
12160 
    oprot.writeFieldStop()
12161 
    oprot.writeStructEnd()
12162 
 
12163 
  def validate(self):
12164 
    return
12165 
 
12166 
 
12167 
  def __repr__(self):
12168 
    L = ['%s=%r' % (key, value)
12169 
      for key, value in self.__dict__.iteritems()]
12170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12171 
 
12172 
  def __eq__(self, other):
12173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12174 
 
12175 
  def __ne__(self, other):
12176 
    return not (self == other)
12177 
 
12178 
class markOrderDoaRequestAuthorized_args:
12179 
  """
12180 
  Attributes:
12181 
   - orderId
12182 
   - isAuthorized
12183 
  """
12184 
 
12185 
  thrift_spec = (
12186 
    None, # 0
12187 
    (1, TType.I64, 'orderId', None, None, ), # 1
12188 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12189 
  )
12190 
 
12191 
  def __init__(self, orderId=None, isAuthorized=None,):
12192 
    self.orderId = orderId
12193 
    self.isAuthorized = isAuthorized
12194 
 
12195 
  def read(self, iprot):
12196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12198 
      return
12199 
    iprot.readStructBegin()
12200 
    while True:
12201 
      (fname, ftype, fid) = iprot.readFieldBegin()
12202 
      if ftype == TType.STOP:
12203 
        break
12204 
      if fid == 1:
12205 
        if ftype == TType.I64:
12206 
          self.orderId = iprot.readI64();
12207 
        else:
12208 
          iprot.skip(ftype)
12209 
      elif fid == 2:
12210 
        if ftype == TType.BOOL:
12211 
          self.isAuthorized = iprot.readBool();
12212 
        else:
12213 
          iprot.skip(ftype)
12214 
      else:
12215 
        iprot.skip(ftype)
12216 
      iprot.readFieldEnd()
12217 
    iprot.readStructEnd()
12218 
 
12219 
  def write(self, oprot):
12220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12222 
      return
12223 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
12224 
    if self.orderId is not None:
12225 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12226 
      oprot.writeI64(self.orderId)
12227 
      oprot.writeFieldEnd()
12228 
    if self.isAuthorized is not None:
12229 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12230 
      oprot.writeBool(self.isAuthorized)
12231 
      oprot.writeFieldEnd()
12232 
    oprot.writeFieldStop()
12233 
    oprot.writeStructEnd()
12234 
 
12235 
  def validate(self):
12236 
    return
12237 
 
12238 
 
12239 
  def __repr__(self):
12240 
    L = ['%s=%r' % (key, value)
12241 
      for key, value in self.__dict__.iteritems()]
12242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12243 
 
12244 
  def __eq__(self, other):
12245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12246 
 
12247 
  def __ne__(self, other):
12248 
    return not (self == other)
12249 
 
12250 
class markOrderDoaRequestAuthorized_result:
12251 
  """
12252 
  Attributes:
12253 
   - success
12254 
   - ex
12255 
  """
12256 
 
12257 
  thrift_spec = (
12258 
    (0, TType.BOOL, 'success', None, None, ), # 0
12259 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12260 
  )
12261 
 
12262 
  def __init__(self, success=None, ex=None,):
12263 
    self.success = success
12264 
    self.ex = ex
12265 
 
12266 
  def read(self, iprot):
12267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12269 
      return
12270 
    iprot.readStructBegin()
12271 
    while True:
12272 
      (fname, ftype, fid) = iprot.readFieldBegin()
12273 
      if ftype == TType.STOP:
12274 
        break
12275 
      if fid == 0:
12276 
        if ftype == TType.BOOL:
12277 
          self.success = iprot.readBool();
12278 
        else:
12279 
          iprot.skip(ftype)
12280 
      elif fid == 1:
12281 
        if ftype == TType.STRUCT:
12282 
          self.ex = TransactionServiceException()
12283 
          self.ex.read(iprot)
12284 
        else:
12285 
          iprot.skip(ftype)
12286 
      else:
12287 
        iprot.skip(ftype)
12288 
      iprot.readFieldEnd()
12289 
    iprot.readStructEnd()
12290 
 
12291 
  def write(self, oprot):
12292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12294 
      return
12295 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
12296 
    if self.success is not None:
12297 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12298 
      oprot.writeBool(self.success)
12299 
      oprot.writeFieldEnd()
12300 
    if self.ex is not None:
12301 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12302 
      self.ex.write(oprot)
12303 
      oprot.writeFieldEnd()
12304 
    oprot.writeFieldStop()
12305 
    oprot.writeStructEnd()
12306 
 
12307 
  def validate(self):
12308 
    return
12309 
 
12310 
 
12311 
  def __repr__(self):
12312 
    L = ['%s=%r' % (key, value)
12313 
      for key, value in self.__dict__.iteritems()]
12314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12315 
 
12316 
  def __eq__(self, other):
12317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12318 
 
12319 
  def __ne__(self, other):
12320 
    return not (self == other)
12321 
 
4488 rajveer 12322 
class markOrderReturnRequestReceived_args:
12323 
  """
12324 
  Attributes:
12325 
   - orderId
12326 
  """
12327 
 
12328 
  thrift_spec = (
12329 
    None, # 0
12330 
    (1, TType.I64, 'orderId', None, None, ), # 1
12331 
  )
12332 
 
12333 
  def __init__(self, orderId=None,):
12334 
    self.orderId = orderId
12335 
 
12336 
  def read(self, iprot):
12337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12339 
      return
12340 
    iprot.readStructBegin()
12341 
    while True:
12342 
      (fname, ftype, fid) = iprot.readFieldBegin()
12343 
      if ftype == TType.STOP:
12344 
        break
12345 
      if fid == 1:
12346 
        if ftype == TType.I64:
12347 
          self.orderId = iprot.readI64();
12348 
        else:
12349 
          iprot.skip(ftype)
12350 
      else:
12351 
        iprot.skip(ftype)
12352 
      iprot.readFieldEnd()
12353 
    iprot.readStructEnd()
12354 
 
12355 
  def write(self, oprot):
12356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12358 
      return
12359 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
12360 
    if self.orderId is not None:
12361 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12362 
      oprot.writeI64(self.orderId)
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 
 
12382 
class markOrderReturnRequestReceived_result:
12383 
  """
12384 
  Attributes:
12385 
   - success
12386 
   - ex
12387 
  """
12388 
 
12389 
  thrift_spec = (
12390 
    (0, TType.BOOL, 'success', None, None, ), # 0
12391 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12392 
  )
12393 
 
12394 
  def __init__(self, success=None, ex=None,):
12395 
    self.success = success
12396 
    self.ex = ex
12397 
 
12398 
  def read(self, iprot):
12399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12401 
      return
12402 
    iprot.readStructBegin()
12403 
    while True:
12404 
      (fname, ftype, fid) = iprot.readFieldBegin()
12405 
      if ftype == TType.STOP:
12406 
        break
12407 
      if fid == 0:
12408 
        if ftype == TType.BOOL:
12409 
          self.success = iprot.readBool();
12410 
        else:
12411 
          iprot.skip(ftype)
12412 
      elif fid == 1:
12413 
        if ftype == TType.STRUCT:
12414 
          self.ex = TransactionServiceException()
12415 
          self.ex.read(iprot)
12416 
        else:
12417 
          iprot.skip(ftype)
12418 
      else:
12419 
        iprot.skip(ftype)
12420 
      iprot.readFieldEnd()
12421 
    iprot.readStructEnd()
12422 
 
12423 
  def write(self, oprot):
12424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12426 
      return
12427 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
12428 
    if self.success is not None:
12429 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12430 
      oprot.writeBool(self.success)
12431 
      oprot.writeFieldEnd()
12432 
    if self.ex is not None:
12433 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12434 
      self.ex.write(oprot)
12435 
      oprot.writeFieldEnd()
12436 
    oprot.writeFieldStop()
12437 
    oprot.writeStructEnd()
12438 
 
12439 
  def validate(self):
12440 
    return
12441 
 
12442 
 
12443 
  def __repr__(self):
12444 
    L = ['%s=%r' % (key, value)
12445 
      for key, value in self.__dict__.iteritems()]
12446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12447 
 
12448 
  def __eq__(self, other):
12449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12450 
 
12451 
  def __ne__(self, other):
12452 
    return not (self == other)
12453 
 
12454 
class markOrderReturnRequestAuthorized_args:
12455 
  """
12456 
  Attributes:
12457 
   - orderId
12458 
   - isAuthorized
12459 
  """
12460 
 
12461 
  thrift_spec = (
12462 
    None, # 0
12463 
    (1, TType.I64, 'orderId', None, None, ), # 1
12464 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12465 
  )
12466 
 
12467 
  def __init__(self, orderId=None, isAuthorized=None,):
12468 
    self.orderId = orderId
12469 
    self.isAuthorized = isAuthorized
12470 
 
12471 
  def read(self, iprot):
12472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12474 
      return
12475 
    iprot.readStructBegin()
12476 
    while True:
12477 
      (fname, ftype, fid) = iprot.readFieldBegin()
12478 
      if ftype == TType.STOP:
12479 
        break
12480 
      if fid == 1:
12481 
        if ftype == TType.I64:
12482 
          self.orderId = iprot.readI64();
12483 
        else:
12484 
          iprot.skip(ftype)
12485 
      elif fid == 2:
12486 
        if ftype == TType.BOOL:
12487 
          self.isAuthorized = iprot.readBool();
12488 
        else:
12489 
          iprot.skip(ftype)
12490 
      else:
12491 
        iprot.skip(ftype)
12492 
      iprot.readFieldEnd()
12493 
    iprot.readStructEnd()
12494 
 
12495 
  def write(self, oprot):
12496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12498 
      return
12499 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
12500 
    if self.orderId is not None:
12501 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12502 
      oprot.writeI64(self.orderId)
12503 
      oprot.writeFieldEnd()
12504 
    if self.isAuthorized is not None:
12505 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12506 
      oprot.writeBool(self.isAuthorized)
12507 
      oprot.writeFieldEnd()
12508 
    oprot.writeFieldStop()
12509 
    oprot.writeStructEnd()
12510 
 
12511 
  def validate(self):
12512 
    return
12513 
 
12514 
 
12515 
  def __repr__(self):
12516 
    L = ['%s=%r' % (key, value)
12517 
      for key, value in self.__dict__.iteritems()]
12518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12519 
 
12520 
  def __eq__(self, other):
12521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12522 
 
12523 
  def __ne__(self, other):
12524 
    return not (self == other)
12525 
 
12526 
class markOrderReturnRequestAuthorized_result:
12527 
  """
12528 
  Attributes:
12529 
   - success
12530 
   - ex
12531 
  """
12532 
 
12533 
  thrift_spec = (
12534 
    (0, TType.BOOL, 'success', None, None, ), # 0
12535 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12536 
  )
12537 
 
12538 
  def __init__(self, success=None, ex=None,):
12539 
    self.success = success
12540 
    self.ex = ex
12541 
 
12542 
  def read(self, iprot):
12543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12545 
      return
12546 
    iprot.readStructBegin()
12547 
    while True:
12548 
      (fname, ftype, fid) = iprot.readFieldBegin()
12549 
      if ftype == TType.STOP:
12550 
        break
12551 
      if fid == 0:
12552 
        if ftype == TType.BOOL:
12553 
          self.success = iprot.readBool();
12554 
        else:
12555 
          iprot.skip(ftype)
12556 
      elif fid == 1:
12557 
        if ftype == TType.STRUCT:
12558 
          self.ex = TransactionServiceException()
12559 
          self.ex.read(iprot)
12560 
        else:
12561 
          iprot.skip(ftype)
12562 
      else:
12563 
        iprot.skip(ftype)
12564 
      iprot.readFieldEnd()
12565 
    iprot.readStructEnd()
12566 
 
12567 
  def write(self, oprot):
12568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12570 
      return
12571 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
12572 
    if self.success is not None:
12573 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12574 
      oprot.writeBool(self.success)
12575 
      oprot.writeFieldEnd()
12576 
    if self.ex is not None:
12577 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12578 
      self.ex.write(oprot)
12579 
      oprot.writeFieldEnd()
12580 
    oprot.writeFieldStop()
12581 
    oprot.writeStructEnd()
12582 
 
12583 
  def validate(self):
12584 
    return
12585 
 
12586 
 
12587 
  def __repr__(self):
12588 
    L = ['%s=%r' % (key, value)
12589 
      for key, value in self.__dict__.iteritems()]
12590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12591 
 
12592 
  def __eq__(self, other):
12593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12594 
 
12595 
  def __ne__(self, other):
12596 
    return not (self == other)
12597 
 
2536 chandransh 12598 
class requestPickupNumber_args:
12599 
  """
12600 
  Attributes:
12601 
   - orderId
4579 rajveer 12602 
   - providerId
2536 chandransh 12603 
  """
12604 
 
12605 
  thrift_spec = (
12606 
    None, # 0
12607 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 12608 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 12609 
  )
12610 
 
4579 rajveer 12611 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 12612 
    self.orderId = orderId
4579 rajveer 12613 
    self.providerId = providerId
2536 chandransh 12614 
 
12615 
  def read(self, iprot):
12616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12618 
      return
12619 
    iprot.readStructBegin()
12620 
    while True:
12621 
      (fname, ftype, fid) = iprot.readFieldBegin()
12622 
      if ftype == TType.STOP:
12623 
        break
12624 
      if fid == 1:
12625 
        if ftype == TType.I64:
12626 
          self.orderId = iprot.readI64();
12627 
        else:
12628 
          iprot.skip(ftype)
4579 rajveer 12629 
      elif fid == 2:
12630 
        if ftype == TType.I64:
12631 
          self.providerId = iprot.readI64();
12632 
        else:
12633 
          iprot.skip(ftype)
2536 chandransh 12634 
      else:
12635 
        iprot.skip(ftype)
12636 
      iprot.readFieldEnd()
12637 
    iprot.readStructEnd()
12638 
 
12639 
  def write(self, oprot):
12640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12642 
      return
12643 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 12644 
    if self.orderId is not None:
2536 chandransh 12645 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12646 
      oprot.writeI64(self.orderId)
12647 
      oprot.writeFieldEnd()
4579 rajveer 12648 
    if self.providerId is not None:
12649 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
12650 
      oprot.writeI64(self.providerId)
12651 
      oprot.writeFieldEnd()
2536 chandransh 12652 
    oprot.writeFieldStop()
12653 
    oprot.writeStructEnd()
12654 
 
3431 rajveer 12655 
  def validate(self):
12656 
    return
12657 
 
12658 
 
2536 chandransh 12659 
  def __repr__(self):
12660 
    L = ['%s=%r' % (key, value)
12661 
      for key, value in self.__dict__.iteritems()]
12662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12663 
 
12664 
  def __eq__(self, other):
12665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12666 
 
12667 
  def __ne__(self, other):
12668 
    return not (self == other)
12669 
 
12670 
class requestPickupNumber_result:
12671 
  """
12672 
  Attributes:
12673 
   - success
12674 
   - ex
12675 
  """
12676 
 
12677 
  thrift_spec = (
12678 
    (0, TType.BOOL, 'success', None, None, ), # 0
12679 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12680 
  )
12681 
 
12682 
  def __init__(self, success=None, ex=None,):
12683 
    self.success = success
12684 
    self.ex = ex
12685 
 
12686 
  def read(self, iprot):
12687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12689 
      return
12690 
    iprot.readStructBegin()
12691 
    while True:
12692 
      (fname, ftype, fid) = iprot.readFieldBegin()
12693 
      if ftype == TType.STOP:
12694 
        break
12695 
      if fid == 0:
12696 
        if ftype == TType.BOOL:
12697 
          self.success = iprot.readBool();
12698 
        else:
12699 
          iprot.skip(ftype)
12700 
      elif fid == 1:
12701 
        if ftype == TType.STRUCT:
12702 
          self.ex = TransactionServiceException()
12703 
          self.ex.read(iprot)
12704 
        else:
12705 
          iprot.skip(ftype)
12706 
      else:
12707 
        iprot.skip(ftype)
12708 
      iprot.readFieldEnd()
12709 
    iprot.readStructEnd()
12710 
 
12711 
  def write(self, oprot):
12712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12714 
      return
12715 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 12716 
    if self.success is not None:
2536 chandransh 12717 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12718 
      oprot.writeBool(self.success)
12719 
      oprot.writeFieldEnd()
3431 rajveer 12720 
    if self.ex is not None:
2536 chandransh 12721 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12722 
      self.ex.write(oprot)
12723 
      oprot.writeFieldEnd()
12724 
    oprot.writeFieldStop()
12725 
    oprot.writeStructEnd()
12726 
 
3431 rajveer 12727 
  def validate(self):
12728 
    return
12729 
 
12730 
 
2536 chandransh 12731 
  def __repr__(self):
12732 
    L = ['%s=%r' % (key, value)
12733 
      for key, value in self.__dict__.iteritems()]
12734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12735 
 
12736 
  def __eq__(self, other):
12737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12738 
 
12739 
  def __ne__(self, other):
12740 
    return not (self == other)
12741 
 
12742 
class authorizePickup_args:
12743 
  """
12744 
  Attributes:
12745 
   - orderId
12746 
   - pickupNumber
4602 rajveer 12747 
   - providerId
2536 chandransh 12748 
  """
12749 
 
12750 
  thrift_spec = (
12751 
    None, # 0
12752 
    (1, TType.I64, 'orderId', None, None, ), # 1
12753 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 12754 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 12755 
  )
12756 
 
4602 rajveer 12757 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 12758 
    self.orderId = orderId
12759 
    self.pickupNumber = pickupNumber
4602 rajveer 12760 
    self.providerId = providerId
2536 chandransh 12761 
 
12762 
  def read(self, iprot):
12763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12765 
      return
12766 
    iprot.readStructBegin()
12767 
    while True:
12768 
      (fname, ftype, fid) = iprot.readFieldBegin()
12769 
      if ftype == TType.STOP:
12770 
        break
12771 
      if fid == 1:
12772 
        if ftype == TType.I64:
12773 
          self.orderId = iprot.readI64();
12774 
        else:
12775 
          iprot.skip(ftype)
12776 
      elif fid == 2:
12777 
        if ftype == TType.STRING:
12778 
          self.pickupNumber = iprot.readString();
12779 
        else:
12780 
          iprot.skip(ftype)
4602 rajveer 12781 
      elif fid == 3:
12782 
        if ftype == TType.I64:
12783 
          self.providerId = iprot.readI64();
12784 
        else:
12785 
          iprot.skip(ftype)
2536 chandransh 12786 
      else:
12787 
        iprot.skip(ftype)
12788 
      iprot.readFieldEnd()
12789 
    iprot.readStructEnd()
12790 
 
12791 
  def write(self, oprot):
12792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12794 
      return
12795 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 12796 
    if self.orderId is not None:
2536 chandransh 12797 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12798 
      oprot.writeI64(self.orderId)
12799 
      oprot.writeFieldEnd()
3431 rajveer 12800 
    if self.pickupNumber is not None:
2536 chandransh 12801 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
12802 
      oprot.writeString(self.pickupNumber)
12803 
      oprot.writeFieldEnd()
4602 rajveer 12804 
    if self.providerId is not None:
12805 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
12806 
      oprot.writeI64(self.providerId)
12807 
      oprot.writeFieldEnd()
2536 chandransh 12808 
    oprot.writeFieldStop()
12809 
    oprot.writeStructEnd()
12810 
 
3431 rajveer 12811 
  def validate(self):
12812 
    return
12813 
 
12814 
 
2536 chandransh 12815 
  def __repr__(self):
12816 
    L = ['%s=%r' % (key, value)
12817 
      for key, value in self.__dict__.iteritems()]
12818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12819 
 
12820 
  def __eq__(self, other):
12821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12822 
 
12823 
  def __ne__(self, other):
12824 
    return not (self == other)
12825 
 
12826 
class authorizePickup_result:
12827 
  """
12828 
  Attributes:
12829 
   - success
12830 
   - ex
12831 
  """
12832 
 
12833 
  thrift_spec = (
12834 
    (0, TType.BOOL, 'success', None, None, ), # 0
12835 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12836 
  )
12837 
 
12838 
  def __init__(self, success=None, ex=None,):
12839 
    self.success = success
12840 
    self.ex = ex
12841 
 
12842 
  def read(self, iprot):
12843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12845 
      return
12846 
    iprot.readStructBegin()
12847 
    while True:
12848 
      (fname, ftype, fid) = iprot.readFieldBegin()
12849 
      if ftype == TType.STOP:
12850 
        break
12851 
      if fid == 0:
12852 
        if ftype == TType.BOOL:
12853 
          self.success = iprot.readBool();
12854 
        else:
12855 
          iprot.skip(ftype)
12856 
      elif fid == 1:
12857 
        if ftype == TType.STRUCT:
12858 
          self.ex = TransactionServiceException()
12859 
          self.ex.read(iprot)
12860 
        else:
12861 
          iprot.skip(ftype)
12862 
      else:
12863 
        iprot.skip(ftype)
12864 
      iprot.readFieldEnd()
12865 
    iprot.readStructEnd()
12866 
 
12867 
  def write(self, oprot):
12868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12870 
      return
12871 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 12872 
    if self.success is not None:
2536 chandransh 12873 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12874 
      oprot.writeBool(self.success)
12875 
      oprot.writeFieldEnd()
3431 rajveer 12876 
    if self.ex is not None:
2536 chandransh 12877 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12878 
      self.ex.write(oprot)
12879 
      oprot.writeFieldEnd()
12880 
    oprot.writeFieldStop()
12881 
    oprot.writeStructEnd()
12882 
 
3431 rajveer 12883 
  def validate(self):
12884 
    return
12885 
 
12886 
 
2536 chandransh 12887 
  def __repr__(self):
12888 
    L = ['%s=%r' % (key, value)
12889 
      for key, value in self.__dict__.iteritems()]
12890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12891 
 
12892 
  def __eq__(self, other):
12893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12894 
 
12895 
  def __ne__(self, other):
12896 
    return not (self == other)
12897 
 
2764 chandransh 12898 
class markDoasAsPickedUp_args:
12899 
  """
12900 
  Attributes:
12901 
   - providerId
12902 
   - pickupDetails
12903 
  """
12904 
 
12905 
  thrift_spec = (
12906 
    None, # 0
12907 
    (1, TType.I64, 'providerId', None, None, ), # 1
12908 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
12909 
  )
12910 
 
12911 
  def __init__(self, providerId=None, pickupDetails=None,):
12912 
    self.providerId = providerId
12913 
    self.pickupDetails = pickupDetails
12914 
 
12915 
  def read(self, iprot):
12916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12918 
      return
12919 
    iprot.readStructBegin()
12920 
    while True:
12921 
      (fname, ftype, fid) = iprot.readFieldBegin()
12922 
      if ftype == TType.STOP:
12923 
        break
12924 
      if fid == 1:
12925 
        if ftype == TType.I64:
12926 
          self.providerId = iprot.readI64();
12927 
        else:
12928 
          iprot.skip(ftype)
12929 
      elif fid == 2:
12930 
        if ftype == TType.MAP:
12931 
          self.pickupDetails = {}
4581 phani.kuma 12932 
          (_ktype198, _vtype199, _size197 ) = iprot.readMapBegin()
12933 
          for _i201 in xrange(_size197):
12934 
            _key202 = iprot.readString();
12935 
            _val203 = iprot.readString();
12936 
            self.pickupDetails[_key202] = _val203
2764 chandransh 12937 
          iprot.readMapEnd()
12938 
        else:
12939 
          iprot.skip(ftype)
12940 
      else:
12941 
        iprot.skip(ftype)
12942 
      iprot.readFieldEnd()
12943 
    iprot.readStructEnd()
12944 
 
12945 
  def write(self, oprot):
12946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12948 
      return
12949 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 12950 
    if self.providerId is not None:
2764 chandransh 12951 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12952 
      oprot.writeI64(self.providerId)
12953 
      oprot.writeFieldEnd()
3431 rajveer 12954 
    if self.pickupDetails is not None:
2764 chandransh 12955 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12956 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4581 phani.kuma 12957 
      for kiter204,viter205 in self.pickupDetails.items():
12958 
        oprot.writeString(kiter204)
12959 
        oprot.writeString(viter205)
2764 chandransh 12960 
      oprot.writeMapEnd()
12961 
      oprot.writeFieldEnd()
12962 
    oprot.writeFieldStop()
12963 
    oprot.writeStructEnd()
12964 
 
3431 rajveer 12965 
  def validate(self):
12966 
    return
12967 
 
12968 
 
2764 chandransh 12969 
  def __repr__(self):
12970 
    L = ['%s=%r' % (key, value)
12971 
      for key, value in self.__dict__.iteritems()]
12972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12973 
 
12974 
  def __eq__(self, other):
12975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12976 
 
12977 
  def __ne__(self, other):
12978 
    return not (self == other)
12979 
 
12980 
class markDoasAsPickedUp_result:
12981 
  """
12982 
  Attributes:
12983 
   - success
12984 
  """
12985 
 
12986 
  thrift_spec = (
12987 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12988 
  )
12989 
 
12990 
  def __init__(self, success=None,):
12991 
    self.success = success
12992 
 
12993 
  def read(self, iprot):
12994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12996 
      return
12997 
    iprot.readStructBegin()
12998 
    while True:
12999 
      (fname, ftype, fid) = iprot.readFieldBegin()
13000 
      if ftype == TType.STOP:
13001 
        break
13002 
      if fid == 0:
13003 
        if ftype == TType.LIST:
13004 
          self.success = []
4581 phani.kuma 13005 
          (_etype209, _size206) = iprot.readListBegin()
13006 
          for _i210 in xrange(_size206):
13007 
            _elem211 = Order()
13008 
            _elem211.read(iprot)
13009 
            self.success.append(_elem211)
2764 chandransh 13010 
          iprot.readListEnd()
13011 
        else:
13012 
          iprot.skip(ftype)
13013 
      else:
13014 
        iprot.skip(ftype)
13015 
      iprot.readFieldEnd()
13016 
    iprot.readStructEnd()
13017 
 
13018 
  def write(self, oprot):
13019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13021 
      return
13022 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 13023 
    if self.success is not None:
2764 chandransh 13024 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13025 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 13026 
      for iter212 in self.success:
13027 
        iter212.write(oprot)
2764 chandransh 13028 
      oprot.writeListEnd()
13029 
      oprot.writeFieldEnd()
13030 
    oprot.writeFieldStop()
13031 
    oprot.writeStructEnd()
13032 
 
3431 rajveer 13033 
  def validate(self):
13034 
    return
13035 
 
13036 
 
2764 chandransh 13037 
  def __repr__(self):
13038 
    L = ['%s=%r' % (key, value)
13039 
      for key, value in self.__dict__.iteritems()]
13040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13041 
 
13042 
  def __eq__(self, other):
13043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13044 
 
13045 
  def __ne__(self, other):
13046 
    return not (self == other)
13047 
 
2616 chandransh 13048 
class receiveReturn_args:
2591 chandransh 13049 
  """
13050 
  Attributes:
13051 
   - orderId
4479 rajveer 13052 
   - receiveCondition
2591 chandransh 13053 
  """
2536 chandransh 13054 
 
2591 chandransh 13055 
  thrift_spec = (
13056 
    None, # 0
13057 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 13058 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 13059 
  )
13060 
 
4479 rajveer 13061 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 13062 
    self.orderId = orderId
4479 rajveer 13063 
    self.receiveCondition = receiveCondition
2591 chandransh 13064 
 
13065 
  def read(self, iprot):
13066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13068 
      return
13069 
    iprot.readStructBegin()
13070 
    while True:
13071 
      (fname, ftype, fid) = iprot.readFieldBegin()
13072 
      if ftype == TType.STOP:
13073 
        break
13074 
      if fid == 1:
13075 
        if ftype == TType.I64:
13076 
          self.orderId = iprot.readI64();
13077 
        else:
13078 
          iprot.skip(ftype)
4479 rajveer 13079 
      elif fid == 2:
13080 
        if ftype == TType.I64:
13081 
          self.receiveCondition = iprot.readI64();
13082 
        else:
13083 
          iprot.skip(ftype)
2591 chandransh 13084 
      else:
13085 
        iprot.skip(ftype)
13086 
      iprot.readFieldEnd()
13087 
    iprot.readStructEnd()
13088 
 
13089 
  def write(self, oprot):
13090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13092 
      return
2616 chandransh 13093 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 13094 
    if self.orderId is not None:
2591 chandransh 13095 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13096 
      oprot.writeI64(self.orderId)
13097 
      oprot.writeFieldEnd()
4479 rajveer 13098 
    if self.receiveCondition is not None:
13099 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
13100 
      oprot.writeI64(self.receiveCondition)
13101 
      oprot.writeFieldEnd()
2591 chandransh 13102 
    oprot.writeFieldStop()
13103 
    oprot.writeStructEnd()
13104 
 
3431 rajveer 13105 
  def validate(self):
13106 
    return
13107 
 
13108 
 
2591 chandransh 13109 
  def __repr__(self):
13110 
    L = ['%s=%r' % (key, value)
13111 
      for key, value in self.__dict__.iteritems()]
13112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13113 
 
13114 
  def __eq__(self, other):
13115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13116 
 
13117 
  def __ne__(self, other):
13118 
    return not (self == other)
13119 
 
2616 chandransh 13120 
class receiveReturn_result:
2591 chandransh 13121 
  """
13122 
  Attributes:
13123 
   - success
13124 
   - ex
13125 
  """
13126 
 
13127 
  thrift_spec = (
13128 
    (0, TType.BOOL, 'success', None, None, ), # 0
13129 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13130 
  )
13131 
 
13132 
  def __init__(self, success=None, ex=None,):
13133 
    self.success = success
13134 
    self.ex = ex
13135 
 
13136 
  def read(self, iprot):
13137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13139 
      return
13140 
    iprot.readStructBegin()
13141 
    while True:
13142 
      (fname, ftype, fid) = iprot.readFieldBegin()
13143 
      if ftype == TType.STOP:
13144 
        break
13145 
      if fid == 0:
13146 
        if ftype == TType.BOOL:
13147 
          self.success = iprot.readBool();
13148 
        else:
13149 
          iprot.skip(ftype)
13150 
      elif fid == 1:
13151 
        if ftype == TType.STRUCT:
13152 
          self.ex = TransactionServiceException()
13153 
          self.ex.read(iprot)
13154 
        else:
13155 
          iprot.skip(ftype)
13156 
      else:
13157 
        iprot.skip(ftype)
13158 
      iprot.readFieldEnd()
13159 
    iprot.readStructEnd()
13160 
 
13161 
  def write(self, oprot):
13162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13164 
      return
2616 chandransh 13165 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 13166 
    if self.success is not None:
2591 chandransh 13167 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13168 
      oprot.writeBool(self.success)
13169 
      oprot.writeFieldEnd()
3431 rajveer 13170 
    if self.ex is not None:
2591 chandransh 13171 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13172 
      self.ex.write(oprot)
13173 
      oprot.writeFieldEnd()
13174 
    oprot.writeFieldStop()
13175 
    oprot.writeStructEnd()
13176 
 
3431 rajveer 13177 
  def validate(self):
13178 
    return
13179 
 
13180 
 
2591 chandransh 13181 
  def __repr__(self):
13182 
    L = ['%s=%r' % (key, value)
13183 
      for key, value in self.__dict__.iteritems()]
13184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13185 
 
13186 
  def __eq__(self, other):
13187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13188 
 
13189 
  def __ne__(self, other):
13190 
    return not (self == other)
13191 
 
13192 
class validateDoa_args:
13193 
  """
13194 
  Attributes:
13195 
   - orderId
13196 
   - isValid
13197 
  """
13198 
 
13199 
  thrift_spec = (
13200 
    None, # 0
13201 
    (1, TType.I64, 'orderId', None, None, ), # 1
13202 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
13203 
  )
13204 
 
13205 
  def __init__(self, orderId=None, isValid=None,):
13206 
    self.orderId = orderId
13207 
    self.isValid = isValid
13208 
 
13209 
  def read(self, iprot):
13210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13212 
      return
13213 
    iprot.readStructBegin()
13214 
    while True:
13215 
      (fname, ftype, fid) = iprot.readFieldBegin()
13216 
      if ftype == TType.STOP:
13217 
        break
13218 
      if fid == 1:
13219 
        if ftype == TType.I64:
13220 
          self.orderId = iprot.readI64();
13221 
        else:
13222 
          iprot.skip(ftype)
13223 
      elif fid == 2:
13224 
        if ftype == TType.BOOL:
13225 
          self.isValid = iprot.readBool();
13226 
        else:
13227 
          iprot.skip(ftype)
13228 
      else:
13229 
        iprot.skip(ftype)
13230 
      iprot.readFieldEnd()
13231 
    iprot.readStructEnd()
13232 
 
13233 
  def write(self, oprot):
13234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13236 
      return
13237 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 13238 
    if self.orderId is not None:
2591 chandransh 13239 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13240 
      oprot.writeI64(self.orderId)
13241 
      oprot.writeFieldEnd()
3431 rajveer 13242 
    if self.isValid is not None:
2591 chandransh 13243 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
13244 
      oprot.writeBool(self.isValid)
13245 
      oprot.writeFieldEnd()
13246 
    oprot.writeFieldStop()
13247 
    oprot.writeStructEnd()
13248 
 
3431 rajveer 13249 
  def validate(self):
13250 
    return
13251 
 
13252 
 
2591 chandransh 13253 
  def __repr__(self):
13254 
    L = ['%s=%r' % (key, value)
13255 
      for key, value in self.__dict__.iteritems()]
13256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13257 
 
13258 
  def __eq__(self, other):
13259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13260 
 
13261 
  def __ne__(self, other):
13262 
    return not (self == other)
13263 
 
13264 
class validateDoa_result:
13265 
  """
13266 
  Attributes:
13267 
   - success
13268 
   - ex
13269 
  """
13270 
 
13271 
  thrift_spec = (
13272 
    (0, TType.BOOL, 'success', None, None, ), # 0
13273 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13274 
  )
13275 
 
13276 
  def __init__(self, success=None, ex=None,):
13277 
    self.success = success
13278 
    self.ex = ex
13279 
 
13280 
  def read(self, iprot):
13281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13283 
      return
13284 
    iprot.readStructBegin()
13285 
    while True:
13286 
      (fname, ftype, fid) = iprot.readFieldBegin()
13287 
      if ftype == TType.STOP:
13288 
        break
13289 
      if fid == 0:
13290 
        if ftype == TType.BOOL:
13291 
          self.success = iprot.readBool();
13292 
        else:
13293 
          iprot.skip(ftype)
13294 
      elif fid == 1:
13295 
        if ftype == TType.STRUCT:
13296 
          self.ex = TransactionServiceException()
13297 
          self.ex.read(iprot)
13298 
        else:
13299 
          iprot.skip(ftype)
13300 
      else:
13301 
        iprot.skip(ftype)
13302 
      iprot.readFieldEnd()
13303 
    iprot.readStructEnd()
13304 
 
13305 
  def write(self, oprot):
13306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13308 
      return
13309 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 13310 
    if self.success is not None:
2591 chandransh 13311 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13312 
      oprot.writeBool(self.success)
13313 
      oprot.writeFieldEnd()
3431 rajveer 13314 
    if self.ex is not None:
2591 chandransh 13315 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13316 
      self.ex.write(oprot)
13317 
      oprot.writeFieldEnd()
13318 
    oprot.writeFieldStop()
13319 
    oprot.writeStructEnd()
13320 
 
3431 rajveer 13321 
  def validate(self):
13322 
    return
13323 
 
13324 
 
2591 chandransh 13325 
  def __repr__(self):
13326 
    L = ['%s=%r' % (key, value)
13327 
      for key, value in self.__dict__.iteritems()]
13328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13329 
 
13330 
  def __eq__(self, other):
13331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13332 
 
13333 
  def __ne__(self, other):
13334 
    return not (self == other)
13335 
 
4495 rajveer 13336 
class validateReturnProduct_args:
13337 
  """
13338 
  Attributes:
13339 
   - orderId
13340 
   - isUsable
13341 
  """
13342 
 
13343 
  thrift_spec = (
13344 
    None, # 0
13345 
    (1, TType.I64, 'orderId', None, None, ), # 1
13346 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
13347 
  )
13348 
 
13349 
  def __init__(self, orderId=None, isUsable=None,):
13350 
    self.orderId = orderId
13351 
    self.isUsable = isUsable
13352 
 
13353 
  def read(self, iprot):
13354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13356 
      return
13357 
    iprot.readStructBegin()
13358 
    while True:
13359 
      (fname, ftype, fid) = iprot.readFieldBegin()
13360 
      if ftype == TType.STOP:
13361 
        break
13362 
      if fid == 1:
13363 
        if ftype == TType.I64:
13364 
          self.orderId = iprot.readI64();
13365 
        else:
13366 
          iprot.skip(ftype)
13367 
      elif fid == 2:
13368 
        if ftype == TType.BOOL:
13369 
          self.isUsable = iprot.readBool();
13370 
        else:
13371 
          iprot.skip(ftype)
13372 
      else:
13373 
        iprot.skip(ftype)
13374 
      iprot.readFieldEnd()
13375 
    iprot.readStructEnd()
13376 
 
13377 
  def write(self, oprot):
13378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13380 
      return
13381 
    oprot.writeStructBegin('validateReturnProduct_args')
13382 
    if self.orderId is not None:
13383 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13384 
      oprot.writeI64(self.orderId)
13385 
      oprot.writeFieldEnd()
13386 
    if self.isUsable is not None:
13387 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
13388 
      oprot.writeBool(self.isUsable)
13389 
      oprot.writeFieldEnd()
13390 
    oprot.writeFieldStop()
13391 
    oprot.writeStructEnd()
13392 
 
13393 
  def validate(self):
13394 
    return
13395 
 
13396 
 
13397 
  def __repr__(self):
13398 
    L = ['%s=%r' % (key, value)
13399 
      for key, value in self.__dict__.iteritems()]
13400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13401 
 
13402 
  def __eq__(self, other):
13403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13404 
 
13405 
  def __ne__(self, other):
13406 
    return not (self == other)
13407 
 
13408 
class validateReturnProduct_result:
13409 
  """
13410 
  Attributes:
13411 
   - success
13412 
   - ex
13413 
  """
13414 
 
13415 
  thrift_spec = (
13416 
    (0, TType.BOOL, 'success', None, None, ), # 0
13417 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13418 
  )
13419 
 
13420 
  def __init__(self, success=None, ex=None,):
13421 
    self.success = success
13422 
    self.ex = ex
13423 
 
13424 
  def read(self, iprot):
13425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13427 
      return
13428 
    iprot.readStructBegin()
13429 
    while True:
13430 
      (fname, ftype, fid) = iprot.readFieldBegin()
13431 
      if ftype == TType.STOP:
13432 
        break
13433 
      if fid == 0:
13434 
        if ftype == TType.BOOL:
13435 
          self.success = iprot.readBool();
13436 
        else:
13437 
          iprot.skip(ftype)
13438 
      elif fid == 1:
13439 
        if ftype == TType.STRUCT:
13440 
          self.ex = TransactionServiceException()
13441 
          self.ex.read(iprot)
13442 
        else:
13443 
          iprot.skip(ftype)
13444 
      else:
13445 
        iprot.skip(ftype)
13446 
      iprot.readFieldEnd()
13447 
    iprot.readStructEnd()
13448 
 
13449 
  def write(self, oprot):
13450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13452 
      return
13453 
    oprot.writeStructBegin('validateReturnProduct_result')
13454 
    if self.success is not None:
13455 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13456 
      oprot.writeBool(self.success)
13457 
      oprot.writeFieldEnd()
13458 
    if self.ex is not None:
13459 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13460 
      self.ex.write(oprot)
13461 
      oprot.writeFieldEnd()
13462 
    oprot.writeFieldStop()
13463 
    oprot.writeStructEnd()
13464 
 
13465 
  def validate(self):
13466 
    return
13467 
 
13468 
 
13469 
  def __repr__(self):
13470 
    L = ['%s=%r' % (key, value)
13471 
      for key, value in self.__dict__.iteritems()]
13472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13473 
 
13474 
  def __eq__(self, other):
13475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13476 
 
13477 
  def __ne__(self, other):
13478 
    return not (self == other)
13479 
 
2616 chandransh 13480 
class reshipOrder_args:
13481 
  """
13482 
  Attributes:
13483 
   - orderId
13484 
  """
2591 chandransh 13485 
 
2616 chandransh 13486 
  thrift_spec = (
13487 
    None, # 0
13488 
    (1, TType.I64, 'orderId', None, None, ), # 1
13489 
  )
13490 
 
13491 
  def __init__(self, orderId=None,):
13492 
    self.orderId = orderId
13493 
 
13494 
  def read(self, iprot):
13495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13497 
      return
13498 
    iprot.readStructBegin()
13499 
    while True:
13500 
      (fname, ftype, fid) = iprot.readFieldBegin()
13501 
      if ftype == TType.STOP:
13502 
        break
13503 
      if fid == 1:
13504 
        if ftype == TType.I64:
13505 
          self.orderId = iprot.readI64();
13506 
        else:
13507 
          iprot.skip(ftype)
13508 
      else:
13509 
        iprot.skip(ftype)
13510 
      iprot.readFieldEnd()
13511 
    iprot.readStructEnd()
13512 
 
13513 
  def write(self, oprot):
13514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13516 
      return
13517 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 13518 
    if self.orderId is not None:
2616 chandransh 13519 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13520 
      oprot.writeI64(self.orderId)
13521 
      oprot.writeFieldEnd()
13522 
    oprot.writeFieldStop()
13523 
    oprot.writeStructEnd()
13524 
 
3431 rajveer 13525 
  def validate(self):
13526 
    return
13527 
 
13528 
 
2616 chandransh 13529 
  def __repr__(self):
13530 
    L = ['%s=%r' % (key, value)
13531 
      for key, value in self.__dict__.iteritems()]
13532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13533 
 
13534 
  def __eq__(self, other):
13535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13536 
 
13537 
  def __ne__(self, other):
13538 
    return not (self == other)
13539 
 
13540 
class reshipOrder_result:
13541 
  """
13542 
  Attributes:
13543 
   - success
13544 
   - ex
13545 
  """
13546 
 
13547 
  thrift_spec = (
13548 
    (0, TType.I64, 'success', None, None, ), # 0
13549 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13550 
  )
13551 
 
13552 
  def __init__(self, success=None, ex=None,):
13553 
    self.success = success
13554 
    self.ex = ex
13555 
 
13556 
  def read(self, iprot):
13557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13559 
      return
13560 
    iprot.readStructBegin()
13561 
    while True:
13562 
      (fname, ftype, fid) = iprot.readFieldBegin()
13563 
      if ftype == TType.STOP:
13564 
        break
13565 
      if fid == 0:
13566 
        if ftype == TType.I64:
13567 
          self.success = iprot.readI64();
13568 
        else:
13569 
          iprot.skip(ftype)
13570 
      elif fid == 1:
13571 
        if ftype == TType.STRUCT:
13572 
          self.ex = TransactionServiceException()
13573 
          self.ex.read(iprot)
13574 
        else:
13575 
          iprot.skip(ftype)
13576 
      else:
13577 
        iprot.skip(ftype)
13578 
      iprot.readFieldEnd()
13579 
    iprot.readStructEnd()
13580 
 
13581 
  def write(self, oprot):
13582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13584 
      return
13585 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 13586 
    if self.success is not None:
2616 chandransh 13587 
      oprot.writeFieldBegin('success', TType.I64, 0)
13588 
      oprot.writeI64(self.success)
13589 
      oprot.writeFieldEnd()
3431 rajveer 13590 
    if self.ex is not None:
2616 chandransh 13591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13592 
      self.ex.write(oprot)
13593 
      oprot.writeFieldEnd()
13594 
    oprot.writeFieldStop()
13595 
    oprot.writeStructEnd()
13596 
 
3431 rajveer 13597 
  def validate(self):
13598 
    return
13599 
 
13600 
 
2616 chandransh 13601 
  def __repr__(self):
13602 
    L = ['%s=%r' % (key, value)
13603 
      for key, value in self.__dict__.iteritems()]
13604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13605 
 
13606 
  def __eq__(self, other):
13607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13608 
 
13609 
  def __ne__(self, other):
13610 
    return not (self == other)
13611 
 
13612 
class refundOrder_args:
13613 
  """
13614 
  Attributes:
13615 
   - orderId
3226 chandransh 13616 
   - refundedBy
13617 
   - reason
2616 chandransh 13618 
  """
13619 
 
13620 
  thrift_spec = (
13621 
    None, # 0
13622 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 13623 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13624 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 13625 
  )
13626 
 
3226 chandransh 13627 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 13628 
    self.orderId = orderId
3226 chandransh 13629 
    self.refundedBy = refundedBy
13630 
    self.reason = reason
2616 chandransh 13631 
 
13632 
  def read(self, iprot):
13633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13635 
      return
13636 
    iprot.readStructBegin()
13637 
    while True:
13638 
      (fname, ftype, fid) = iprot.readFieldBegin()
13639 
      if ftype == TType.STOP:
13640 
        break
13641 
      if fid == 1:
13642 
        if ftype == TType.I64:
13643 
          self.orderId = iprot.readI64();
13644 
        else:
13645 
          iprot.skip(ftype)
3226 chandransh 13646 
      elif fid == 2:
13647 
        if ftype == TType.STRING:
13648 
          self.refundedBy = iprot.readString();
13649 
        else:
13650 
          iprot.skip(ftype)
13651 
      elif fid == 3:
13652 
        if ftype == TType.STRING:
13653 
          self.reason = iprot.readString();
13654 
        else:
13655 
          iprot.skip(ftype)
2616 chandransh 13656 
      else:
13657 
        iprot.skip(ftype)
13658 
      iprot.readFieldEnd()
13659 
    iprot.readStructEnd()
13660 
 
13661 
  def write(self, oprot):
13662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13664 
      return
13665 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 13666 
    if self.orderId is not None:
2616 chandransh 13667 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13668 
      oprot.writeI64(self.orderId)
13669 
      oprot.writeFieldEnd()
3431 rajveer 13670 
    if self.refundedBy is not None:
3226 chandransh 13671 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13672 
      oprot.writeString(self.refundedBy)
13673 
      oprot.writeFieldEnd()
3431 rajveer 13674 
    if self.reason is not None:
3226 chandransh 13675 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13676 
      oprot.writeString(self.reason)
13677 
      oprot.writeFieldEnd()
2616 chandransh 13678 
    oprot.writeFieldStop()
13679 
    oprot.writeStructEnd()
13680 
 
3431 rajveer 13681 
  def validate(self):
13682 
    return
13683 
 
13684 
 
2616 chandransh 13685 
  def __repr__(self):
13686 
    L = ['%s=%r' % (key, value)
13687 
      for key, value in self.__dict__.iteritems()]
13688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13689 
 
13690 
  def __eq__(self, other):
13691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13692 
 
13693 
  def __ne__(self, other):
13694 
    return not (self == other)
13695 
 
13696 
class refundOrder_result:
13697 
  """
13698 
  Attributes:
13699 
   - success
13700 
   - ex
13701 
  """
13702 
 
13703 
  thrift_spec = (
13704 
    (0, TType.BOOL, 'success', None, None, ), # 0
13705 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13706 
  )
13707 
 
13708 
  def __init__(self, success=None, ex=None,):
13709 
    self.success = success
13710 
    self.ex = ex
13711 
 
13712 
  def read(self, iprot):
13713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13715 
      return
13716 
    iprot.readStructBegin()
13717 
    while True:
13718 
      (fname, ftype, fid) = iprot.readFieldBegin()
13719 
      if ftype == TType.STOP:
13720 
        break
13721 
      if fid == 0:
13722 
        if ftype == TType.BOOL:
13723 
          self.success = iprot.readBool();
13724 
        else:
13725 
          iprot.skip(ftype)
13726 
      elif fid == 1:
13727 
        if ftype == TType.STRUCT:
13728 
          self.ex = TransactionServiceException()
13729 
          self.ex.read(iprot)
13730 
        else:
13731 
          iprot.skip(ftype)
13732 
      else:
13733 
        iprot.skip(ftype)
13734 
      iprot.readFieldEnd()
13735 
    iprot.readStructEnd()
13736 
 
13737 
  def write(self, oprot):
13738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13740 
      return
13741 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 13742 
    if self.success is not None:
2616 chandransh 13743 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13744 
      oprot.writeBool(self.success)
13745 
      oprot.writeFieldEnd()
3431 rajveer 13746 
    if self.ex is not None:
2616 chandransh 13747 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13748 
      self.ex.write(oprot)
13749 
      oprot.writeFieldEnd()
13750 
    oprot.writeFieldStop()
13751 
    oprot.writeStructEnd()
13752 
 
3431 rajveer 13753 
  def validate(self):
13754 
    return
13755 
 
13756 
 
2616 chandransh 13757 
  def __repr__(self):
13758 
    L = ['%s=%r' % (key, value)
13759 
      for key, value in self.__dict__.iteritems()]
13760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13761 
 
13762 
  def __eq__(self, other):
13763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13764 
 
13765 
  def __ne__(self, other):
13766 
    return not (self == other)
13767 
 
2690 chandransh 13768 
class getReturnOrders_args:
13769 
  """
13770 
  Attributes:
13771 
   - warehouseId
13772 
   - fromDate
13773 
   - toDate
13774 
  """
2616 chandransh 13775 
 
2690 chandransh 13776 
  thrift_spec = (
13777 
    None, # 0
13778 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13779 
    (2, TType.I64, 'fromDate', None, None, ), # 2
13780 
    (3, TType.I64, 'toDate', None, None, ), # 3
13781 
  )
13782 
 
13783 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
13784 
    self.warehouseId = warehouseId
13785 
    self.fromDate = fromDate
13786 
    self.toDate = toDate
13787 
 
13788 
  def read(self, iprot):
13789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13791 
      return
13792 
    iprot.readStructBegin()
13793 
    while True:
13794 
      (fname, ftype, fid) = iprot.readFieldBegin()
13795 
      if ftype == TType.STOP:
13796 
        break
13797 
      if fid == 1:
13798 
        if ftype == TType.I64:
13799 
          self.warehouseId = iprot.readI64();
13800 
        else:
13801 
          iprot.skip(ftype)
13802 
      elif fid == 2:
13803 
        if ftype == TType.I64:
13804 
          self.fromDate = iprot.readI64();
13805 
        else:
13806 
          iprot.skip(ftype)
13807 
      elif fid == 3:
13808 
        if ftype == TType.I64:
13809 
          self.toDate = iprot.readI64();
13810 
        else:
13811 
          iprot.skip(ftype)
13812 
      else:
13813 
        iprot.skip(ftype)
13814 
      iprot.readFieldEnd()
13815 
    iprot.readStructEnd()
13816 
 
13817 
  def write(self, oprot):
13818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13820 
      return
13821 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 13822 
    if self.warehouseId is not None:
2690 chandransh 13823 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13824 
      oprot.writeI64(self.warehouseId)
13825 
      oprot.writeFieldEnd()
3431 rajveer 13826 
    if self.fromDate is not None:
2690 chandransh 13827 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
13828 
      oprot.writeI64(self.fromDate)
13829 
      oprot.writeFieldEnd()
3431 rajveer 13830 
    if self.toDate is not None:
2690 chandransh 13831 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
13832 
      oprot.writeI64(self.toDate)
13833 
      oprot.writeFieldEnd()
13834 
    oprot.writeFieldStop()
13835 
    oprot.writeStructEnd()
13836 
 
3431 rajveer 13837 
  def validate(self):
13838 
    return
13839 
 
13840 
 
2690 chandransh 13841 
  def __repr__(self):
13842 
    L = ['%s=%r' % (key, value)
13843 
      for key, value in self.__dict__.iteritems()]
13844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13845 
 
13846 
  def __eq__(self, other):
13847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13848 
 
13849 
  def __ne__(self, other):
13850 
    return not (self == other)
13851 
 
13852 
class getReturnOrders_result:
13853 
  """
13854 
  Attributes:
13855 
   - success
13856 
  """
13857 
 
13858 
  thrift_spec = (
13859 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
13860 
  )
13861 
 
13862 
  def __init__(self, success=None,):
13863 
    self.success = success
13864 
 
13865 
  def read(self, iprot):
13866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13868 
      return
13869 
    iprot.readStructBegin()
13870 
    while True:
13871 
      (fname, ftype, fid) = iprot.readFieldBegin()
13872 
      if ftype == TType.STOP:
13873 
        break
13874 
      if fid == 0:
13875 
        if ftype == TType.LIST:
13876 
          self.success = []
4581 phani.kuma 13877 
          (_etype216, _size213) = iprot.readListBegin()
13878 
          for _i217 in xrange(_size213):
13879 
            _elem218 = ReturnOrder()
13880 
            _elem218.read(iprot)
13881 
            self.success.append(_elem218)
2690 chandransh 13882 
          iprot.readListEnd()
13883 
        else:
13884 
          iprot.skip(ftype)
13885 
      else:
13886 
        iprot.skip(ftype)
13887 
      iprot.readFieldEnd()
13888 
    iprot.readStructEnd()
13889 
 
13890 
  def write(self, oprot):
13891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13893 
      return
13894 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 13895 
    if self.success is not None:
2690 chandransh 13896 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13897 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4581 phani.kuma 13898 
      for iter219 in self.success:
13899 
        iter219.write(oprot)
2690 chandransh 13900 
      oprot.writeListEnd()
13901 
      oprot.writeFieldEnd()
13902 
    oprot.writeFieldStop()
13903 
    oprot.writeStructEnd()
13904 
 
3431 rajveer 13905 
  def validate(self):
13906 
    return
13907 
 
13908 
 
2690 chandransh 13909 
  def __repr__(self):
13910 
    L = ['%s=%r' % (key, value)
13911 
      for key, value in self.__dict__.iteritems()]
13912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13913 
 
13914 
  def __eq__(self, other):
13915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13916 
 
13917 
  def __ne__(self, other):
13918 
    return not (self == other)
13919 
 
2700 chandransh 13920 
class getReturnOrder_args:
13921 
  """
13922 
  Attributes:
13923 
   - id
13924 
  """
13925 
 
13926 
  thrift_spec = (
13927 
    None, # 0
13928 
    (1, TType.I64, 'id', None, None, ), # 1
13929 
  )
13930 
 
13931 
  def __init__(self, id=None,):
13932 
    self.id = id
13933 
 
13934 
  def read(self, iprot):
13935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13937 
      return
13938 
    iprot.readStructBegin()
13939 
    while True:
13940 
      (fname, ftype, fid) = iprot.readFieldBegin()
13941 
      if ftype == TType.STOP:
13942 
        break
13943 
      if fid == 1:
13944 
        if ftype == TType.I64:
13945 
          self.id = iprot.readI64();
13946 
        else:
13947 
          iprot.skip(ftype)
13948 
      else:
13949 
        iprot.skip(ftype)
13950 
      iprot.readFieldEnd()
13951 
    iprot.readStructEnd()
13952 
 
13953 
  def write(self, oprot):
13954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13956 
      return
13957 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 13958 
    if self.id is not None:
2700 chandransh 13959 
      oprot.writeFieldBegin('id', TType.I64, 1)
13960 
      oprot.writeI64(self.id)
13961 
      oprot.writeFieldEnd()
13962 
    oprot.writeFieldStop()
13963 
    oprot.writeStructEnd()
13964 
 
3431 rajveer 13965 
  def validate(self):
13966 
    return
13967 
 
13968 
 
2700 chandransh 13969 
  def __repr__(self):
13970 
    L = ['%s=%r' % (key, value)
13971 
      for key, value in self.__dict__.iteritems()]
13972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13973 
 
13974 
  def __eq__(self, other):
13975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13976 
 
13977 
  def __ne__(self, other):
13978 
    return not (self == other)
13979 
 
13980 
class getReturnOrder_result:
13981 
  """
13982 
  Attributes:
13983 
   - success
13984 
   - ex
13985 
  """
13986 
 
13987 
  thrift_spec = (
13988 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
13989 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13990 
  )
13991 
 
13992 
  def __init__(self, success=None, ex=None,):
13993 
    self.success = success
13994 
    self.ex = ex
13995 
 
13996 
  def read(self, iprot):
13997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13999 
      return
14000 
    iprot.readStructBegin()
14001 
    while True:
14002 
      (fname, ftype, fid) = iprot.readFieldBegin()
14003 
      if ftype == TType.STOP:
14004 
        break
14005 
      if fid == 0:
14006 
        if ftype == TType.STRUCT:
14007 
          self.success = ReturnOrder()
14008 
          self.success.read(iprot)
14009 
        else:
14010 
          iprot.skip(ftype)
14011 
      elif fid == 1:
14012 
        if ftype == TType.STRUCT:
14013 
          self.ex = TransactionServiceException()
14014 
          self.ex.read(iprot)
14015 
        else:
14016 
          iprot.skip(ftype)
14017 
      else:
14018 
        iprot.skip(ftype)
14019 
      iprot.readFieldEnd()
14020 
    iprot.readStructEnd()
14021 
 
14022 
  def write(self, oprot):
14023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14025 
      return
14026 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 14027 
    if self.success is not None:
2700 chandransh 14028 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14029 
      self.success.write(oprot)
14030 
      oprot.writeFieldEnd()
3431 rajveer 14031 
    if self.ex is not None:
2700 chandransh 14032 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14033 
      self.ex.write(oprot)
14034 
      oprot.writeFieldEnd()
14035 
    oprot.writeFieldStop()
14036 
    oprot.writeStructEnd()
14037 
 
3431 rajveer 14038 
  def validate(self):
14039 
    return
14040 
 
14041 
 
2700 chandransh 14042 
  def __repr__(self):
14043 
    L = ['%s=%r' % (key, value)
14044 
      for key, value in self.__dict__.iteritems()]
14045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14046 
 
14047 
  def __eq__(self, other):
14048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14049 
 
14050 
  def __ne__(self, other):
14051 
    return not (self == other)
14052 
 
2690 chandransh 14053 
class processReturn_args:
14054 
  """
14055 
  Attributes:
14056 
   - returnOrderId
14057 
  """
14058 
 
14059 
  thrift_spec = (
14060 
    None, # 0
14061 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
14062 
  )
14063 
 
14064 
  def __init__(self, returnOrderId=None,):
14065 
    self.returnOrderId = returnOrderId
14066 
 
14067 
  def read(self, iprot):
14068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14070 
      return
14071 
    iprot.readStructBegin()
14072 
    while True:
14073 
      (fname, ftype, fid) = iprot.readFieldBegin()
14074 
      if ftype == TType.STOP:
14075 
        break
14076 
      if fid == 1:
14077 
        if ftype == TType.I64:
14078 
          self.returnOrderId = iprot.readI64();
14079 
        else:
14080 
          iprot.skip(ftype)
14081 
      else:
14082 
        iprot.skip(ftype)
14083 
      iprot.readFieldEnd()
14084 
    iprot.readStructEnd()
14085 
 
14086 
  def write(self, oprot):
14087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14089 
      return
14090 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 14091 
    if self.returnOrderId is not None:
2690 chandransh 14092 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
14093 
      oprot.writeI64(self.returnOrderId)
14094 
      oprot.writeFieldEnd()
14095 
    oprot.writeFieldStop()
14096 
    oprot.writeStructEnd()
14097 
 
3431 rajveer 14098 
  def validate(self):
14099 
    return
14100 
 
14101 
 
2690 chandransh 14102 
  def __repr__(self):
14103 
    L = ['%s=%r' % (key, value)
14104 
      for key, value in self.__dict__.iteritems()]
14105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14106 
 
14107 
  def __eq__(self, other):
14108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14109 
 
14110 
  def __ne__(self, other):
14111 
    return not (self == other)
14112 
 
14113 
class processReturn_result:
14114 
  """
14115 
  Attributes:
14116 
   - ex
14117 
  """
14118 
 
14119 
  thrift_spec = (
14120 
    None, # 0
14121 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14122 
  )
14123 
 
14124 
  def __init__(self, ex=None,):
14125 
    self.ex = ex
14126 
 
14127 
  def read(self, iprot):
14128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14130 
      return
14131 
    iprot.readStructBegin()
14132 
    while True:
14133 
      (fname, ftype, fid) = iprot.readFieldBegin()
14134 
      if ftype == TType.STOP:
14135 
        break
14136 
      if fid == 1:
14137 
        if ftype == TType.STRUCT:
14138 
          self.ex = TransactionServiceException()
14139 
          self.ex.read(iprot)
14140 
        else:
14141 
          iprot.skip(ftype)
14142 
      else:
14143 
        iprot.skip(ftype)
14144 
      iprot.readFieldEnd()
14145 
    iprot.readStructEnd()
14146 
 
14147 
  def write(self, oprot):
14148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14150 
      return
14151 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 14152 
    if self.ex is not None:
2690 chandransh 14153 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14154 
      self.ex.write(oprot)
14155 
      oprot.writeFieldEnd()
14156 
    oprot.writeFieldStop()
14157 
    oprot.writeStructEnd()
14158 
 
3431 rajveer 14159 
  def validate(self):
14160 
    return
14161 
 
14162 
 
2690 chandransh 14163 
  def __repr__(self):
14164 
    L = ['%s=%r' % (key, value)
14165 
      for key, value in self.__dict__.iteritems()]
14166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14167 
 
14168 
  def __eq__(self, other):
14169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14170 
 
14171 
  def __ne__(self, other):
14172 
    return not (self == other)
14173 
 
2819 chandransh 14174 
class createPurchaseOrder_args:
14175 
  """
14176 
  Attributes:
14177 
   - warehouseId
14178 
  """
2690 chandransh 14179 
 
2819 chandransh 14180 
  thrift_spec = (
14181 
    None, # 0
14182 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14183 
  )
14184 
 
14185 
  def __init__(self, warehouseId=None,):
14186 
    self.warehouseId = warehouseId
14187 
 
14188 
  def read(self, iprot):
14189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14191 
      return
14192 
    iprot.readStructBegin()
14193 
    while True:
14194 
      (fname, ftype, fid) = iprot.readFieldBegin()
14195 
      if ftype == TType.STOP:
14196 
        break
14197 
      if fid == 1:
14198 
        if ftype == TType.I64:
14199 
          self.warehouseId = iprot.readI64();
14200 
        else:
14201 
          iprot.skip(ftype)
14202 
      else:
14203 
        iprot.skip(ftype)
14204 
      iprot.readFieldEnd()
14205 
    iprot.readStructEnd()
14206 
 
14207 
  def write(self, oprot):
14208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14210 
      return
14211 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 14212 
    if self.warehouseId is not None:
2819 chandransh 14213 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14214 
      oprot.writeI64(self.warehouseId)
14215 
      oprot.writeFieldEnd()
14216 
    oprot.writeFieldStop()
14217 
    oprot.writeStructEnd()
14218 
 
3431 rajveer 14219 
  def validate(self):
14220 
    return
14221 
 
14222 
 
2819 chandransh 14223 
  def __repr__(self):
14224 
    L = ['%s=%r' % (key, value)
14225 
      for key, value in self.__dict__.iteritems()]
14226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14227 
 
14228 
  def __eq__(self, other):
14229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14230 
 
14231 
  def __ne__(self, other):
14232 
    return not (self == other)
14233 
 
14234 
class createPurchaseOrder_result:
14235 
  """
14236 
  Attributes:
14237 
   - success
14238 
   - ex
14239 
  """
14240 
 
14241 
  thrift_spec = (
4586 mandeep.dh 14242 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
2819 chandransh 14243 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14244 
  )
14245 
 
14246 
  def __init__(self, success=None, ex=None,):
14247 
    self.success = success
14248 
    self.ex = ex
14249 
 
14250 
  def read(self, iprot):
14251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14253 
      return
14254 
    iprot.readStructBegin()
14255 
    while True:
14256 
      (fname, ftype, fid) = iprot.readFieldBegin()
14257 
      if ftype == TType.STOP:
14258 
        break
14259 
      if fid == 0:
4586 mandeep.dh 14260 
        if ftype == TType.LIST:
14261 
          self.success = []
14262 
          (_etype223, _size220) = iprot.readListBegin()
14263 
          for _i224 in xrange(_size220):
14264 
            _elem225 = iprot.readI64();
14265 
            self.success.append(_elem225)
14266 
          iprot.readListEnd()
2819 chandransh 14267 
        else:
14268 
          iprot.skip(ftype)
14269 
      elif fid == 1:
14270 
        if ftype == TType.STRUCT:
14271 
          self.ex = TransactionServiceException()
14272 
          self.ex.read(iprot)
14273 
        else:
14274 
          iprot.skip(ftype)
14275 
      else:
14276 
        iprot.skip(ftype)
14277 
      iprot.readFieldEnd()
14278 
    iprot.readStructEnd()
14279 
 
14280 
  def write(self, oprot):
14281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14283 
      return
14284 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 14285 
    if self.success is not None:
4586 mandeep.dh 14286 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14287 
      oprot.writeListBegin(TType.I64, len(self.success))
14288 
      for iter226 in self.success:
14289 
        oprot.writeI64(iter226)
14290 
      oprot.writeListEnd()
2819 chandransh 14291 
      oprot.writeFieldEnd()
3431 rajveer 14292 
    if self.ex is not None:
2819 chandransh 14293 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14294 
      self.ex.write(oprot)
14295 
      oprot.writeFieldEnd()
14296 
    oprot.writeFieldStop()
14297 
    oprot.writeStructEnd()
14298 
 
3431 rajveer 14299 
  def validate(self):
14300 
    return
14301 
 
14302 
 
2819 chandransh 14303 
  def __repr__(self):
14304 
    L = ['%s=%r' % (key, value)
14305 
      for key, value in self.__dict__.iteritems()]
14306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14307 
 
14308 
  def __eq__(self, other):
14309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14310 
 
14311 
  def __ne__(self, other):
14312 
    return not (self == other)
3451 chandransh 14313 
 
14314 
class updateWeight_args:
14315 
  """
14316 
  Attributes:
14317 
   - orderId
14318 
   - weight
14319 
  """
14320 
 
14321 
  thrift_spec = (
14322 
    None, # 0
14323 
    (1, TType.I64, 'orderId', None, None, ), # 1
14324 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
14325 
  )
14326 
 
14327 
  def __init__(self, orderId=None, weight=None,):
14328 
    self.orderId = orderId
14329 
    self.weight = weight
14330 
 
14331 
  def read(self, iprot):
14332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14334 
      return
14335 
    iprot.readStructBegin()
14336 
    while True:
14337 
      (fname, ftype, fid) = iprot.readFieldBegin()
14338 
      if ftype == TType.STOP:
14339 
        break
14340 
      if fid == 1:
14341 
        if ftype == TType.I64:
14342 
          self.orderId = iprot.readI64();
14343 
        else:
14344 
          iprot.skip(ftype)
14345 
      elif fid == 2:
14346 
        if ftype == TType.DOUBLE:
14347 
          self.weight = iprot.readDouble();
14348 
        else:
14349 
          iprot.skip(ftype)
14350 
      else:
14351 
        iprot.skip(ftype)
14352 
      iprot.readFieldEnd()
14353 
    iprot.readStructEnd()
14354 
 
14355 
  def write(self, oprot):
14356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14358 
      return
14359 
    oprot.writeStructBegin('updateWeight_args')
14360 
    if self.orderId is not None:
14361 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14362 
      oprot.writeI64(self.orderId)
14363 
      oprot.writeFieldEnd()
14364 
    if self.weight is not None:
14365 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
14366 
      oprot.writeDouble(self.weight)
14367 
      oprot.writeFieldEnd()
14368 
    oprot.writeFieldStop()
14369 
    oprot.writeStructEnd()
14370 
 
14371 
  def validate(self):
14372 
    return
14373 
 
14374 
 
14375 
  def __repr__(self):
14376 
    L = ['%s=%r' % (key, value)
14377 
      for key, value in self.__dict__.iteritems()]
14378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14379 
 
14380 
  def __eq__(self, other):
14381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14382 
 
14383 
  def __ne__(self, other):
14384 
    return not (self == other)
14385 
 
14386 
class updateWeight_result:
14387 
  """
14388 
  Attributes:
14389 
   - success
14390 
   - ex
14391 
  """
14392 
 
14393 
  thrift_spec = (
14394 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14395 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14396 
  )
14397 
 
14398 
  def __init__(self, success=None, ex=None,):
14399 
    self.success = success
14400 
    self.ex = ex
14401 
 
14402 
  def read(self, iprot):
14403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14405 
      return
14406 
    iprot.readStructBegin()
14407 
    while True:
14408 
      (fname, ftype, fid) = iprot.readFieldBegin()
14409 
      if ftype == TType.STOP:
14410 
        break
14411 
      if fid == 0:
14412 
        if ftype == TType.STRUCT:
14413 
          self.success = Order()
14414 
          self.success.read(iprot)
14415 
        else:
14416 
          iprot.skip(ftype)
14417 
      elif fid == 1:
14418 
        if ftype == TType.STRUCT:
14419 
          self.ex = TransactionServiceException()
14420 
          self.ex.read(iprot)
14421 
        else:
14422 
          iprot.skip(ftype)
14423 
      else:
14424 
        iprot.skip(ftype)
14425 
      iprot.readFieldEnd()
14426 
    iprot.readStructEnd()
14427 
 
14428 
  def write(self, oprot):
14429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14431 
      return
14432 
    oprot.writeStructBegin('updateWeight_result')
14433 
    if self.success is not None:
14434 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14435 
      self.success.write(oprot)
14436 
      oprot.writeFieldEnd()
14437 
    if self.ex is not None:
14438 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14439 
      self.ex.write(oprot)
14440 
      oprot.writeFieldEnd()
14441 
    oprot.writeFieldStop()
14442 
    oprot.writeStructEnd()
14443 
 
14444 
  def validate(self):
14445 
    return
14446 
 
14447 
 
14448 
  def __repr__(self):
14449 
    L = ['%s=%r' % (key, value)
14450 
      for key, value in self.__dict__.iteritems()]
14451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14452 
 
14453 
  def __eq__(self, other):
14454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14455 
 
14456 
  def __ne__(self, other):
14457 
    return not (self == other)
3469 chandransh 14458 
 
14459 
class changeItem_args:
14460 
  """
14461 
  Attributes:
14462 
   - orderId
14463 
   - itemId
14464 
  """
14465 
 
14466 
  thrift_spec = (
14467 
    None, # 0
14468 
    (1, TType.I64, 'orderId', None, None, ), # 1
14469 
    (2, TType.I64, 'itemId', None, None, ), # 2
14470 
  )
14471 
 
14472 
  def __init__(self, orderId=None, itemId=None,):
14473 
    self.orderId = orderId
14474 
    self.itemId = itemId
14475 
 
14476 
  def read(self, iprot):
14477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14479 
      return
14480 
    iprot.readStructBegin()
14481 
    while True:
14482 
      (fname, ftype, fid) = iprot.readFieldBegin()
14483 
      if ftype == TType.STOP:
14484 
        break
14485 
      if fid == 1:
14486 
        if ftype == TType.I64:
14487 
          self.orderId = iprot.readI64();
14488 
        else:
14489 
          iprot.skip(ftype)
14490 
      elif fid == 2:
14491 
        if ftype == TType.I64:
14492 
          self.itemId = iprot.readI64();
14493 
        else:
14494 
          iprot.skip(ftype)
14495 
      else:
14496 
        iprot.skip(ftype)
14497 
      iprot.readFieldEnd()
14498 
    iprot.readStructEnd()
14499 
 
14500 
  def write(self, oprot):
14501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14503 
      return
14504 
    oprot.writeStructBegin('changeItem_args')
14505 
    if self.orderId is not None:
14506 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14507 
      oprot.writeI64(self.orderId)
14508 
      oprot.writeFieldEnd()
14509 
    if self.itemId is not None:
14510 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14511 
      oprot.writeI64(self.itemId)
14512 
      oprot.writeFieldEnd()
14513 
    oprot.writeFieldStop()
14514 
    oprot.writeStructEnd()
14515 
 
14516 
  def validate(self):
14517 
    return
14518 
 
14519 
 
14520 
  def __repr__(self):
14521 
    L = ['%s=%r' % (key, value)
14522 
      for key, value in self.__dict__.iteritems()]
14523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14524 
 
14525 
  def __eq__(self, other):
14526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14527 
 
14528 
  def __ne__(self, other):
14529 
    return not (self == other)
14530 
 
14531 
class changeItem_result:
14532 
  """
14533 
  Attributes:
14534 
   - success
14535 
   - ex
14536 
  """
14537 
 
14538 
  thrift_spec = (
14539 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14540 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14541 
  )
14542 
 
14543 
  def __init__(self, success=None, ex=None,):
14544 
    self.success = success
14545 
    self.ex = ex
14546 
 
14547 
  def read(self, iprot):
14548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14550 
      return
14551 
    iprot.readStructBegin()
14552 
    while True:
14553 
      (fname, ftype, fid) = iprot.readFieldBegin()
14554 
      if ftype == TType.STOP:
14555 
        break
14556 
      if fid == 0:
14557 
        if ftype == TType.STRUCT:
14558 
          self.success = Order()
14559 
          self.success.read(iprot)
14560 
        else:
14561 
          iprot.skip(ftype)
14562 
      elif fid == 1:
14563 
        if ftype == TType.STRUCT:
14564 
          self.ex = TransactionServiceException()
14565 
          self.ex.read(iprot)
14566 
        else:
14567 
          iprot.skip(ftype)
14568 
      else:
14569 
        iprot.skip(ftype)
14570 
      iprot.readFieldEnd()
14571 
    iprot.readStructEnd()
14572 
 
14573 
  def write(self, oprot):
14574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14576 
      return
14577 
    oprot.writeStructBegin('changeItem_result')
14578 
    if self.success is not None:
14579 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14580 
      self.success.write(oprot)
14581 
      oprot.writeFieldEnd()
14582 
    if self.ex is not None:
14583 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14584 
      self.ex.write(oprot)
14585 
      oprot.writeFieldEnd()
14586 
    oprot.writeFieldStop()
14587 
    oprot.writeStructEnd()
14588 
 
14589 
  def validate(self):
14590 
    return
14591 
 
14592 
 
14593 
  def __repr__(self):
14594 
    L = ['%s=%r' % (key, value)
14595 
      for key, value in self.__dict__.iteritems()]
14596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14597 
 
14598 
  def __eq__(self, other):
14599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14600 
 
14601 
  def __ne__(self, other):
14602 
    return not (self == other)
14603 
 
14604 
class shiftToWarehouse_args:
14605 
  """
14606 
  Attributes:
14607 
   - orderId
14608 
   - warehouseId
14609 
  """
14610 
 
14611 
  thrift_spec = (
14612 
    None, # 0
14613 
    (1, TType.I64, 'orderId', None, None, ), # 1
14614 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
14615 
  )
14616 
 
14617 
  def __init__(self, orderId=None, warehouseId=None,):
14618 
    self.orderId = orderId
14619 
    self.warehouseId = warehouseId
14620 
 
14621 
  def read(self, iprot):
14622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14624 
      return
14625 
    iprot.readStructBegin()
14626 
    while True:
14627 
      (fname, ftype, fid) = iprot.readFieldBegin()
14628 
      if ftype == TType.STOP:
14629 
        break
14630 
      if fid == 1:
14631 
        if ftype == TType.I64:
14632 
          self.orderId = iprot.readI64();
14633 
        else:
14634 
          iprot.skip(ftype)
14635 
      elif fid == 2:
14636 
        if ftype == TType.I64:
14637 
          self.warehouseId = iprot.readI64();
14638 
        else:
14639 
          iprot.skip(ftype)
14640 
      else:
14641 
        iprot.skip(ftype)
14642 
      iprot.readFieldEnd()
14643 
    iprot.readStructEnd()
14644 
 
14645 
  def write(self, oprot):
14646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14648 
      return
14649 
    oprot.writeStructBegin('shiftToWarehouse_args')
14650 
    if self.orderId is not None:
14651 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14652 
      oprot.writeI64(self.orderId)
14653 
      oprot.writeFieldEnd()
14654 
    if self.warehouseId is not None:
14655 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14656 
      oprot.writeI64(self.warehouseId)
14657 
      oprot.writeFieldEnd()
14658 
    oprot.writeFieldStop()
14659 
    oprot.writeStructEnd()
14660 
 
14661 
  def validate(self):
14662 
    return
14663 
 
14664 
 
14665 
  def __repr__(self):
14666 
    L = ['%s=%r' % (key, value)
14667 
      for key, value in self.__dict__.iteritems()]
14668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14669 
 
14670 
  def __eq__(self, other):
14671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14672 
 
14673 
  def __ne__(self, other):
14674 
    return not (self == other)
14675 
 
14676 
class shiftToWarehouse_result:
14677 
  """
14678 
  Attributes:
14679 
   - success
14680 
   - ex
14681 
  """
14682 
 
14683 
  thrift_spec = (
14684 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14685 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14686 
  )
14687 
 
14688 
  def __init__(self, success=None, ex=None,):
14689 
    self.success = success
14690 
    self.ex = ex
14691 
 
14692 
  def read(self, iprot):
14693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14695 
      return
14696 
    iprot.readStructBegin()
14697 
    while True:
14698 
      (fname, ftype, fid) = iprot.readFieldBegin()
14699 
      if ftype == TType.STOP:
14700 
        break
14701 
      if fid == 0:
14702 
        if ftype == TType.STRUCT:
14703 
          self.success = Order()
14704 
          self.success.read(iprot)
14705 
        else:
14706 
          iprot.skip(ftype)
14707 
      elif fid == 1:
14708 
        if ftype == TType.STRUCT:
14709 
          self.ex = TransactionServiceException()
14710 
          self.ex.read(iprot)
14711 
        else:
14712 
          iprot.skip(ftype)
14713 
      else:
14714 
        iprot.skip(ftype)
14715 
      iprot.readFieldEnd()
14716 
    iprot.readStructEnd()
14717 
 
14718 
  def write(self, oprot):
14719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14721 
      return
14722 
    oprot.writeStructBegin('shiftToWarehouse_result')
14723 
    if self.success is not None:
14724 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14725 
      self.success.write(oprot)
14726 
      oprot.writeFieldEnd()
14727 
    if self.ex is not None:
14728 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14729 
      self.ex.write(oprot)
14730 
      oprot.writeFieldEnd()
14731 
    oprot.writeFieldStop()
14732 
    oprot.writeStructEnd()
14733 
 
14734 
  def validate(self):
14735 
    return
14736 
 
14737 
 
14738 
  def __repr__(self):
14739 
    L = ['%s=%r' % (key, value)
14740 
      for key, value in self.__dict__.iteritems()]
14741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14742 
 
14743 
  def __eq__(self, other):
14744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14745 
 
14746 
  def __ne__(self, other):
14747 
    return not (self == other)
3553 chandransh 14748 
 
14749 
class addDelayReason_args:
14750 
  """
14751 
  Attributes:
14752 
   - orderId
14753 
   - delayReason
3986 chandransh 14754 
   - furtherDelay
4647 rajveer 14755 
   - delayReasonText
3553 chandransh 14756 
  """
14757 
 
14758 
  thrift_spec = (
14759 
    None, # 0
14760 
    (1, TType.I64, 'orderId', None, None, ), # 1
14761 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 14762 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 14763 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 14764 
  )
14765 
 
4647 rajveer 14766 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 14767 
    self.orderId = orderId
14768 
    self.delayReason = delayReason
3986 chandransh 14769 
    self.furtherDelay = furtherDelay
4647 rajveer 14770 
    self.delayReasonText = delayReasonText
3553 chandransh 14771 
 
14772 
  def read(self, iprot):
14773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14775 
      return
14776 
    iprot.readStructBegin()
14777 
    while True:
14778 
      (fname, ftype, fid) = iprot.readFieldBegin()
14779 
      if ftype == TType.STOP:
14780 
        break
14781 
      if fid == 1:
14782 
        if ftype == TType.I64:
14783 
          self.orderId = iprot.readI64();
14784 
        else:
14785 
          iprot.skip(ftype)
14786 
      elif fid == 2:
14787 
        if ftype == TType.I32:
14788 
          self.delayReason = iprot.readI32();
14789 
        else:
14790 
          iprot.skip(ftype)
3986 chandransh 14791 
      elif fid == 3:
14792 
        if ftype == TType.I64:
14793 
          self.furtherDelay = iprot.readI64();
14794 
        else:
14795 
          iprot.skip(ftype)
4647 rajveer 14796 
      elif fid == 4:
14797 
        if ftype == TType.STRING:
14798 
          self.delayReasonText = iprot.readString();
14799 
        else:
14800 
          iprot.skip(ftype)
3553 chandransh 14801 
      else:
14802 
        iprot.skip(ftype)
14803 
      iprot.readFieldEnd()
14804 
    iprot.readStructEnd()
14805 
 
14806 
  def write(self, oprot):
14807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14809 
      return
14810 
    oprot.writeStructBegin('addDelayReason_args')
14811 
    if self.orderId is not None:
14812 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14813 
      oprot.writeI64(self.orderId)
14814 
      oprot.writeFieldEnd()
14815 
    if self.delayReason is not None:
14816 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
14817 
      oprot.writeI32(self.delayReason)
14818 
      oprot.writeFieldEnd()
3986 chandransh 14819 
    if self.furtherDelay is not None:
14820 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
14821 
      oprot.writeI64(self.furtherDelay)
14822 
      oprot.writeFieldEnd()
4647 rajveer 14823 
    if self.delayReasonText is not None:
14824 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
14825 
      oprot.writeString(self.delayReasonText)
14826 
      oprot.writeFieldEnd()
3553 chandransh 14827 
    oprot.writeFieldStop()
14828 
    oprot.writeStructEnd()
14829 
 
14830 
  def validate(self):
14831 
    return
14832 
 
14833 
 
14834 
  def __repr__(self):
14835 
    L = ['%s=%r' % (key, value)
14836 
      for key, value in self.__dict__.iteritems()]
14837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14838 
 
14839 
  def __eq__(self, other):
14840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14841 
 
14842 
  def __ne__(self, other):
14843 
    return not (self == other)
14844 
 
14845 
class addDelayReason_result:
14846 
  """
14847 
  Attributes:
14848 
   - success
14849 
   - ex
14850 
  """
14851 
 
14852 
  thrift_spec = (
14853 
    (0, TType.BOOL, 'success', None, None, ), # 0
14854 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14855 
  )
14856 
 
14857 
  def __init__(self, success=None, ex=None,):
14858 
    self.success = success
14859 
    self.ex = ex
14860 
 
14861 
  def read(self, iprot):
14862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14864 
      return
14865 
    iprot.readStructBegin()
14866 
    while True:
14867 
      (fname, ftype, fid) = iprot.readFieldBegin()
14868 
      if ftype == TType.STOP:
14869 
        break
14870 
      if fid == 0:
14871 
        if ftype == TType.BOOL:
14872 
          self.success = iprot.readBool();
14873 
        else:
14874 
          iprot.skip(ftype)
14875 
      elif fid == 1:
14876 
        if ftype == TType.STRUCT:
14877 
          self.ex = TransactionServiceException()
14878 
          self.ex.read(iprot)
14879 
        else:
14880 
          iprot.skip(ftype)
14881 
      else:
14882 
        iprot.skip(ftype)
14883 
      iprot.readFieldEnd()
14884 
    iprot.readStructEnd()
14885 
 
14886 
  def write(self, oprot):
14887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14889 
      return
14890 
    oprot.writeStructBegin('addDelayReason_result')
14891 
    if self.success is not None:
14892 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14893 
      oprot.writeBool(self.success)
14894 
      oprot.writeFieldEnd()
14895 
    if self.ex is not None:
14896 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14897 
      self.ex.write(oprot)
14898 
      oprot.writeFieldEnd()
14899 
    oprot.writeFieldStop()
14900 
    oprot.writeStructEnd()
14901 
 
14902 
  def validate(self):
14903 
    return
14904 
 
14905 
 
14906 
  def __repr__(self):
14907 
    L = ['%s=%r' % (key, value)
14908 
      for key, value in self.__dict__.iteritems()]
14909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14910 
 
14911 
  def __eq__(self, other):
14912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14913 
 
14914 
  def __ne__(self, other):
14915 
    return not (self == other)
3956 chandransh 14916 
 
14917 
class reconcileCodCollection_args:
14918 
  """
14919 
  Attributes:
14920 
   - collectedAmountMap
14921 
   - xferBy
14922 
   - xferTxnId
14923 
   - xferDate
14924 
  """
14925 
 
14926 
  thrift_spec = (
14927 
    None, # 0
14928 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
14929 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
14930 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
14931 
    (4, TType.I64, 'xferDate', None, None, ), # 4
14932 
  )
14933 
 
14934 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
14935 
    self.collectedAmountMap = collectedAmountMap
14936 
    self.xferBy = xferBy
14937 
    self.xferTxnId = xferTxnId
14938 
    self.xferDate = xferDate
14939 
 
14940 
  def read(self, iprot):
14941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14943 
      return
14944 
    iprot.readStructBegin()
14945 
    while True:
14946 
      (fname, ftype, fid) = iprot.readFieldBegin()
14947 
      if ftype == TType.STOP:
14948 
        break
14949 
      if fid == 1:
14950 
        if ftype == TType.MAP:
14951 
          self.collectedAmountMap = {}
4586 mandeep.dh 14952 
          (_ktype228, _vtype229, _size227 ) = iprot.readMapBegin()
14953 
          for _i231 in xrange(_size227):
14954 
            _key232 = iprot.readString();
14955 
            _val233 = iprot.readDouble();
14956 
            self.collectedAmountMap[_key232] = _val233
3956 chandransh 14957 
          iprot.readMapEnd()
14958 
        else:
14959 
          iprot.skip(ftype)
14960 
      elif fid == 2:
14961 
        if ftype == TType.STRING:
14962 
          self.xferBy = iprot.readString();
14963 
        else:
14964 
          iprot.skip(ftype)
14965 
      elif fid == 3:
14966 
        if ftype == TType.STRING:
14967 
          self.xferTxnId = iprot.readString();
14968 
        else:
14969 
          iprot.skip(ftype)
14970 
      elif fid == 4:
14971 
        if ftype == TType.I64:
14972 
          self.xferDate = iprot.readI64();
14973 
        else:
14974 
          iprot.skip(ftype)
14975 
      else:
14976 
        iprot.skip(ftype)
14977 
      iprot.readFieldEnd()
14978 
    iprot.readStructEnd()
14979 
 
14980 
  def write(self, oprot):
14981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14983 
      return
14984 
    oprot.writeStructBegin('reconcileCodCollection_args')
14985 
    if self.collectedAmountMap is not None:
14986 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
14987 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4586 mandeep.dh 14988 
      for kiter234,viter235 in self.collectedAmountMap.items():
14989 
        oprot.writeString(kiter234)
14990 
        oprot.writeDouble(viter235)
3956 chandransh 14991 
      oprot.writeMapEnd()
14992 
      oprot.writeFieldEnd()
14993 
    if self.xferBy is not None:
14994 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
14995 
      oprot.writeString(self.xferBy)
14996 
      oprot.writeFieldEnd()
14997 
    if self.xferTxnId is not None:
14998 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
14999 
      oprot.writeString(self.xferTxnId)
15000 
      oprot.writeFieldEnd()
15001 
    if self.xferDate is not None:
15002 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
15003 
      oprot.writeI64(self.xferDate)
15004 
      oprot.writeFieldEnd()
15005 
    oprot.writeFieldStop()
15006 
    oprot.writeStructEnd()
15007 
 
15008 
  def validate(self):
15009 
    return
15010 
 
15011 
 
15012 
  def __repr__(self):
15013 
    L = ['%s=%r' % (key, value)
15014 
      for key, value in self.__dict__.iteritems()]
15015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15016 
 
15017 
  def __eq__(self, other):
15018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15019 
 
15020 
  def __ne__(self, other):
15021 
    return not (self == other)
15022 
 
15023 
class reconcileCodCollection_result:
15024 
  """
15025 
  Attributes:
15026 
   - success
15027 
   - ex
15028 
  """
15029 
 
15030 
  thrift_spec = (
15031 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15032 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15033 
  )
15034 
 
15035 
  def __init__(self, success=None, ex=None,):
15036 
    self.success = success
15037 
    self.ex = ex
15038 
 
15039 
  def read(self, iprot):
15040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15042 
      return
15043 
    iprot.readStructBegin()
15044 
    while True:
15045 
      (fname, ftype, fid) = iprot.readFieldBegin()
15046 
      if ftype == TType.STOP:
15047 
        break
15048 
      if fid == 0:
15049 
        if ftype == TType.MAP:
15050 
          self.success = {}
4586 mandeep.dh 15051 
          (_ktype237, _vtype238, _size236 ) = iprot.readMapBegin()
15052 
          for _i240 in xrange(_size236):
15053 
            _key241 = iprot.readString();
15054 
            _val242 = iprot.readString();
15055 
            self.success[_key241] = _val242
3956 chandransh 15056 
          iprot.readMapEnd()
15057 
        else:
15058 
          iprot.skip(ftype)
15059 
      elif fid == 1:
15060 
        if ftype == TType.STRUCT:
15061 
          self.ex = TransactionServiceException()
15062 
          self.ex.read(iprot)
15063 
        else:
15064 
          iprot.skip(ftype)
15065 
      else:
15066 
        iprot.skip(ftype)
15067 
      iprot.readFieldEnd()
15068 
    iprot.readStructEnd()
15069 
 
15070 
  def write(self, oprot):
15071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15073 
      return
15074 
    oprot.writeStructBegin('reconcileCodCollection_result')
15075 
    if self.success is not None:
15076 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15077 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4586 mandeep.dh 15078 
      for kiter243,viter244 in self.success.items():
15079 
        oprot.writeString(kiter243)
15080 
        oprot.writeString(viter244)
3956 chandransh 15081 
      oprot.writeMapEnd()
15082 
      oprot.writeFieldEnd()
15083 
    if self.ex is not None:
15084 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15085 
      self.ex.write(oprot)
15086 
      oprot.writeFieldEnd()
15087 
    oprot.writeFieldStop()
15088 
    oprot.writeStructEnd()
15089 
 
15090 
  def validate(self):
15091 
    return
15092 
 
15093 
 
15094 
  def __repr__(self):
15095 
    L = ['%s=%r' % (key, value)
15096 
      for key, value in self.__dict__.iteritems()]
15097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15098 
 
15099 
  def __eq__(self, other):
15100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15101 
 
15102 
  def __ne__(self, other):
15103 
    return not (self == other)
4008 mandeep.dh 15104 
 
15105 
class getTransactionsRequiringExtraProcessing_args:
15106 
  """
15107 
  Attributes:
15108 
   - category
15109 
  """
15110 
 
15111 
  thrift_spec = (
15112 
    None, # 0
15113 
    (1, TType.I32, 'category', None, None, ), # 1
15114 
  )
15115 
 
15116 
  def __init__(self, category=None,):
15117 
    self.category = category
15118 
 
15119 
  def read(self, iprot):
15120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15122 
      return
15123 
    iprot.readStructBegin()
15124 
    while True:
15125 
      (fname, ftype, fid) = iprot.readFieldBegin()
15126 
      if ftype == TType.STOP:
15127 
        break
15128 
      if fid == 1:
15129 
        if ftype == TType.I32:
15130 
          self.category = iprot.readI32();
15131 
        else:
15132 
          iprot.skip(ftype)
15133 
      else:
15134 
        iprot.skip(ftype)
15135 
      iprot.readFieldEnd()
15136 
    iprot.readStructEnd()
15137 
 
15138 
  def write(self, oprot):
15139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15141 
      return
15142 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
15143 
    if self.category is not None:
15144 
      oprot.writeFieldBegin('category', TType.I32, 1)
15145 
      oprot.writeI32(self.category)
15146 
      oprot.writeFieldEnd()
15147 
    oprot.writeFieldStop()
15148 
    oprot.writeStructEnd()
15149 
 
15150 
  def validate(self):
15151 
    return
15152 
 
15153 
 
15154 
  def __repr__(self):
15155 
    L = ['%s=%r' % (key, value)
15156 
      for key, value in self.__dict__.iteritems()]
15157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15158 
 
15159 
  def __eq__(self, other):
15160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15161 
 
15162 
  def __ne__(self, other):
15163 
    return not (self == other)
15164 
 
15165 
class getTransactionsRequiringExtraProcessing_result:
15166 
  """
15167 
  Attributes:
15168 
   - success
15169 
  """
15170 
 
15171 
  thrift_spec = (
15172 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15173 
  )
15174 
 
15175 
  def __init__(self, success=None,):
15176 
    self.success = success
15177 
 
15178 
  def read(self, iprot):
15179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15181 
      return
15182 
    iprot.readStructBegin()
15183 
    while True:
15184 
      (fname, ftype, fid) = iprot.readFieldBegin()
15185 
      if ftype == TType.STOP:
15186 
        break
15187 
      if fid == 0:
15188 
        if ftype == TType.LIST:
15189 
          self.success = []
4586 mandeep.dh 15190 
          (_etype248, _size245) = iprot.readListBegin()
15191 
          for _i249 in xrange(_size245):
15192 
            _elem250 = iprot.readI64();
15193 
            self.success.append(_elem250)
4008 mandeep.dh 15194 
          iprot.readListEnd()
15195 
        else:
15196 
          iprot.skip(ftype)
15197 
      else:
15198 
        iprot.skip(ftype)
15199 
      iprot.readFieldEnd()
15200 
    iprot.readStructEnd()
15201 
 
15202 
  def write(self, oprot):
15203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15205 
      return
15206 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
15207 
    if self.success is not None:
15208 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15209 
      oprot.writeListBegin(TType.I64, len(self.success))
4586 mandeep.dh 15210 
      for iter251 in self.success:
15211 
        oprot.writeI64(iter251)
4008 mandeep.dh 15212 
      oprot.writeListEnd()
15213 
      oprot.writeFieldEnd()
15214 
    oprot.writeFieldStop()
15215 
    oprot.writeStructEnd()
15216 
 
15217 
  def validate(self):
15218 
    return
15219 
 
15220 
 
15221 
  def __repr__(self):
15222 
    L = ['%s=%r' % (key, value)
15223 
      for key, value in self.__dict__.iteritems()]
15224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15225 
 
15226 
  def __eq__(self, other):
15227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15228 
 
15229 
  def __ne__(self, other):
15230 
    return not (self == other)
15231 
 
15232 
class markTransactionAsProcessed_args:
15233 
  """
15234 
  Attributes:
15235 
   - transactionId
15236 
   - category
15237 
  """
15238 
 
15239 
  thrift_spec = (
15240 
    None, # 0
15241 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15242 
    (2, TType.I32, 'category', None, None, ), # 2
15243 
  )
15244 
 
15245 
  def __init__(self, transactionId=None, category=None,):
15246 
    self.transactionId = transactionId
15247 
    self.category = category
15248 
 
15249 
  def read(self, iprot):
15250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15252 
      return
15253 
    iprot.readStructBegin()
15254 
    while True:
15255 
      (fname, ftype, fid) = iprot.readFieldBegin()
15256 
      if ftype == TType.STOP:
15257 
        break
15258 
      if fid == 1:
15259 
        if ftype == TType.I64:
15260 
          self.transactionId = iprot.readI64();
15261 
        else:
15262 
          iprot.skip(ftype)
15263 
      elif fid == 2:
15264 
        if ftype == TType.I32:
15265 
          self.category = iprot.readI32();
15266 
        else:
15267 
          iprot.skip(ftype)
15268 
      else:
15269 
        iprot.skip(ftype)
15270 
      iprot.readFieldEnd()
15271 
    iprot.readStructEnd()
15272 
 
15273 
  def write(self, oprot):
15274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15276 
      return
15277 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
15278 
    if self.transactionId is not None:
15279 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15280 
      oprot.writeI64(self.transactionId)
15281 
      oprot.writeFieldEnd()
15282 
    if self.category is not None:
15283 
      oprot.writeFieldBegin('category', TType.I32, 2)
15284 
      oprot.writeI32(self.category)
15285 
      oprot.writeFieldEnd()
15286 
    oprot.writeFieldStop()
15287 
    oprot.writeStructEnd()
15288 
 
15289 
  def validate(self):
15290 
    return
15291 
 
15292 
 
15293 
  def __repr__(self):
15294 
    L = ['%s=%r' % (key, value)
15295 
      for key, value in self.__dict__.iteritems()]
15296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15297 
 
15298 
  def __eq__(self, other):
15299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15300 
 
15301 
  def __ne__(self, other):
15302 
    return not (self == other)
15303 
 
15304 
class markTransactionAsProcessed_result:
15305 
 
15306 
  thrift_spec = (
15307 
  )
15308 
 
15309 
  def read(self, iprot):
15310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15312 
      return
15313 
    iprot.readStructBegin()
15314 
    while True:
15315 
      (fname, ftype, fid) = iprot.readFieldBegin()
15316 
      if ftype == TType.STOP:
15317 
        break
15318 
      else:
15319 
        iprot.skip(ftype)
15320 
      iprot.readFieldEnd()
15321 
    iprot.readStructEnd()
15322 
 
15323 
  def write(self, oprot):
15324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15326 
      return
15327 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
15328 
    oprot.writeFieldStop()
15329 
    oprot.writeStructEnd()
15330 
 
15331 
  def validate(self):
15332 
    return
15333 
 
15334 
 
15335 
  def __repr__(self):
15336 
    L = ['%s=%r' % (key, value)
15337 
      for key, value in self.__dict__.iteritems()]
15338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15339 
 
15340 
  def __eq__(self, other):
15341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15342 
 
15343 
  def __ne__(self, other):
15344 
    return not (self == other)
4018 chandransh 15345 
 
15346 
class getItemWiseRiskyOrdersCount_args:
15347 
 
15348 
  thrift_spec = (
15349 
  )
15350 
 
15351 
  def read(self, iprot):
15352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15354 
      return
15355 
    iprot.readStructBegin()
15356 
    while True:
15357 
      (fname, ftype, fid) = iprot.readFieldBegin()
15358 
      if ftype == TType.STOP:
15359 
        break
15360 
      else:
15361 
        iprot.skip(ftype)
15362 
      iprot.readFieldEnd()
15363 
    iprot.readStructEnd()
15364 
 
15365 
  def write(self, oprot):
15366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15368 
      return
15369 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
15370 
    oprot.writeFieldStop()
15371 
    oprot.writeStructEnd()
15372 
 
15373 
  def validate(self):
15374 
    return
15375 
 
15376 
 
15377 
  def __repr__(self):
15378 
    L = ['%s=%r' % (key, value)
15379 
      for key, value in self.__dict__.iteritems()]
15380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15381 
 
15382 
  def __eq__(self, other):
15383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15384 
 
15385 
  def __ne__(self, other):
15386 
    return not (self == other)
15387 
 
15388 
class getItemWiseRiskyOrdersCount_result:
15389 
  """
15390 
  Attributes:
15391 
   - success
15392 
  """
15393 
 
15394 
  thrift_spec = (
15395 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
15396 
  )
15397 
 
15398 
  def __init__(self, success=None,):
15399 
    self.success = success
15400 
 
15401 
  def read(self, iprot):
15402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15404 
      return
15405 
    iprot.readStructBegin()
15406 
    while True:
15407 
      (fname, ftype, fid) = iprot.readFieldBegin()
15408 
      if ftype == TType.STOP:
15409 
        break
15410 
      if fid == 0:
15411 
        if ftype == TType.MAP:
15412 
          self.success = {}
4586 mandeep.dh 15413 
          (_ktype253, _vtype254, _size252 ) = iprot.readMapBegin()
15414 
          for _i256 in xrange(_size252):
15415 
            _key257 = iprot.readI64();
15416 
            _val258 = iprot.readI64();
15417 
            self.success[_key257] = _val258
4018 chandransh 15418 
          iprot.readMapEnd()
15419 
        else:
15420 
          iprot.skip(ftype)
15421 
      else:
15422 
        iprot.skip(ftype)
15423 
      iprot.readFieldEnd()
15424 
    iprot.readStructEnd()
15425 
 
15426 
  def write(self, oprot):
15427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15429 
      return
15430 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
15431 
    if self.success is not None:
15432 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15433 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4586 mandeep.dh 15434 
      for kiter259,viter260 in self.success.items():
15435 
        oprot.writeI64(kiter259)
15436 
        oprot.writeI64(viter260)
4018 chandransh 15437 
      oprot.writeMapEnd()
15438 
      oprot.writeFieldEnd()
15439 
    oprot.writeFieldStop()
15440 
    oprot.writeStructEnd()
15441 
 
15442 
  def validate(self):
15443 
    return
15444 
 
15445 
 
15446 
  def __repr__(self):
15447 
    L = ['%s=%r' % (key, value)
15448 
      for key, value in self.__dict__.iteritems()]
15449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15450 
 
15451 
  def __eq__(self, other):
15452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15453 
 
15454 
  def __ne__(self, other):
15455 
    return not (self == other)
4247 rajveer 15456 
 
4295 varun.gupt 15457 
class getOrdersForItemIds_args:
15458 
  """
15459 
  Attributes:
15460 
   - itemIds
15461 
  """
15462 
 
15463 
  thrift_spec = (
15464 
    None, # 0
15465 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15466 
  )
15467 
 
15468 
  def __init__(self, itemIds=None,):
15469 
    self.itemIds = itemIds
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 == 1:
15481 
        if ftype == TType.LIST:
15482 
          self.itemIds = []
4586 mandeep.dh 15483 
          (_etype264, _size261) = iprot.readListBegin()
15484 
          for _i265 in xrange(_size261):
15485 
            _elem266 = iprot.readI64();
15486 
            self.itemIds.append(_elem266)
4295 varun.gupt 15487 
          iprot.readListEnd()
15488 
        else:
15489 
          iprot.skip(ftype)
15490 
      else:
15491 
        iprot.skip(ftype)
15492 
      iprot.readFieldEnd()
15493 
    iprot.readStructEnd()
15494 
 
15495 
  def write(self, oprot):
15496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15498 
      return
15499 
    oprot.writeStructBegin('getOrdersForItemIds_args')
15500 
    if self.itemIds is not None:
15501 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15502 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4586 mandeep.dh 15503 
      for iter267 in self.itemIds:
15504 
        oprot.writeI64(iter267)
4295 varun.gupt 15505 
      oprot.writeListEnd()
15506 
      oprot.writeFieldEnd()
15507 
    oprot.writeFieldStop()
15508 
    oprot.writeStructEnd()
15509 
 
15510 
  def validate(self):
15511 
    return
15512 
 
15513 
 
15514 
  def __repr__(self):
15515 
    L = ['%s=%r' % (key, value)
15516 
      for key, value in self.__dict__.iteritems()]
15517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15518 
 
15519 
  def __eq__(self, other):
15520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15521 
 
15522 
  def __ne__(self, other):
15523 
    return not (self == other)
15524 
 
15525 
class getOrdersForItemIds_result:
15526 
  """
15527 
  Attributes:
15528 
   - success
15529 
  """
15530 
 
15531 
  thrift_spec = (
15532 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15533 
  )
15534 
 
15535 
  def __init__(self, success=None,):
15536 
    self.success = success
15537 
 
15538 
  def read(self, iprot):
15539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15541 
      return
15542 
    iprot.readStructBegin()
15543 
    while True:
15544 
      (fname, ftype, fid) = iprot.readFieldBegin()
15545 
      if ftype == TType.STOP:
15546 
        break
15547 
      if fid == 0:
15548 
        if ftype == TType.LIST:
15549 
          self.success = []
4586 mandeep.dh 15550 
          (_etype271, _size268) = iprot.readListBegin()
15551 
          for _i272 in xrange(_size268):
15552 
            _elem273 = Order()
15553 
            _elem273.read(iprot)
15554 
            self.success.append(_elem273)
4295 varun.gupt 15555 
          iprot.readListEnd()
15556 
        else:
15557 
          iprot.skip(ftype)
15558 
      else:
15559 
        iprot.skip(ftype)
15560 
      iprot.readFieldEnd()
15561 
    iprot.readStructEnd()
15562 
 
15563 
  def write(self, oprot):
15564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15566 
      return
15567 
    oprot.writeStructBegin('getOrdersForItemIds_result')
15568 
    if self.success is not None:
15569 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15570 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 15571 
      for iter274 in self.success:
15572 
        iter274.write(oprot)
4295 varun.gupt 15573 
      oprot.writeListEnd()
15574 
      oprot.writeFieldEnd()
15575 
    oprot.writeFieldStop()
15576 
    oprot.writeStructEnd()
15577 
 
15578 
  def validate(self):
15579 
    return
15580 
 
15581 
 
15582 
  def __repr__(self):
15583 
    L = ['%s=%r' % (key, value)
15584 
      for key, value in self.__dict__.iteritems()]
15585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15586 
 
15587 
  def __eq__(self, other):
15588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15589 
 
15590 
  def __ne__(self, other):
15591 
    return not (self == other)
15592 
 
4247 rajveer 15593 
class markOrderCancellationRequestReceived_args:
15594 
  """
15595 
  Attributes:
15596 
   - orderId
15597 
  """
15598 
 
15599 
  thrift_spec = (
15600 
    None, # 0
15601 
    (1, TType.I64, 'orderId', None, None, ), # 1
15602 
  )
15603 
 
15604 
  def __init__(self, orderId=None,):
15605 
    self.orderId = orderId
15606 
 
15607 
  def read(self, iprot):
15608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15610 
      return
15611 
    iprot.readStructBegin()
15612 
    while True:
15613 
      (fname, ftype, fid) = iprot.readFieldBegin()
15614 
      if ftype == TType.STOP:
15615 
        break
15616 
      if fid == 1:
15617 
        if ftype == TType.I64:
15618 
          self.orderId = iprot.readI64();
15619 
        else:
15620 
          iprot.skip(ftype)
15621 
      else:
15622 
        iprot.skip(ftype)
15623 
      iprot.readFieldEnd()
15624 
    iprot.readStructEnd()
15625 
 
15626 
  def write(self, oprot):
15627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15629 
      return
15630 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
15631 
    if self.orderId is not None:
15632 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15633 
      oprot.writeI64(self.orderId)
15634 
      oprot.writeFieldEnd()
15635 
    oprot.writeFieldStop()
15636 
    oprot.writeStructEnd()
15637 
 
15638 
  def validate(self):
15639 
    return
15640 
 
15641 
 
15642 
  def __repr__(self):
15643 
    L = ['%s=%r' % (key, value)
15644 
      for key, value in self.__dict__.iteritems()]
15645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15646 
 
15647 
  def __eq__(self, other):
15648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15649 
 
15650 
  def __ne__(self, other):
15651 
    return not (self == other)
15652 
 
15653 
class markOrderCancellationRequestReceived_result:
15654 
  """
15655 
  Attributes:
15656 
   - ex
15657 
  """
15658 
 
15659 
  thrift_spec = (
15660 
    None, # 0
15661 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15662 
  )
15663 
 
15664 
  def __init__(self, ex=None,):
15665 
    self.ex = ex
15666 
 
15667 
  def read(self, iprot):
15668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15670 
      return
15671 
    iprot.readStructBegin()
15672 
    while True:
15673 
      (fname, ftype, fid) = iprot.readFieldBegin()
15674 
      if ftype == TType.STOP:
15675 
        break
15676 
      if fid == 1:
15677 
        if ftype == TType.STRUCT:
15678 
          self.ex = TransactionServiceException()
15679 
          self.ex.read(iprot)
15680 
        else:
15681 
          iprot.skip(ftype)
15682 
      else:
15683 
        iprot.skip(ftype)
15684 
      iprot.readFieldEnd()
15685 
    iprot.readStructEnd()
15686 
 
15687 
  def write(self, oprot):
15688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15690 
      return
15691 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
15692 
    if self.ex is not None:
15693 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15694 
      self.ex.write(oprot)
15695 
      oprot.writeFieldEnd()
15696 
    oprot.writeFieldStop()
15697 
    oprot.writeStructEnd()
15698 
 
15699 
  def validate(self):
15700 
    return
15701 
 
15702 
 
15703 
  def __repr__(self):
15704 
    L = ['%s=%r' % (key, value)
15705 
      for key, value in self.__dict__.iteritems()]
15706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15707 
 
15708 
  def __eq__(self, other):
15709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15710 
 
15711 
  def __ne__(self, other):
15712 
    return not (self == other)
15713 
 
15714 
class markOrderCancellationRequestConfirmed_args:
15715 
  """
15716 
  Attributes:
15717 
   - orderId
15718 
  """
15719 
 
15720 
  thrift_spec = (
15721 
    None, # 0
15722 
    (1, TType.I64, 'orderId', None, None, ), # 1
15723 
  )
15724 
 
15725 
  def __init__(self, orderId=None,):
15726 
    self.orderId = orderId
15727 
 
15728 
  def read(self, iprot):
15729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15731 
      return
15732 
    iprot.readStructBegin()
15733 
    while True:
15734 
      (fname, ftype, fid) = iprot.readFieldBegin()
15735 
      if ftype == TType.STOP:
15736 
        break
15737 
      if fid == 1:
15738 
        if ftype == TType.I64:
15739 
          self.orderId = iprot.readI64();
15740 
        else:
15741 
          iprot.skip(ftype)
15742 
      else:
15743 
        iprot.skip(ftype)
15744 
      iprot.readFieldEnd()
15745 
    iprot.readStructEnd()
15746 
 
15747 
  def write(self, oprot):
15748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15750 
      return
15751 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
15752 
    if self.orderId is not None:
15753 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15754 
      oprot.writeI64(self.orderId)
15755 
      oprot.writeFieldEnd()
15756 
    oprot.writeFieldStop()
15757 
    oprot.writeStructEnd()
15758 
 
15759 
  def validate(self):
15760 
    return
15761 
 
15762 
 
15763 
  def __repr__(self):
15764 
    L = ['%s=%r' % (key, value)
15765 
      for key, value in self.__dict__.iteritems()]
15766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15767 
 
15768 
  def __eq__(self, other):
15769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15770 
 
15771 
  def __ne__(self, other):
15772 
    return not (self == other)
15773 
 
15774 
class markOrderCancellationRequestConfirmed_result:
15775 
  """
15776 
  Attributes:
15777 
   - ex
15778 
  """
15779 
 
15780 
  thrift_spec = (
15781 
    None, # 0
15782 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15783 
  )
15784 
 
15785 
  def __init__(self, ex=None,):
15786 
    self.ex = ex
15787 
 
15788 
  def read(self, iprot):
15789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15791 
      return
15792 
    iprot.readStructBegin()
15793 
    while True:
15794 
      (fname, ftype, fid) = iprot.readFieldBegin()
15795 
      if ftype == TType.STOP:
15796 
        break
15797 
      if fid == 1:
15798 
        if ftype == TType.STRUCT:
15799 
          self.ex = TransactionServiceException()
15800 
          self.ex.read(iprot)
15801 
        else:
15802 
          iprot.skip(ftype)
15803 
      else:
15804 
        iprot.skip(ftype)
15805 
      iprot.readFieldEnd()
15806 
    iprot.readStructEnd()
15807 
 
15808 
  def write(self, oprot):
15809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15811 
      return
15812 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
15813 
    if self.ex is not None:
15814 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15815 
      self.ex.write(oprot)
15816 
      oprot.writeFieldEnd()
15817 
    oprot.writeFieldStop()
15818 
    oprot.writeStructEnd()
15819 
 
15820 
  def validate(self):
15821 
    return
15822 
 
15823 
 
15824 
  def __repr__(self):
15825 
    L = ['%s=%r' % (key, value)
15826 
      for key, value in self.__dict__.iteritems()]
15827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15828 
 
15829 
  def __eq__(self, other):
15830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15831 
 
15832 
  def __ne__(self, other):
15833 
    return not (self == other)
15834 
 
15835 
class markOrderCancellationRequestDenied_args:
15836 
  """
15837 
  Attributes:
15838 
   - orderId
15839 
  """
15840 
 
15841 
  thrift_spec = (
15842 
    None, # 0
15843 
    (1, TType.I64, 'orderId', None, None, ), # 1
15844 
  )
15845 
 
15846 
  def __init__(self, orderId=None,):
15847 
    self.orderId = orderId
15848 
 
15849 
  def read(self, iprot):
15850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15852 
      return
15853 
    iprot.readStructBegin()
15854 
    while True:
15855 
      (fname, ftype, fid) = iprot.readFieldBegin()
15856 
      if ftype == TType.STOP:
15857 
        break
15858 
      if fid == 1:
15859 
        if ftype == TType.I64:
15860 
          self.orderId = iprot.readI64();
15861 
        else:
15862 
          iprot.skip(ftype)
15863 
      else:
15864 
        iprot.skip(ftype)
15865 
      iprot.readFieldEnd()
15866 
    iprot.readStructEnd()
15867 
 
15868 
  def write(self, oprot):
15869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15871 
      return
15872 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
15873 
    if self.orderId is not None:
15874 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15875 
      oprot.writeI64(self.orderId)
15876 
      oprot.writeFieldEnd()
15877 
    oprot.writeFieldStop()
15878 
    oprot.writeStructEnd()
15879 
 
15880 
  def validate(self):
15881 
    return
15882 
 
15883 
 
15884 
  def __repr__(self):
15885 
    L = ['%s=%r' % (key, value)
15886 
      for key, value in self.__dict__.iteritems()]
15887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15888 
 
15889 
  def __eq__(self, other):
15890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15891 
 
15892 
  def __ne__(self, other):
15893 
    return not (self == other)
15894 
 
15895 
class markOrderCancellationRequestDenied_result:
15896 
  """
15897 
  Attributes:
15898 
   - ex
15899 
  """
15900 
 
15901 
  thrift_spec = (
15902 
    None, # 0
15903 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15904 
  )
15905 
 
15906 
  def __init__(self, ex=None,):
15907 
    self.ex = ex
15908 
 
15909 
  def read(self, iprot):
15910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15912 
      return
15913 
    iprot.readStructBegin()
15914 
    while True:
15915 
      (fname, ftype, fid) = iprot.readFieldBegin()
15916 
      if ftype == TType.STOP:
15917 
        break
15918 
      if fid == 1:
15919 
        if ftype == TType.STRUCT:
15920 
          self.ex = TransactionServiceException()
15921 
          self.ex.read(iprot)
15922 
        else:
15923 
          iprot.skip(ftype)
15924 
      else:
15925 
        iprot.skip(ftype)
15926 
      iprot.readFieldEnd()
15927 
    iprot.readStructEnd()
15928 
 
15929 
  def write(self, oprot):
15930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15932 
      return
15933 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
15934 
    if self.ex is not None:
15935 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15936 
      self.ex.write(oprot)
15937 
      oprot.writeFieldEnd()
15938 
    oprot.writeFieldStop()
15939 
    oprot.writeStructEnd()
15940 
 
15941 
  def validate(self):
15942 
    return
15943 
 
15944 
 
15945 
  def __repr__(self):
15946 
    L = ['%s=%r' % (key, value)
15947 
      for key, value in self.__dict__.iteritems()]
15948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15949 
 
15950 
  def __eq__(self, other):
15951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15952 
 
15953 
  def __ne__(self, other):
15954 
    return not (self == other)
15955 
 
4258 rajveer 15956 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 15957 
  """
15958 
  Attributes:
4258 rajveer 15959 
   - transactionId
4247 rajveer 15960 
  """
15961 
 
15962 
  thrift_spec = (
15963 
    None, # 0
4258 rajveer 15964 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 15965 
  )
15966 
 
4258 rajveer 15967 
  def __init__(self, transactionId=None,):
15968 
    self.transactionId = transactionId
4247 rajveer 15969 
 
15970 
  def read(self, iprot):
15971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15973 
      return
15974 
    iprot.readStructBegin()
15975 
    while True:
15976 
      (fname, ftype, fid) = iprot.readFieldBegin()
15977 
      if ftype == TType.STOP:
15978 
        break
15979 
      if fid == 1:
15980 
        if ftype == TType.I64:
4258 rajveer 15981 
          self.transactionId = iprot.readI64();
4247 rajveer 15982 
        else:
15983 
          iprot.skip(ftype)
15984 
      else:
15985 
        iprot.skip(ftype)
15986 
      iprot.readFieldEnd()
15987 
    iprot.readStructEnd()
15988 
 
15989 
  def write(self, oprot):
15990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15992 
      return
4258 rajveer 15993 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
15994 
    if self.transactionId is not None:
15995 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15996 
      oprot.writeI64(self.transactionId)
4247 rajveer 15997 
      oprot.writeFieldEnd()
15998 
    oprot.writeFieldStop()
15999 
    oprot.writeStructEnd()
16000 
 
16001 
  def validate(self):
16002 
    return
16003 
 
16004 
 
16005 
  def __repr__(self):
16006 
    L = ['%s=%r' % (key, value)
16007 
      for key, value in self.__dict__.iteritems()]
16008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16009 
 
16010 
  def __eq__(self, other):
16011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16012 
 
16013 
  def __ne__(self, other):
16014 
    return not (self == other)
16015 
 
4258 rajveer 16016 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 16017 
  """
16018 
  Attributes:
16019 
   - ex
16020 
  """
16021 
 
16022 
  thrift_spec = (
16023 
    None, # 0
16024 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16025 
  )
16026 
 
16027 
  def __init__(self, ex=None,):
16028 
    self.ex = ex
16029 
 
16030 
  def read(self, iprot):
16031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16033 
      return
16034 
    iprot.readStructBegin()
16035 
    while True:
16036 
      (fname, ftype, fid) = iprot.readFieldBegin()
16037 
      if ftype == TType.STOP:
16038 
        break
16039 
      if fid == 1:
16040 
        if ftype == TType.STRUCT:
16041 
          self.ex = TransactionServiceException()
16042 
          self.ex.read(iprot)
16043 
        else:
16044 
          iprot.skip(ftype)
16045 
      else:
16046 
        iprot.skip(ftype)
16047 
      iprot.readFieldEnd()
16048 
    iprot.readStructEnd()
16049 
 
16050 
  def write(self, oprot):
16051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16053 
      return
4258 rajveer 16054 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 16055 
    if self.ex is not None:
16056 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16057 
      self.ex.write(oprot)
16058 
      oprot.writeFieldEnd()
16059 
    oprot.writeFieldStop()
16060 
    oprot.writeStructEnd()
16061 
 
16062 
  def validate(self):
16063 
    return
16064 
 
16065 
 
16066 
  def __repr__(self):
16067 
    L = ['%s=%r' % (key, value)
16068 
      for key, value in self.__dict__.iteritems()]
16069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16070 
 
16071 
  def __eq__(self, other):
16072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16073 
 
16074 
  def __ne__(self, other):
16075 
    return not (self == other)
4259 anupam.sin 16076 
 
16077 
class refundTransaction_args:
16078 
  """
16079 
  Attributes:
16080 
   - transactionId
16081 
   - refundedBy
16082 
   - reason
16083 
  """
16084 
 
16085 
  thrift_spec = (
16086 
    None, # 0
16087 
    (1, TType.I64, 'transactionId', None, None, ), # 1
16088 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
16089 
    (3, TType.STRING, 'reason', None, None, ), # 3
16090 
  )
16091 
 
16092 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
16093 
    self.transactionId = transactionId
16094 
    self.refundedBy = refundedBy
16095 
    self.reason = reason
16096 
 
16097 
  def read(self, iprot):
16098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16100 
      return
16101 
    iprot.readStructBegin()
16102 
    while True:
16103 
      (fname, ftype, fid) = iprot.readFieldBegin()
16104 
      if ftype == TType.STOP:
16105 
        break
16106 
      if fid == 1:
16107 
        if ftype == TType.I64:
16108 
          self.transactionId = iprot.readI64();
16109 
        else:
16110 
          iprot.skip(ftype)
16111 
      elif fid == 2:
16112 
        if ftype == TType.STRING:
16113 
          self.refundedBy = iprot.readString();
16114 
        else:
16115 
          iprot.skip(ftype)
16116 
      elif fid == 3:
16117 
        if ftype == TType.STRING:
16118 
          self.reason = iprot.readString();
16119 
        else:
16120 
          iprot.skip(ftype)
16121 
      else:
16122 
        iprot.skip(ftype)
16123 
      iprot.readFieldEnd()
16124 
    iprot.readStructEnd()
16125 
 
16126 
  def write(self, oprot):
16127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16129 
      return
16130 
    oprot.writeStructBegin('refundTransaction_args')
16131 
    if self.transactionId is not None:
16132 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16133 
      oprot.writeI64(self.transactionId)
16134 
      oprot.writeFieldEnd()
16135 
    if self.refundedBy is not None:
16136 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16137 
      oprot.writeString(self.refundedBy)
16138 
      oprot.writeFieldEnd()
16139 
    if self.reason is not None:
16140 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16141 
      oprot.writeString(self.reason)
16142 
      oprot.writeFieldEnd()
16143 
    oprot.writeFieldStop()
16144 
    oprot.writeStructEnd()
16145 
 
16146 
  def validate(self):
16147 
    return
16148 
 
16149 
 
16150 
  def __repr__(self):
16151 
    L = ['%s=%r' % (key, value)
16152 
      for key, value in self.__dict__.iteritems()]
16153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16154 
 
16155 
  def __eq__(self, other):
16156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16157 
 
16158 
  def __ne__(self, other):
16159 
    return not (self == other)
16160 
 
16161 
class refundTransaction_result:
16162 
  """
16163 
  Attributes:
16164 
   - ex
16165 
  """
16166 
 
16167 
  thrift_spec = (
16168 
    None, # 0
16169 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16170 
  )
16171 
 
16172 
  def __init__(self, ex=None,):
16173 
    self.ex = ex
16174 
 
16175 
  def read(self, iprot):
16176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16178 
      return
16179 
    iprot.readStructBegin()
16180 
    while True:
16181 
      (fname, ftype, fid) = iprot.readFieldBegin()
16182 
      if ftype == TType.STOP:
16183 
        break
16184 
      if fid == 1:
16185 
        if ftype == TType.STRUCT:
16186 
          self.ex = TransactionServiceException()
16187 
          self.ex.read(iprot)
16188 
        else:
16189 
          iprot.skip(ftype)
16190 
      else:
16191 
        iprot.skip(ftype)
16192 
      iprot.readFieldEnd()
16193 
    iprot.readStructEnd()
16194 
 
16195 
  def write(self, oprot):
16196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16198 
      return
16199 
    oprot.writeStructBegin('refundTransaction_result')
16200 
    if self.ex is not None:
16201 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16202 
      self.ex.write(oprot)
16203 
      oprot.writeFieldEnd()
16204 
    oprot.writeFieldStop()
16205 
    oprot.writeStructEnd()
16206 
 
16207 
  def validate(self):
16208 
    return
16209 
 
16210 
 
16211 
  def __repr__(self):
16212 
    L = ['%s=%r' % (key, value)
16213 
      for key, value in self.__dict__.iteritems()]
16214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16215 
 
16216 
  def __eq__(self, other):
16217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16218 
 
16219 
  def __ne__(self, other):
16220 
    return not (self == other)
4285 rajveer 16221 
 
4324 mandeep.dh 16222 
class updateShipmentAddress_args:
16223 
  """
16224 
  Attributes:
16225 
   - orderId
16226 
   - addressId
16227 
  """
16228 
 
16229 
  thrift_spec = (
16230 
    None, # 0
16231 
    (1, TType.I64, 'orderId', None, None, ), # 1
16232 
    (2, TType.I64, 'addressId', None, None, ), # 2
16233 
  )
16234 
 
16235 
  def __init__(self, orderId=None, addressId=None,):
16236 
    self.orderId = orderId
16237 
    self.addressId = addressId
16238 
 
16239 
  def read(self, iprot):
16240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16242 
      return
16243 
    iprot.readStructBegin()
16244 
    while True:
16245 
      (fname, ftype, fid) = iprot.readFieldBegin()
16246 
      if ftype == TType.STOP:
16247 
        break
16248 
      if fid == 1:
16249 
        if ftype == TType.I64:
16250 
          self.orderId = iprot.readI64();
16251 
        else:
16252 
          iprot.skip(ftype)
16253 
      elif fid == 2:
16254 
        if ftype == TType.I64:
16255 
          self.addressId = iprot.readI64();
16256 
        else:
16257 
          iprot.skip(ftype)
16258 
      else:
16259 
        iprot.skip(ftype)
16260 
      iprot.readFieldEnd()
16261 
    iprot.readStructEnd()
16262 
 
16263 
  def write(self, oprot):
16264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16266 
      return
16267 
    oprot.writeStructBegin('updateShipmentAddress_args')
16268 
    if self.orderId is not None:
16269 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16270 
      oprot.writeI64(self.orderId)
16271 
      oprot.writeFieldEnd()
16272 
    if self.addressId is not None:
16273 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
16274 
      oprot.writeI64(self.addressId)
16275 
      oprot.writeFieldEnd()
16276 
    oprot.writeFieldStop()
16277 
    oprot.writeStructEnd()
16278 
 
16279 
  def validate(self):
16280 
    return
16281 
 
16282 
 
16283 
  def __repr__(self):
16284 
    L = ['%s=%r' % (key, value)
16285 
      for key, value in self.__dict__.iteritems()]
16286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16287 
 
16288 
  def __eq__(self, other):
16289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16290 
 
16291 
  def __ne__(self, other):
16292 
    return not (self == other)
16293 
 
16294 
class updateShipmentAddress_result:
16295 
  """
16296 
  Attributes:
16297 
   - ex
16298 
  """
16299 
 
16300 
  thrift_spec = (
16301 
    None, # 0
16302 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16303 
  )
16304 
 
16305 
  def __init__(self, ex=None,):
16306 
    self.ex = ex
16307 
 
16308 
  def read(self, iprot):
16309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16311 
      return
16312 
    iprot.readStructBegin()
16313 
    while True:
16314 
      (fname, ftype, fid) = iprot.readFieldBegin()
16315 
      if ftype == TType.STOP:
16316 
        break
16317 
      if fid == 1:
16318 
        if ftype == TType.STRUCT:
16319 
          self.ex = TransactionServiceException()
16320 
          self.ex.read(iprot)
16321 
        else:
16322 
          iprot.skip(ftype)
16323 
      else:
16324 
        iprot.skip(ftype)
16325 
      iprot.readFieldEnd()
16326 
    iprot.readStructEnd()
16327 
 
16328 
  def write(self, oprot):
16329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16331 
      return
16332 
    oprot.writeStructBegin('updateShipmentAddress_result')
16333 
    if self.ex is not None:
16334 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16335 
      self.ex.write(oprot)
16336 
      oprot.writeFieldEnd()
16337 
    oprot.writeFieldStop()
16338 
    oprot.writeStructEnd()
16339 
 
16340 
  def validate(self):
16341 
    return
16342 
 
16343 
 
16344 
  def __repr__(self):
16345 
    L = ['%s=%r' % (key, value)
16346 
      for key, value in self.__dict__.iteritems()]
16347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16348 
 
16349 
  def __eq__(self, other):
16350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16351 
 
16352 
  def __ne__(self, other):
16353 
    return not (self == other)
16354 
 
4285 rajveer 16355 
class acceptOrdersForItemId_args:
16356 
  """
16357 
  Attributes:
16358 
   - itemId
16359 
   - inventory
16360 
  """
16361 
 
16362 
  thrift_spec = (
16363 
    None, # 0
16364 
    (1, TType.I64, 'itemId', None, None, ), # 1
16365 
    (2, TType.I64, 'inventory', None, None, ), # 2
16366 
  )
16367 
 
16368 
  def __init__(self, itemId=None, inventory=None,):
16369 
    self.itemId = itemId
16370 
    self.inventory = inventory
16371 
 
16372 
  def read(self, iprot):
16373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16375 
      return
16376 
    iprot.readStructBegin()
16377 
    while True:
16378 
      (fname, ftype, fid) = iprot.readFieldBegin()
16379 
      if ftype == TType.STOP:
16380 
        break
16381 
      if fid == 1:
16382 
        if ftype == TType.I64:
16383 
          self.itemId = iprot.readI64();
16384 
        else:
16385 
          iprot.skip(ftype)
16386 
      elif fid == 2:
16387 
        if ftype == TType.I64:
16388 
          self.inventory = iprot.readI64();
16389 
        else:
16390 
          iprot.skip(ftype)
16391 
      else:
16392 
        iprot.skip(ftype)
16393 
      iprot.readFieldEnd()
16394 
    iprot.readStructEnd()
16395 
 
16396 
  def write(self, oprot):
16397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16399 
      return
16400 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
16401 
    if self.itemId is not None:
16402 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16403 
      oprot.writeI64(self.itemId)
16404 
      oprot.writeFieldEnd()
16405 
    if self.inventory is not None:
16406 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
16407 
      oprot.writeI64(self.inventory)
16408 
      oprot.writeFieldEnd()
16409 
    oprot.writeFieldStop()
16410 
    oprot.writeStructEnd()
16411 
 
16412 
  def validate(self):
16413 
    return
16414 
 
16415 
 
16416 
  def __repr__(self):
16417 
    L = ['%s=%r' % (key, value)
16418 
      for key, value in self.__dict__.iteritems()]
16419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16420 
 
16421 
  def __eq__(self, other):
16422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16423 
 
16424 
  def __ne__(self, other):
16425 
    return not (self == other)
16426 
 
16427 
class acceptOrdersForItemId_result:
16428 
  """
16429 
  Attributes:
16430 
   - success
16431 
   - ex
16432 
  """
16433 
 
16434 
  thrift_spec = (
16435 
    (0, TType.BOOL, 'success', None, None, ), # 0
16436 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16437 
  )
16438 
 
16439 
  def __init__(self, success=None, ex=None,):
16440 
    self.success = success
16441 
    self.ex = ex
16442 
 
16443 
  def read(self, iprot):
16444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16446 
      return
16447 
    iprot.readStructBegin()
16448 
    while True:
16449 
      (fname, ftype, fid) = iprot.readFieldBegin()
16450 
      if ftype == TType.STOP:
16451 
        break
16452 
      if fid == 0:
16453 
        if ftype == TType.BOOL:
16454 
          self.success = iprot.readBool();
16455 
        else:
16456 
          iprot.skip(ftype)
16457 
      elif fid == 1:
16458 
        if ftype == TType.STRUCT:
16459 
          self.ex = TransactionServiceException()
16460 
          self.ex.read(iprot)
16461 
        else:
16462 
          iprot.skip(ftype)
16463 
      else:
16464 
        iprot.skip(ftype)
16465 
      iprot.readFieldEnd()
16466 
    iprot.readStructEnd()
16467 
 
16468 
  def write(self, oprot):
16469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16471 
      return
16472 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
16473 
    if self.success is not None:
16474 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16475 
      oprot.writeBool(self.success)
16476 
      oprot.writeFieldEnd()
16477 
    if self.ex is not None:
16478 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16479 
      self.ex.write(oprot)
16480 
      oprot.writeFieldEnd()
16481 
    oprot.writeFieldStop()
16482 
    oprot.writeStructEnd()
16483 
 
16484 
  def validate(self):
16485 
    return
16486 
 
16487 
 
16488 
  def __repr__(self):
16489 
    L = ['%s=%r' % (key, value)
16490 
      for key, value in self.__dict__.iteritems()]
16491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16492 
 
16493 
  def __eq__(self, other):
16494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16495 
 
16496 
  def __ne__(self, other):
16497 
    return not (self == other)
4303 rajveer 16498 
 
16499 
class markOrdersAsPORaised_args:
16500 
  """
16501 
  Attributes:
16502 
   - vendorId
16503 
   - itemId
16504 
   - quantity
16505 
   - estimate
4369 rajveer 16506 
   - isReminder
4303 rajveer 16507 
  """
16508 
 
16509 
  thrift_spec = (
16510 
    None, # 0
16511 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16512 
    (2, TType.I64, 'itemId', None, None, ), # 2
16513 
    (3, TType.I64, 'quantity', None, None, ), # 3
16514 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16515 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16516 
  )
16517 
 
4369 rajveer 16518 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16519 
    self.vendorId = vendorId
16520 
    self.itemId = itemId
16521 
    self.quantity = quantity
16522 
    self.estimate = estimate
4369 rajveer 16523 
    self.isReminder = isReminder
4303 rajveer 16524 
 
16525 
  def read(self, iprot):
16526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16528 
      return
16529 
    iprot.readStructBegin()
16530 
    while True:
16531 
      (fname, ftype, fid) = iprot.readFieldBegin()
16532 
      if ftype == TType.STOP:
16533 
        break
16534 
      if fid == 1:
16535 
        if ftype == TType.I64:
16536 
          self.vendorId = iprot.readI64();
16537 
        else:
16538 
          iprot.skip(ftype)
16539 
      elif fid == 2:
16540 
        if ftype == TType.I64:
16541 
          self.itemId = iprot.readI64();
16542 
        else:
16543 
          iprot.skip(ftype)
16544 
      elif fid == 3:
16545 
        if ftype == TType.I64:
16546 
          self.quantity = iprot.readI64();
16547 
        else:
16548 
          iprot.skip(ftype)
16549 
      elif fid == 4:
16550 
        if ftype == TType.I64:
16551 
          self.estimate = iprot.readI64();
16552 
        else:
16553 
          iprot.skip(ftype)
4369 rajveer 16554 
      elif fid == 5:
16555 
        if ftype == TType.BOOL:
16556 
          self.isReminder = iprot.readBool();
16557 
        else:
16558 
          iprot.skip(ftype)
4303 rajveer 16559 
      else:
16560 
        iprot.skip(ftype)
16561 
      iprot.readFieldEnd()
16562 
    iprot.readStructEnd()
16563 
 
16564 
  def write(self, oprot):
16565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16567 
      return
16568 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
16569 
    if self.vendorId is not None:
16570 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16571 
      oprot.writeI64(self.vendorId)
16572 
      oprot.writeFieldEnd()
16573 
    if self.itemId is not None:
16574 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16575 
      oprot.writeI64(self.itemId)
16576 
      oprot.writeFieldEnd()
16577 
    if self.quantity is not None:
16578 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16579 
      oprot.writeI64(self.quantity)
16580 
      oprot.writeFieldEnd()
16581 
    if self.estimate is not None:
16582 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16583 
      oprot.writeI64(self.estimate)
16584 
      oprot.writeFieldEnd()
4369 rajveer 16585 
    if self.isReminder is not None:
16586 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16587 
      oprot.writeBool(self.isReminder)
16588 
      oprot.writeFieldEnd()
4303 rajveer 16589 
    oprot.writeFieldStop()
16590 
    oprot.writeStructEnd()
16591 
 
16592 
  def validate(self):
16593 
    return
16594 
 
16595 
 
16596 
  def __repr__(self):
16597 
    L = ['%s=%r' % (key, value)
16598 
      for key, value in self.__dict__.iteritems()]
16599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16600 
 
16601 
  def __eq__(self, other):
16602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16603 
 
16604 
  def __ne__(self, other):
16605 
    return not (self == other)
16606 
 
16607 
class markOrdersAsPORaised_result:
16608 
  """
16609 
  Attributes:
16610 
   - ex
16611 
  """
16612 
 
16613 
  thrift_spec = (
16614 
    None, # 0
16615 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16616 
  )
16617 
 
16618 
  def __init__(self, ex=None,):
16619 
    self.ex = ex
16620 
 
16621 
  def read(self, iprot):
16622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16624 
      return
16625 
    iprot.readStructBegin()
16626 
    while True:
16627 
      (fname, ftype, fid) = iprot.readFieldBegin()
16628 
      if ftype == TType.STOP:
16629 
        break
16630 
      if fid == 1:
16631 
        if ftype == TType.STRUCT:
16632 
          self.ex = TransactionServiceException()
16633 
          self.ex.read(iprot)
16634 
        else:
16635 
          iprot.skip(ftype)
16636 
      else:
16637 
        iprot.skip(ftype)
16638 
      iprot.readFieldEnd()
16639 
    iprot.readStructEnd()
16640 
 
16641 
  def write(self, oprot):
16642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16644 
      return
16645 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
16646 
    if self.ex is not None:
16647 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16648 
      self.ex.write(oprot)
16649 
      oprot.writeFieldEnd()
16650 
    oprot.writeFieldStop()
16651 
    oprot.writeStructEnd()
16652 
 
16653 
  def validate(self):
16654 
    return
16655 
 
16656 
 
16657 
  def __repr__(self):
16658 
    L = ['%s=%r' % (key, value)
16659 
      for key, value in self.__dict__.iteritems()]
16660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16661 
 
16662 
  def __eq__(self, other):
16663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16664 
 
16665 
  def __ne__(self, other):
16666 
    return not (self == other)
16667 
 
16668 
class markOrdersAsReversalInitiated_args:
16669 
  """
16670 
  Attributes:
16671 
   - vendorId
16672 
   - itemId
16673 
   - quantity
16674 
   - estimate
4369 rajveer 16675 
   - isReminder
4303 rajveer 16676 
  """
16677 
 
16678 
  thrift_spec = (
16679 
    None, # 0
16680 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16681 
    (2, TType.I64, 'itemId', None, None, ), # 2
16682 
    (3, TType.I64, 'quantity', None, None, ), # 3
16683 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16684 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16685 
  )
16686 
 
4369 rajveer 16687 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16688 
    self.vendorId = vendorId
16689 
    self.itemId = itemId
16690 
    self.quantity = quantity
16691 
    self.estimate = estimate
4369 rajveer 16692 
    self.isReminder = isReminder
4303 rajveer 16693 
 
16694 
  def read(self, iprot):
16695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16697 
      return
16698 
    iprot.readStructBegin()
16699 
    while True:
16700 
      (fname, ftype, fid) = iprot.readFieldBegin()
16701 
      if ftype == TType.STOP:
16702 
        break
16703 
      if fid == 1:
16704 
        if ftype == TType.I64:
16705 
          self.vendorId = iprot.readI64();
16706 
        else:
16707 
          iprot.skip(ftype)
16708 
      elif fid == 2:
16709 
        if ftype == TType.I64:
16710 
          self.itemId = iprot.readI64();
16711 
        else:
16712 
          iprot.skip(ftype)
16713 
      elif fid == 3:
16714 
        if ftype == TType.I64:
16715 
          self.quantity = iprot.readI64();
16716 
        else:
16717 
          iprot.skip(ftype)
16718 
      elif fid == 4:
16719 
        if ftype == TType.I64:
16720 
          self.estimate = iprot.readI64();
16721 
        else:
16722 
          iprot.skip(ftype)
4369 rajveer 16723 
      elif fid == 5:
16724 
        if ftype == TType.BOOL:
16725 
          self.isReminder = iprot.readBool();
16726 
        else:
16727 
          iprot.skip(ftype)
4303 rajveer 16728 
      else:
16729 
        iprot.skip(ftype)
16730 
      iprot.readFieldEnd()
16731 
    iprot.readStructEnd()
16732 
 
16733 
  def write(self, oprot):
16734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16736 
      return
16737 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
16738 
    if self.vendorId is not None:
16739 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16740 
      oprot.writeI64(self.vendorId)
16741 
      oprot.writeFieldEnd()
16742 
    if self.itemId is not None:
16743 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16744 
      oprot.writeI64(self.itemId)
16745 
      oprot.writeFieldEnd()
16746 
    if self.quantity is not None:
16747 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16748 
      oprot.writeI64(self.quantity)
16749 
      oprot.writeFieldEnd()
16750 
    if self.estimate is not None:
16751 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16752 
      oprot.writeI64(self.estimate)
16753 
      oprot.writeFieldEnd()
4369 rajveer 16754 
    if self.isReminder is not None:
16755 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16756 
      oprot.writeBool(self.isReminder)
16757 
      oprot.writeFieldEnd()
4303 rajveer 16758 
    oprot.writeFieldStop()
16759 
    oprot.writeStructEnd()
16760 
 
16761 
  def validate(self):
16762 
    return
16763 
 
16764 
 
16765 
  def __repr__(self):
16766 
    L = ['%s=%r' % (key, value)
16767 
      for key, value in self.__dict__.iteritems()]
16768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16769 
 
16770 
  def __eq__(self, other):
16771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16772 
 
16773 
  def __ne__(self, other):
16774 
    return not (self == other)
16775 
 
16776 
class markOrdersAsReversalInitiated_result:
16777 
  """
16778 
  Attributes:
16779 
   - ex
16780 
  """
16781 
 
16782 
  thrift_spec = (
16783 
    None, # 0
16784 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16785 
  )
16786 
 
16787 
  def __init__(self, ex=None,):
16788 
    self.ex = ex
16789 
 
16790 
  def read(self, iprot):
16791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16793 
      return
16794 
    iprot.readStructBegin()
16795 
    while True:
16796 
      (fname, ftype, fid) = iprot.readFieldBegin()
16797 
      if ftype == TType.STOP:
16798 
        break
16799 
      if fid == 1:
16800 
        if ftype == TType.STRUCT:
16801 
          self.ex = TransactionServiceException()
16802 
          self.ex.read(iprot)
16803 
        else:
16804 
          iprot.skip(ftype)
16805 
      else:
16806 
        iprot.skip(ftype)
16807 
      iprot.readFieldEnd()
16808 
    iprot.readStructEnd()
16809 
 
16810 
  def write(self, oprot):
16811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16813 
      return
16814 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
16815 
    if self.ex is not None:
16816 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16817 
      self.ex.write(oprot)
16818 
      oprot.writeFieldEnd()
16819 
    oprot.writeFieldStop()
16820 
    oprot.writeStructEnd()
16821 
 
16822 
  def validate(self):
16823 
    return
16824 
 
16825 
 
16826 
  def __repr__(self):
16827 
    L = ['%s=%r' % (key, value)
16828 
      for key, value in self.__dict__.iteritems()]
16829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16830 
 
16831 
  def __eq__(self, other):
16832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16833 
 
16834 
  def __ne__(self, other):
16835 
    return not (self == other)
16836 
 
16837 
class markOrdersAsNotAvailabke_args:
16838 
  """
16839 
  Attributes:
16840 
   - vendorId
16841 
   - itemId
16842 
   - quantity
16843 
   - estimate
4369 rajveer 16844 
   - isReminder
4303 rajveer 16845 
  """
16846 
 
16847 
  thrift_spec = (
16848 
    None, # 0
16849 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16850 
    (2, TType.I64, 'itemId', None, None, ), # 2
16851 
    (3, TType.I64, 'quantity', None, None, ), # 3
16852 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16853 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16854 
  )
16855 
 
4369 rajveer 16856 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16857 
    self.vendorId = vendorId
16858 
    self.itemId = itemId
16859 
    self.quantity = quantity
16860 
    self.estimate = estimate
4369 rajveer 16861 
    self.isReminder = isReminder
4303 rajveer 16862 
 
16863 
  def read(self, iprot):
16864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16866 
      return
16867 
    iprot.readStructBegin()
16868 
    while True:
16869 
      (fname, ftype, fid) = iprot.readFieldBegin()
16870 
      if ftype == TType.STOP:
16871 
        break
16872 
      if fid == 1:
16873 
        if ftype == TType.I64:
16874 
          self.vendorId = iprot.readI64();
16875 
        else:
16876 
          iprot.skip(ftype)
16877 
      elif fid == 2:
16878 
        if ftype == TType.I64:
16879 
          self.itemId = iprot.readI64();
16880 
        else:
16881 
          iprot.skip(ftype)
16882 
      elif fid == 3:
16883 
        if ftype == TType.I64:
16884 
          self.quantity = iprot.readI64();
16885 
        else:
16886 
          iprot.skip(ftype)
16887 
      elif fid == 4:
16888 
        if ftype == TType.I64:
16889 
          self.estimate = iprot.readI64();
16890 
        else:
16891 
          iprot.skip(ftype)
4369 rajveer 16892 
      elif fid == 5:
16893 
        if ftype == TType.BOOL:
16894 
          self.isReminder = iprot.readBool();
16895 
        else:
16896 
          iprot.skip(ftype)
4303 rajveer 16897 
      else:
16898 
        iprot.skip(ftype)
16899 
      iprot.readFieldEnd()
16900 
    iprot.readStructEnd()
16901 
 
16902 
  def write(self, oprot):
16903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16905 
      return
16906 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
16907 
    if self.vendorId is not None:
16908 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16909 
      oprot.writeI64(self.vendorId)
16910 
      oprot.writeFieldEnd()
16911 
    if self.itemId is not None:
16912 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16913 
      oprot.writeI64(self.itemId)
16914 
      oprot.writeFieldEnd()
16915 
    if self.quantity is not None:
16916 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16917 
      oprot.writeI64(self.quantity)
16918 
      oprot.writeFieldEnd()
16919 
    if self.estimate is not None:
16920 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16921 
      oprot.writeI64(self.estimate)
16922 
      oprot.writeFieldEnd()
4369 rajveer 16923 
    if self.isReminder is not None:
16924 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16925 
      oprot.writeBool(self.isReminder)
16926 
      oprot.writeFieldEnd()
4303 rajveer 16927 
    oprot.writeFieldStop()
16928 
    oprot.writeStructEnd()
16929 
 
16930 
  def validate(self):
16931 
    return
16932 
 
16933 
 
16934 
  def __repr__(self):
16935 
    L = ['%s=%r' % (key, value)
16936 
      for key, value in self.__dict__.iteritems()]
16937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16938 
 
16939 
  def __eq__(self, other):
16940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16941 
 
16942 
  def __ne__(self, other):
16943 
    return not (self == other)
16944 
 
16945 
class markOrdersAsNotAvailabke_result:
16946 
  """
16947 
  Attributes:
16948 
   - ex
16949 
  """
16950 
 
16951 
  thrift_spec = (
16952 
    None, # 0
16953 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16954 
  )
16955 
 
16956 
  def __init__(self, ex=None,):
16957 
    self.ex = ex
16958 
 
16959 
  def read(self, iprot):
16960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16962 
      return
16963 
    iprot.readStructBegin()
16964 
    while True:
16965 
      (fname, ftype, fid) = iprot.readFieldBegin()
16966 
      if ftype == TType.STOP:
16967 
        break
16968 
      if fid == 1:
16969 
        if ftype == TType.STRUCT:
16970 
          self.ex = TransactionServiceException()
16971 
          self.ex.read(iprot)
16972 
        else:
16973 
          iprot.skip(ftype)
16974 
      else:
16975 
        iprot.skip(ftype)
16976 
      iprot.readFieldEnd()
16977 
    iprot.readStructEnd()
16978 
 
16979 
  def write(self, oprot):
16980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16982 
      return
16983 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
16984 
    if self.ex is not None:
16985 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16986 
      self.ex.write(oprot)
16987 
      oprot.writeFieldEnd()
16988 
    oprot.writeFieldStop()
16989 
    oprot.writeStructEnd()
16990 
 
16991 
  def validate(self):
16992 
    return
16993 
 
16994 
 
16995 
  def __repr__(self):
16996 
    L = ['%s=%r' % (key, value)
16997 
      for key, value in self.__dict__.iteritems()]
16998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16999 
 
17000 
  def __eq__(self, other):
17001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17002 
 
17003 
  def __ne__(self, other):
17004 
    return not (self == other)
4369 rajveer 17005 
 
17006 
class markOrdersAsTimeout_args:
17007 
  """
17008 
  Attributes:
17009 
   - vendorId
17010 
  """
17011 
 
17012 
  thrift_spec = (
17013 
    None, # 0
17014 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17015 
  )
17016 
 
17017 
  def __init__(self, vendorId=None,):
17018 
    self.vendorId = vendorId
17019 
 
17020 
  def read(self, iprot):
17021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17023 
      return
17024 
    iprot.readStructBegin()
17025 
    while True:
17026 
      (fname, ftype, fid) = iprot.readFieldBegin()
17027 
      if ftype == TType.STOP:
17028 
        break
17029 
      if fid == 1:
17030 
        if ftype == TType.I64:
17031 
          self.vendorId = iprot.readI64();
17032 
        else:
17033 
          iprot.skip(ftype)
17034 
      else:
17035 
        iprot.skip(ftype)
17036 
      iprot.readFieldEnd()
17037 
    iprot.readStructEnd()
17038 
 
17039 
  def write(self, oprot):
17040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17042 
      return
17043 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
17044 
    if self.vendorId is not None:
17045 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17046 
      oprot.writeI64(self.vendorId)
17047 
      oprot.writeFieldEnd()
17048 
    oprot.writeFieldStop()
17049 
    oprot.writeStructEnd()
17050 
 
17051 
  def validate(self):
17052 
    return
17053 
 
17054 
 
17055 
  def __repr__(self):
17056 
    L = ['%s=%r' % (key, value)
17057 
      for key, value in self.__dict__.iteritems()]
17058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17059 
 
17060 
  def __eq__(self, other):
17061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17062 
 
17063 
  def __ne__(self, other):
17064 
    return not (self == other)
17065 
 
17066 
class markOrdersAsTimeout_result:
17067 
  """
17068 
  Attributes:
17069 
   - success
17070 
   - ex
17071 
  """
17072 
 
17073 
  thrift_spec = (
17074 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
17075 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17076 
  )
17077 
 
17078 
  def __init__(self, success=None, ex=None,):
17079 
    self.success = success
17080 
    self.ex = ex
17081 
 
17082 
  def read(self, iprot):
17083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17085 
      return
17086 
    iprot.readStructBegin()
17087 
    while True:
17088 
      (fname, ftype, fid) = iprot.readFieldBegin()
17089 
      if ftype == TType.STOP:
17090 
        break
17091 
      if fid == 0:
17092 
        if ftype == TType.MAP:
17093 
          self.success = {}
4586 mandeep.dh 17094 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
17095 
          for _i279 in xrange(_size275):
17096 
            _key280 = iprot.readI32();
17097 
            _val281 = TimeoutSummary()
17098 
            _val281.read(iprot)
17099 
            self.success[_key280] = _val281
4369 rajveer 17100 
          iprot.readMapEnd()
17101 
        else:
17102 
          iprot.skip(ftype)
17103 
      elif fid == 1:
17104 
        if ftype == TType.STRUCT:
17105 
          self.ex = TransactionServiceException()
17106 
          self.ex.read(iprot)
17107 
        else:
17108 
          iprot.skip(ftype)
17109 
      else:
17110 
        iprot.skip(ftype)
17111 
      iprot.readFieldEnd()
17112 
    iprot.readStructEnd()
17113 
 
17114 
  def write(self, oprot):
17115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17117 
      return
17118 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
17119 
    if self.success is not None:
17120 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17121 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4586 mandeep.dh 17122 
      for kiter282,viter283 in self.success.items():
17123 
        oprot.writeI32(kiter282)
17124 
        viter283.write(oprot)
4369 rajveer 17125 
      oprot.writeMapEnd()
17126 
      oprot.writeFieldEnd()
17127 
    if self.ex is not None:
17128 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17129 
      self.ex.write(oprot)
17130 
      oprot.writeFieldEnd()
17131 
    oprot.writeFieldStop()
17132 
    oprot.writeStructEnd()
17133 
 
17134 
  def validate(self):
17135 
    return
17136 
 
17137 
 
17138 
  def __repr__(self):
17139 
    L = ['%s=%r' % (key, value)
17140 
      for key, value in self.__dict__.iteritems()]
17141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17142 
 
17143 
  def __eq__(self, other):
17144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17145 
 
17146 
  def __ne__(self, other):
17147 
    return not (self == other)
4386 anupam.sin 17148 
 
4662 rajveer 17149 
class markOrderAsLostInTransit_args:
17150 
  """
17151 
  Attributes:
17152 
   - orderId
17153 
  """
17154 
 
17155 
  thrift_spec = (
17156 
    None, # 0
17157 
    (1, TType.I64, 'orderId', None, None, ), # 1
17158 
  )
17159 
 
17160 
  def __init__(self, orderId=None,):
17161 
    self.orderId = orderId
17162 
 
17163 
  def read(self, iprot):
17164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17166 
      return
17167 
    iprot.readStructBegin()
17168 
    while True:
17169 
      (fname, ftype, fid) = iprot.readFieldBegin()
17170 
      if ftype == TType.STOP:
17171 
        break
17172 
      if fid == 1:
17173 
        if ftype == TType.I64:
17174 
          self.orderId = iprot.readI64();
17175 
        else:
17176 
          iprot.skip(ftype)
17177 
      else:
17178 
        iprot.skip(ftype)
17179 
      iprot.readFieldEnd()
17180 
    iprot.readStructEnd()
17181 
 
17182 
  def write(self, oprot):
17183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17185 
      return
17186 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
17187 
    if self.orderId is not None:
17188 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17189 
      oprot.writeI64(self.orderId)
17190 
      oprot.writeFieldEnd()
17191 
    oprot.writeFieldStop()
17192 
    oprot.writeStructEnd()
17193 
 
17194 
  def validate(self):
17195 
    return
17196 
 
17197 
 
17198 
  def __repr__(self):
17199 
    L = ['%s=%r' % (key, value)
17200 
      for key, value in self.__dict__.iteritems()]
17201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17202 
 
17203 
  def __eq__(self, other):
17204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17205 
 
17206 
  def __ne__(self, other):
17207 
    return not (self == other)
17208 
 
17209 
class markOrderAsLostInTransit_result:
17210 
  """
17211 
  Attributes:
17212 
   - success
17213 
   - ex
17214 
  """
17215 
 
17216 
  thrift_spec = (
17217 
    (0, TType.BOOL, 'success', None, None, ), # 0
17218 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17219 
  )
17220 
 
17221 
  def __init__(self, success=None, ex=None,):
17222 
    self.success = success
17223 
    self.ex = ex
17224 
 
17225 
  def read(self, iprot):
17226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17228 
      return
17229 
    iprot.readStructBegin()
17230 
    while True:
17231 
      (fname, ftype, fid) = iprot.readFieldBegin()
17232 
      if ftype == TType.STOP:
17233 
        break
17234 
      if fid == 0:
17235 
        if ftype == TType.BOOL:
17236 
          self.success = iprot.readBool();
17237 
        else:
17238 
          iprot.skip(ftype)
17239 
      elif fid == 1:
17240 
        if ftype == TType.STRUCT:
17241 
          self.ex = TransactionServiceException()
17242 
          self.ex.read(iprot)
17243 
        else:
17244 
          iprot.skip(ftype)
17245 
      else:
17246 
        iprot.skip(ftype)
17247 
      iprot.readFieldEnd()
17248 
    iprot.readStructEnd()
17249 
 
17250 
  def write(self, oprot):
17251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17253 
      return
17254 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
17255 
    if self.success is not None:
17256 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17257 
      oprot.writeBool(self.success)
17258 
      oprot.writeFieldEnd()
17259 
    if self.ex is not None:
17260 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17261 
      self.ex.write(oprot)
17262 
      oprot.writeFieldEnd()
17263 
    oprot.writeFieldStop()
17264 
    oprot.writeStructEnd()
17265 
 
17266 
  def validate(self):
17267 
    return
17268 
 
17269 
 
17270 
  def __repr__(self):
17271 
    L = ['%s=%r' % (key, value)
17272 
      for key, value in self.__dict__.iteritems()]
17273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17274 
 
17275 
  def __eq__(self, other):
17276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17277 
 
17278 
  def __ne__(self, other):
17279 
    return not (self == other)
17280 
 
4386 anupam.sin 17281 
class getOrderForAwb_args:
17282 
  """
17283 
  Attributes:
17284 
   - awb
17285 
  """
17286 
 
17287 
  thrift_spec = (
17288 
    None, # 0
17289 
    (1, TType.STRING, 'awb', None, None, ), # 1
17290 
  )
17291 
 
17292 
  def __init__(self, awb=None,):
17293 
    self.awb = awb
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 == 1:
17305 
        if ftype == TType.STRING:
17306 
          self.awb = iprot.readString();
17307 
        else:
17308 
          iprot.skip(ftype)
17309 
      else:
17310 
        iprot.skip(ftype)
17311 
      iprot.readFieldEnd()
17312 
    iprot.readStructEnd()
17313 
 
17314 
  def write(self, oprot):
17315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17317 
      return
17318 
    oprot.writeStructBegin('getOrderForAwb_args')
17319 
    if self.awb is not None:
17320 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
17321 
      oprot.writeString(self.awb)
17322 
      oprot.writeFieldEnd()
17323 
    oprot.writeFieldStop()
17324 
    oprot.writeStructEnd()
17325 
 
17326 
  def validate(self):
17327 
    return
17328 
 
17329 
 
17330 
  def __repr__(self):
17331 
    L = ['%s=%r' % (key, value)
17332 
      for key, value in self.__dict__.iteritems()]
17333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17334 
 
17335 
  def __eq__(self, other):
17336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17337 
 
17338 
  def __ne__(self, other):
17339 
    return not (self == other)
17340 
 
17341 
class getOrderForAwb_result:
17342 
  """
17343 
  Attributes:
17344 
   - success
17345 
   - ex
17346 
  """
17347 
 
17348 
  thrift_spec = (
17349 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17350 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17351 
  )
17352 
 
17353 
  def __init__(self, success=None, ex=None,):
17354 
    self.success = success
17355 
    self.ex = ex
17356 
 
17357 
  def read(self, iprot):
17358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17360 
      return
17361 
    iprot.readStructBegin()
17362 
    while True:
17363 
      (fname, ftype, fid) = iprot.readFieldBegin()
17364 
      if ftype == TType.STOP:
17365 
        break
17366 
      if fid == 0:
17367 
        if ftype == TType.STRUCT:
17368 
          self.success = Order()
17369 
          self.success.read(iprot)
17370 
        else:
17371 
          iprot.skip(ftype)
17372 
      elif fid == 1:
17373 
        if ftype == TType.STRUCT:
17374 
          self.ex = TransactionServiceException()
17375 
          self.ex.read(iprot)
17376 
        else:
17377 
          iprot.skip(ftype)
17378 
      else:
17379 
        iprot.skip(ftype)
17380 
      iprot.readFieldEnd()
17381 
    iprot.readStructEnd()
17382 
 
17383 
  def write(self, oprot):
17384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17386 
      return
17387 
    oprot.writeStructBegin('getOrderForAwb_result')
17388 
    if self.success is not None:
17389 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17390 
      self.success.write(oprot)
17391 
      oprot.writeFieldEnd()
17392 
    if self.ex is not None:
17393 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17394 
      self.ex.write(oprot)
17395 
      oprot.writeFieldEnd()
17396 
    oprot.writeFieldStop()
17397 
    oprot.writeStructEnd()
17398 
 
17399 
  def validate(self):
17400 
    return
17401 
 
17402 
 
17403 
  def __repr__(self):
17404 
    L = ['%s=%r' % (key, value)
17405 
      for key, value in self.__dict__.iteritems()]
17406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17407 
 
17408 
  def __eq__(self, other):
17409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17410 
 
17411 
  def __ne__(self, other):
17412 
    return not (self == other)
4506 phani.kuma 17413 
 
17414 
class getOrdersForProviderForStatus_args:
17415 
  """
17416 
  Attributes:
17417 
   - logistics_provider_id
17418 
   - order_status
17419 
  """
17420 
 
17421 
  thrift_spec = (
17422 
    None, # 0
17423 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
17424 
    (2, TType.I32, 'order_status', None, None, ), # 2
17425 
  )
17426 
 
17427 
  def __init__(self, logistics_provider_id=None, order_status=None,):
17428 
    self.logistics_provider_id = logistics_provider_id
17429 
    self.order_status = order_status
17430 
 
17431 
  def read(self, iprot):
17432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17434 
      return
17435 
    iprot.readStructBegin()
17436 
    while True:
17437 
      (fname, ftype, fid) = iprot.readFieldBegin()
17438 
      if ftype == TType.STOP:
17439 
        break
17440 
      if fid == 1:
17441 
        if ftype == TType.I64:
17442 
          self.logistics_provider_id = iprot.readI64();
17443 
        else:
17444 
          iprot.skip(ftype)
17445 
      elif fid == 2:
17446 
        if ftype == TType.I32:
17447 
          self.order_status = iprot.readI32();
17448 
        else:
17449 
          iprot.skip(ftype)
17450 
      else:
17451 
        iprot.skip(ftype)
17452 
      iprot.readFieldEnd()
17453 
    iprot.readStructEnd()
17454 
 
17455 
  def write(self, oprot):
17456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17458 
      return
17459 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
17460 
    if self.logistics_provider_id is not None:
17461 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
17462 
      oprot.writeI64(self.logistics_provider_id)
17463 
      oprot.writeFieldEnd()
17464 
    if self.order_status is not None:
17465 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
17466 
      oprot.writeI32(self.order_status)
17467 
      oprot.writeFieldEnd()
17468 
    oprot.writeFieldStop()
17469 
    oprot.writeStructEnd()
17470 
 
17471 
  def validate(self):
17472 
    return
17473 
 
17474 
 
17475 
  def __repr__(self):
17476 
    L = ['%s=%r' % (key, value)
17477 
      for key, value in self.__dict__.iteritems()]
17478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17479 
 
17480 
  def __eq__(self, other):
17481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17482 
 
17483 
  def __ne__(self, other):
17484 
    return not (self == other)
17485 
 
17486 
class getOrdersForProviderForStatus_result:
17487 
  """
17488 
  Attributes:
17489 
   - success
17490 
   - ex
17491 
  """
17492 
 
17493 
  thrift_spec = (
17494 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17495 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17496 
  )
17497 
 
17498 
  def __init__(self, success=None, ex=None,):
17499 
    self.success = success
17500 
    self.ex = ex
17501 
 
17502 
  def read(self, iprot):
17503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17505 
      return
17506 
    iprot.readStructBegin()
17507 
    while True:
17508 
      (fname, ftype, fid) = iprot.readFieldBegin()
17509 
      if ftype == TType.STOP:
17510 
        break
17511 
      if fid == 0:
17512 
        if ftype == TType.LIST:
17513 
          self.success = []
4586 mandeep.dh 17514 
          (_etype287, _size284) = iprot.readListBegin()
17515 
          for _i288 in xrange(_size284):
17516 
            _elem289 = Order()
17517 
            _elem289.read(iprot)
17518 
            self.success.append(_elem289)
4506 phani.kuma 17519 
          iprot.readListEnd()
17520 
        else:
17521 
          iprot.skip(ftype)
17522 
      elif fid == 1:
17523 
        if ftype == TType.STRUCT:
17524 
          self.ex = TransactionServiceException()
17525 
          self.ex.read(iprot)
17526 
        else:
17527 
          iprot.skip(ftype)
17528 
      else:
17529 
        iprot.skip(ftype)
17530 
      iprot.readFieldEnd()
17531 
    iprot.readStructEnd()
17532 
 
17533 
  def write(self, oprot):
17534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17536 
      return
17537 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
17538 
    if self.success is not None:
17539 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17540 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4586 mandeep.dh 17541 
      for iter290 in self.success:
17542 
        iter290.write(oprot)
4506 phani.kuma 17543 
      oprot.writeListEnd()
17544 
      oprot.writeFieldEnd()
17545 
    if self.ex is not None:
17546 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17547 
      self.ex.write(oprot)
17548 
      oprot.writeFieldEnd()
17549 
    oprot.writeFieldStop()
17550 
    oprot.writeStructEnd()
17551 
 
17552 
  def validate(self):
17553 
    return
17554 
 
17555 
 
17556 
  def __repr__(self):
17557 
    L = ['%s=%r' % (key, value)
17558 
      for key, value in self.__dict__.iteritems()]
17559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17560 
 
17561 
  def __eq__(self, other):
17562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17563 
 
17564 
  def __ne__(self, other):
17565 
    return not (self == other)
4600 varun.gupt 17566 
 
17567 
class getBilledOrdersForVendor_args:
17568 
  """
17569 
  Attributes:
17570 
   - vendorId
17571 
   - billingDateFrom
17572 
   - billingDateTo
17573 
  """
17574 
 
17575 
  thrift_spec = (
17576 
    None, # 0
17577 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17578 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
17579 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
17580 
  )
17581 
 
17582 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
17583 
    self.vendorId = vendorId
17584 
    self.billingDateFrom = billingDateFrom
17585 
    self.billingDateTo = billingDateTo
17586 
 
17587 
  def read(self, iprot):
17588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17590 
      return
17591 
    iprot.readStructBegin()
17592 
    while True:
17593 
      (fname, ftype, fid) = iprot.readFieldBegin()
17594 
      if ftype == TType.STOP:
17595 
        break
17596 
      if fid == 1:
17597 
        if ftype == TType.I64:
17598 
          self.vendorId = iprot.readI64();
17599 
        else:
17600 
          iprot.skip(ftype)
17601 
      elif fid == 2:
17602 
        if ftype == TType.I64:
17603 
          self.billingDateFrom = iprot.readI64();
17604 
        else:
17605 
          iprot.skip(ftype)
17606 
      elif fid == 3:
17607 
        if ftype == TType.I64:
17608 
          self.billingDateTo = iprot.readI64();
17609 
        else:
17610 
          iprot.skip(ftype)
17611 
      else:
17612 
        iprot.skip(ftype)
17613 
      iprot.readFieldEnd()
17614 
    iprot.readStructEnd()
17615 
 
17616 
  def write(self, oprot):
17617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17619 
      return
17620 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
17621 
    if self.vendorId is not None:
17622 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17623 
      oprot.writeI64(self.vendorId)
17624 
      oprot.writeFieldEnd()
17625 
    if self.billingDateFrom is not None:
17626 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
17627 
      oprot.writeI64(self.billingDateFrom)
17628 
      oprot.writeFieldEnd()
17629 
    if self.billingDateTo is not None:
17630 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
17631 
      oprot.writeI64(self.billingDateTo)
17632 
      oprot.writeFieldEnd()
17633 
    oprot.writeFieldStop()
17634 
    oprot.writeStructEnd()
17635 
 
17636 
  def validate(self):
17637 
    return
17638 
 
17639 
 
17640 
  def __repr__(self):
17641 
    L = ['%s=%r' % (key, value)
17642 
      for key, value in self.__dict__.iteritems()]
17643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17644 
 
17645 
  def __eq__(self, other):
17646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17647 
 
17648 
  def __ne__(self, other):
17649 
    return not (self == other)
17650 
 
17651 
class getBilledOrdersForVendor_result:
17652 
  """
17653 
  Attributes:
17654 
   - success
17655 
   - ex
17656 
  """
17657 
 
17658 
  thrift_spec = (
17659 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17660 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17661 
  )
17662 
 
17663 
  def __init__(self, success=None, ex=None,):
17664 
    self.success = success
17665 
    self.ex = ex
17666 
 
17667 
  def read(self, iprot):
17668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17670 
      return
17671 
    iprot.readStructBegin()
17672 
    while True:
17673 
      (fname, ftype, fid) = iprot.readFieldBegin()
17674 
      if ftype == TType.STOP:
17675 
        break
17676 
      if fid == 0:
17677 
        if ftype == TType.LIST:
17678 
          self.success = []
17679 
          (_etype294, _size291) = iprot.readListBegin()
17680 
          for _i295 in xrange(_size291):
17681 
            _elem296 = Order()
17682 
            _elem296.read(iprot)
17683 
            self.success.append(_elem296)
17684 
          iprot.readListEnd()
17685 
        else:
17686 
          iprot.skip(ftype)
17687 
      elif fid == 1:
17688 
        if ftype == TType.STRUCT:
17689 
          self.ex = TransactionServiceException()
17690 
          self.ex.read(iprot)
17691 
        else:
17692 
          iprot.skip(ftype)
17693 
      else:
17694 
        iprot.skip(ftype)
17695 
      iprot.readFieldEnd()
17696 
    iprot.readStructEnd()
17697 
 
17698 
  def write(self, oprot):
17699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17701 
      return
17702 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
17703 
    if self.success is not None:
17704 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17705 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17706 
      for iter297 in self.success:
17707 
        iter297.write(oprot)
17708 
      oprot.writeListEnd()
17709 
      oprot.writeFieldEnd()
17710 
    if self.ex is not None:
17711 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17712 
      self.ex.write(oprot)
17713 
      oprot.writeFieldEnd()
17714 
    oprot.writeFieldStop()
17715 
    oprot.writeStructEnd()
17716 
 
17717 
  def validate(self):
17718 
    return
17719 
 
17720 
 
17721 
  def __repr__(self):
17722 
    L = ['%s=%r' % (key, value)
17723 
      for key, value in self.__dict__.iteritems()]
17724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17725 
 
17726 
  def __eq__(self, other):
17727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17728 
 
17729 
  def __ne__(self, other):
17730 
    return not (self == other)
17731 
 
4607 rajveer 17732 
class getSlippedSippingDateOrders_args:
17733 
 
17734 
  thrift_spec = (
17735 
  )
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 
      else:
17747 
        iprot.skip(ftype)
17748 
      iprot.readFieldEnd()
17749 
    iprot.readStructEnd()
17750 
 
17751 
  def write(self, oprot):
17752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17754 
      return
17755 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
17756 
    oprot.writeFieldStop()
17757 
    oprot.writeStructEnd()
17758 
 
17759 
  def validate(self):
17760 
    return
17761 
 
17762 
 
17763 
  def __repr__(self):
17764 
    L = ['%s=%r' % (key, value)
17765 
      for key, value in self.__dict__.iteritems()]
17766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17767 
 
17768 
  def __eq__(self, other):
17769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17770 
 
17771 
  def __ne__(self, other):
17772 
    return not (self == other)
17773 
 
17774 
class getSlippedSippingDateOrders_result:
17775 
  """
17776 
  Attributes:
17777 
   - success
17778 
   - ex
17779 
  """
17780 
 
17781 
  thrift_spec = (
17782 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17783 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17784 
  )
17785 
 
17786 
  def __init__(self, success=None, ex=None,):
17787 
    self.success = success
17788 
    self.ex = ex
17789 
 
17790 
  def read(self, iprot):
17791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17793 
      return
17794 
    iprot.readStructBegin()
17795 
    while True:
17796 
      (fname, ftype, fid) = iprot.readFieldBegin()
17797 
      if ftype == TType.STOP:
17798 
        break
17799 
      if fid == 0:
17800 
        if ftype == TType.LIST:
17801 
          self.success = []
17802 
          (_etype301, _size298) = iprot.readListBegin()
17803 
          for _i302 in xrange(_size298):
17804 
            _elem303 = Order()
17805 
            _elem303.read(iprot)
17806 
            self.success.append(_elem303)
17807 
          iprot.readListEnd()
17808 
        else:
17809 
          iprot.skip(ftype)
17810 
      elif fid == 1:
17811 
        if ftype == TType.STRUCT:
17812 
          self.ex = TransactionServiceException()
17813 
          self.ex.read(iprot)
17814 
        else:
17815 
          iprot.skip(ftype)
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_result')
17826 
    if self.success is not None:
17827 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17828 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17829 
      for iter304 in self.success:
17830 
        iter304.write(oprot)
17831 
      oprot.writeListEnd()
17832 
      oprot.writeFieldEnd()
17833 
    if self.ex is not None:
17834 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17835 
      self.ex.write(oprot)
17836 
      oprot.writeFieldEnd()
17837 
    oprot.writeFieldStop()
17838 
    oprot.writeStructEnd()
17839 
 
17840 
  def validate(self):
17841 
    return
17842 
 
17843 
 
17844 
  def __repr__(self):
17845 
    L = ['%s=%r' % (key, value)
17846 
      for key, value in self.__dict__.iteritems()]
17847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17848 
 
17849 
  def __eq__(self, other):
17850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17851 
 
17852 
  def __ne__(self, other):
17853 
    return not (self == other)
17854 
 
4709 rajveer 17855 
class getCancelledOrders_args:
17856 
  """
17857 
  Attributes:
17858 
   - cancelDateFrom
17859 
   - cancelDateTo
17860 
  """
17861 
 
17862 
  thrift_spec = (
17863 
    None, # 0
17864 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
17865 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
17866 
  )
17867 
 
17868 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
17869 
    self.cancelDateFrom = cancelDateFrom
17870 
    self.cancelDateTo = cancelDateTo
17871 
 
17872 
  def read(self, iprot):
17873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17875 
      return
17876 
    iprot.readStructBegin()
17877 
    while True:
17878 
      (fname, ftype, fid) = iprot.readFieldBegin()
17879 
      if ftype == TType.STOP:
17880 
        break
17881 
      if fid == 1:
17882 
        if ftype == TType.I64:
17883 
          self.cancelDateFrom = iprot.readI64();
17884 
        else:
17885 
          iprot.skip(ftype)
17886 
      elif fid == 2:
17887 
        if ftype == TType.I64:
17888 
          self.cancelDateTo = iprot.readI64();
17889 
        else:
17890 
          iprot.skip(ftype)
17891 
      else:
17892 
        iprot.skip(ftype)
17893 
      iprot.readFieldEnd()
17894 
    iprot.readStructEnd()
17895 
 
17896 
  def write(self, oprot):
17897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17899 
      return
17900 
    oprot.writeStructBegin('getCancelledOrders_args')
17901 
    if self.cancelDateFrom is not None:
17902 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
17903 
      oprot.writeI64(self.cancelDateFrom)
17904 
      oprot.writeFieldEnd()
17905 
    if self.cancelDateTo is not None:
17906 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
17907 
      oprot.writeI64(self.cancelDateTo)
17908 
      oprot.writeFieldEnd()
17909 
    oprot.writeFieldStop()
17910 
    oprot.writeStructEnd()
17911 
 
17912 
  def validate(self):
17913 
    return
17914 
 
17915 
 
17916 
  def __repr__(self):
17917 
    L = ['%s=%r' % (key, value)
17918 
      for key, value in self.__dict__.iteritems()]
17919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17920 
 
17921 
  def __eq__(self, other):
17922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17923 
 
17924 
  def __ne__(self, other):
17925 
    return not (self == other)
17926 
 
17927 
class getCancelledOrders_result:
17928 
  """
17929 
  Attributes:
17930 
   - success
17931 
   - ex
17932 
  """
17933 
 
17934 
  thrift_spec = (
17935 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17936 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17937 
  )
17938 
 
17939 
  def __init__(self, success=None, ex=None,):
17940 
    self.success = success
17941 
    self.ex = ex
17942 
 
17943 
  def read(self, iprot):
17944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17946 
      return
17947 
    iprot.readStructBegin()
17948 
    while True:
17949 
      (fname, ftype, fid) = iprot.readFieldBegin()
17950 
      if ftype == TType.STOP:
17951 
        break
17952 
      if fid == 0:
17953 
        if ftype == TType.LIST:
17954 
          self.success = []
17955 
          (_etype308, _size305) = iprot.readListBegin()
17956 
          for _i309 in xrange(_size305):
17957 
            _elem310 = Order()
17958 
            _elem310.read(iprot)
17959 
            self.success.append(_elem310)
17960 
          iprot.readListEnd()
17961 
        else:
17962 
          iprot.skip(ftype)
17963 
      elif fid == 1:
17964 
        if ftype == TType.STRUCT:
17965 
          self.ex = TransactionServiceException()
17966 
          self.ex.read(iprot)
17967 
        else:
17968 
          iprot.skip(ftype)
17969 
      else:
17970 
        iprot.skip(ftype)
17971 
      iprot.readFieldEnd()
17972 
    iprot.readStructEnd()
17973 
 
17974 
  def write(self, oprot):
17975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17977 
      return
17978 
    oprot.writeStructBegin('getCancelledOrders_result')
17979 
    if self.success is not None:
17980 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17981 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17982 
      for iter311 in self.success:
17983 
        iter311.write(oprot)
17984 
      oprot.writeListEnd()
17985 
      oprot.writeFieldEnd()
17986 
    if self.ex is not None:
17987 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17988 
      self.ex.write(oprot)
17989 
      oprot.writeFieldEnd()
17990 
    oprot.writeFieldStop()
17991 
    oprot.writeStructEnd()
17992 
 
17993 
  def validate(self):
17994 
    return
17995 
 
17996 
 
17997 
  def __repr__(self):
17998 
    L = ['%s=%r' % (key, value)
17999 
      for key, value in self.__dict__.iteritems()]
18000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18001 
 
18002 
  def __eq__(self, other):
18003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18004 
 
18005 
  def __ne__(self, other):
18006 
    return not (self == other)
18007 
 
4600 varun.gupt 18008 
class saveBluedartSettlements_args:
18009 
  """
18010 
  Attributes:
18011 
   - mapAWBAndAmount
18012 
  """
18013 
 
18014 
  thrift_spec = (
18015 
    None, # 0
18016 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
18017 
  )
18018 
 
18019 
  def __init__(self, mapAWBAndAmount=None,):
18020 
    self.mapAWBAndAmount = mapAWBAndAmount
18021 
 
18022 
  def read(self, iprot):
18023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18025 
      return
18026 
    iprot.readStructBegin()
18027 
    while True:
18028 
      (fname, ftype, fid) = iprot.readFieldBegin()
18029 
      if ftype == TType.STOP:
18030 
        break
18031 
      if fid == 1:
18032 
        if ftype == TType.MAP:
18033 
          self.mapAWBAndAmount = {}
4709 rajveer 18034 
          (_ktype313, _vtype314, _size312 ) = iprot.readMapBegin()
18035 
          for _i316 in xrange(_size312):
18036 
            _key317 = iprot.readI64();
18037 
            _val318 = iprot.readDouble();
18038 
            self.mapAWBAndAmount[_key317] = _val318
4600 varun.gupt 18039 
          iprot.readMapEnd()
18040 
        else:
18041 
          iprot.skip(ftype)
18042 
      else:
18043 
        iprot.skip(ftype)
18044 
      iprot.readFieldEnd()
18045 
    iprot.readStructEnd()
18046 
 
18047 
  def write(self, oprot):
18048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18050 
      return
18051 
    oprot.writeStructBegin('saveBluedartSettlements_args')
18052 
    if self.mapAWBAndAmount is not None:
18053 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
18054 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
4709 rajveer 18055 
      for kiter319,viter320 in self.mapAWBAndAmount.items():
18056 
        oprot.writeI64(kiter319)
18057 
        oprot.writeDouble(viter320)
4600 varun.gupt 18058 
      oprot.writeMapEnd()
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 
 
18078 
class saveBluedartSettlements_result:
18079 
  """
18080 
  Attributes:
18081 
   - ex
18082 
  """
18083 
 
18084 
  thrift_spec = (
18085 
    None, # 0
18086 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18087 
  )
18088 
 
18089 
  def __init__(self, ex=None,):
18090 
    self.ex = ex
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.STRUCT:
18103 
          self.ex = TransactionServiceException()
18104 
          self.ex.read(iprot)
18105 
        else:
18106 
          iprot.skip(ftype)
18107 
      else:
18108 
        iprot.skip(ftype)
18109 
      iprot.readFieldEnd()
18110 
    iprot.readStructEnd()
18111 
 
18112 
  def write(self, oprot):
18113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18115 
      return
18116 
    oprot.writeStructBegin('saveBluedartSettlements_result')
18117 
    if self.ex is not None:
18118 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18119 
      self.ex.write(oprot)
18120 
      oprot.writeFieldEnd()
18121 
    oprot.writeFieldStop()
18122 
    oprot.writeStructEnd()
18123 
 
18124 
  def validate(self):
18125 
    return
18126 
 
18127 
 
18128 
  def __repr__(self):
18129 
    L = ['%s=%r' % (key, value)
18130 
      for key, value in self.__dict__.iteritems()]
18131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18132 
 
18133 
  def __eq__(self, other):
18134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18135 
 
18136 
  def __ne__(self, other):
18137 
    return not (self == other)
18138 
 
18139 
class savePaymentSettlements_args:
18140 
  """
18141 
  Attributes:
18142 
   - settlementDate
18143 
   - paymentGatewayId
18144 
   - paymentId
18145 
   - serviceTax
18146 
   - otherCharges
18147 
   - netCollection
18148 
  """
18149 
 
18150 
  thrift_spec = (
18151 
    None, # 0
18152 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
18153 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
18154 
    (3, TType.I64, 'paymentId', None, None, ), # 3
18155 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
18156 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
18157 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
18158 
  )
18159 
 
18160 
  def __init__(self, settlementDate=None, paymentGatewayId=None, paymentId=None, serviceTax=None, otherCharges=None, netCollection=None,):
18161 
    self.settlementDate = settlementDate
18162 
    self.paymentGatewayId = paymentGatewayId
18163 
    self.paymentId = paymentId
18164 
    self.serviceTax = serviceTax
18165 
    self.otherCharges = otherCharges
18166 
    self.netCollection = netCollection
18167 
 
18168 
  def read(self, iprot):
18169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18171 
      return
18172 
    iprot.readStructBegin()
18173 
    while True:
18174 
      (fname, ftype, fid) = iprot.readFieldBegin()
18175 
      if ftype == TType.STOP:
18176 
        break
18177 
      if fid == 1:
18178 
        if ftype == TType.I64:
18179 
          self.settlementDate = iprot.readI64();
18180 
        else:
18181 
          iprot.skip(ftype)
18182 
      elif fid == 2:
18183 
        if ftype == TType.I64:
18184 
          self.paymentGatewayId = iprot.readI64();
18185 
        else:
18186 
          iprot.skip(ftype)
18187 
      elif fid == 3:
18188 
        if ftype == TType.I64:
18189 
          self.paymentId = iprot.readI64();
18190 
        else:
18191 
          iprot.skip(ftype)
18192 
      elif fid == 4:
18193 
        if ftype == TType.DOUBLE:
18194 
          self.serviceTax = iprot.readDouble();
18195 
        else:
18196 
          iprot.skip(ftype)
18197 
      elif fid == 5:
18198 
        if ftype == TType.DOUBLE:
18199 
          self.otherCharges = iprot.readDouble();
18200 
        else:
18201 
          iprot.skip(ftype)
18202 
      elif fid == 6:
18203 
        if ftype == TType.DOUBLE:
18204 
          self.netCollection = iprot.readDouble();
18205 
        else:
18206 
          iprot.skip(ftype)
18207 
      else:
18208 
        iprot.skip(ftype)
18209 
      iprot.readFieldEnd()
18210 
    iprot.readStructEnd()
18211 
 
18212 
  def write(self, oprot):
18213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18215 
      return
18216 
    oprot.writeStructBegin('savePaymentSettlements_args')
18217 
    if self.settlementDate is not None:
18218 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
18219 
      oprot.writeI64(self.settlementDate)
18220 
      oprot.writeFieldEnd()
18221 
    if self.paymentGatewayId is not None:
18222 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
18223 
      oprot.writeI64(self.paymentGatewayId)
18224 
      oprot.writeFieldEnd()
18225 
    if self.paymentId is not None:
18226 
      oprot.writeFieldBegin('paymentId', TType.I64, 3)
18227 
      oprot.writeI64(self.paymentId)
18228 
      oprot.writeFieldEnd()
18229 
    if self.serviceTax is not None:
18230 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
18231 
      oprot.writeDouble(self.serviceTax)
18232 
      oprot.writeFieldEnd()
18233 
    if self.otherCharges is not None:
18234 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
18235 
      oprot.writeDouble(self.otherCharges)
18236 
      oprot.writeFieldEnd()
18237 
    if self.netCollection is not None:
18238 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
18239 
      oprot.writeDouble(self.netCollection)
18240 
      oprot.writeFieldEnd()
18241 
    oprot.writeFieldStop()
18242 
    oprot.writeStructEnd()
18243 
 
18244 
  def validate(self):
18245 
    return
18246 
 
18247 
 
18248 
  def __repr__(self):
18249 
    L = ['%s=%r' % (key, value)
18250 
      for key, value in self.__dict__.iteritems()]
18251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18252 
 
18253 
  def __eq__(self, other):
18254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18255 
 
18256 
  def __ne__(self, other):
18257 
    return not (self == other)
18258 
 
18259 
class savePaymentSettlements_result:
18260 
  """
18261 
  Attributes:
18262 
   - ex
18263 
  """
18264 
 
18265 
  thrift_spec = (
18266 
    None, # 0
18267 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18268 
  )
18269 
 
18270 
  def __init__(self, ex=None,):
18271 
    self.ex = ex
18272 
 
18273 
  def read(self, iprot):
18274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18276 
      return
18277 
    iprot.readStructBegin()
18278 
    while True:
18279 
      (fname, ftype, fid) = iprot.readFieldBegin()
18280 
      if ftype == TType.STOP:
18281 
        break
18282 
      if fid == 1:
18283 
        if ftype == TType.STRUCT:
18284 
          self.ex = TransactionServiceException()
18285 
          self.ex.read(iprot)
18286 
        else:
18287 
          iprot.skip(ftype)
18288 
      else:
18289 
        iprot.skip(ftype)
18290 
      iprot.readFieldEnd()
18291 
    iprot.readStructEnd()
18292 
 
18293 
  def write(self, oprot):
18294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18296 
      return
18297 
    oprot.writeStructBegin('savePaymentSettlements_result')
18298 
    if self.ex is not None:
18299 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18300 
      self.ex.write(oprot)
18301 
      oprot.writeFieldEnd()
18302 
    oprot.writeFieldStop()
18303 
    oprot.writeStructEnd()
18304 
 
18305 
  def validate(self):
18306 
    return
18307 
 
18308 
 
18309 
  def __repr__(self):
18310 
    L = ['%s=%r' % (key, value)
18311 
      for key, value in self.__dict__.iteritems()]
18312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18313 
 
18314 
  def __eq__(self, other):
18315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18316 
 
18317 
  def __ne__(self, other):
18318 
    return not (self == other)
18319 
 
18320 
class saveEBSSettlementSummary_args:
18321 
  """
18322 
  Attributes:
18323 
   - settlementId
18324 
   - settlementDate
18325 
   - transactionDateFrom
18326 
   - transactionDateTo
18327 
   - amount
18328 
  """
18329 
 
18330 
  thrift_spec = (
18331 
    None, # 0
18332 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18333 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
18334 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
18335 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
18336 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
18337 
  )
18338 
 
18339 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
18340 
    self.settlementId = settlementId
18341 
    self.settlementDate = settlementDate
18342 
    self.transactionDateFrom = transactionDateFrom
18343 
    self.transactionDateTo = transactionDateTo
18344 
    self.amount = amount
18345 
 
18346 
  def read(self, iprot):
18347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18349 
      return
18350 
    iprot.readStructBegin()
18351 
    while True:
18352 
      (fname, ftype, fid) = iprot.readFieldBegin()
18353 
      if ftype == TType.STOP:
18354 
        break
18355 
      if fid == 1:
18356 
        if ftype == TType.I64:
18357 
          self.settlementId = iprot.readI64();
18358 
        else:
18359 
          iprot.skip(ftype)
18360 
      elif fid == 2:
18361 
        if ftype == TType.I64:
18362 
          self.settlementDate = iprot.readI64();
18363 
        else:
18364 
          iprot.skip(ftype)
18365 
      elif fid == 3:
18366 
        if ftype == TType.I64:
18367 
          self.transactionDateFrom = iprot.readI64();
18368 
        else:
18369 
          iprot.skip(ftype)
18370 
      elif fid == 4:
18371 
        if ftype == TType.I64:
18372 
          self.transactionDateTo = iprot.readI64();
18373 
        else:
18374 
          iprot.skip(ftype)
18375 
      elif fid == 5:
18376 
        if ftype == TType.DOUBLE:
18377 
          self.amount = iprot.readDouble();
18378 
        else:
18379 
          iprot.skip(ftype)
18380 
      else:
18381 
        iprot.skip(ftype)
18382 
      iprot.readFieldEnd()
18383 
    iprot.readStructEnd()
18384 
 
18385 
  def write(self, oprot):
18386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18388 
      return
18389 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
18390 
    if self.settlementId is not None:
18391 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18392 
      oprot.writeI64(self.settlementId)
18393 
      oprot.writeFieldEnd()
18394 
    if self.settlementDate is not None:
18395 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
18396 
      oprot.writeI64(self.settlementDate)
18397 
      oprot.writeFieldEnd()
18398 
    if self.transactionDateFrom is not None:
18399 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
18400 
      oprot.writeI64(self.transactionDateFrom)
18401 
      oprot.writeFieldEnd()
18402 
    if self.transactionDateTo is not None:
18403 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
18404 
      oprot.writeI64(self.transactionDateTo)
18405 
      oprot.writeFieldEnd()
18406 
    if self.amount is not None:
18407 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
18408 
      oprot.writeDouble(self.amount)
18409 
      oprot.writeFieldEnd()
18410 
    oprot.writeFieldStop()
18411 
    oprot.writeStructEnd()
18412 
 
18413 
  def validate(self):
18414 
    return
18415 
 
18416 
 
18417 
  def __repr__(self):
18418 
    L = ['%s=%r' % (key, value)
18419 
      for key, value in self.__dict__.iteritems()]
18420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18421 
 
18422 
  def __eq__(self, other):
18423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18424 
 
18425 
  def __ne__(self, other):
18426 
    return not (self == other)
18427 
 
18428 
class saveEBSSettlementSummary_result:
18429 
  """
18430 
  Attributes:
18431 
   - ex
18432 
  """
18433 
 
18434 
  thrift_spec = (
18435 
    None, # 0
18436 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18437 
  )
18438 
 
18439 
  def __init__(self, ex=None,):
18440 
    self.ex = ex
18441 
 
18442 
  def read(self, iprot):
18443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18445 
      return
18446 
    iprot.readStructBegin()
18447 
    while True:
18448 
      (fname, ftype, fid) = iprot.readFieldBegin()
18449 
      if ftype == TType.STOP:
18450 
        break
18451 
      if fid == 1:
18452 
        if ftype == TType.STRUCT:
18453 
          self.ex = TransactionServiceException()
18454 
          self.ex.read(iprot)
18455 
        else:
18456 
          iprot.skip(ftype)
18457 
      else:
18458 
        iprot.skip(ftype)
18459 
      iprot.readFieldEnd()
18460 
    iprot.readStructEnd()
18461 
 
18462 
  def write(self, oprot):
18463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18465 
      return
18466 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
18467 
    if self.ex is not None:
18468 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18469 
      self.ex.write(oprot)
18470 
      oprot.writeFieldEnd()
18471 
    oprot.writeFieldStop()
18472 
    oprot.writeStructEnd()
18473 
 
18474 
  def validate(self):
18475 
    return
18476 
 
18477 
 
18478 
  def __repr__(self):
18479 
    L = ['%s=%r' % (key, value)
18480 
      for key, value in self.__dict__.iteritems()]
18481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18482 
 
18483 
  def __eq__(self, other):
18484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18485 
 
18486 
  def __ne__(self, other):
18487 
    return not (self == other)
18488 
 
18489 
class getSettlementForPaymentId_args:
18490 
  """
18491 
  Attributes:
18492 
   - paymentId
18493 
  """
18494 
 
18495 
  thrift_spec = (
18496 
    None, # 0
18497 
    (1, TType.I64, 'paymentId', None, None, ), # 1
18498 
  )
18499 
 
18500 
  def __init__(self, paymentId=None,):
18501 
    self.paymentId = paymentId
18502 
 
18503 
  def read(self, iprot):
18504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18506 
      return
18507 
    iprot.readStructBegin()
18508 
    while True:
18509 
      (fname, ftype, fid) = iprot.readFieldBegin()
18510 
      if ftype == TType.STOP:
18511 
        break
18512 
      if fid == 1:
18513 
        if ftype == TType.I64:
18514 
          self.paymentId = iprot.readI64();
18515 
        else:
18516 
          iprot.skip(ftype)
18517 
      else:
18518 
        iprot.skip(ftype)
18519 
      iprot.readFieldEnd()
18520 
    iprot.readStructEnd()
18521 
 
18522 
  def write(self, oprot):
18523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18525 
      return
18526 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
18527 
    if self.paymentId is not None:
18528 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
18529 
      oprot.writeI64(self.paymentId)
18530 
      oprot.writeFieldEnd()
18531 
    oprot.writeFieldStop()
18532 
    oprot.writeStructEnd()
18533 
 
18534 
  def validate(self):
18535 
    return
18536 
 
18537 
 
18538 
  def __repr__(self):
18539 
    L = ['%s=%r' % (key, value)
18540 
      for key, value in self.__dict__.iteritems()]
18541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18542 
 
18543 
  def __eq__(self, other):
18544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18545 
 
18546 
  def __ne__(self, other):
18547 
    return not (self == other)
18548 
 
18549 
class getSettlementForPaymentId_result:
18550 
  """
18551 
  Attributes:
18552 
   - success
18553 
   - ex
18554 
  """
18555 
 
18556 
  thrift_spec = (
18557 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
18558 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18559 
  )
18560 
 
18561 
  def __init__(self, success=None, ex=None,):
18562 
    self.success = success
18563 
    self.ex = ex
18564 
 
18565 
  def read(self, iprot):
18566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18568 
      return
18569 
    iprot.readStructBegin()
18570 
    while True:
18571 
      (fname, ftype, fid) = iprot.readFieldBegin()
18572 
      if ftype == TType.STOP:
18573 
        break
18574 
      if fid == 0:
18575 
        if ftype == TType.STRUCT:
18576 
          self.success = PaymentSettlement()
18577 
          self.success.read(iprot)
18578 
        else:
18579 
          iprot.skip(ftype)
18580 
      elif fid == 1:
18581 
        if ftype == TType.STRUCT:
18582 
          self.ex = TransactionServiceException()
18583 
          self.ex.read(iprot)
18584 
        else:
18585 
          iprot.skip(ftype)
18586 
      else:
18587 
        iprot.skip(ftype)
18588 
      iprot.readFieldEnd()
18589 
    iprot.readStructEnd()
18590 
 
18591 
  def write(self, oprot):
18592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18594 
      return
18595 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
18596 
    if self.success is not None:
18597 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18598 
      self.success.write(oprot)
18599 
      oprot.writeFieldEnd()
18600 
    if self.ex is not None:
18601 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18602 
      self.ex.write(oprot)
18603 
      oprot.writeFieldEnd()
18604 
    oprot.writeFieldStop()
18605 
    oprot.writeStructEnd()
18606 
 
18607 
  def validate(self):
18608 
    return
18609 
 
18610 
 
18611 
  def __repr__(self):
18612 
    L = ['%s=%r' % (key, value)
18613 
      for key, value in self.__dict__.iteritems()]
18614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18615 
 
18616 
  def __eq__(self, other):
18617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18618 
 
18619 
  def __ne__(self, other):
18620 
    return not (self == other)
18621 
 
18622 
class getEBSSettlementSummaries_args:
18623 
 
18624 
  thrift_spec = (
18625 
  )
18626 
 
18627 
  def read(self, iprot):
18628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18630 
      return
18631 
    iprot.readStructBegin()
18632 
    while True:
18633 
      (fname, ftype, fid) = iprot.readFieldBegin()
18634 
      if ftype == TType.STOP:
18635 
        break
18636 
      else:
18637 
        iprot.skip(ftype)
18638 
      iprot.readFieldEnd()
18639 
    iprot.readStructEnd()
18640 
 
18641 
  def write(self, oprot):
18642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18644 
      return
18645 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
18646 
    oprot.writeFieldStop()
18647 
    oprot.writeStructEnd()
18648 
 
18649 
  def validate(self):
18650 
    return
18651 
 
18652 
 
18653 
  def __repr__(self):
18654 
    L = ['%s=%r' % (key, value)
18655 
      for key, value in self.__dict__.iteritems()]
18656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18657 
 
18658 
  def __eq__(self, other):
18659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18660 
 
18661 
  def __ne__(self, other):
18662 
    return not (self == other)
18663 
 
18664 
class getEBSSettlementSummaries_result:
18665 
  """
18666 
  Attributes:
18667 
   - success
18668 
   - ex
18669 
  """
18670 
 
18671 
  thrift_spec = (
18672 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
18673 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18674 
  )
18675 
 
18676 
  def __init__(self, success=None, ex=None,):
18677 
    self.success = success
18678 
    self.ex = ex
18679 
 
18680 
  def read(self, iprot):
18681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18683 
      return
18684 
    iprot.readStructBegin()
18685 
    while True:
18686 
      (fname, ftype, fid) = iprot.readFieldBegin()
18687 
      if ftype == TType.STOP:
18688 
        break
18689 
      if fid == 0:
18690 
        if ftype == TType.MAP:
18691 
          self.success = {}
4709 rajveer 18692 
          (_ktype322, _vtype323, _size321 ) = iprot.readMapBegin()
18693 
          for _i325 in xrange(_size321):
18694 
            _key326 = iprot.readI64();
18695 
            _val327 = iprot.readString();
18696 
            self.success[_key326] = _val327
4600 varun.gupt 18697 
          iprot.readMapEnd()
18698 
        else:
18699 
          iprot.skip(ftype)
18700 
      elif fid == 1:
18701 
        if ftype == TType.STRUCT:
18702 
          self.ex = TransactionServiceException()
18703 
          self.ex.read(iprot)
18704 
        else:
18705 
          iprot.skip(ftype)
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_result')
18716 
    if self.success is not None:
18717 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18718 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
4709 rajveer 18719 
      for kiter328,viter329 in self.success.items():
18720 
        oprot.writeI64(kiter328)
18721 
        oprot.writeString(viter329)
4600 varun.gupt 18722 
      oprot.writeMapEnd()
18723 
      oprot.writeFieldEnd()
18724 
    if self.ex is not None:
18725 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18726 
      self.ex.write(oprot)
18727 
      oprot.writeFieldEnd()
18728 
    oprot.writeFieldStop()
18729 
    oprot.writeStructEnd()
18730 
 
18731 
  def validate(self):
18732 
    return
18733 
 
18734 
 
18735 
  def __repr__(self):
18736 
    L = ['%s=%r' % (key, value)
18737 
      for key, value in self.__dict__.iteritems()]
18738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18739 
 
18740 
  def __eq__(self, other):
18741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18742 
 
18743 
  def __ne__(self, other):
18744 
    return not (self == other)
18745 
 
18746 
class markEBSSettlementUploaded_args:
18747 
  """
18748 
  Attributes:
18749 
   - settlementId
18750 
  """
18751 
 
18752 
  thrift_spec = (
18753 
    None, # 0
18754 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18755 
  )
18756 
 
18757 
  def __init__(self, settlementId=None,):
18758 
    self.settlementId = settlementId
18759 
 
18760 
  def read(self, iprot):
18761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18763 
      return
18764 
    iprot.readStructBegin()
18765 
    while True:
18766 
      (fname, ftype, fid) = iprot.readFieldBegin()
18767 
      if ftype == TType.STOP:
18768 
        break
18769 
      if fid == 1:
18770 
        if ftype == TType.I64:
18771 
          self.settlementId = iprot.readI64();
18772 
        else:
18773 
          iprot.skip(ftype)
18774 
      else:
18775 
        iprot.skip(ftype)
18776 
      iprot.readFieldEnd()
18777 
    iprot.readStructEnd()
18778 
 
18779 
  def write(self, oprot):
18780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18782 
      return
18783 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
18784 
    if self.settlementId is not None:
18785 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18786 
      oprot.writeI64(self.settlementId)
18787 
      oprot.writeFieldEnd()
18788 
    oprot.writeFieldStop()
18789 
    oprot.writeStructEnd()
18790 
 
18791 
  def validate(self):
18792 
    return
18793 
 
18794 
 
18795 
  def __repr__(self):
18796 
    L = ['%s=%r' % (key, value)
18797 
      for key, value in self.__dict__.iteritems()]
18798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18799 
 
18800 
  def __eq__(self, other):
18801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18802 
 
18803 
  def __ne__(self, other):
18804 
    return not (self == other)
18805 
 
18806 
class markEBSSettlementUploaded_result:
18807 
  """
18808 
  Attributes:
18809 
   - ex
18810 
  """
18811 
 
18812 
  thrift_spec = (
18813 
    None, # 0
18814 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18815 
  )
18816 
 
18817 
  def __init__(self, ex=None,):
18818 
    self.ex = ex
18819 
 
18820 
  def read(self, iprot):
18821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18823 
      return
18824 
    iprot.readStructBegin()
18825 
    while True:
18826 
      (fname, ftype, fid) = iprot.readFieldBegin()
18827 
      if ftype == TType.STOP:
18828 
        break
18829 
      if fid == 1:
18830 
        if ftype == TType.STRUCT:
18831 
          self.ex = TransactionServiceException()
18832 
          self.ex.read(iprot)
18833 
        else:
18834 
          iprot.skip(ftype)
18835 
      else:
18836 
        iprot.skip(ftype)
18837 
      iprot.readFieldEnd()
18838 
    iprot.readStructEnd()
18839 
 
18840 
  def write(self, oprot):
18841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18843 
      return
18844 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
18845 
    if self.ex is not None:
18846 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18847 
      self.ex.write(oprot)
18848 
      oprot.writeFieldEnd()
18849 
    oprot.writeFieldStop()
18850 
    oprot.writeStructEnd()
18851 
 
18852 
  def validate(self):
18853 
    return
18854 
 
18855 
 
18856 
  def __repr__(self):
18857 
    L = ['%s=%r' % (key, value)
18858 
      for key, value in self.__dict__.iteritems()]
18859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18860 
 
18861 
  def __eq__(self, other):
18862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18863 
 
18864 
  def __ne__(self, other):
18865 
    return not (self == other)
18866 
 
18867 
class getEBSSettlementDate_args:
18868 
  """
18869 
  Attributes:
18870 
   - settlementId
18871 
  """
18872 
 
18873 
  thrift_spec = (
18874 
    None, # 0
18875 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18876 
  )
18877 
 
18878 
  def __init__(self, settlementId=None,):
18879 
    self.settlementId = settlementId
18880 
 
18881 
  def read(self, iprot):
18882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18884 
      return
18885 
    iprot.readStructBegin()
18886 
    while True:
18887 
      (fname, ftype, fid) = iprot.readFieldBegin()
18888 
      if ftype == TType.STOP:
18889 
        break
18890 
      if fid == 1:
18891 
        if ftype == TType.I64:
18892 
          self.settlementId = iprot.readI64();
18893 
        else:
18894 
          iprot.skip(ftype)
18895 
      else:
18896 
        iprot.skip(ftype)
18897 
      iprot.readFieldEnd()
18898 
    iprot.readStructEnd()
18899 
 
18900 
  def write(self, oprot):
18901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18903 
      return
18904 
    oprot.writeStructBegin('getEBSSettlementDate_args')
18905 
    if self.settlementId is not None:
18906 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18907 
      oprot.writeI64(self.settlementId)
18908 
      oprot.writeFieldEnd()
18909 
    oprot.writeFieldStop()
18910 
    oprot.writeStructEnd()
18911 
 
18912 
  def validate(self):
18913 
    return
18914 
 
18915 
 
18916 
  def __repr__(self):
18917 
    L = ['%s=%r' % (key, value)
18918 
      for key, value in self.__dict__.iteritems()]
18919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18920 
 
18921 
  def __eq__(self, other):
18922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18923 
 
18924 
  def __ne__(self, other):
18925 
    return not (self == other)
18926 
 
18927 
class getEBSSettlementDate_result:
18928 
  """
18929 
  Attributes:
18930 
   - success
18931 
   - ex
18932 
  """
18933 
 
18934 
  thrift_spec = (
18935 
    (0, TType.I64, 'success', None, None, ), # 0
18936 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18937 
  )
18938 
 
18939 
  def __init__(self, success=None, ex=None,):
18940 
    self.success = success
18941 
    self.ex = ex
18942 
 
18943 
  def read(self, iprot):
18944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18946 
      return
18947 
    iprot.readStructBegin()
18948 
    while True:
18949 
      (fname, ftype, fid) = iprot.readFieldBegin()
18950 
      if ftype == TType.STOP:
18951 
        break
18952 
      if fid == 0:
18953 
        if ftype == TType.I64:
18954 
          self.success = iprot.readI64();
18955 
        else:
18956 
          iprot.skip(ftype)
18957 
      elif fid == 1:
18958 
        if ftype == TType.STRUCT:
18959 
          self.ex = TransactionServiceException()
18960 
          self.ex.read(iprot)
18961 
        else:
18962 
          iprot.skip(ftype)
18963 
      else:
18964 
        iprot.skip(ftype)
18965 
      iprot.readFieldEnd()
18966 
    iprot.readStructEnd()
18967 
 
18968 
  def write(self, oprot):
18969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18971 
      return
18972 
    oprot.writeStructBegin('getEBSSettlementDate_result')
18973 
    if self.success is not None:
18974 
      oprot.writeFieldBegin('success', TType.I64, 0)
18975 
      oprot.writeI64(self.success)
18976 
      oprot.writeFieldEnd()
18977 
    if self.ex is not None:
18978 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18979 
      self.ex.write(oprot)
18980 
      oprot.writeFieldEnd()
18981 
    oprot.writeFieldStop()
18982 
    oprot.writeStructEnd()
18983 
 
18984 
  def validate(self):
18985 
    return
18986 
 
18987 
 
18988 
  def __repr__(self):
18989 
    L = ['%s=%r' % (key, value)
18990 
      for key, value in self.__dict__.iteritems()]
18991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18992 
 
18993 
  def __eq__(self, other):
18994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18995 
 
18996 
  def __ne__(self, other):
18997 
    return not (self == other)
4715 varun.gupt 18998 
 
18999 
class getSettlementsByDate_args:
19000 
  """
19001 
  Attributes:
19002 
   - settlementDateFrom
19003 
   - settlementDateTo
19004 
   - isRefund
19005 
  """
19006 
 
19007 
  thrift_spec = (
19008 
    None, # 0
19009 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
19010 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
19011 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
19012 
  )
19013 
 
19014 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
19015 
    self.settlementDateFrom = settlementDateFrom
19016 
    self.settlementDateTo = settlementDateTo
19017 
    self.isRefund = isRefund
19018 
 
19019 
  def read(self, iprot):
19020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19022 
      return
19023 
    iprot.readStructBegin()
19024 
    while True:
19025 
      (fname, ftype, fid) = iprot.readFieldBegin()
19026 
      if ftype == TType.STOP:
19027 
        break
19028 
      if fid == 1:
19029 
        if ftype == TType.I64:
19030 
          self.settlementDateFrom = iprot.readI64();
19031 
        else:
19032 
          iprot.skip(ftype)
19033 
      elif fid == 2:
19034 
        if ftype == TType.I64:
19035 
          self.settlementDateTo = iprot.readI64();
19036 
        else:
19037 
          iprot.skip(ftype)
19038 
      elif fid == 3:
19039 
        if ftype == TType.BOOL:
19040 
          self.isRefund = iprot.readBool();
19041 
        else:
19042 
          iprot.skip(ftype)
19043 
      else:
19044 
        iprot.skip(ftype)
19045 
      iprot.readFieldEnd()
19046 
    iprot.readStructEnd()
19047 
 
19048 
  def write(self, oprot):
19049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19051 
      return
19052 
    oprot.writeStructBegin('getSettlementsByDate_args')
19053 
    if self.settlementDateFrom is not None:
19054 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
19055 
      oprot.writeI64(self.settlementDateFrom)
19056 
      oprot.writeFieldEnd()
19057 
    if self.settlementDateTo is not None:
19058 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
19059 
      oprot.writeI64(self.settlementDateTo)
19060 
      oprot.writeFieldEnd()
19061 
    if self.isRefund is not None:
19062 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
19063 
      oprot.writeBool(self.isRefund)
19064 
      oprot.writeFieldEnd()
19065 
    oprot.writeFieldStop()
19066 
    oprot.writeStructEnd()
19067 
 
19068 
  def validate(self):
19069 
    return
19070 
 
19071 
 
19072 
  def __repr__(self):
19073 
    L = ['%s=%r' % (key, value)
19074 
      for key, value in self.__dict__.iteritems()]
19075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19076 
 
19077 
  def __eq__(self, other):
19078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19079 
 
19080 
  def __ne__(self, other):
19081 
    return not (self == other)
19082 
 
19083 
class getSettlementsByDate_result:
19084 
  """
19085 
  Attributes:
19086 
   - success
19087 
   - ex
19088 
  """
19089 
 
19090 
  thrift_spec = (
19091 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
19092 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19093 
  )
19094 
 
19095 
  def __init__(self, success=None, ex=None,):
19096 
    self.success = success
19097 
    self.ex = ex
19098 
 
19099 
  def read(self, iprot):
19100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19102 
      return
19103 
    iprot.readStructBegin()
19104 
    while True:
19105 
      (fname, ftype, fid) = iprot.readFieldBegin()
19106 
      if ftype == TType.STOP:
19107 
        break
19108 
      if fid == 0:
19109 
        if ftype == TType.LIST:
19110 
          self.success = []
19111 
          (_etype326, _size323) = iprot.readListBegin()
19112 
          for _i327 in xrange(_size323):
19113 
            _elem328 = PaymentSettlement()
19114 
            _elem328.read(iprot)
19115 
            self.success.append(_elem328)
19116 
          iprot.readListEnd()
19117 
        else:
19118 
          iprot.skip(ftype)
19119 
      elif fid == 1:
19120 
        if ftype == TType.STRUCT:
19121 
          self.ex = TransactionServiceException()
19122 
          self.ex.read(iprot)
19123 
        else:
19124 
          iprot.skip(ftype)
19125 
      else:
19126 
        iprot.skip(ftype)
19127 
      iprot.readFieldEnd()
19128 
    iprot.readStructEnd()
19129 
 
19130 
  def write(self, oprot):
19131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19133 
      return
19134 
    oprot.writeStructBegin('getSettlementsByDate_result')
19135 
    if self.success is not None:
19136 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19137 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
19138 
      for iter329 in self.success:
19139 
        iter329.write(oprot)
19140 
      oprot.writeListEnd()
19141 
      oprot.writeFieldEnd()
19142 
    if self.ex is not None:
19143 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19144 
      self.ex.write(oprot)
19145 
      oprot.writeFieldEnd()
19146 
    oprot.writeFieldStop()
19147 
    oprot.writeStructEnd()
19148 
 
19149 
  def validate(self):
19150 
    return
19151 
 
19152 
 
19153 
  def __repr__(self):
19154 
    L = ['%s=%r' % (key, value)
19155 
      for key, value in self.__dict__.iteritems()]
19156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19157 
 
19158 
  def __eq__(self, other):
19159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19160 
 
19161 
  def __ne__(self, other):
19162 
    return not (self == other)
19163 
 
19164 
class getReshippedOrderIds_args:
19165 
  """
19166 
  Attributes:
19167 
   - orderIds
19168 
  """
19169 
 
19170 
  thrift_spec = (
19171 
    None, # 0
19172 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
19173 
  )
19174 
 
19175 
  def __init__(self, orderIds=None,):
19176 
    self.orderIds = orderIds
19177 
 
19178 
  def read(self, iprot):
19179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19181 
      return
19182 
    iprot.readStructBegin()
19183 
    while True:
19184 
      (fname, ftype, fid) = iprot.readFieldBegin()
19185 
      if ftype == TType.STOP:
19186 
        break
19187 
      if fid == 1:
19188 
        if ftype == TType.LIST:
19189 
          self.orderIds = []
19190 
          (_etype333, _size330) = iprot.readListBegin()
19191 
          for _i334 in xrange(_size330):
19192 
            _elem335 = iprot.readI64();
19193 
            self.orderIds.append(_elem335)
19194 
          iprot.readListEnd()
19195 
        else:
19196 
          iprot.skip(ftype)
19197 
      else:
19198 
        iprot.skip(ftype)
19199 
      iprot.readFieldEnd()
19200 
    iprot.readStructEnd()
19201 
 
19202 
  def write(self, oprot):
19203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19205 
      return
19206 
    oprot.writeStructBegin('getReshippedOrderIds_args')
19207 
    if self.orderIds is not None:
19208 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
19209 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
19210 
      for iter336 in self.orderIds:
19211 
        oprot.writeI64(iter336)
19212 
      oprot.writeListEnd()
19213 
      oprot.writeFieldEnd()
19214 
    oprot.writeFieldStop()
19215 
    oprot.writeStructEnd()
19216 
 
19217 
  def validate(self):
19218 
    return
19219 
 
19220 
 
19221 
  def __repr__(self):
19222 
    L = ['%s=%r' % (key, value)
19223 
      for key, value in self.__dict__.iteritems()]
19224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19225 
 
19226 
  def __eq__(self, other):
19227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19228 
 
19229 
  def __ne__(self, other):
19230 
    return not (self == other)
19231 
 
19232 
class getReshippedOrderIds_result:
19233 
  """
19234 
  Attributes:
19235 
   - success
19236 
   - ex
19237 
  """
19238 
 
19239 
  thrift_spec = (
19240 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19241 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19242 
  )
19243 
 
19244 
  def __init__(self, success=None, ex=None,):
19245 
    self.success = success
19246 
    self.ex = ex
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 == 0:
19258 
        if ftype == TType.LIST:
19259 
          self.success = []
19260 
          (_etype340, _size337) = iprot.readListBegin()
19261 
          for _i341 in xrange(_size337):
19262 
            _elem342 = iprot.readI64();
19263 
            self.success.append(_elem342)
19264 
          iprot.readListEnd()
19265 
        else:
19266 
          iprot.skip(ftype)
19267 
      elif fid == 1:
19268 
        if ftype == TType.STRUCT:
19269 
          self.ex = TransactionServiceException()
19270 
          self.ex.read(iprot)
19271 
        else:
19272 
          iprot.skip(ftype)
19273 
      else:
19274 
        iprot.skip(ftype)
19275 
      iprot.readFieldEnd()
19276 
    iprot.readStructEnd()
19277 
 
19278 
  def write(self, oprot):
19279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19281 
      return
19282 
    oprot.writeStructBegin('getReshippedOrderIds_result')
19283 
    if self.success is not None:
19284 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19285 
      oprot.writeListBegin(TType.I64, len(self.success))
19286 
      for iter343 in self.success:
19287 
        oprot.writeI64(iter343)
19288 
      oprot.writeListEnd()
19289 
      oprot.writeFieldEnd()
19290 
    if self.ex is not None:
19291 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19292 
      self.ex.write(oprot)
19293 
      oprot.writeFieldEnd()
19294 
    oprot.writeFieldStop()
19295 
    oprot.writeStructEnd()
19296 
 
19297 
  def validate(self):
19298 
    return
19299 
 
19300 
 
19301 
  def __repr__(self):
19302 
    L = ['%s=%r' % (key, value)
19303 
      for key, value in self.__dict__.iteritems()]
19304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19305 
 
19306 
  def __eq__(self, other):
19307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19308 
 
19309 
  def __ne__(self, other):
19310 
    return not (self == other)