Subversion Repositories SmartDukaan

Rev

Rev 4783 | Rev 4801 | 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 
 
4763 rajveer 318 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 319 
    """
320 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 321 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 322 
    the IMEI no. if a -1 is supplied.
323 
    Also, it generates an invoice number for the order, marks the order as
324 
    BILLED and sets the billing timestamp.
325 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 326 
 
3064 chandransh 327 
    Parameters:
328 
     - orderId
4283 anupam.sin 329 
     - invoice_number
4658 mandeep.dh 330 
     - serialNumber
3064 chandransh 331 
     - itemNumber
4283 anupam.sin 332 
     - billed_by
333 
     - jacketNumber
3064 chandransh 334 
     - billingType
4283 anupam.sin 335 
     - vendorId
4763 rajveer 336 
     - authorize
3064 chandransh 337 
    """
338 
    pass
339 
 
4763 rajveer 340 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 341 
    """
342 
    Add the invoice number to the order.
343 
 
344 
    Parameters:
345 
     - orderId
346 
     - invoiceNumber
4763 rajveer 347 
     - color
4579 rajveer 348 
    """
349 
    pass
350 
 
3064 chandransh 351 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
352 
    """
353 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 354 
    given warehouse and were picked up by the given provider as MANIFESTED.
355 
 
356 
    Parameters:
357 
     - warehouseId
358 
     - providerId
359 
     - cod
360 
    """
361 
    pass
362 
 
4789 rajveer 363 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
4410 rajveer 364 
    """
365 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
3064 chandransh 366 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 367 
 
3064 chandransh 368 
    Parameters:
759 chandransh 369 
     - warehouseId
370 
     - providerId
3064 chandransh 371 
     - cod
4789 rajveer 372 
     - orderIds
759 chandransh 373 
    """
374 
    pass
375 
 
1113 chandransh 376 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
377 
    """
378 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
379 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
380 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 381 
 
1113 chandransh 382 
    Parameters:
383 
     - providerId
384 
     - pickupDetails
385 
    """
386 
    pass
387 
 
1132 chandransh 388 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
389 
    """
390 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
391 
    the name of the receiver.
392 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 393 
 
1132 chandransh 394 
    Parameters:
395 
     - providerId
396 
     - deliveredOrders
397 
    """
398 
    pass
399 
 
1135 chandransh 400 
  def markOrdersAsFailed(self, providerId, returnedOrders):
401 
    """
402 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
403 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 404 
 
1135 chandransh 405 
    Parameters:
406 
     - providerId
407 
     - returnedOrders
408 
    """
409 
    pass
410 
 
1246 chandransh 411 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
412 
    """
413 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 414 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 415 
 
1246 chandransh 416 
    Parameters:
417 
     - providerId
418 
     - undeliveredOrders
419 
    """
420 
    pass
421 
 
1408 ankur.sing 422 
  def getUndeliveredOrders(self, providerId, warehouseId):
423 
    """
424 
    Returns the list of orders whose delivery time has passed but have not been
425 
    delivered yet for the given provider and warehouse. To get a complete list of
426 
    undelivered orders, pass them as -1.
427 
    Returns an empty list if no such orders exist.
3431 rajveer 428 
 
1408 ankur.sing 429 
    Parameters:
430 
     - providerId
431 
     - warehouseId
432 
    """
433 
    pass
434 
 
4783 phani.kuma 435 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
436 
    """
437 
    Returns the list of orders whose expected delivery date has passed but have not been
438 
    delivered yet.
439 
    Returns an empty list if no such orders exist.
440 
    """
441 
    pass
442 
 
2536 chandransh 443 
  def toggleDOAFlag(self, orderId):
444 
    """
445 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
446 
    Returns the final flag status.
447 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 448 
 
2536 chandransh 449 
    Parameters:
450 
     - orderId
451 
    """
452 
    pass
1886 ankur.sing 453 
 
4712 rajveer 454 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
455 
    """
456 
    Parameters:
457 
     - orderId
458 
     - deliveryTimestamp
459 
     - receiver
460 
    """
461 
    pass
462 
 
4454 rajveer 463 
  def markOrderDoaRequestReceived(self, orderId):
464 
    """
465 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
466 
 
467 
    Parameters:
468 
     - orderId
469 
    """
470 
    pass
471 
 
472 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
473 
    """
474 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
475 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
476 
 
477 
    Parameters:
478 
     - orderId
479 
     - isAuthorized
480 
    """
481 
    pass
482 
 
4488 rajveer 483 
  def markOrderReturnRequestReceived(self, orderId):
484 
    """
485 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
486 
 
487 
    Parameters:
488 
     - orderId
489 
    """
490 
    pass
491 
 
492 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
493 
    """
494 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
495 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
496 
 
497 
    Parameters:
498 
     - orderId
499 
     - isAuthorized
500 
    """
501 
    pass
502 
 
4579 rajveer 503 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 504 
    """
505 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 506 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
507 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 508 
    For any other status, it returns false.
509 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 510 
 
2536 chandransh 511 
    Parameters:
512 
     - orderId
4579 rajveer 513 
     - providerId
2536 chandransh 514 
    """
515 
    pass
516 
 
4602 rajveer 517 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 518 
    """
4452 rajveer 519 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 520 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
521 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
522 
    	3. Returns true
2591 chandransh 523 
    If the order is in any other status, it returns false.
2536 chandransh 524 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 525 
 
2536 chandransh 526 
    Parameters:
527 
     - orderId
528 
     - pickupNumber
4602 rajveer 529 
     - providerId
2536 chandransh 530 
    """
531 
    pass
532 
 
2764 chandransh 533 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
534 
    """
535 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
536 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 537 
 
2764 chandransh 538 
    Parameters:
539 
     - providerId
540 
     - pickupDetails
541 
    """
542 
    pass
543 
 
4741 phani.kuma 544 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
545 
    """
546 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
547 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
548 
 
549 
    Parameters:
550 
     - providerId
551 
     - pickupDetails
552 
    """
553 
    pass
554 
 
4479 rajveer 555 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 556 
    """
4452 rajveer 557 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 558 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 559 
    If the order is in any other state, it returns false.
560 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 561 
 
2591 chandransh 562 
    Parameters:
563 
     - orderId
4479 rajveer 564 
     - receiveCondition
2591 chandransh 565 
    """
566 
    pass
2536 chandransh 567 
 
2591 chandransh 568 
  def validateDoa(self, orderId, isValid):
569 
    """
4452 rajveer 570 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 571 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 572 
    If the order is in any other state, it returns false.
573 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 574 
 
2591 chandransh 575 
    Parameters:
576 
     - orderId
577 
     - isValid
578 
    """
579 
    pass
580 
 
4495 rajveer 581 
  def validateReturnProduct(self, orderId, isUsable):
582 
    """
583 
    Parameters:
584 
     - orderId
585 
     - isUsable
586 
    """
587 
    pass
588 
 
2616 chandransh 589 
  def reshipOrder(self, orderId):
590 
    """
4484 rajveer 591 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 592 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 593 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 594 
 
595 
    If the order is in DOA_CERT_VALID state, it does the following:
596 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
597 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 598 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 599 
 
2616 chandransh 600 
    Returns the id of the newly created order.
3431 rajveer 601 
 
2616 chandransh 602 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 603 
 
2616 chandransh 604 
    Parameters:
605 
     - orderId
606 
    """
607 
    pass
2591 chandransh 608 
 
3226 chandransh 609 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 610 
    """
4484 rajveer 611 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 612 
    	1. Creates a refund request for batch processing.
613 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 614 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 615 
 
2616 chandransh 616 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
617 
    	1. Creates a refund request for batch processing.
3226 chandransh 618 
    	2. Cancels the reservation of the item in the warehouse.
619 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 620 
 
3226 chandransh 621 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
622 
    	1. Cancels the reservation of the item in the warehouse.
623 
    	2. Marks the current order as CANCELED.
624 
 
625 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
626 
 
2616 chandransh 627 
    Returns True if it is successful, False otherwise.
3431 rajveer 628 
 
2616 chandransh 629 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 630 
 
2616 chandransh 631 
    Parameters:
632 
     - orderId
3226 chandransh 633 
     - refundedBy
634 
     - reason
2616 chandransh 635 
    """
636 
    pass
637 
 
2690 chandransh 638 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
639 
    """
640 
    Get all return orders created between the from and to dates for the given warehouse.
641 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 642 
 
2690 chandransh 643 
    Parameters:
644 
     - warehouseId
645 
     - fromDate
646 
     - toDate
647 
    """
648 
    pass
2616 chandransh 649 
 
2700 chandransh 650 
  def getReturnOrder(self, id):
651 
    """
652 
    Returns the ReturnOrder corresponding to the given id.
653 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 654 
 
2700 chandransh 655 
    Parameters:
656 
     - id
657 
    """
658 
    pass
659 
 
2690 chandransh 660 
  def processReturn(self, returnOrderId):
661 
    """
662 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 663 
 
2690 chandransh 664 
    Parameters:
665 
     - returnOrderId
666 
    """
667 
    pass
668 
 
3451 chandransh 669 
  def updateWeight(self, orderId, weight):
670 
    """
671 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 672 
 
3451 chandransh 673 
    Parameters:
674 
     - orderId
675 
     - weight
676 
    """
677 
    pass
678 
 
3469 chandransh 679 
  def changeItem(self, orderId, itemId):
680 
    """
681 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
682 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 683 
 
3469 chandransh 684 
    Parameters:
685 
     - orderId
686 
     - itemId
687 
    """
688 
    pass
689 
 
690 
  def shiftToWarehouse(self, orderId, warehouseId):
691 
    """
692 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
693 
 
694 
    Parameters:
695 
     - orderId
696 
     - warehouseId
697 
    """
698 
    pass
699 
 
4647 rajveer 700 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 701 
    """
702 
    Adds the given delay reason to the given order.
3986 chandransh 703 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 704 
    Raises an exception if no order with the given id can be found.
3469 chandransh 705 
 
3553 chandransh 706 
    Parameters:
707 
     - orderId
708 
     - delayReason
3986 chandransh 709 
     - furtherDelay
4647 rajveer 710 
     - delayReasonText
3553 chandransh 711 
    """
712 
    pass
713 
 
3956 chandransh 714 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
715 
    """
716 
    Marks the COD orders with given AWB nos. as having been processed.
717 
    Updates the captured amount for the corresponding payment.
3553 chandransh 718 
 
3956 chandransh 719 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
720 
    1. There is no order corresponding to an AWB number.
721 
    2. The captured amount for a payment exceeds the total payment.
722 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
723 
 
724 
    Parameters:
725 
     - collectedAmountMap
726 
     - xferBy
727 
     - xferTxnId
728 
     - xferDate
729 
    """
730 
    pass
731 
 
4008 mandeep.dh 732 
  def getTransactionsRequiringExtraProcessing(self, category):
733 
    """
4065 mandeep.dh 734 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 735 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 736 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 737 
 
4008 mandeep.dh 738 
    Parameters:
739 
     - category
740 
    """
741 
    pass
742 
 
743 
  def markTransactionAsProcessed(self, transactionId, category):
744 
    """
745 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 746 
    It essentially deletes the transaction id record for a particular
747 
    processing type category (if present) from DB.
748 
    This is currently used by CRM application.
4008 mandeep.dh 749 
 
750 
    Parameters:
751 
     - transactionId
752 
     - category
753 
    """
754 
    pass
755 
 
4018 chandransh 756 
  def getItemWiseRiskyOrdersCount(self, ):
757 
    """
758 
    Returns a map containing the number of risky orders keyed by item id. A risky order
759 
    is defined as one whose shipping date is about to expire.
760 
    """
761 
    pass
4008 mandeep.dh 762 
 
4295 varun.gupt 763 
  def getOrdersForItemIds(self, itemIds):
764 
    """
765 
    Returns a list of all orders which have items with given id
766 
 
767 
    Parameters:
768 
     - itemIds
769 
    """
770 
    pass
771 
 
4247 rajveer 772 
  def markOrderCancellationRequestReceived(self, orderId):
773 
    """
774 
    Mark order as cancellation request received. If customer sends request of cancellation of
775 
    a particular order, this method will be called. It will just change status of the order
776 
    depending on its current status. It also records the previous status, so that we can move
777 
    back to that status if cancellation request is denied.
4018 chandransh 778 
 
4247 rajveer 779 
    Parameters:
780 
     - orderId
781 
    """
782 
    pass
783 
 
784 
  def markOrderCancellationRequestConfirmed(self, orderId):
785 
    """
786 
    If we decide to to cancel order, CRM will call this method to move the status of order to
787 
    cancellation request confirmed. After this OM will be able to cancel the order.
788 
 
789 
    Parameters:
790 
     - orderId
791 
    """
792 
    pass
793 
 
794 
  def markOrderCancellationRequestDenied(self, orderId):
795 
    """
796 
    If we decide to not to cancel order, we will move the order ro previous status.
797 
 
798 
    Parameters:
799 
     - orderId
800 
    """
801 
    pass
802 
 
4258 rajveer 803 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 804 
    """
4258 rajveer 805 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
806 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 807 
 
808 
    Parameters:
4258 rajveer 809 
     - transactionId
4247 rajveer 810 
    """
811 
    pass
812 
 
4259 anupam.sin 813 
  def refundTransaction(self, transactionId, refundedBy, reason):
814 
    """
815 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
816 
    need to be cancelled
4247 rajveer 817 
 
4259 anupam.sin 818 
    Parameters:
819 
     - transactionId
820 
     - refundedBy
821 
     - reason
822 
    """
823 
    pass
824 
 
4324 mandeep.dh 825 
  def updateShipmentAddress(self, orderId, addressId):
826 
    """
827 
    Updates shipment address of an order. Delivery and shipping date estimates
828 
    etc. are also updated here.
829 
 
830 
    Throws TransactionServiceException in case address change is not
831 
    possible due to certain reasons such as new pincode in address is
832 
    not serviceable etc.
833 
 
834 
    Parameters:
835 
     - orderId
836 
     - addressId
837 
    """
838 
    pass
839 
 
4285 rajveer 840 
  def acceptOrdersForItemId(self, itemId, inventory):
841 
    """
842 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
843 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 844 
 
4285 rajveer 845 
    Parameters:
846 
     - itemId
847 
     - inventory
848 
    """
849 
    pass
850 
 
4369 rajveer 851 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 852 
    """
853 
    Parameters:
854 
     - vendorId
855 
     - itemId
856 
     - quantity
857 
     - estimate
4369 rajveer 858 
     - isReminder
4303 rajveer 859 
    """
860 
    pass
4285 rajveer 861 
 
4369 rajveer 862 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 863 
    """
864 
    Parameters:
865 
     - vendorId
866 
     - itemId
867 
     - quantity
868 
     - estimate
4369 rajveer 869 
     - isReminder
4303 rajveer 870 
    """
871 
    pass
872 
 
4369 rajveer 873 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 874 
    """
875 
    Parameters:
876 
     - vendorId
877 
     - itemId
878 
     - quantity
879 
     - estimate
4369 rajveer 880 
     - isReminder
4303 rajveer 881 
    """
882 
    pass
883 
 
4369 rajveer 884 
  def markOrdersAsTimeout(self, vendorId):
885 
    """
886 
    Parameters:
887 
     - vendorId
888 
    """
889 
    pass
4303 rajveer 890 
 
4662 rajveer 891 
  def markOrderAsLostInTransit(self, orderId):
892 
    """
893 
    Mark order as LOST_IN_TRANSIT
894 
 
895 
    Parameters:
896 
     - orderId
897 
    """
898 
    pass
899 
 
4386 anupam.sin 900 
  def getOrderForAwb(self, awb):
901 
    """
902 
    Returns the order corresponding to an AWB number
4369 rajveer 903 
 
4386 anupam.sin 904 
    Parameters:
905 
     - awb
906 
    """
907 
    pass
908 
 
4506 phani.kuma 909 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
910 
    """
911 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 912 
 
4506 phani.kuma 913 
    Parameters:
914 
     - logistics_provider_id
915 
     - order_status
916 
    """
917 
    pass
918 
 
4600 varun.gupt 919 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
920 
    """
921 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 922 
 
4600 varun.gupt 923 
    Parameters:
924 
     - vendorId
925 
     - billingDateFrom
926 
     - billingDateTo
927 
    """
928 
    pass
929 
 
4607 rajveer 930 
  def getSlippedSippingDateOrders(self, ):
931 
    pass
932 
 
4709 rajveer 933 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
934 
    """
935 
    Parameters:
936 
     - cancelDateFrom
937 
     - cancelDateTo
938 
    """
939 
    pass
940 
 
4600 varun.gupt 941 
  def saveBluedartSettlements(self, mapAWBAndAmount):
942 
    """
943 
    Parameters:
944 
     - mapAWBAndAmount
945 
    """
946 
    pass
947 
 
948 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
949 
    """
950 
    Parameters:
951 
     - settlementDate
952 
     - paymentGatewayId
953 
     - paymentId
954 
     - serviceTax
955 
     - otherCharges
956 
     - netCollection
957 
    """
958 
    pass
959 
 
960 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
961 
    """
962 
    Parameters:
963 
     - settlementId
964 
     - settlementDate
965 
     - transactionDateFrom
966 
     - transactionDateTo
967 
     - amount
968 
    """
969 
    pass
970 
 
971 
  def getSettlementForPaymentId(self, paymentId):
972 
    """
973 
    Parameters:
974 
     - paymentId
975 
    """
976 
    pass
977 
 
978 
  def getEBSSettlementSummaries(self, ):
979 
    pass
980 
 
981 
  def markEBSSettlementUploaded(self, settlementId):
982 
    """
983 
    Parameters:
984 
     - settlementId
985 
    """
986 
    pass
987 
 
988 
  def getEBSSettlementDate(self, settlementId):
989 
    """
990 
    Parameters:
991 
     - settlementId
992 
    """
993 
    pass
994 
 
4715 varun.gupt 995 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
996 
    """
997 
    Parameters:
998 
     - settlementDateFrom
999 
     - settlementDateTo
1000 
     - isRefund
1001 
    """
1002 
    pass
4600 varun.gupt 1003 
 
4715 varun.gupt 1004 
  def getReshippedOrderIds(self, orderIds):
1005 
    """
1006 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1007 
 
1008 
    Parameters:
1009 
     - orderIds
1010 
    """
1011 
    pass
1012 
 
4757 mandeep.dh 1013 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
1014 
    """
1015 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
1016 
    the quantities for which the PO is raised.
4715 varun.gupt 1017 
 
4757 mandeep.dh 1018 
    Parameters:
1019 
     - itemIdQuantityMap
1020 
     - purchaseOrderId
1021 
     - warehouseId
1022 
    """
1023 
    pass
1024 
 
1025 
 
3376 rajveer 1026 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1027 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1028 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1029 
 
1030 
  def createTransaction(self, transaction):
1031 
    """
1032 
    Parameters:
1033 
     - transaction
1034 
    """
1035 
    self.send_createTransaction(transaction)
132 ashish 1036 
    return self.recv_createTransaction()
94 ashish 1037 
 
1038 
  def send_createTransaction(self, transaction):
1039 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1040 
    args = createTransaction_args()
1041 
    args.transaction = transaction
1042 
    args.write(self._oprot)
1043 
    self._oprot.writeMessageEnd()
1044 
    self._oprot.trans.flush()
1045 
 
1046 
  def recv_createTransaction(self, ):
1047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1048 
    if mtype == TMessageType.EXCEPTION:
1049 
      x = TApplicationException()
1050 
      x.read(self._iprot)
1051 
      self._iprot.readMessageEnd()
1052 
      raise x
1053 
    result = createTransaction_result()
1054 
    result.read(self._iprot)
1055 
    self._iprot.readMessageEnd()
3431 rajveer 1056 
    if result.success is not None:
132 ashish 1057 
      return result.success
3431 rajveer 1058 
    if result.ex is not None:
94 ashish 1059 
      raise result.ex
132 ashish 1060 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1061 
 
1062 
  def getTransaction(self, id):
1063 
    """
1064 
    Parameters:
1065 
     - id
1066 
    """
1067 
    self.send_getTransaction(id)
1068 
    return self.recv_getTransaction()
1069 
 
1070 
  def send_getTransaction(self, id):
1071 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1072 
    args = getTransaction_args()
1073 
    args.id = id
1074 
    args.write(self._oprot)
1075 
    self._oprot.writeMessageEnd()
1076 
    self._oprot.trans.flush()
1077 
 
1078 
  def recv_getTransaction(self, ):
1079 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1080 
    if mtype == TMessageType.EXCEPTION:
1081 
      x = TApplicationException()
1082 
      x.read(self._iprot)
1083 
      self._iprot.readMessageEnd()
1084 
      raise x
1085 
    result = getTransaction_result()
1086 
    result.read(self._iprot)
1087 
    self._iprot.readMessageEnd()
3431 rajveer 1088 
    if result.success is not None:
94 ashish 1089 
      return result.success
3431 rajveer 1090 
    if result.ex is not None:
94 ashish 1091 
      raise result.ex
1092 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1093 
 
1094 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1095 
    """
1096 
    Parameters:
1097 
     - customerId
1098 
     - from_date
1099 
     - to_date
1100 
     - status
1101 
    """
1102 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1103 
    return self.recv_getTransactionsForCustomer()
1104 
 
1105 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1106 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1107 
    args = getTransactionsForCustomer_args()
1108 
    args.customerId = customerId
1109 
    args.from_date = from_date
1110 
    args.to_date = to_date
1111 
    args.status = status
1112 
    args.write(self._oprot)
1113 
    self._oprot.writeMessageEnd()
1114 
    self._oprot.trans.flush()
1115 
 
1116 
  def recv_getTransactionsForCustomer(self, ):
1117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1118 
    if mtype == TMessageType.EXCEPTION:
1119 
      x = TApplicationException()
1120 
      x.read(self._iprot)
1121 
      self._iprot.readMessageEnd()
1122 
      raise x
1123 
    result = getTransactionsForCustomer_result()
1124 
    result.read(self._iprot)
1125 
    self._iprot.readMessageEnd()
3431 rajveer 1126 
    if result.success is not None:
94 ashish 1127 
      return result.success
3431 rajveer 1128 
    if result.ex is not None:
94 ashish 1129 
      raise result.ex
1130 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1131 
 
132 ashish 1132 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1133 
    """
1134 
    Parameters:
1135 
     - shoppingCartId
1136 
    """
1137 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1138 
    return self.recv_getTransactionsForShoppingCartId()
1139 
 
1140 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1141 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1142 
    args = getTransactionsForShoppingCartId_args()
1143 
    args.shoppingCartId = shoppingCartId
1144 
    args.write(self._oprot)
1145 
    self._oprot.writeMessageEnd()
1146 
    self._oprot.trans.flush()
1147 
 
1148 
  def recv_getTransactionsForShoppingCartId(self, ):
1149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1150 
    if mtype == TMessageType.EXCEPTION:
1151 
      x = TApplicationException()
1152 
      x.read(self._iprot)
1153 
      self._iprot.readMessageEnd()
1154 
      raise x
1155 
    result = getTransactionsForShoppingCartId_result()
1156 
    result.read(self._iprot)
1157 
    self._iprot.readMessageEnd()
3431 rajveer 1158 
    if result.success is not None:
132 ashish 1159 
      return result.success
3431 rajveer 1160 
    if result.ex is not None:
132 ashish 1161 
      raise result.ex
1162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1163 
 
94 ashish 1164 
  def getTransactionStatus(self, transactionId):
1165 
    """
1166 
    Parameters:
1167 
     - transactionId
1168 
    """
1169 
    self.send_getTransactionStatus(transactionId)
1170 
    return self.recv_getTransactionStatus()
1171 
 
1172 
  def send_getTransactionStatus(self, transactionId):
1173 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1174 
    args = getTransactionStatus_args()
1175 
    args.transactionId = transactionId
1176 
    args.write(self._oprot)
1177 
    self._oprot.writeMessageEnd()
1178 
    self._oprot.trans.flush()
1179 
 
1180 
  def recv_getTransactionStatus(self, ):
1181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1182 
    if mtype == TMessageType.EXCEPTION:
1183 
      x = TApplicationException()
1184 
      x.read(self._iprot)
1185 
      self._iprot.readMessageEnd()
1186 
      raise x
1187 
    result = getTransactionStatus_result()
1188 
    result.read(self._iprot)
1189 
    self._iprot.readMessageEnd()
3431 rajveer 1190 
    if result.success is not None:
94 ashish 1191 
      return result.success
3431 rajveer 1192 
    if result.ex is not None:
94 ashish 1193 
      raise result.ex
1194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1195 
 
1196 
  def changeTransactionStatus(self, transactionId, status, description):
1197 
    """
1198 
    Parameters:
1199 
     - transactionId
1200 
     - status
1201 
     - description
1202 
    """
1203 
    self.send_changeTransactionStatus(transactionId, status, description)
1204 
    return self.recv_changeTransactionStatus()
1205 
 
1206 
  def send_changeTransactionStatus(self, transactionId, status, description):
1207 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1208 
    args = changeTransactionStatus_args()
1209 
    args.transactionId = transactionId
1210 
    args.status = status
1211 
    args.description = description
1212 
    args.write(self._oprot)
1213 
    self._oprot.writeMessageEnd()
1214 
    self._oprot.trans.flush()
1215 
 
1216 
  def recv_changeTransactionStatus(self, ):
1217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1218 
    if mtype == TMessageType.EXCEPTION:
1219 
      x = TApplicationException()
1220 
      x.read(self._iprot)
1221 
      self._iprot.readMessageEnd()
1222 
      raise x
1223 
    result = changeTransactionStatus_result()
1224 
    result.read(self._iprot)
1225 
    self._iprot.readMessageEnd()
3431 rajveer 1226 
    if result.success is not None:
94 ashish 1227 
      return result.success
3431 rajveer 1228 
    if result.ex is not None:
94 ashish 1229 
      raise result.ex
1230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1231 
 
1398 varun.gupt 1232 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1233 
    """
1234 
    Parameters:
1235 
     - transactionId
1236 
    """
1398 varun.gupt 1237 
    self.send_enqueueTransactionInfoEmail(transactionId)
1238 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1239 
 
1398 varun.gupt 1240 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1241 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1242 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1243 
    args.transactionId = transactionId
1244 
    args.write(self._oprot)
1245 
    self._oprot.writeMessageEnd()
1246 
    self._oprot.trans.flush()
1247 
 
1398 varun.gupt 1248 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1250 
    if mtype == TMessageType.EXCEPTION:
1251 
      x = TApplicationException()
1252 
      x.read(self._iprot)
1253 
      self._iprot.readMessageEnd()
1254 
      raise x
1398 varun.gupt 1255 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1256 
    result.read(self._iprot)
1257 
    self._iprot.readMessageEnd()
3431 rajveer 1258 
    if result.success is not None:
1382 varun.gupt 1259 
      return result.success
3431 rajveer 1260 
    if result.ex is not None:
1382 varun.gupt 1261 
      raise result.ex
1398 varun.gupt 1262 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1263 
 
483 rajveer 1264 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1265 
    """
1266 
    Parameters:
483 rajveer 1267 
     - status
1268 
     - from_date
1269 
     - to_date
1270 
     - warehouse_id
94 ashish 1271 
    """
483 rajveer 1272 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1273 
    return self.recv_getAllOrders()
94 ashish 1274 
 
483 rajveer 1275 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1276 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1277 
    args = getAllOrders_args()
1278 
    args.status = status
1279 
    args.from_date = from_date
1280 
    args.to_date = to_date
1281 
    args.warehouse_id = warehouse_id
94 ashish 1282 
    args.write(self._oprot)
1283 
    self._oprot.writeMessageEnd()
1284 
    self._oprot.trans.flush()
1285 
 
483 rajveer 1286 
  def recv_getAllOrders(self, ):
94 ashish 1287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1288 
    if mtype == TMessageType.EXCEPTION:
1289 
      x = TApplicationException()
1290 
      x.read(self._iprot)
1291 
      self._iprot.readMessageEnd()
1292 
      raise x
483 rajveer 1293 
    result = getAllOrders_result()
94 ashish 1294 
    result.read(self._iprot)
1295 
    self._iprot.readMessageEnd()
3431 rajveer 1296 
    if result.success is not None:
94 ashish 1297 
      return result.success
3431 rajveer 1298 
    if result.ex is not None:
94 ashish 1299 
      raise result.ex
483 rajveer 1300 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1301 
 
4133 chandransh 1302 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1303 
    """
1304 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1305 
    Pass the status as null and the limit as 0 to ignore them.
1306 
 
1307 
    Parameters:
1308 
     - statuses
1309 
     - offset
1310 
     - limit
1311 
     - warehouse_id
1312 
    """
1313 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1314 
    return self.recv_getOrdersInBatch()
1315 
 
1316 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1317 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1318 
    args = getOrdersInBatch_args()
1319 
    args.statuses = statuses
1320 
    args.offset = offset
1321 
    args.limit = limit
1322 
    args.warehouse_id = warehouse_id
1323 
    args.write(self._oprot)
1324 
    self._oprot.writeMessageEnd()
1325 
    self._oprot.trans.flush()
1326 
 
1327 
  def recv_getOrdersInBatch(self, ):
1328 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1329 
    if mtype == TMessageType.EXCEPTION:
1330 
      x = TApplicationException()
1331 
      x.read(self._iprot)
1332 
      self._iprot.readMessageEnd()
1333 
      raise x
1334 
    result = getOrdersInBatch_result()
1335 
    result.read(self._iprot)
1336 
    self._iprot.readMessageEnd()
1337 
    if result.success is not None:
1338 
      return result.success
1339 
    if result.ex is not None:
1340 
      raise result.ex
1341 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1342 
 
1343 
  def getOrderCount(self, statuses, warehouseId):
1344 
    """
1345 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1346 
 
1347 
    Parameters:
1348 
     - statuses
1349 
     - warehouseId
1350 
    """
1351 
    self.send_getOrderCount(statuses, warehouseId)
1352 
    return self.recv_getOrderCount()
1353 
 
1354 
  def send_getOrderCount(self, statuses, warehouseId):
1355 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1356 
    args = getOrderCount_args()
1357 
    args.statuses = statuses
1358 
    args.warehouseId = warehouseId
1359 
    args.write(self._oprot)
1360 
    self._oprot.writeMessageEnd()
1361 
    self._oprot.trans.flush()
1362 
 
1363 
  def recv_getOrderCount(self, ):
1364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1365 
    if mtype == TMessageType.EXCEPTION:
1366 
      x = TApplicationException()
1367 
      x.read(self._iprot)
1368 
      self._iprot.readMessageEnd()
1369 
      raise x
1370 
    result = getOrderCount_result()
1371 
    result.read(self._iprot)
1372 
    self._iprot.readMessageEnd()
1373 
    if result.success is not None:
1374 
      return result.success
1375 
    if result.ex is not None:
1376 
      raise result.ex
1377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1378 
 
999 varun.gupt 1379 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1380 
    """
1132 chandransh 1381 
    Returns orders within a range of their billing dates
3431 rajveer 1382 
 
999 varun.gupt 1383 
    Parameters:
1384 
     - status
1385 
     - start_billing_date
1386 
     - end_billing_date
1387 
     - warehouse_id
1388 
    """
1389 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1390 
    return self.recv_getOrdersByBillingDate()
1391 
 
1392 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1393 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1394 
    args = getOrdersByBillingDate_args()
1395 
    args.status = status
1396 
    args.start_billing_date = start_billing_date
1397 
    args.end_billing_date = end_billing_date
1398 
    args.warehouse_id = warehouse_id
1399 
    args.write(self._oprot)
1400 
    self._oprot.writeMessageEnd()
1401 
    self._oprot.trans.flush()
1402 
 
1403 
  def recv_getOrdersByBillingDate(self, ):
1404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1405 
    if mtype == TMessageType.EXCEPTION:
1406 
      x = TApplicationException()
1407 
      x.read(self._iprot)
1408 
      self._iprot.readMessageEnd()
1409 
      raise x
1410 
    result = getOrdersByBillingDate_result()
1411 
    result.read(self._iprot)
1412 
    self._iprot.readMessageEnd()
3431 rajveer 1413 
    if result.success is not None:
999 varun.gupt 1414 
      return result.success
3431 rajveer 1415 
    if result.ex is not None:
999 varun.gupt 1416 
      raise result.ex
1417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1418 
 
3451 chandransh 1419 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1420 
    """
1421 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1422 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1423 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1424 
 
3427 chandransh 1425 
    Parameters:
1426 
     - fromShippingDate
1427 
     - toShippingDate
1428 
     - providerId
1429 
     - warehouseId
3451 chandransh 1430 
     - cod
3427 chandransh 1431 
    """
3451 chandransh 1432 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1433 
    return self.recv_getOrdersByShippingDate()
1434 
 
3451 chandransh 1435 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1436 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1437 
    args = getOrdersByShippingDate_args()
1438 
    args.fromShippingDate = fromShippingDate
1439 
    args.toShippingDate = toShippingDate
1440 
    args.providerId = providerId
1441 
    args.warehouseId = warehouseId
3451 chandransh 1442 
    args.cod = cod
3427 chandransh 1443 
    args.write(self._oprot)
1444 
    self._oprot.writeMessageEnd()
1445 
    self._oprot.trans.flush()
1446 
 
1447 
  def recv_getOrdersByShippingDate(self, ):
1448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1449 
    if mtype == TMessageType.EXCEPTION:
1450 
      x = TApplicationException()
1451 
      x.read(self._iprot)
1452 
      self._iprot.readMessageEnd()
1453 
      raise x
1454 
    result = getOrdersByShippingDate_result()
1455 
    result.read(self._iprot)
1456 
    self._iprot.readMessageEnd()
3431 rajveer 1457 
    if result.success is not None:
3427 chandransh 1458 
      return result.success
3431 rajveer 1459 
    if result.ex is not None:
3427 chandransh 1460 
      raise result.ex
1461 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1462 
 
1382 varun.gupt 1463 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1464 
    """
1465 
    Returns order ids for orders which can be returned
3431 rajveer 1466 
 
1382 varun.gupt 1467 
    Parameters:
1468 
     - customer_id
1469 
     - limit
1470 
    """
1471 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1472 
    return self.recv_getReturnableOrdersForCustomer()
1473 
 
1474 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1475 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1476 
    args = getReturnableOrdersForCustomer_args()
1477 
    args.customer_id = customer_id
1478 
    args.limit = limit
1479 
    args.write(self._oprot)
1480 
    self._oprot.writeMessageEnd()
1481 
    self._oprot.trans.flush()
1482 
 
1483 
  def recv_getReturnableOrdersForCustomer(self, ):
1484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1485 
    if mtype == TMessageType.EXCEPTION:
1486 
      x = TApplicationException()
1487 
      x.read(self._iprot)
1488 
      self._iprot.readMessageEnd()
1489 
      raise x
1490 
    result = getReturnableOrdersForCustomer_result()
1491 
    result.read(self._iprot)
1492 
    self._iprot.readMessageEnd()
3431 rajveer 1493 
    if result.success is not None:
1382 varun.gupt 1494 
      return result.success
3431 rajveer 1495 
    if result.ex is not None:
1382 varun.gupt 1496 
      raise result.ex
1497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1498 
 
1499 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1500 
    """
1501 
    Returns order ids for orders which can be cancelled
3431 rajveer 1502 
 
1382 varun.gupt 1503 
    Parameters:
1504 
     - customer_id
1505 
     - limit
1506 
    """
1507 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1508 
    return self.recv_getCancellableOrdersForCustomer()
1509 
 
1510 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1511 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1512 
    args = getCancellableOrdersForCustomer_args()
1513 
    args.customer_id = customer_id
1514 
    args.limit = limit
1515 
    args.write(self._oprot)
1516 
    self._oprot.writeMessageEnd()
1517 
    self._oprot.trans.flush()
1518 
 
1519 
  def recv_getCancellableOrdersForCustomer(self, ):
1520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1521 
    if mtype == TMessageType.EXCEPTION:
1522 
      x = TApplicationException()
1523 
      x.read(self._iprot)
1524 
      self._iprot.readMessageEnd()
1525 
      raise x
1526 
    result = getCancellableOrdersForCustomer_result()
1527 
    result.read(self._iprot)
1528 
    self._iprot.readMessageEnd()
3431 rajveer 1529 
    if result.success is not None:
1382 varun.gupt 1530 
      return result.success
3431 rajveer 1531 
    if result.ex is not None:
1382 varun.gupt 1532 
      raise result.ex
1533 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1534 
 
483 rajveer 1535 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1536 
    """
1537 
    Parameters:
483 rajveer 1538 
     - orderId
1539 
     - status
1540 
     - description
94 ashish 1541 
    """
483 rajveer 1542 
    self.send_changeOrderStatus(orderId, status, description)
1543 
    return self.recv_changeOrderStatus()
94 ashish 1544 
 
483 rajveer 1545 
  def send_changeOrderStatus(self, orderId, status, description):
1546 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1547 
    args = changeOrderStatus_args()
1548 
    args.orderId = orderId
1549 
    args.status = status
1550 
    args.description = description
94 ashish 1551 
    args.write(self._oprot)
1552 
    self._oprot.writeMessageEnd()
1553 
    self._oprot.trans.flush()
1554 
 
483 rajveer 1555 
  def recv_changeOrderStatus(self, ):
94 ashish 1556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1557 
    if mtype == TMessageType.EXCEPTION:
1558 
      x = TApplicationException()
1559 
      x.read(self._iprot)
1560 
      self._iprot.readMessageEnd()
1561 
      raise x
483 rajveer 1562 
    result = changeOrderStatus_result()
94 ashish 1563 
    result.read(self._iprot)
1564 
    self._iprot.readMessageEnd()
3431 rajveer 1565 
    if result.success is not None:
94 ashish 1566 
      return result.success
3431 rajveer 1567 
    if result.ex is not None:
94 ashish 1568 
      raise result.ex
483 rajveer 1569 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1570 
 
1528 ankur.sing 1571 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1572 
    """
1528 ankur.sing 1573 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1574 
    only user who owns the transaction can view its order details.
3431 rajveer 1575 
 
94 ashish 1576 
    Parameters:
1577 
     - transactionId
1528 ankur.sing 1578 
     - customerId
94 ashish 1579 
    """
1528 ankur.sing 1580 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1581 
    return self.recv_getOrdersForTransaction()
94 ashish 1582 
 
1528 ankur.sing 1583 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1584 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1585 
    args = getOrdersForTransaction_args()
94 ashish 1586 
    args.transactionId = transactionId
1528 ankur.sing 1587 
    args.customerId = customerId
94 ashish 1588 
    args.write(self._oprot)
1589 
    self._oprot.writeMessageEnd()
1590 
    self._oprot.trans.flush()
1591 
 
483 rajveer 1592 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1594 
    if mtype == TMessageType.EXCEPTION:
1595 
      x = TApplicationException()
1596 
      x.read(self._iprot)
1597 
      self._iprot.readMessageEnd()
1598 
      raise x
483 rajveer 1599 
    result = getOrdersForTransaction_result()
94 ashish 1600 
    result.read(self._iprot)
1601 
    self._iprot.readMessageEnd()
3431 rajveer 1602 
    if result.success is not None:
94 ashish 1603 
      return result.success
3431 rajveer 1604 
    if result.ex is not None:
94 ashish 1605 
      raise result.ex
483 rajveer 1606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1607 
 
3014 chandransh 1608 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1609 
    """
3014 chandransh 1610 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1611 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1612 
 
94 ashish 1613 
    Parameters:
483 rajveer 1614 
     - customerId
1615 
     - from_date
1616 
     - to_date
3014 chandransh 1617 
     - statuses
94 ashish 1618 
    """
3014 chandransh 1619 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1620 
    return self.recv_getOrdersForCustomer()
94 ashish 1621 
 
3014 chandransh 1622 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1623 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1624 
    args = getOrdersForCustomer_args()
1625 
    args.customerId = customerId
1626 
    args.from_date = from_date
1627 
    args.to_date = to_date
3014 chandransh 1628 
    args.statuses = statuses
94 ashish 1629 
    args.write(self._oprot)
1630 
    self._oprot.writeMessageEnd()
1631 
    self._oprot.trans.flush()
1632 
 
483 rajveer 1633 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1635 
    if mtype == TMessageType.EXCEPTION:
1636 
      x = TApplicationException()
1637 
      x.read(self._iprot)
1638 
      self._iprot.readMessageEnd()
1639 
      raise x
483 rajveer 1640 
    result = getOrdersForCustomer_result()
94 ashish 1641 
    result.read(self._iprot)
1642 
    self._iprot.readMessageEnd()
3431 rajveer 1643 
    if result.success is not None:
94 ashish 1644 
      return result.success
3431 rajveer 1645 
    if result.ex is not None:
94 ashish 1646 
      raise result.ex
483 rajveer 1647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1648 
 
483 rajveer 1649 
  def createOrder(self, order):
94 ashish 1650 
    """
1651 
    Parameters:
483 rajveer 1652 
     - order
94 ashish 1653 
    """
483 rajveer 1654 
    self.send_createOrder(order)
1655 
    return self.recv_createOrder()
94 ashish 1656 
 
483 rajveer 1657 
  def send_createOrder(self, order):
1658 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1659 
    args = createOrder_args()
1660 
    args.order = order
94 ashish 1661 
    args.write(self._oprot)
1662 
    self._oprot.writeMessageEnd()
1663 
    self._oprot.trans.flush()
1664 
 
483 rajveer 1665 
  def recv_createOrder(self, ):
94 ashish 1666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1667 
    if mtype == TMessageType.EXCEPTION:
1668 
      x = TApplicationException()
1669 
      x.read(self._iprot)
1670 
      self._iprot.readMessageEnd()
1671 
      raise x
483 rajveer 1672 
    result = createOrder_result()
94 ashish 1673 
    result.read(self._iprot)
1674 
    self._iprot.readMessageEnd()
3431 rajveer 1675 
    if result.success is not None:
94 ashish 1676 
      return result.success
3431 rajveer 1677 
    if result.ex is not None:
94 ashish 1678 
      raise result.ex
483 rajveer 1679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1680 
 
483 rajveer 1681 
  def getOrder(self, id):
94 ashish 1682 
    """
1683 
    Parameters:
483 rajveer 1684 
     - id
94 ashish 1685 
    """
483 rajveer 1686 
    self.send_getOrder(id)
1687 
    return self.recv_getOrder()
94 ashish 1688 
 
483 rajveer 1689 
  def send_getOrder(self, id):
1690 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1691 
    args = getOrder_args()
1692 
    args.id = id
94 ashish 1693 
    args.write(self._oprot)
1694 
    self._oprot.writeMessageEnd()
1695 
    self._oprot.trans.flush()
1696 
 
483 rajveer 1697 
  def recv_getOrder(self, ):
94 ashish 1698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1699 
    if mtype == TMessageType.EXCEPTION:
1700 
      x = TApplicationException()
1701 
      x.read(self._iprot)
1702 
      self._iprot.readMessageEnd()
1703 
      raise x
483 rajveer 1704 
    result = getOrder_result()
94 ashish 1705 
    result.read(self._iprot)
1706 
    self._iprot.readMessageEnd()
3431 rajveer 1707 
    if result.success is not None:
94 ashish 1708 
      return result.success
3431 rajveer 1709 
    if result.ex is not None:
94 ashish 1710 
      raise result.ex
483 rajveer 1711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1712 
 
483 rajveer 1713 
  def getLineItemsForOrder(self, orderId):
94 ashish 1714 
    """
1715 
    Parameters:
483 rajveer 1716 
     - orderId
94 ashish 1717 
    """
483 rajveer 1718 
    self.send_getLineItemsForOrder(orderId)
1719 
    return self.recv_getLineItemsForOrder()
94 ashish 1720 
 
483 rajveer 1721 
  def send_getLineItemsForOrder(self, orderId):
1722 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1723 
    args = getLineItemsForOrder_args()
1724 
    args.orderId = orderId
94 ashish 1725 
    args.write(self._oprot)
1726 
    self._oprot.writeMessageEnd()
1727 
    self._oprot.trans.flush()
1728 
 
483 rajveer 1729 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1731 
    if mtype == TMessageType.EXCEPTION:
1732 
      x = TApplicationException()
1733 
      x.read(self._iprot)
1734 
      self._iprot.readMessageEnd()
1735 
      raise x
483 rajveer 1736 
    result = getLineItemsForOrder_result()
94 ashish 1737 
    result.read(self._iprot)
1738 
    self._iprot.readMessageEnd()
3431 rajveer 1739 
    if result.success is not None:
94 ashish 1740 
      return result.success
3431 rajveer 1741 
    if result.ex is not None:
94 ashish 1742 
      raise result.ex
483 rajveer 1743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1744 
 
1528 ankur.sing 1745 
  def getOrderForCustomer(self, orderId, customerId):
1746 
    """
1747 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1748 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1749 
 
1528 ankur.sing 1750 
    Parameters:
1751 
     - orderId
1752 
     - customerId
1753 
    """
1754 
    self.send_getOrderForCustomer(orderId, customerId)
1755 
    return self.recv_getOrderForCustomer()
1756 
 
1757 
  def send_getOrderForCustomer(self, orderId, customerId):
1758 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1759 
    args = getOrderForCustomer_args()
1760 
    args.orderId = orderId
1761 
    args.customerId = customerId
1762 
    args.write(self._oprot)
1763 
    self._oprot.writeMessageEnd()
1764 
    self._oprot.trans.flush()
1765 
 
1766 
  def recv_getOrderForCustomer(self, ):
1767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1768 
    if mtype == TMessageType.EXCEPTION:
1769 
      x = TApplicationException()
1770 
      x.read(self._iprot)
1771 
      self._iprot.readMessageEnd()
1772 
      raise x
1773 
    result = getOrderForCustomer_result()
1774 
    result.read(self._iprot)
1775 
    self._iprot.readMessageEnd()
3431 rajveer 1776 
    if result.success is not None:
1528 ankur.sing 1777 
      return result.success
3431 rajveer 1778 
    if result.ex is not None:
1528 ankur.sing 1779 
      raise result.ex
1780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1781 
 
4444 rajveer 1782 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1783 
    """
1784 
    Parameters:
4394 rajveer 1785 
     - type
4444 rajveer 1786 
     - warehouseId
4394 rajveer 1787 
     - status
1788 
     - timestamp
3064 chandransh 1789 
    """
4444 rajveer 1790 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1791 
    return self.recv_getAlerts()
1792 
 
4444 rajveer 1793 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1794 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1795 
    args = getAlerts_args()
4394 rajveer 1796 
    args.type = type
4444 rajveer 1797 
    args.warehouseId = warehouseId
4394 rajveer 1798 
    args.status = status
1799 
    args.timestamp = timestamp
3064 chandransh 1800 
    args.write(self._oprot)
1801 
    self._oprot.writeMessageEnd()
1802 
    self._oprot.trans.flush()
1803 
 
1804 
  def recv_getAlerts(self, ):
1805 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1806 
    if mtype == TMessageType.EXCEPTION:
1807 
      x = TApplicationException()
1808 
      x.read(self._iprot)
1809 
      self._iprot.readMessageEnd()
1810 
      raise x
1811 
    result = getAlerts_result()
1812 
    result.read(self._iprot)
1813 
    self._iprot.readMessageEnd()
3431 rajveer 1814 
    if result.success is not None:
3064 chandransh 1815 
      return result.success
1816 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1817 
 
4444 rajveer 1818 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1819 
    """
1820 
    Parameters:
1821 
     - type
4444 rajveer 1822 
     - warehouseId
4394 rajveer 1823 
     - description
3064 chandransh 1824 
    """
4444 rajveer 1825 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1826 
    self.recv_addAlert()
3064 chandransh 1827 
 
4444 rajveer 1828 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1829 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1830 
    args = addAlert_args()
3064 chandransh 1831 
    args.type = type
4444 rajveer 1832 
    args.warehouseId = warehouseId
4394 rajveer 1833 
    args.description = description
3064 chandransh 1834 
    args.write(self._oprot)
1835 
    self._oprot.writeMessageEnd()
1836 
    self._oprot.trans.flush()
1837 
 
4394 rajveer 1838 
  def recv_addAlert(self, ):
3064 chandransh 1839 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1840 
    if mtype == TMessageType.EXCEPTION:
1841 
      x = TApplicationException()
1842 
      x.read(self._iprot)
1843 
      self._iprot.readMessageEnd()
1844 
      raise x
4394 rajveer 1845 
    result = addAlert_result()
3064 chandransh 1846 
    result.read(self._iprot)
1847 
    self._iprot.readMessageEnd()
1848 
    return
1849 
 
4444 rajveer 1850 
  def markAlertsAsSeen(self, warehouseId):
1851 
    """
1852 
    Parameters:
1853 
     - warehouseId
1854 
    """
1855 
    self.send_markAlertsAsSeen(warehouseId)
1856 
    self.recv_markAlertsAsSeen()
1857 
 
1858 
  def send_markAlertsAsSeen(self, warehouseId):
1859 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1860 
    args = markAlertsAsSeen_args()
1861 
    args.warehouseId = warehouseId
1862 
    args.write(self._oprot)
1863 
    self._oprot.writeMessageEnd()
1864 
    self._oprot.trans.flush()
1865 
 
1866 
  def recv_markAlertsAsSeen(self, ):
1867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1868 
    if mtype == TMessageType.EXCEPTION:
1869 
      x = TApplicationException()
1870 
      x.read(self._iprot)
1871 
      self._iprot.readMessageEnd()
1872 
      raise x
1873 
    result = markAlertsAsSeen_result()
1874 
    result.read(self._iprot)
1875 
    self._iprot.readMessageEnd()
1876 
    return
1877 
 
3064 chandransh 1878 
  def getValidOrderCount(self, ):
1879 
    """
1880 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1881 
    """
1882 
    self.send_getValidOrderCount()
1883 
    return self.recv_getValidOrderCount()
1884 
 
1885 
  def send_getValidOrderCount(self, ):
1886 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1887 
    args = getValidOrderCount_args()
1888 
    args.write(self._oprot)
1889 
    self._oprot.writeMessageEnd()
1890 
    self._oprot.trans.flush()
1891 
 
1892 
  def recv_getValidOrderCount(self, ):
1893 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1894 
    if mtype == TMessageType.EXCEPTION:
1895 
      x = TApplicationException()
1896 
      x.read(self._iprot)
1897 
      self._iprot.readMessageEnd()
1898 
      raise x
1899 
    result = getValidOrderCount_result()
1900 
    result.read(self._iprot)
1901 
    self._iprot.readMessageEnd()
3431 rajveer 1902 
    if result.success is not None:
3064 chandransh 1903 
      return result.success
1904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1905 
 
1906 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1907 
    """
1908 
    Returns the number of distinct customers who have done successful transactions
1909 
    """
1910 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1911 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1912 
 
1913 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1914 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1915 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1916 
    args.write(self._oprot)
1917 
    self._oprot.writeMessageEnd()
1918 
    self._oprot.trans.flush()
1919 
 
1920 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1922 
    if mtype == TMessageType.EXCEPTION:
1923 
      x = TApplicationException()
1924 
      x.read(self._iprot)
1925 
      self._iprot.readMessageEnd()
1926 
      raise x
1927 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1928 
    result.read(self._iprot)
1929 
    self._iprot.readMessageEnd()
3431 rajveer 1930 
    if result.success is not None:
3064 chandransh 1931 
      return result.success
1932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1933 
 
1934 
  def getValidOrdersAmountRange(self, ):
1935 
    """
1936 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1937 
    List contains two values, first minimum amount and second maximum amount.
1938 
    """
1939 
    self.send_getValidOrdersAmountRange()
1940 
    return self.recv_getValidOrdersAmountRange()
1941 
 
1942 
  def send_getValidOrdersAmountRange(self, ):
1943 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1944 
    args = getValidOrdersAmountRange_args()
1945 
    args.write(self._oprot)
1946 
    self._oprot.writeMessageEnd()
1947 
    self._oprot.trans.flush()
1948 
 
1949 
  def recv_getValidOrdersAmountRange(self, ):
1950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1951 
    if mtype == TMessageType.EXCEPTION:
1952 
      x = TApplicationException()
1953 
      x.read(self._iprot)
1954 
      self._iprot.readMessageEnd()
1955 
      raise x
1956 
    result = getValidOrdersAmountRange_result()
1957 
    result.read(self._iprot)
1958 
    self._iprot.readMessageEnd()
3431 rajveer 1959 
    if result.success is not None:
3064 chandransh 1960 
      return result.success
1961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1962 
 
1963 
  def getValidOrders(self, limit):
1964 
    """
1965 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1966 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1967 
 
3064 chandransh 1968 
    Parameters:
1969 
     - limit
1970 
    """
1971 
    self.send_getValidOrders(limit)
1972 
    return self.recv_getValidOrders()
1973 
 
1974 
  def send_getValidOrders(self, limit):
1975 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1976 
    args = getValidOrders_args()
1977 
    args.limit = limit
1978 
    args.write(self._oprot)
1979 
    self._oprot.writeMessageEnd()
1980 
    self._oprot.trans.flush()
1981 
 
1982 
  def recv_getValidOrders(self, ):
1983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1984 
    if mtype == TMessageType.EXCEPTION:
1985 
      x = TApplicationException()
1986 
      x.read(self._iprot)
1987 
      self._iprot.readMessageEnd()
1988 
      raise x
1989 
    result = getValidOrders_result()
1990 
    result.read(self._iprot)
1991 
    self._iprot.readMessageEnd()
3431 rajveer 1992 
    if result.success is not None:
3064 chandransh 1993 
      return result.success
1994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1995 
 
1220 chandransh 1996 
  def batchOrders(self, warehouseId):
1997 
    """
1998 
    Create a batch of all the pending orders for the given warehouse.
1999 
    The returned list is orderd by created_timestamp.
2000 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2001 
 
1220 chandransh 2002 
    Parameters:
2003 
     - warehouseId
2004 
    """
2005 
    self.send_batchOrders(warehouseId)
2006 
    return self.recv_batchOrders()
2007 
 
2008 
  def send_batchOrders(self, warehouseId):
2009 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2010 
    args = batchOrders_args()
2011 
    args.warehouseId = warehouseId
2012 
    args.write(self._oprot)
2013 
    self._oprot.writeMessageEnd()
2014 
    self._oprot.trans.flush()
2015 
 
2016 
  def recv_batchOrders(self, ):
2017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2018 
    if mtype == TMessageType.EXCEPTION:
2019 
      x = TApplicationException()
2020 
      x.read(self._iprot)
2021 
      self._iprot.readMessageEnd()
2022 
      raise x
2023 
    result = batchOrders_result()
2024 
    result.read(self._iprot)
2025 
    self._iprot.readMessageEnd()
3431 rajveer 2026 
    if result.success is not None:
1220 chandransh 2027 
      return result.success
3431 rajveer 2028 
    if result.ex is not None:
1220 chandransh 2029 
      raise result.ex
2030 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2031 
 
1208 chandransh 2032 
  def markOrderAsOutOfStock(self, orderId):
2033 
    """
2034 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2035 
 
1208 chandransh 2036 
    Parameters:
2037 
     - orderId
2038 
    """
2039 
    self.send_markOrderAsOutOfStock(orderId)
2040 
    return self.recv_markOrderAsOutOfStock()
2041 
 
2042 
  def send_markOrderAsOutOfStock(self, orderId):
2043 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2044 
    args = markOrderAsOutOfStock_args()
2045 
    args.orderId = orderId
2046 
    args.write(self._oprot)
2047 
    self._oprot.writeMessageEnd()
2048 
    self._oprot.trans.flush()
2049 
 
2050 
  def recv_markOrderAsOutOfStock(self, ):
2051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2052 
    if mtype == TMessageType.EXCEPTION:
2053 
      x = TApplicationException()
2054 
      x.read(self._iprot)
2055 
      self._iprot.readMessageEnd()
2056 
      raise x
2057 
    result = markOrderAsOutOfStock_result()
2058 
    result.read(self._iprot)
2059 
    self._iprot.readMessageEnd()
3431 rajveer 2060 
    if result.success is not None:
1208 chandransh 2061 
      return result.success
3431 rajveer 2062 
    if result.ex is not None:
1208 chandransh 2063 
      raise result.ex
2064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2065 
 
3064 chandransh 2066 
  def verifyOrder(self, orderId):
759 chandransh 2067 
    """
3064 chandransh 2068 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2069 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2070 
    used for all other orders as well.
2071 
    Throws an exception if no such order exists.
3431 rajveer 2072 
 
759 chandransh 2073 
    Parameters:
3064 chandransh 2074 
     - orderId
759 chandransh 2075 
    """
3064 chandransh 2076 
    self.send_verifyOrder(orderId)
2077 
    return self.recv_verifyOrder()
759 chandransh 2078 
 
3064 chandransh 2079 
  def send_verifyOrder(self, orderId):
2080 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2081 
    args = verifyOrder_args()
2082 
    args.orderId = orderId
759 chandransh 2083 
    args.write(self._oprot)
2084 
    self._oprot.writeMessageEnd()
2085 
    self._oprot.trans.flush()
2086 
 
3064 chandransh 2087 
  def recv_verifyOrder(self, ):
759 chandransh 2088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2089 
    if mtype == TMessageType.EXCEPTION:
2090 
      x = TApplicationException()
2091 
      x.read(self._iprot)
2092 
      self._iprot.readMessageEnd()
2093 
      raise x
3064 chandransh 2094 
    result = verifyOrder_result()
759 chandransh 2095 
    result.read(self._iprot)
2096 
    self._iprot.readMessageEnd()
3431 rajveer 2097 
    if result.success is not None:
759 chandransh 2098 
      return result.success
3431 rajveer 2099 
    if result.ex is not None:
759 chandransh 2100 
      raise result.ex
3064 chandransh 2101 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2102 
 
3064 chandransh 2103 
  def acceptOrder(self, orderId):
1113 chandransh 2104 
    """
3064 chandransh 2105 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2106 
    given order is not a COD order, it also captures the payment if the same has
2107 
    not been captured.
2108 
    Throws an exception if no such order exists.
3431 rajveer 2109 
 
1113 chandransh 2110 
    Parameters:
3064 chandransh 2111 
     - orderId
1113 chandransh 2112 
    """
3064 chandransh 2113 
    self.send_acceptOrder(orderId)
2114 
    return self.recv_acceptOrder()
1113 chandransh 2115 
 
3064 chandransh 2116 
  def send_acceptOrder(self, orderId):
2117 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2118 
    args = acceptOrder_args()
2119 
    args.orderId = orderId
1113 chandransh 2120 
    args.write(self._oprot)
2121 
    self._oprot.writeMessageEnd()
2122 
    self._oprot.trans.flush()
2123 
 
3064 chandransh 2124 
  def recv_acceptOrder(self, ):
1113 chandransh 2125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2126 
    if mtype == TMessageType.EXCEPTION:
2127 
      x = TApplicationException()
2128 
      x.read(self._iprot)
2129 
      self._iprot.readMessageEnd()
2130 
      raise x
3064 chandransh 2131 
    result = acceptOrder_result()
1113 chandransh 2132 
    result.read(self._iprot)
2133 
    self._iprot.readMessageEnd()
3431 rajveer 2134 
    if result.success is not None:
1113 chandransh 2135 
      return result.success
3431 rajveer 2136 
    if result.ex is not None:
1113 chandransh 2137 
      raise result.ex
3064 chandransh 2138 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2139 
 
4763 rajveer 2140 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
1132 chandransh 2141 
    """
3064 chandransh 2142 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2143 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2144 
    the IMEI no. if a -1 is supplied.
2145 
    Also, it generates an invoice number for the order, marks the order as
2146 
    BILLED and sets the billing timestamp.
2147 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2148 
 
1135 chandransh 2149 
    Parameters:
3064 chandransh 2150 
     - orderId
2151 
     - invoice_number
4658 mandeep.dh 2152 
     - serialNumber
4283 anupam.sin 2153 
     - itemNumber
3064 chandransh 2154 
     - billed_by
4264 rajveer 2155 
     - jacketNumber
4283 anupam.sin 2156 
     - billingType
2157 
     - vendorId
4763 rajveer 2158 
     - authorize
1135 chandransh 2159 
    """
4763 rajveer 2160 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize)
3064 chandransh 2161 
    return self.recv_addBillingDetails()
1135 chandransh 2162 
 
4763 rajveer 2163 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 2164 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2165 
    args = addBillingDetails_args()
2166 
    args.orderId = orderId
2167 
    args.invoice_number = invoice_number
4658 mandeep.dh 2168 
    args.serialNumber = serialNumber
4283 anupam.sin 2169 
    args.itemNumber = itemNumber
3064 chandransh 2170 
    args.billed_by = billed_by
4264 rajveer 2171 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2172 
    args.billingType = billingType
2173 
    args.vendorId = vendorId
4763 rajveer 2174 
    args.authorize = authorize
1135 chandransh 2175 
    args.write(self._oprot)
2176 
    self._oprot.writeMessageEnd()
2177 
    self._oprot.trans.flush()
2178 
 
3064 chandransh 2179 
  def recv_addBillingDetails(self, ):
1135 chandransh 2180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2181 
    if mtype == TMessageType.EXCEPTION:
2182 
      x = TApplicationException()
2183 
      x.read(self._iprot)
2184 
      self._iprot.readMessageEnd()
2185 
      raise x
3064 chandransh 2186 
    result = addBillingDetails_result()
1135 chandransh 2187 
    result.read(self._iprot)
2188 
    self._iprot.readMessageEnd()
3431 rajveer 2189 
    if result.success is not None:
3064 chandransh 2190 
      return result.success
3431 rajveer 2191 
    if result.ex is not None:
1135 chandransh 2192 
      raise result.ex
3064 chandransh 2193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2194 
 
4763 rajveer 2195 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2196 
    """
2197 
    Add the invoice number to the order.
2198 
 
2199 
    Parameters:
2200 
     - orderId
2201 
     - invoiceNumber
4763 rajveer 2202 
     - color
4579 rajveer 2203 
    """
4763 rajveer 2204 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2205 
    self.recv_addInvoiceNumber()
2206 
 
4763 rajveer 2207 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2208 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2209 
    args = addInvoiceNumber_args()
2210 
    args.orderId = orderId
2211 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2212 
    args.color = color
4579 rajveer 2213 
    args.write(self._oprot)
2214 
    self._oprot.writeMessageEnd()
2215 
    self._oprot.trans.flush()
2216 
 
2217 
  def recv_addInvoiceNumber(self, ):
2218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2219 
    if mtype == TMessageType.EXCEPTION:
2220 
      x = TApplicationException()
2221 
      x.read(self._iprot)
2222 
      self._iprot.readMessageEnd()
2223 
      raise x
2224 
    result = addInvoiceNumber_result()
2225 
    result.read(self._iprot)
2226 
    self._iprot.readMessageEnd()
2227 
    if result.ex is not None:
2228 
      raise result.ex
2229 
    return
2230 
 
3064 chandransh 2231 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2232 
    """
3064 chandransh 2233 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2234 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2235 
 
1408 ankur.sing 2236 
    Parameters:
3064 chandransh 2237 
     - warehouseId
1408 ankur.sing 2238 
     - providerId
3064 chandransh 2239 
     - cod
1408 ankur.sing 2240 
    """
3064 chandransh 2241 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2242 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2243 
 
3064 chandransh 2244 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2245 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2246 
    args = markOrdersAsManifested_args()
2247 
    args.warehouseId = warehouseId
1408 ankur.sing 2248 
    args.providerId = providerId
3064 chandransh 2249 
    args.cod = cod
1408 ankur.sing 2250 
    args.write(self._oprot)
2251 
    self._oprot.writeMessageEnd()
2252 
    self._oprot.trans.flush()
2253 
 
3064 chandransh 2254 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2256 
    if mtype == TMessageType.EXCEPTION:
2257 
      x = TApplicationException()
2258 
      x.read(self._iprot)
2259 
      self._iprot.readMessageEnd()
2260 
      raise x
3064 chandransh 2261 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2262 
    result.read(self._iprot)
2263 
    self._iprot.readMessageEnd()
3431 rajveer 2264 
    if result.success is not None:
1408 ankur.sing 2265 
      return result.success
3431 rajveer 2266 
    if result.ex is not None:
3064 chandransh 2267 
      raise result.ex
2268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2269 
 
4789 rajveer 2270 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
4410 rajveer 2271 
    """
2272 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2273 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2274 
 
2275 
    Parameters:
2276 
     - warehouseId
2277 
     - providerId
2278 
     - cod
4789 rajveer 2279 
     - orderIds
4410 rajveer 2280 
    """
4789 rajveer 2281 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
4410 rajveer 2282 
    return self.recv_markOrdersAsShippedFromWarehouse()
2283 
 
4789 rajveer 2284 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
4410 rajveer 2285 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2286 
    args = markOrdersAsShippedFromWarehouse_args()
2287 
    args.warehouseId = warehouseId
2288 
    args.providerId = providerId
2289 
    args.cod = cod
4789 rajveer 2290 
    args.orderIds = orderIds
4410 rajveer 2291 
    args.write(self._oprot)
2292 
    self._oprot.writeMessageEnd()
2293 
    self._oprot.trans.flush()
2294 
 
2295 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2297 
    if mtype == TMessageType.EXCEPTION:
2298 
      x = TApplicationException()
2299 
      x.read(self._iprot)
2300 
      self._iprot.readMessageEnd()
2301 
      raise x
2302 
    result = markOrdersAsShippedFromWarehouse_result()
2303 
    result.read(self._iprot)
2304 
    self._iprot.readMessageEnd()
2305 
    if result.success is not None:
2306 
      return result.success
2307 
    if result.ex is not None:
2308 
      raise result.ex
2309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2310 
 
3064 chandransh 2311 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2312 
    """
3064 chandransh 2313 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2314 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2315 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2316 
 
94 ashish 2317 
    Parameters:
3064 chandransh 2318 
     - providerId
2319 
     - pickupDetails
304 ashish 2320 
    """
3064 chandransh 2321 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2322 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2323 
 
3064 chandransh 2324 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2325 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2326 
    args = markOrdersAsPickedUp_args()
2327 
    args.providerId = providerId
2328 
    args.pickupDetails = pickupDetails
304 ashish 2329 
    args.write(self._oprot)
2330 
    self._oprot.writeMessageEnd()
2331 
    self._oprot.trans.flush()
2332 
 
3064 chandransh 2333 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2335 
    if mtype == TMessageType.EXCEPTION:
2336 
      x = TApplicationException()
2337 
      x.read(self._iprot)
2338 
      self._iprot.readMessageEnd()
2339 
      raise x
3064 chandransh 2340 
    result = markOrdersAsPickedUp_result()
304 ashish 2341 
    result.read(self._iprot)
2342 
    self._iprot.readMessageEnd()
3431 rajveer 2343 
    if result.success is not None:
304 ashish 2344 
      return result.success
3431 rajveer 2345 
    if result.ex is not None:
3064 chandransh 2346 
      raise result.ex
2347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2348 
 
3064 chandransh 2349 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2350 
    """
3064 chandransh 2351 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2352 
    the name of the receiver.
2353 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2354 
 
304 ashish 2355 
    Parameters:
3064 chandransh 2356 
     - providerId
2357 
     - deliveredOrders
304 ashish 2358 
    """
3064 chandransh 2359 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2360 
    self.recv_markOrdersAsDelivered()
304 ashish 2361 
 
3064 chandransh 2362 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2363 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2364 
    args = markOrdersAsDelivered_args()
2365 
    args.providerId = providerId
2366 
    args.deliveredOrders = deliveredOrders
304 ashish 2367 
    args.write(self._oprot)
2368 
    self._oprot.writeMessageEnd()
2369 
    self._oprot.trans.flush()
2370 
 
3064 chandransh 2371 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2373 
    if mtype == TMessageType.EXCEPTION:
2374 
      x = TApplicationException()
2375 
      x.read(self._iprot)
2376 
      self._iprot.readMessageEnd()
2377 
      raise x
3064 chandransh 2378 
    result = markOrdersAsDelivered_result()
304 ashish 2379 
    result.read(self._iprot)
2380 
    self._iprot.readMessageEnd()
3431 rajveer 2381 
    if result.ex is not None:
3064 chandransh 2382 
      raise result.ex
304 ashish 2383 
    return
2384 
 
3064 chandransh 2385 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2386 
    """
3064 chandransh 2387 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2388 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2389 
 
3064 chandransh 2390 
    Parameters:
2391 
     - providerId
2392 
     - returnedOrders
1596 ankur.sing 2393 
    """
3064 chandransh 2394 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2395 
    self.recv_markOrdersAsFailed()
304 ashish 2396 
 
3064 chandransh 2397 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2398 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2399 
    args = markOrdersAsFailed_args()
2400 
    args.providerId = providerId
2401 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2402 
    args.write(self._oprot)
2403 
    self._oprot.writeMessageEnd()
2404 
    self._oprot.trans.flush()
2405 
 
3064 chandransh 2406 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2408 
    if mtype == TMessageType.EXCEPTION:
2409 
      x = TApplicationException()
2410 
      x.read(self._iprot)
2411 
      self._iprot.readMessageEnd()
2412 
      raise x
3064 chandransh 2413 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2414 
    result.read(self._iprot)
2415 
    self._iprot.readMessageEnd()
3431 rajveer 2416 
    if result.ex is not None:
3064 chandransh 2417 
      raise result.ex
2418 
    return
1596 ankur.sing 2419 
 
3064 chandransh 2420 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2421 
    """
3064 chandransh 2422 
    Update the status description of orders whose AWB numbers are keys of the Map.
4581 phani.kuma 2423 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3431 rajveer 2424 
 
3064 chandransh 2425 
    Parameters:
2426 
     - providerId
2427 
     - undeliveredOrders
1627 ankur.sing 2428 
    """
3064 chandransh 2429 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4581 phani.kuma 2430 
    return self.recv_updateNonDeliveryReason()
1596 ankur.sing 2431 
 
3064 chandransh 2432 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2433 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2434 
    args = updateNonDeliveryReason_args()
2435 
    args.providerId = providerId
2436 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2437 
    args.write(self._oprot)
2438 
    self._oprot.writeMessageEnd()
2439 
    self._oprot.trans.flush()
2440 
 
3064 chandransh 2441 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2443 
    if mtype == TMessageType.EXCEPTION:
2444 
      x = TApplicationException()
2445 
      x.read(self._iprot)
2446 
      self._iprot.readMessageEnd()
2447 
      raise x
3064 chandransh 2448 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2449 
    result.read(self._iprot)
2450 
    self._iprot.readMessageEnd()
4581 phani.kuma 2451 
    if result.success is not None:
2452 
      return result.success
3431 rajveer 2453 
    if result.ex is not None:
3064 chandransh 2454 
      raise result.ex
4581 phani.kuma 2455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
1627 ankur.sing 2456 
 
3064 chandransh 2457 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2458 
    """
3064 chandransh 2459 
    Returns the list of orders whose delivery time has passed but have not been
2460 
    delivered yet for the given provider and warehouse. To get a complete list of
2461 
    undelivered orders, pass them as -1.
2462 
    Returns an empty list if no such orders exist.
3431 rajveer 2463 
 
1886 ankur.sing 2464 
    Parameters:
3064 chandransh 2465 
     - providerId
2466 
     - warehouseId
1886 ankur.sing 2467 
    """
3064 chandransh 2468 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2469 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2470 
 
3064 chandransh 2471 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2472 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2473 
    args = getUndeliveredOrders_args()
2474 
    args.providerId = providerId
2475 
    args.warehouseId = warehouseId
1886 ankur.sing 2476 
    args.write(self._oprot)
2477 
    self._oprot.writeMessageEnd()
2478 
    self._oprot.trans.flush()
2479 
 
3064 chandransh 2480 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2482 
    if mtype == TMessageType.EXCEPTION:
2483 
      x = TApplicationException()
2484 
      x.read(self._iprot)
2485 
      self._iprot.readMessageEnd()
2486 
      raise x
3064 chandransh 2487 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2488 
    result.read(self._iprot)
2489 
    self._iprot.readMessageEnd()
3431 rajveer 2490 
    if result.success is not None:
1886 ankur.sing 2491 
      return result.success
3064 chandransh 2492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2493 
 
4783 phani.kuma 2494 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2495 
    """
2496 
    Returns the list of orders whose expected delivery date has passed but have not been
2497 
    delivered yet.
2498 
    Returns an empty list if no such orders exist.
2499 
    """
2500 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2501 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2502 
 
2503 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2504 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2505 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2506 
    args.write(self._oprot)
2507 
    self._oprot.writeMessageEnd()
2508 
    self._oprot.trans.flush()
2509 
 
2510 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2512 
    if mtype == TMessageType.EXCEPTION:
2513 
      x = TApplicationException()
2514 
      x.read(self._iprot)
2515 
      self._iprot.readMessageEnd()
2516 
      raise x
2517 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2518 
    result.read(self._iprot)
2519 
    self._iprot.readMessageEnd()
2520 
    if result.success is not None:
2521 
      return result.success
2522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2523 
 
2536 chandransh 2524 
  def toggleDOAFlag(self, orderId):
2525 
    """
2526 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
2527 
    Returns the final flag status.
2528 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 2529 
 
2536 chandransh 2530 
    Parameters:
2531 
     - orderId
2532 
    """
2533 
    self.send_toggleDOAFlag(orderId)
2534 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2535 
 
2536 chandransh 2536 
  def send_toggleDOAFlag(self, orderId):
2537 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2538 
    args = toggleDOAFlag_args()
2539 
    args.orderId = orderId
2540 
    args.write(self._oprot)
2541 
    self._oprot.writeMessageEnd()
2542 
    self._oprot.trans.flush()
2543 
 
2544 
  def recv_toggleDOAFlag(self, ):
2545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2546 
    if mtype == TMessageType.EXCEPTION:
2547 
      x = TApplicationException()
2548 
      x.read(self._iprot)
2549 
      self._iprot.readMessageEnd()
2550 
      raise x
2551 
    result = toggleDOAFlag_result()
2552 
    result.read(self._iprot)
2553 
    self._iprot.readMessageEnd()
3431 rajveer 2554 
    if result.success is not None:
2536 chandransh 2555 
      return result.success
3431 rajveer 2556 
    if result.ex is not None:
2536 chandransh 2557 
      raise result.ex
2558 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2559 
 
4712 rajveer 2560 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2561 
    """
2562 
    Parameters:
2563 
     - orderId
2564 
     - deliveryTimestamp
2565 
     - receiver
2566 
    """
2567 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2568 
    self.recv_markOrderAsDelivered()
2569 
 
2570 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2571 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2572 
    args = markOrderAsDelivered_args()
2573 
    args.orderId = orderId
2574 
    args.deliveryTimestamp = deliveryTimestamp
2575 
    args.receiver = receiver
2576 
    args.write(self._oprot)
2577 
    self._oprot.writeMessageEnd()
2578 
    self._oprot.trans.flush()
2579 
 
2580 
  def recv_markOrderAsDelivered(self, ):
2581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2582 
    if mtype == TMessageType.EXCEPTION:
2583 
      x = TApplicationException()
2584 
      x.read(self._iprot)
2585 
      self._iprot.readMessageEnd()
2586 
      raise x
2587 
    result = markOrderAsDelivered_result()
2588 
    result.read(self._iprot)
2589 
    self._iprot.readMessageEnd()
2590 
    if result.ex is not None:
2591 
      raise result.ex
2592 
    return
2593 
 
4454 rajveer 2594 
  def markOrderDoaRequestReceived(self, orderId):
2595 
    """
2596 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2597 
 
2598 
    Parameters:
2599 
     - orderId
2600 
    """
2601 
    self.send_markOrderDoaRequestReceived(orderId)
2602 
    return self.recv_markOrderDoaRequestReceived()
2603 
 
2604 
  def send_markOrderDoaRequestReceived(self, orderId):
2605 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2606 
    args = markOrderDoaRequestReceived_args()
2607 
    args.orderId = orderId
2608 
    args.write(self._oprot)
2609 
    self._oprot.writeMessageEnd()
2610 
    self._oprot.trans.flush()
2611 
 
2612 
  def recv_markOrderDoaRequestReceived(self, ):
2613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2614 
    if mtype == TMessageType.EXCEPTION:
2615 
      x = TApplicationException()
2616 
      x.read(self._iprot)
2617 
      self._iprot.readMessageEnd()
2618 
      raise x
2619 
    result = markOrderDoaRequestReceived_result()
2620 
    result.read(self._iprot)
2621 
    self._iprot.readMessageEnd()
2622 
    if result.success is not None:
2623 
      return result.success
2624 
    if result.ex is not None:
2625 
      raise result.ex
2626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2627 
 
2628 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2629 
    """
2630 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2631 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2632 
 
2633 
    Parameters:
2634 
     - orderId
2635 
     - isAuthorized
2636 
    """
2637 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2638 
    return self.recv_markOrderDoaRequestAuthorized()
2639 
 
2640 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2641 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2642 
    args = markOrderDoaRequestAuthorized_args()
2643 
    args.orderId = orderId
2644 
    args.isAuthorized = isAuthorized
2645 
    args.write(self._oprot)
2646 
    self._oprot.writeMessageEnd()
2647 
    self._oprot.trans.flush()
2648 
 
2649 
  def recv_markOrderDoaRequestAuthorized(self, ):
2650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2651 
    if mtype == TMessageType.EXCEPTION:
2652 
      x = TApplicationException()
2653 
      x.read(self._iprot)
2654 
      self._iprot.readMessageEnd()
2655 
      raise x
2656 
    result = markOrderDoaRequestAuthorized_result()
2657 
    result.read(self._iprot)
2658 
    self._iprot.readMessageEnd()
2659 
    if result.success is not None:
2660 
      return result.success
2661 
    if result.ex is not None:
2662 
      raise result.ex
2663 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2664 
 
4488 rajveer 2665 
  def markOrderReturnRequestReceived(self, orderId):
2666 
    """
2667 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2668 
 
2669 
    Parameters:
2670 
     - orderId
2671 
    """
2672 
    self.send_markOrderReturnRequestReceived(orderId)
2673 
    return self.recv_markOrderReturnRequestReceived()
2674 
 
2675 
  def send_markOrderReturnRequestReceived(self, orderId):
2676 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2677 
    args = markOrderReturnRequestReceived_args()
2678 
    args.orderId = orderId
2679 
    args.write(self._oprot)
2680 
    self._oprot.writeMessageEnd()
2681 
    self._oprot.trans.flush()
2682 
 
2683 
  def recv_markOrderReturnRequestReceived(self, ):
2684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2685 
    if mtype == TMessageType.EXCEPTION:
2686 
      x = TApplicationException()
2687 
      x.read(self._iprot)
2688 
      self._iprot.readMessageEnd()
2689 
      raise x
2690 
    result = markOrderReturnRequestReceived_result()
2691 
    result.read(self._iprot)
2692 
    self._iprot.readMessageEnd()
2693 
    if result.success is not None:
2694 
      return result.success
2695 
    if result.ex is not None:
2696 
      raise result.ex
2697 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2698 
 
2699 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2700 
    """
2701 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2702 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2703 
 
2704 
    Parameters:
2705 
     - orderId
2706 
     - isAuthorized
2707 
    """
2708 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2709 
    return self.recv_markOrderReturnRequestAuthorized()
2710 
 
2711 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2712 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2713 
    args = markOrderReturnRequestAuthorized_args()
2714 
    args.orderId = orderId
2715 
    args.isAuthorized = isAuthorized
2716 
    args.write(self._oprot)
2717 
    self._oprot.writeMessageEnd()
2718 
    self._oprot.trans.flush()
2719 
 
2720 
  def recv_markOrderReturnRequestAuthorized(self, ):
2721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2722 
    if mtype == TMessageType.EXCEPTION:
2723 
      x = TApplicationException()
2724 
      x.read(self._iprot)
2725 
      self._iprot.readMessageEnd()
2726 
      raise x
2727 
    result = markOrderReturnRequestAuthorized_result()
2728 
    result.read(self._iprot)
2729 
    self._iprot.readMessageEnd()
2730 
    if result.success is not None:
2731 
      return result.success
2732 
    if result.ex is not None:
2733 
      raise result.ex
2734 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2735 
 
4579 rajveer 2736 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 2737 
    """
2738 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2739 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2740 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2741 
    For any other status, it returns false.
2742 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2743 
 
2536 chandransh 2744 
    Parameters:
2745 
     - orderId
4579 rajveer 2746 
     - providerId
2536 chandransh 2747 
    """
4579 rajveer 2748 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 2749 
    return self.recv_requestPickupNumber()
2750 
 
4579 rajveer 2751 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 2752 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2753 
    args = requestPickupNumber_args()
2754 
    args.orderId = orderId
4579 rajveer 2755 
    args.providerId = providerId
2536 chandransh 2756 
    args.write(self._oprot)
2757 
    self._oprot.writeMessageEnd()
2758 
    self._oprot.trans.flush()
2759 
 
2760 
  def recv_requestPickupNumber(self, ):
2761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2762 
    if mtype == TMessageType.EXCEPTION:
2763 
      x = TApplicationException()
2764 
      x.read(self._iprot)
2765 
      self._iprot.readMessageEnd()
2766 
      raise x
2767 
    result = requestPickupNumber_result()
2768 
    result.read(self._iprot)
2769 
    self._iprot.readMessageEnd()
3431 rajveer 2770 
    if result.success is not None:
2536 chandransh 2771 
      return result.success
3431 rajveer 2772 
    if result.ex is not None:
2536 chandransh 2773 
      raise result.ex
2774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2775 
 
4602 rajveer 2776 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2777 
    """
4452 rajveer 2778 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2779 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2780 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2781 
    	3. Returns true
2591 chandransh 2782 
    If the order is in any other status, it returns false.
2536 chandransh 2783 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2784 
 
2536 chandransh 2785 
    Parameters:
2786 
     - orderId
2787 
     - pickupNumber
4602 rajveer 2788 
     - providerId
2536 chandransh 2789 
    """
4602 rajveer 2790 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 2791 
    return self.recv_authorizePickup()
2792 
 
4602 rajveer 2793 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 2794 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2795 
    args = authorizePickup_args()
2796 
    args.orderId = orderId
2797 
    args.pickupNumber = pickupNumber
4602 rajveer 2798 
    args.providerId = providerId
2536 chandransh 2799 
    args.write(self._oprot)
2800 
    self._oprot.writeMessageEnd()
2801 
    self._oprot.trans.flush()
2802 
 
2803 
  def recv_authorizePickup(self, ):
2804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2805 
    if mtype == TMessageType.EXCEPTION:
2806 
      x = TApplicationException()
2807 
      x.read(self._iprot)
2808 
      self._iprot.readMessageEnd()
2809 
      raise x
2810 
    result = authorizePickup_result()
2811 
    result.read(self._iprot)
2812 
    self._iprot.readMessageEnd()
3431 rajveer 2813 
    if result.success is not None:
2536 chandransh 2814 
      return result.success
3431 rajveer 2815 
    if result.ex is not None:
2536 chandransh 2816 
      raise result.ex
2817 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2818 
 
2764 chandransh 2819 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2820 
    """
2821 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2822 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2823 
 
2764 chandransh 2824 
    Parameters:
2825 
     - providerId
2826 
     - pickupDetails
2827 
    """
2828 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2829 
    return self.recv_markDoasAsPickedUp()
2830 
 
2831 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2832 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2833 
    args = markDoasAsPickedUp_args()
2834 
    args.providerId = providerId
2835 
    args.pickupDetails = pickupDetails
2836 
    args.write(self._oprot)
2837 
    self._oprot.writeMessageEnd()
2838 
    self._oprot.trans.flush()
2839 
 
2840 
  def recv_markDoasAsPickedUp(self, ):
2841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2842 
    if mtype == TMessageType.EXCEPTION:
2843 
      x = TApplicationException()
2844 
      x.read(self._iprot)
2845 
      self._iprot.readMessageEnd()
2846 
      raise x
2847 
    result = markDoasAsPickedUp_result()
2848 
    result.read(self._iprot)
2849 
    self._iprot.readMessageEnd()
3431 rajveer 2850 
    if result.success is not None:
2764 chandransh 2851 
      return result.success
2852 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2853 
 
4741 phani.kuma 2854 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
2855 
    """
2856 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
2857 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
2858 
 
2859 
    Parameters:
2860 
     - providerId
2861 
     - pickupDetails
2862 
    """
2863 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
2864 
    return self.recv_markReturnOrdersAsPickedUp()
2865 
 
2866 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
2867 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2868 
    args = markReturnOrdersAsPickedUp_args()
2869 
    args.providerId = providerId
2870 
    args.pickupDetails = pickupDetails
2871 
    args.write(self._oprot)
2872 
    self._oprot.writeMessageEnd()
2873 
    self._oprot.trans.flush()
2874 
 
2875 
  def recv_markReturnOrdersAsPickedUp(self, ):
2876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2877 
    if mtype == TMessageType.EXCEPTION:
2878 
      x = TApplicationException()
2879 
      x.read(self._iprot)
2880 
      self._iprot.readMessageEnd()
2881 
      raise x
2882 
    result = markReturnOrdersAsPickedUp_result()
2883 
    result.read(self._iprot)
2884 
    self._iprot.readMessageEnd()
2885 
    if result.success is not None:
2886 
      return result.success
2887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markReturnOrdersAsPickedUp failed: unknown result");
2888 
 
4479 rajveer 2889 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2890 
    """
4452 rajveer 2891 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 2892 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2893 
    If the order is in any other state, it returns false.
2894 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2895 
 
2591 chandransh 2896 
    Parameters:
2897 
     - orderId
4479 rajveer 2898 
     - receiveCondition
2591 chandransh 2899 
    """
4479 rajveer 2900 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2901 
    return self.recv_receiveReturn()
2536 chandransh 2902 
 
4479 rajveer 2903 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2904 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2905 
    args = receiveReturn_args()
2591 chandransh 2906 
    args.orderId = orderId
4479 rajveer 2907 
    args.receiveCondition = receiveCondition
2591 chandransh 2908 
    args.write(self._oprot)
2909 
    self._oprot.writeMessageEnd()
2910 
    self._oprot.trans.flush()
2911 
 
2616 chandransh 2912 
  def recv_receiveReturn(self, ):
2591 chandransh 2913 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2914 
    if mtype == TMessageType.EXCEPTION:
2915 
      x = TApplicationException()
2916 
      x.read(self._iprot)
2917 
      self._iprot.readMessageEnd()
2918 
      raise x
2616 chandransh 2919 
    result = receiveReturn_result()
2591 chandransh 2920 
    result.read(self._iprot)
2921 
    self._iprot.readMessageEnd()
3431 rajveer 2922 
    if result.success is not None:
2591 chandransh 2923 
      return result.success
3431 rajveer 2924 
    if result.ex is not None:
2591 chandransh 2925 
      raise result.ex
2616 chandransh 2926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2927 
 
2928 
  def validateDoa(self, orderId, isValid):
2929 
    """
4452 rajveer 2930 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2931 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 2932 
    If the order is in any other state, it returns false.
2933 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2934 
 
2591 chandransh 2935 
    Parameters:
2936 
     - orderId
2937 
     - isValid
2938 
    """
2939 
    self.send_validateDoa(orderId, isValid)
2940 
    return self.recv_validateDoa()
2941 
 
2942 
  def send_validateDoa(self, orderId, isValid):
2943 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2944 
    args = validateDoa_args()
2945 
    args.orderId = orderId
2946 
    args.isValid = isValid
2947 
    args.write(self._oprot)
2948 
    self._oprot.writeMessageEnd()
2949 
    self._oprot.trans.flush()
2950 
 
2951 
  def recv_validateDoa(self, ):
2952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2953 
    if mtype == TMessageType.EXCEPTION:
2954 
      x = TApplicationException()
2955 
      x.read(self._iprot)
2956 
      self._iprot.readMessageEnd()
2957 
      raise x
2958 
    result = validateDoa_result()
2959 
    result.read(self._iprot)
2960 
    self._iprot.readMessageEnd()
3431 rajveer 2961 
    if result.success is not None:
2591 chandransh 2962 
      return result.success
3431 rajveer 2963 
    if result.ex is not None:
2591 chandransh 2964 
      raise result.ex
2965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2966 
 
4495 rajveer 2967 
  def validateReturnProduct(self, orderId, isUsable):
2968 
    """
2969 
    Parameters:
2970 
     - orderId
2971 
     - isUsable
2972 
    """
2973 
    self.send_validateReturnProduct(orderId, isUsable)
2974 
    return self.recv_validateReturnProduct()
2975 
 
2976 
  def send_validateReturnProduct(self, orderId, isUsable):
2977 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
2978 
    args = validateReturnProduct_args()
2979 
    args.orderId = orderId
2980 
    args.isUsable = isUsable
2981 
    args.write(self._oprot)
2982 
    self._oprot.writeMessageEnd()
2983 
    self._oprot.trans.flush()
2984 
 
2985 
  def recv_validateReturnProduct(self, ):
2986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2987 
    if mtype == TMessageType.EXCEPTION:
2988 
      x = TApplicationException()
2989 
      x.read(self._iprot)
2990 
      self._iprot.readMessageEnd()
2991 
      raise x
2992 
    result = validateReturnProduct_result()
2993 
    result.read(self._iprot)
2994 
    self._iprot.readMessageEnd()
2995 
    if result.success is not None:
2996 
      return result.success
2997 
    if result.ex is not None:
2998 
      raise result.ex
2999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3000 
 
2616 chandransh 3001 
  def reshipOrder(self, orderId):
3002 
    """
4484 rajveer 3003 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3004 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3005 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 3006 
 
3007 
    If the order is in DOA_CERT_VALID state, it does the following:
3008 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3009 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3010 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3011 
 
2616 chandransh 3012 
    Returns the id of the newly created order.
3431 rajveer 3013 
 
2616 chandransh 3014 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3015 
 
2616 chandransh 3016 
    Parameters:
3017 
     - orderId
3018 
    """
3019 
    self.send_reshipOrder(orderId)
3020 
    return self.recv_reshipOrder()
2591 chandransh 3021 
 
2616 chandransh 3022 
  def send_reshipOrder(self, orderId):
3023 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3024 
    args = reshipOrder_args()
3025 
    args.orderId = orderId
3026 
    args.write(self._oprot)
3027 
    self._oprot.writeMessageEnd()
3028 
    self._oprot.trans.flush()
3029 
 
3030 
  def recv_reshipOrder(self, ):
3031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3032 
    if mtype == TMessageType.EXCEPTION:
3033 
      x = TApplicationException()
3034 
      x.read(self._iprot)
3035 
      self._iprot.readMessageEnd()
3036 
      raise x
3037 
    result = reshipOrder_result()
3038 
    result.read(self._iprot)
3039 
    self._iprot.readMessageEnd()
3431 rajveer 3040 
    if result.success is not None:
2616 chandransh 3041 
      return result.success
3431 rajveer 3042 
    if result.ex is not None:
2616 chandransh 3043 
      raise result.ex
3044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3045 
 
3226 chandransh 3046 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3047 
    """
4484 rajveer 3048 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3049 
    	1. Creates a refund request for batch processing.
3050 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3051 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3052 
 
2616 chandransh 3053 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3054 
    	1. Creates a refund request for batch processing.
3226 chandransh 3055 
    	2. Cancels the reservation of the item in the warehouse.
3056 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3057 
 
3226 chandransh 3058 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3059 
    	1. Cancels the reservation of the item in the warehouse.
3060 
    	2. Marks the current order as CANCELED.
3061 
 
3062 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3063 
 
2616 chandransh 3064 
    Returns True if it is successful, False otherwise.
3431 rajveer 3065 
 
2616 chandransh 3066 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3067 
 
2616 chandransh 3068 
    Parameters:
3069 
     - orderId
3226 chandransh 3070 
     - refundedBy
3071 
     - reason
2616 chandransh 3072 
    """
3226 chandransh 3073 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3074 
    return self.recv_refundOrder()
3075 
 
3226 chandransh 3076 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3077 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3078 
    args = refundOrder_args()
3079 
    args.orderId = orderId
3226 chandransh 3080 
    args.refundedBy = refundedBy
3081 
    args.reason = reason
2616 chandransh 3082 
    args.write(self._oprot)
3083 
    self._oprot.writeMessageEnd()
3084 
    self._oprot.trans.flush()
3085 
 
3086 
  def recv_refundOrder(self, ):
3087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3088 
    if mtype == TMessageType.EXCEPTION:
3089 
      x = TApplicationException()
3090 
      x.read(self._iprot)
3091 
      self._iprot.readMessageEnd()
3092 
      raise x
3093 
    result = refundOrder_result()
3094 
    result.read(self._iprot)
3095 
    self._iprot.readMessageEnd()
3431 rajveer 3096 
    if result.success is not None:
2616 chandransh 3097 
      return result.success
3431 rajveer 3098 
    if result.ex is not None:
2616 chandransh 3099 
      raise result.ex
3100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3101 
 
2690 chandransh 3102 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3103 
    """
3104 
    Get all return orders created between the from and to dates for the given warehouse.
3105 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3106 
 
2690 chandransh 3107 
    Parameters:
3108 
     - warehouseId
3109 
     - fromDate
3110 
     - toDate
3111 
    """
3112 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3113 
    return self.recv_getReturnOrders()
2616 chandransh 3114 
 
2690 chandransh 3115 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3116 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3117 
    args = getReturnOrders_args()
3118 
    args.warehouseId = warehouseId
3119 
    args.fromDate = fromDate
3120 
    args.toDate = toDate
3121 
    args.write(self._oprot)
3122 
    self._oprot.writeMessageEnd()
3123 
    self._oprot.trans.flush()
3124 
 
3125 
  def recv_getReturnOrders(self, ):
3126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3127 
    if mtype == TMessageType.EXCEPTION:
3128 
      x = TApplicationException()
3129 
      x.read(self._iprot)
3130 
      self._iprot.readMessageEnd()
3131 
      raise x
3132 
    result = getReturnOrders_result()
3133 
    result.read(self._iprot)
3134 
    self._iprot.readMessageEnd()
3431 rajveer 3135 
    if result.success is not None:
2690 chandransh 3136 
      return result.success
3137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3138 
 
2700 chandransh 3139 
  def getReturnOrder(self, id):
3140 
    """
3141 
    Returns the ReturnOrder corresponding to the given id.
3142 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3143 
 
2700 chandransh 3144 
    Parameters:
3145 
     - id
3146 
    """
3147 
    self.send_getReturnOrder(id)
3148 
    return self.recv_getReturnOrder()
3149 
 
3150 
  def send_getReturnOrder(self, id):
3151 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3152 
    args = getReturnOrder_args()
3153 
    args.id = id
3154 
    args.write(self._oprot)
3155 
    self._oprot.writeMessageEnd()
3156 
    self._oprot.trans.flush()
3157 
 
3158 
  def recv_getReturnOrder(self, ):
3159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3160 
    if mtype == TMessageType.EXCEPTION:
3161 
      x = TApplicationException()
3162 
      x.read(self._iprot)
3163 
      self._iprot.readMessageEnd()
3164 
      raise x
3165 
    result = getReturnOrder_result()
3166 
    result.read(self._iprot)
3167 
    self._iprot.readMessageEnd()
3431 rajveer 3168 
    if result.success is not None:
2700 chandransh 3169 
      return result.success
3431 rajveer 3170 
    if result.ex is not None:
2700 chandransh 3171 
      raise result.ex
3172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3173 
 
2690 chandransh 3174 
  def processReturn(self, returnOrderId):
3175 
    """
3176 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3177 
 
2690 chandransh 3178 
    Parameters:
3179 
     - returnOrderId
3180 
    """
3181 
    self.send_processReturn(returnOrderId)
3182 
    self.recv_processReturn()
3183 
 
3184 
  def send_processReturn(self, returnOrderId):
3185 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3186 
    args = processReturn_args()
3187 
    args.returnOrderId = returnOrderId
3188 
    args.write(self._oprot)
3189 
    self._oprot.writeMessageEnd()
3190 
    self._oprot.trans.flush()
3191 
 
3192 
  def recv_processReturn(self, ):
3193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3194 
    if mtype == TMessageType.EXCEPTION:
3195 
      x = TApplicationException()
3196 
      x.read(self._iprot)
3197 
      self._iprot.readMessageEnd()
3198 
      raise x
3199 
    result = processReturn_result()
3200 
    result.read(self._iprot)
3201 
    self._iprot.readMessageEnd()
3431 rajveer 3202 
    if result.ex is not None:
2690 chandransh 3203 
      raise result.ex
3204 
    return
3205 
 
3451 chandransh 3206 
  def updateWeight(self, orderId, weight):
3207 
    """
3208 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 3209 
 
3451 chandransh 3210 
    Parameters:
3211 
     - orderId
3212 
     - weight
3213 
    """
3214 
    self.send_updateWeight(orderId, weight)
3215 
    return self.recv_updateWeight()
3216 
 
3217 
  def send_updateWeight(self, orderId, weight):
3218 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3219 
    args = updateWeight_args()
3220 
    args.orderId = orderId
3221 
    args.weight = weight
3222 
    args.write(self._oprot)
3223 
    self._oprot.writeMessageEnd()
3224 
    self._oprot.trans.flush()
3225 
 
3226 
  def recv_updateWeight(self, ):
3227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3228 
    if mtype == TMessageType.EXCEPTION:
3229 
      x = TApplicationException()
3230 
      x.read(self._iprot)
3231 
      self._iprot.readMessageEnd()
3232 
      raise x
3233 
    result = updateWeight_result()
3234 
    result.read(self._iprot)
3235 
    self._iprot.readMessageEnd()
3236 
    if result.success is not None:
3237 
      return result.success
3238 
    if result.ex is not None:
3239 
      raise result.ex
3240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3241 
 
3469 chandransh 3242 
  def changeItem(self, orderId, itemId):
3243 
    """
3244 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3245 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3246 
 
3469 chandransh 3247 
    Parameters:
3248 
     - orderId
3249 
     - itemId
3250 
    """
3251 
    self.send_changeItem(orderId, itemId)
3252 
    return self.recv_changeItem()
3253 
 
3254 
  def send_changeItem(self, orderId, itemId):
3255 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3256 
    args = changeItem_args()
3257 
    args.orderId = orderId
3258 
    args.itemId = itemId
3259 
    args.write(self._oprot)
3260 
    self._oprot.writeMessageEnd()
3261 
    self._oprot.trans.flush()
3262 
 
3263 
  def recv_changeItem(self, ):
3264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3265 
    if mtype == TMessageType.EXCEPTION:
3266 
      x = TApplicationException()
3267 
      x.read(self._iprot)
3268 
      self._iprot.readMessageEnd()
3269 
      raise x
3270 
    result = changeItem_result()
3271 
    result.read(self._iprot)
3272 
    self._iprot.readMessageEnd()
3273 
    if result.success is not None:
3274 
      return result.success
3275 
    if result.ex is not None:
3276 
      raise result.ex
3277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3278 
 
3279 
  def shiftToWarehouse(self, orderId, warehouseId):
3280 
    """
3281 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3282 
 
3283 
    Parameters:
3284 
     - orderId
3285 
     - warehouseId
3286 
    """
3287 
    self.send_shiftToWarehouse(orderId, warehouseId)
3288 
    return self.recv_shiftToWarehouse()
3289 
 
3290 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3291 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3292 
    args = shiftToWarehouse_args()
3293 
    args.orderId = orderId
3294 
    args.warehouseId = warehouseId
3295 
    args.write(self._oprot)
3296 
    self._oprot.writeMessageEnd()
3297 
    self._oprot.trans.flush()
3298 
 
3299 
  def recv_shiftToWarehouse(self, ):
3300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3301 
    if mtype == TMessageType.EXCEPTION:
3302 
      x = TApplicationException()
3303 
      x.read(self._iprot)
3304 
      self._iprot.readMessageEnd()
3305 
      raise x
3306 
    result = shiftToWarehouse_result()
3307 
    result.read(self._iprot)
3308 
    self._iprot.readMessageEnd()
3309 
    if result.success is not None:
3310 
      return result.success
3311 
    if result.ex is not None:
3312 
      raise result.ex
3313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3314 
 
4647 rajveer 3315 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3316 
    """
3317 
    Adds the given delay reason to the given order.
3986 chandransh 3318 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3319 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3320 
 
3553 chandransh 3321 
    Parameters:
3322 
     - orderId
3323 
     - delayReason
3986 chandransh 3324 
     - furtherDelay
4647 rajveer 3325 
     - delayReasonText
3553 chandransh 3326 
    """
4647 rajveer 3327 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3328 
    return self.recv_addDelayReason()
3329 
 
4647 rajveer 3330 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3331 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3332 
    args = addDelayReason_args()
3333 
    args.orderId = orderId
3334 
    args.delayReason = delayReason
3986 chandransh 3335 
    args.furtherDelay = furtherDelay
4647 rajveer 3336 
    args.delayReasonText = delayReasonText
3553 chandransh 3337 
    args.write(self._oprot)
3338 
    self._oprot.writeMessageEnd()
3339 
    self._oprot.trans.flush()
3340 
 
3341 
  def recv_addDelayReason(self, ):
3342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3343 
    if mtype == TMessageType.EXCEPTION:
3344 
      x = TApplicationException()
3345 
      x.read(self._iprot)
3346 
      self._iprot.readMessageEnd()
3347 
      raise x
3348 
    result = addDelayReason_result()
3349 
    result.read(self._iprot)
3350 
    self._iprot.readMessageEnd()
3351 
    if result.success is not None:
3352 
      return result.success
3353 
    if result.ex is not None:
3354 
      raise result.ex
3355 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3356 
 
3956 chandransh 3357 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3358 
    """
3359 
    Marks the COD orders with given AWB nos. as having been processed.
3360 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3361 
 
3956 chandransh 3362 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3363 
    1. There is no order corresponding to an AWB number.
3364 
    2. The captured amount for a payment exceeds the total payment.
3365 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3366 
 
3367 
    Parameters:
3368 
     - collectedAmountMap
3369 
     - xferBy
3370 
     - xferTxnId
3371 
     - xferDate
3372 
    """
3373 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3374 
    return self.recv_reconcileCodCollection()
3375 
 
3376 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3377 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3378 
    args = reconcileCodCollection_args()
3379 
    args.collectedAmountMap = collectedAmountMap
3380 
    args.xferBy = xferBy
3381 
    args.xferTxnId = xferTxnId
3382 
    args.xferDate = xferDate
3383 
    args.write(self._oprot)
3384 
    self._oprot.writeMessageEnd()
3385 
    self._oprot.trans.flush()
3386 
 
3387 
  def recv_reconcileCodCollection(self, ):
3388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3389 
    if mtype == TMessageType.EXCEPTION:
3390 
      x = TApplicationException()
3391 
      x.read(self._iprot)
3392 
      self._iprot.readMessageEnd()
3393 
      raise x
3394 
    result = reconcileCodCollection_result()
3395 
    result.read(self._iprot)
3396 
    self._iprot.readMessageEnd()
3397 
    if result.success is not None:
3398 
      return result.success
3399 
    if result.ex is not None:
3400 
      raise result.ex
3401 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3402 
 
4008 mandeep.dh 3403 
  def getTransactionsRequiringExtraProcessing(self, category):
3404 
    """
4065 mandeep.dh 3405 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3406 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3407 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3408 
 
4008 mandeep.dh 3409 
    Parameters:
3410 
     - category
3411 
    """
3412 
    self.send_getTransactionsRequiringExtraProcessing(category)
3413 
    return self.recv_getTransactionsRequiringExtraProcessing()
3414 
 
3415 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3416 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3417 
    args = getTransactionsRequiringExtraProcessing_args()
3418 
    args.category = category
3419 
    args.write(self._oprot)
3420 
    self._oprot.writeMessageEnd()
3421 
    self._oprot.trans.flush()
3422 
 
3423 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3425 
    if mtype == TMessageType.EXCEPTION:
3426 
      x = TApplicationException()
3427 
      x.read(self._iprot)
3428 
      self._iprot.readMessageEnd()
3429 
      raise x
3430 
    result = getTransactionsRequiringExtraProcessing_result()
3431 
    result.read(self._iprot)
3432 
    self._iprot.readMessageEnd()
3433 
    if result.success is not None:
3434 
      return result.success
3435 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3436 
 
3437 
  def markTransactionAsProcessed(self, transactionId, category):
3438 
    """
3439 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3440 
    It essentially deletes the transaction id record for a particular
3441 
    processing type category (if present) from DB.
3442 
    This is currently used by CRM application.
4008 mandeep.dh 3443 
 
3444 
    Parameters:
3445 
     - transactionId
3446 
     - category
3447 
    """
3448 
    self.send_markTransactionAsProcessed(transactionId, category)
3449 
    self.recv_markTransactionAsProcessed()
3450 
 
3451 
  def send_markTransactionAsProcessed(self, transactionId, category):
3452 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3453 
    args = markTransactionAsProcessed_args()
3454 
    args.transactionId = transactionId
3455 
    args.category = category
3456 
    args.write(self._oprot)
3457 
    self._oprot.writeMessageEnd()
3458 
    self._oprot.trans.flush()
3459 
 
3460 
  def recv_markTransactionAsProcessed(self, ):
3461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3462 
    if mtype == TMessageType.EXCEPTION:
3463 
      x = TApplicationException()
3464 
      x.read(self._iprot)
3465 
      self._iprot.readMessageEnd()
3466 
      raise x
3467 
    result = markTransactionAsProcessed_result()
3468 
    result.read(self._iprot)
3469 
    self._iprot.readMessageEnd()
3470 
    return
3471 
 
4018 chandransh 3472 
  def getItemWiseRiskyOrdersCount(self, ):
3473 
    """
3474 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3475 
    is defined as one whose shipping date is about to expire.
3476 
    """
3477 
    self.send_getItemWiseRiskyOrdersCount()
3478 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3479 
 
4018 chandransh 3480 
  def send_getItemWiseRiskyOrdersCount(self, ):
3481 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3482 
    args = getItemWiseRiskyOrdersCount_args()
3483 
    args.write(self._oprot)
3484 
    self._oprot.writeMessageEnd()
3485 
    self._oprot.trans.flush()
3486 
 
3487 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3488 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3489 
    if mtype == TMessageType.EXCEPTION:
3490 
      x = TApplicationException()
3491 
      x.read(self._iprot)
3492 
      self._iprot.readMessageEnd()
3493 
      raise x
3494 
    result = getItemWiseRiskyOrdersCount_result()
3495 
    result.read(self._iprot)
3496 
    self._iprot.readMessageEnd()
3497 
    if result.success is not None:
3498 
      return result.success
3499 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3500 
 
4295 varun.gupt 3501 
  def getOrdersForItemIds(self, itemIds):
3502 
    """
3503 
    Returns a list of all orders which have items with given id
3504 
 
3505 
    Parameters:
3506 
     - itemIds
3507 
    """
3508 
    self.send_getOrdersForItemIds(itemIds)
3509 
    return self.recv_getOrdersForItemIds()
3510 
 
3511 
  def send_getOrdersForItemIds(self, itemIds):
3512 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3513 
    args = getOrdersForItemIds_args()
3514 
    args.itemIds = itemIds
3515 
    args.write(self._oprot)
3516 
    self._oprot.writeMessageEnd()
3517 
    self._oprot.trans.flush()
3518 
 
3519 
  def recv_getOrdersForItemIds(self, ):
3520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3521 
    if mtype == TMessageType.EXCEPTION:
3522 
      x = TApplicationException()
3523 
      x.read(self._iprot)
3524 
      self._iprot.readMessageEnd()
3525 
      raise x
3526 
    result = getOrdersForItemIds_result()
3527 
    result.read(self._iprot)
3528 
    self._iprot.readMessageEnd()
3529 
    if result.success is not None:
3530 
      return result.success
3531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3532 
 
4247 rajveer 3533 
  def markOrderCancellationRequestReceived(self, orderId):
3534 
    """
3535 
    Mark order as cancellation request received. If customer sends request of cancellation of
3536 
    a particular order, this method will be called. It will just change status of the order
3537 
    depending on its current status. It also records the previous status, so that we can move
3538 
    back to that status if cancellation request is denied.
4018 chandransh 3539 
 
4247 rajveer 3540 
    Parameters:
3541 
     - orderId
3542 
    """
3543 
    self.send_markOrderCancellationRequestReceived(orderId)
3544 
    self.recv_markOrderCancellationRequestReceived()
3545 
 
3546 
  def send_markOrderCancellationRequestReceived(self, orderId):
3547 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3548 
    args = markOrderCancellationRequestReceived_args()
3549 
    args.orderId = orderId
3550 
    args.write(self._oprot)
3551 
    self._oprot.writeMessageEnd()
3552 
    self._oprot.trans.flush()
3553 
 
3554 
  def recv_markOrderCancellationRequestReceived(self, ):
3555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3556 
    if mtype == TMessageType.EXCEPTION:
3557 
      x = TApplicationException()
3558 
      x.read(self._iprot)
3559 
      self._iprot.readMessageEnd()
3560 
      raise x
3561 
    result = markOrderCancellationRequestReceived_result()
3562 
    result.read(self._iprot)
3563 
    self._iprot.readMessageEnd()
3564 
    if result.ex is not None:
3565 
      raise result.ex
3566 
    return
3567 
 
3568 
  def markOrderCancellationRequestConfirmed(self, orderId):
3569 
    """
3570 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3571 
    cancellation request confirmed. After this OM will be able to cancel the order.
3572 
 
3573 
    Parameters:
3574 
     - orderId
3575 
    """
3576 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3577 
    self.recv_markOrderCancellationRequestConfirmed()
3578 
 
3579 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3580 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3581 
    args = markOrderCancellationRequestConfirmed_args()
3582 
    args.orderId = orderId
3583 
    args.write(self._oprot)
3584 
    self._oprot.writeMessageEnd()
3585 
    self._oprot.trans.flush()
3586 
 
3587 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3589 
    if mtype == TMessageType.EXCEPTION:
3590 
      x = TApplicationException()
3591 
      x.read(self._iprot)
3592 
      self._iprot.readMessageEnd()
3593 
      raise x
3594 
    result = markOrderCancellationRequestConfirmed_result()
3595 
    result.read(self._iprot)
3596 
    self._iprot.readMessageEnd()
3597 
    if result.ex is not None:
3598 
      raise result.ex
3599 
    return
3600 
 
3601 
  def markOrderCancellationRequestDenied(self, orderId):
3602 
    """
3603 
    If we decide to not to cancel order, we will move the order ro previous status.
3604 
 
3605 
    Parameters:
3606 
     - orderId
3607 
    """
3608 
    self.send_markOrderCancellationRequestDenied(orderId)
3609 
    self.recv_markOrderCancellationRequestDenied()
3610 
 
3611 
  def send_markOrderCancellationRequestDenied(self, orderId):
3612 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3613 
    args = markOrderCancellationRequestDenied_args()
3614 
    args.orderId = orderId
3615 
    args.write(self._oprot)
3616 
    self._oprot.writeMessageEnd()
3617 
    self._oprot.trans.flush()
3618 
 
3619 
  def recv_markOrderCancellationRequestDenied(self, ):
3620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3621 
    if mtype == TMessageType.EXCEPTION:
3622 
      x = TApplicationException()
3623 
      x.read(self._iprot)
3624 
      self._iprot.readMessageEnd()
3625 
      raise x
3626 
    result = markOrderCancellationRequestDenied_result()
3627 
    result.read(self._iprot)
3628 
    self._iprot.readMessageEnd()
3629 
    if result.ex is not None:
3630 
      raise result.ex
3631 
    return
3632 
 
4258 rajveer 3633 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3634 
    """
4258 rajveer 3635 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3636 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3637 
 
3638 
    Parameters:
4258 rajveer 3639 
     - transactionId
4247 rajveer 3640 
    """
4258 rajveer 3641 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3642 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3643 
 
4258 rajveer 3644 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3645 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3646 
    args = markTransactionAsPaymentFlagRemoved_args()
3647 
    args.transactionId = transactionId
4247 rajveer 3648 
    args.write(self._oprot)
3649 
    self._oprot.writeMessageEnd()
3650 
    self._oprot.trans.flush()
3651 
 
4258 rajveer 3652 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3654 
    if mtype == TMessageType.EXCEPTION:
3655 
      x = TApplicationException()
3656 
      x.read(self._iprot)
3657 
      self._iprot.readMessageEnd()
3658 
      raise x
4258 rajveer 3659 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3660 
    result.read(self._iprot)
3661 
    self._iprot.readMessageEnd()
3662 
    if result.ex is not None:
3663 
      raise result.ex
3664 
    return
3665 
 
4259 anupam.sin 3666 
  def refundTransaction(self, transactionId, refundedBy, reason):
3667 
    """
3668 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3669 
    need to be cancelled
4247 rajveer 3670 
 
4259 anupam.sin 3671 
    Parameters:
3672 
     - transactionId
3673 
     - refundedBy
3674 
     - reason
3675 
    """
3676 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3677 
    self.recv_refundTransaction()
3678 
 
3679 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3680 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3681 
    args = refundTransaction_args()
3682 
    args.transactionId = transactionId
3683 
    args.refundedBy = refundedBy
3684 
    args.reason = reason
3685 
    args.write(self._oprot)
3686 
    self._oprot.writeMessageEnd()
3687 
    self._oprot.trans.flush()
3688 
 
3689 
  def recv_refundTransaction(self, ):
3690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3691 
    if mtype == TMessageType.EXCEPTION:
3692 
      x = TApplicationException()
3693 
      x.read(self._iprot)
3694 
      self._iprot.readMessageEnd()
3695 
      raise x
3696 
    result = refundTransaction_result()
3697 
    result.read(self._iprot)
3698 
    self._iprot.readMessageEnd()
3699 
    if result.ex is not None:
3700 
      raise result.ex
3701 
    return
3702 
 
4324 mandeep.dh 3703 
  def updateShipmentAddress(self, orderId, addressId):
3704 
    """
3705 
    Updates shipment address of an order. Delivery and shipping date estimates
3706 
    etc. are also updated here.
3707 
 
3708 
    Throws TransactionServiceException in case address change is not
3709 
    possible due to certain reasons such as new pincode in address is
3710 
    not serviceable etc.
3711 
 
3712 
    Parameters:
3713 
     - orderId
3714 
     - addressId
3715 
    """
3716 
    self.send_updateShipmentAddress(orderId, addressId)
3717 
    self.recv_updateShipmentAddress()
3718 
 
3719 
  def send_updateShipmentAddress(self, orderId, addressId):
3720 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3721 
    args = updateShipmentAddress_args()
3722 
    args.orderId = orderId
3723 
    args.addressId = addressId
3724 
    args.write(self._oprot)
3725 
    self._oprot.writeMessageEnd()
3726 
    self._oprot.trans.flush()
3727 
 
3728 
  def recv_updateShipmentAddress(self, ):
3729 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3730 
    if mtype == TMessageType.EXCEPTION:
3731 
      x = TApplicationException()
3732 
      x.read(self._iprot)
3733 
      self._iprot.readMessageEnd()
3734 
      raise x
3735 
    result = updateShipmentAddress_result()
3736 
    result.read(self._iprot)
3737 
    self._iprot.readMessageEnd()
3738 
    if result.ex is not None:
3739 
      raise result.ex
3740 
    return
3741 
 
4285 rajveer 3742 
  def acceptOrdersForItemId(self, itemId, inventory):
3743 
    """
3744 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3745 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3746 
 
4285 rajveer 3747 
    Parameters:
3748 
     - itemId
3749 
     - inventory
3750 
    """
3751 
    self.send_acceptOrdersForItemId(itemId, inventory)
3752 
    return self.recv_acceptOrdersForItemId()
3753 
 
3754 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3755 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3756 
    args = acceptOrdersForItemId_args()
3757 
    args.itemId = itemId
3758 
    args.inventory = inventory
3759 
    args.write(self._oprot)
3760 
    self._oprot.writeMessageEnd()
3761 
    self._oprot.trans.flush()
3762 
 
3763 
  def recv_acceptOrdersForItemId(self, ):
3764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3765 
    if mtype == TMessageType.EXCEPTION:
3766 
      x = TApplicationException()
3767 
      x.read(self._iprot)
3768 
      self._iprot.readMessageEnd()
3769 
      raise x
3770 
    result = acceptOrdersForItemId_result()
3771 
    result.read(self._iprot)
3772 
    self._iprot.readMessageEnd()
3773 
    if result.success is not None:
3774 
      return result.success
3775 
    if result.ex is not None:
3776 
      raise result.ex
3777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3778 
 
4369 rajveer 3779 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3780 
    """
3781 
    Parameters:
3782 
     - vendorId
3783 
     - itemId
3784 
     - quantity
3785 
     - estimate
4369 rajveer 3786 
     - isReminder
4303 rajveer 3787 
    """
4369 rajveer 3788 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3789 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3790 
 
4369 rajveer 3791 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3792 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3793 
    args = markOrdersAsPORaised_args()
3794 
    args.vendorId = vendorId
3795 
    args.itemId = itemId
3796 
    args.quantity = quantity
3797 
    args.estimate = estimate
4369 rajveer 3798 
    args.isReminder = isReminder
4303 rajveer 3799 
    args.write(self._oprot)
3800 
    self._oprot.writeMessageEnd()
3801 
    self._oprot.trans.flush()
3802 
 
3803 
  def recv_markOrdersAsPORaised(self, ):
3804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3805 
    if mtype == TMessageType.EXCEPTION:
3806 
      x = TApplicationException()
3807 
      x.read(self._iprot)
3808 
      self._iprot.readMessageEnd()
3809 
      raise x
3810 
    result = markOrdersAsPORaised_result()
3811 
    result.read(self._iprot)
3812 
    self._iprot.readMessageEnd()
3813 
    if result.ex is not None:
3814 
      raise result.ex
3815 
    return
3816 
 
4369 rajveer 3817 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3818 
    """
3819 
    Parameters:
3820 
     - vendorId
3821 
     - itemId
3822 
     - quantity
3823 
     - estimate
4369 rajveer 3824 
     - isReminder
4303 rajveer 3825 
    """
4369 rajveer 3826 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3827 
    self.recv_markOrdersAsReversalInitiated()
3828 
 
4369 rajveer 3829 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3830 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3831 
    args = markOrdersAsReversalInitiated_args()
3832 
    args.vendorId = vendorId
3833 
    args.itemId = itemId
3834 
    args.quantity = quantity
3835 
    args.estimate = estimate
4369 rajveer 3836 
    args.isReminder = isReminder
4303 rajveer 3837 
    args.write(self._oprot)
3838 
    self._oprot.writeMessageEnd()
3839 
    self._oprot.trans.flush()
3840 
 
3841 
  def recv_markOrdersAsReversalInitiated(self, ):
3842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3843 
    if mtype == TMessageType.EXCEPTION:
3844 
      x = TApplicationException()
3845 
      x.read(self._iprot)
3846 
      self._iprot.readMessageEnd()
3847 
      raise x
3848 
    result = markOrdersAsReversalInitiated_result()
3849 
    result.read(self._iprot)
3850 
    self._iprot.readMessageEnd()
3851 
    if result.ex is not None:
3852 
      raise result.ex
3853 
    return
3854 
 
4369 rajveer 3855 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3856 
    """
3857 
    Parameters:
3858 
     - vendorId
3859 
     - itemId
3860 
     - quantity
3861 
     - estimate
4369 rajveer 3862 
     - isReminder
4303 rajveer 3863 
    """
4369 rajveer 3864 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3865 
    self.recv_markOrdersAsNotAvailabke()
3866 
 
4369 rajveer 3867 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3868 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3869 
    args = markOrdersAsNotAvailabke_args()
3870 
    args.vendorId = vendorId
3871 
    args.itemId = itemId
3872 
    args.quantity = quantity
3873 
    args.estimate = estimate
4369 rajveer 3874 
    args.isReminder = isReminder
4303 rajveer 3875 
    args.write(self._oprot)
3876 
    self._oprot.writeMessageEnd()
3877 
    self._oprot.trans.flush()
3878 
 
3879 
  def recv_markOrdersAsNotAvailabke(self, ):
3880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3881 
    if mtype == TMessageType.EXCEPTION:
3882 
      x = TApplicationException()
3883 
      x.read(self._iprot)
3884 
      self._iprot.readMessageEnd()
3885 
      raise x
3886 
    result = markOrdersAsNotAvailabke_result()
3887 
    result.read(self._iprot)
3888 
    self._iprot.readMessageEnd()
3889 
    if result.ex is not None:
3890 
      raise result.ex
3891 
    return
3892 
 
4369 rajveer 3893 
  def markOrdersAsTimeout(self, vendorId):
3894 
    """
3895 
    Parameters:
3896 
     - vendorId
3897 
    """
3898 
    self.send_markOrdersAsTimeout(vendorId)
3899 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3900 
 
4369 rajveer 3901 
  def send_markOrdersAsTimeout(self, vendorId):
3902 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3903 
    args = markOrdersAsTimeout_args()
3904 
    args.vendorId = vendorId
3905 
    args.write(self._oprot)
3906 
    self._oprot.writeMessageEnd()
3907 
    self._oprot.trans.flush()
3908 
 
3909 
  def recv_markOrdersAsTimeout(self, ):
3910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3911 
    if mtype == TMessageType.EXCEPTION:
3912 
      x = TApplicationException()
3913 
      x.read(self._iprot)
3914 
      self._iprot.readMessageEnd()
3915 
      raise x
3916 
    result = markOrdersAsTimeout_result()
3917 
    result.read(self._iprot)
3918 
    self._iprot.readMessageEnd()
3919 
    if result.success is not None:
3920 
      return result.success
3921 
    if result.ex is not None:
3922 
      raise result.ex
3923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3924 
 
4662 rajveer 3925 
  def markOrderAsLostInTransit(self, orderId):
3926 
    """
3927 
    Mark order as LOST_IN_TRANSIT
3928 
 
3929 
    Parameters:
3930 
     - orderId
3931 
    """
3932 
    self.send_markOrderAsLostInTransit(orderId)
3933 
    return self.recv_markOrderAsLostInTransit()
3934 
 
3935 
  def send_markOrderAsLostInTransit(self, orderId):
3936 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
3937 
    args = markOrderAsLostInTransit_args()
3938 
    args.orderId = orderId
3939 
    args.write(self._oprot)
3940 
    self._oprot.writeMessageEnd()
3941 
    self._oprot.trans.flush()
3942 
 
3943 
  def recv_markOrderAsLostInTransit(self, ):
3944 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3945 
    if mtype == TMessageType.EXCEPTION:
3946 
      x = TApplicationException()
3947 
      x.read(self._iprot)
3948 
      self._iprot.readMessageEnd()
3949 
      raise x
3950 
    result = markOrderAsLostInTransit_result()
3951 
    result.read(self._iprot)
3952 
    self._iprot.readMessageEnd()
3953 
    if result.success is not None:
3954 
      return result.success
3955 
    if result.ex is not None:
3956 
      raise result.ex
3957 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
3958 
 
4386 anupam.sin 3959 
  def getOrderForAwb(self, awb):
3960 
    """
3961 
    Returns the order corresponding to an AWB number
4369 rajveer 3962 
 
4386 anupam.sin 3963 
    Parameters:
3964 
     - awb
3965 
    """
3966 
    self.send_getOrderForAwb(awb)
3967 
    return self.recv_getOrderForAwb()
3968 
 
3969 
  def send_getOrderForAwb(self, awb):
3970 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3971 
    args = getOrderForAwb_args()
3972 
    args.awb = awb
3973 
    args.write(self._oprot)
3974 
    self._oprot.writeMessageEnd()
3975 
    self._oprot.trans.flush()
3976 
 
3977 
  def recv_getOrderForAwb(self, ):
3978 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3979 
    if mtype == TMessageType.EXCEPTION:
3980 
      x = TApplicationException()
3981 
      x.read(self._iprot)
3982 
      self._iprot.readMessageEnd()
3983 
      raise x
3984 
    result = getOrderForAwb_result()
3985 
    result.read(self._iprot)
3986 
    self._iprot.readMessageEnd()
3987 
    if result.success is not None:
3988 
      return result.success
3989 
    if result.ex is not None:
3990 
      raise result.ex
3991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3992 
 
4506 phani.kuma 3993 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
3994 
    """
3995 
    Returns the order corresponding to a logistics provider id for a given order status
4386 anupam.sin 3996 
 
4506 phani.kuma 3997 
    Parameters:
3998 
     - logistics_provider_id
3999 
     - order_status
4000 
    """
4001 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
4002 
    return self.recv_getOrdersForProviderForStatus()
4003 
 
4004 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
4005 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4006 
    args = getOrdersForProviderForStatus_args()
4007 
    args.logistics_provider_id = logistics_provider_id
4008 
    args.order_status = order_status
4009 
    args.write(self._oprot)
4010 
    self._oprot.writeMessageEnd()
4011 
    self._oprot.trans.flush()
4012 
 
4013 
  def recv_getOrdersForProviderForStatus(self, ):
4014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4015 
    if mtype == TMessageType.EXCEPTION:
4016 
      x = TApplicationException()
4017 
      x.read(self._iprot)
4018 
      self._iprot.readMessageEnd()
4019 
      raise x
4020 
    result = getOrdersForProviderForStatus_result()
4021 
    result.read(self._iprot)
4022 
    self._iprot.readMessageEnd()
4023 
    if result.success is not None:
4024 
      return result.success
4025 
    if result.ex is not None:
4026 
      raise result.ex
4027 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4028 
 
4600 varun.gupt 4029 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4030 
    """
4031 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4032 
 
4600 varun.gupt 4033 
    Parameters:
4034 
     - vendorId
4035 
     - billingDateFrom
4036 
     - billingDateTo
4037 
    """
4038 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4039 
    return self.recv_getBilledOrdersForVendor()
4040 
 
4041 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4042 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4043 
    args = getBilledOrdersForVendor_args()
4044 
    args.vendorId = vendorId
4045 
    args.billingDateFrom = billingDateFrom
4046 
    args.billingDateTo = billingDateTo
4047 
    args.write(self._oprot)
4048 
    self._oprot.writeMessageEnd()
4049 
    self._oprot.trans.flush()
4050 
 
4051 
  def recv_getBilledOrdersForVendor(self, ):
4052 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4053 
    if mtype == TMessageType.EXCEPTION:
4054 
      x = TApplicationException()
4055 
      x.read(self._iprot)
4056 
      self._iprot.readMessageEnd()
4057 
      raise x
4058 
    result = getBilledOrdersForVendor_result()
4059 
    result.read(self._iprot)
4060 
    self._iprot.readMessageEnd()
4061 
    if result.success is not None:
4062 
      return result.success
4063 
    if result.ex is not None:
4064 
      raise result.ex
4065 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4066 
 
4607 rajveer 4067 
  def getSlippedSippingDateOrders(self, ):
4068 
    self.send_getSlippedSippingDateOrders()
4069 
    return self.recv_getSlippedSippingDateOrders()
4070 
 
4071 
  def send_getSlippedSippingDateOrders(self, ):
4072 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4073 
    args = getSlippedSippingDateOrders_args()
4074 
    args.write(self._oprot)
4075 
    self._oprot.writeMessageEnd()
4076 
    self._oprot.trans.flush()
4077 
 
4078 
  def recv_getSlippedSippingDateOrders(self, ):
4079 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4080 
    if mtype == TMessageType.EXCEPTION:
4081 
      x = TApplicationException()
4082 
      x.read(self._iprot)
4083 
      self._iprot.readMessageEnd()
4084 
      raise x
4085 
    result = getSlippedSippingDateOrders_result()
4086 
    result.read(self._iprot)
4087 
    self._iprot.readMessageEnd()
4088 
    if result.success is not None:
4089 
      return result.success
4090 
    if result.ex is not None:
4091 
      raise result.ex
4092 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4093 
 
4709 rajveer 4094 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4095 
    """
4096 
    Parameters:
4097 
     - cancelDateFrom
4098 
     - cancelDateTo
4099 
    """
4100 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4101 
    return self.recv_getCancelledOrders()
4102 
 
4103 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4104 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4105 
    args = getCancelledOrders_args()
4106 
    args.cancelDateFrom = cancelDateFrom
4107 
    args.cancelDateTo = cancelDateTo
4108 
    args.write(self._oprot)
4109 
    self._oprot.writeMessageEnd()
4110 
    self._oprot.trans.flush()
4111 
 
4112 
  def recv_getCancelledOrders(self, ):
4113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4114 
    if mtype == TMessageType.EXCEPTION:
4115 
      x = TApplicationException()
4116 
      x.read(self._iprot)
4117 
      self._iprot.readMessageEnd()
4118 
      raise x
4119 
    result = getCancelledOrders_result()
4120 
    result.read(self._iprot)
4121 
    self._iprot.readMessageEnd()
4122 
    if result.success is not None:
4123 
      return result.success
4124 
    if result.ex is not None:
4125 
      raise result.ex
4126 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4127 
 
4600 varun.gupt 4128 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4129 
    """
4130 
    Parameters:
4131 
     - mapAWBAndAmount
4132 
    """
4133 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4134 
    self.recv_saveBluedartSettlements()
4135 
 
4136 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4137 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4138 
    args = saveBluedartSettlements_args()
4139 
    args.mapAWBAndAmount = mapAWBAndAmount
4140 
    args.write(self._oprot)
4141 
    self._oprot.writeMessageEnd()
4142 
    self._oprot.trans.flush()
4143 
 
4144 
  def recv_saveBluedartSettlements(self, ):
4145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4146 
    if mtype == TMessageType.EXCEPTION:
4147 
      x = TApplicationException()
4148 
      x.read(self._iprot)
4149 
      self._iprot.readMessageEnd()
4150 
      raise x
4151 
    result = saveBluedartSettlements_result()
4152 
    result.read(self._iprot)
4153 
    self._iprot.readMessageEnd()
4154 
    if result.ex is not None:
4155 
      raise result.ex
4156 
    return
4157 
 
4158 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4159 
    """
4160 
    Parameters:
4161 
     - settlementDate
4162 
     - paymentGatewayId
4163 
     - paymentId
4164 
     - serviceTax
4165 
     - otherCharges
4166 
     - netCollection
4167 
    """
4168 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection)
4169 
    self.recv_savePaymentSettlements()
4170 
 
4171 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, paymentId, serviceTax, otherCharges, netCollection):
4172 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4173 
    args = savePaymentSettlements_args()
4174 
    args.settlementDate = settlementDate
4175 
    args.paymentGatewayId = paymentGatewayId
4176 
    args.paymentId = paymentId
4177 
    args.serviceTax = serviceTax
4178 
    args.otherCharges = otherCharges
4179 
    args.netCollection = netCollection
4180 
    args.write(self._oprot)
4181 
    self._oprot.writeMessageEnd()
4182 
    self._oprot.trans.flush()
4183 
 
4184 
  def recv_savePaymentSettlements(self, ):
4185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4186 
    if mtype == TMessageType.EXCEPTION:
4187 
      x = TApplicationException()
4188 
      x.read(self._iprot)
4189 
      self._iprot.readMessageEnd()
4190 
      raise x
4191 
    result = savePaymentSettlements_result()
4192 
    result.read(self._iprot)
4193 
    self._iprot.readMessageEnd()
4194 
    if result.ex is not None:
4195 
      raise result.ex
4196 
    return
4197 
 
4198 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4199 
    """
4200 
    Parameters:
4201 
     - settlementId
4202 
     - settlementDate
4203 
     - transactionDateFrom
4204 
     - transactionDateTo
4205 
     - amount
4206 
    """
4207 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4208 
    self.recv_saveEBSSettlementSummary()
4209 
 
4210 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4211 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4212 
    args = saveEBSSettlementSummary_args()
4213 
    args.settlementId = settlementId
4214 
    args.settlementDate = settlementDate
4215 
    args.transactionDateFrom = transactionDateFrom
4216 
    args.transactionDateTo = transactionDateTo
4217 
    args.amount = amount
4218 
    args.write(self._oprot)
4219 
    self._oprot.writeMessageEnd()
4220 
    self._oprot.trans.flush()
4221 
 
4222 
  def recv_saveEBSSettlementSummary(self, ):
4223 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4224 
    if mtype == TMessageType.EXCEPTION:
4225 
      x = TApplicationException()
4226 
      x.read(self._iprot)
4227 
      self._iprot.readMessageEnd()
4228 
      raise x
4229 
    result = saveEBSSettlementSummary_result()
4230 
    result.read(self._iprot)
4231 
    self._iprot.readMessageEnd()
4232 
    if result.ex is not None:
4233 
      raise result.ex
4234 
    return
4235 
 
4236 
  def getSettlementForPaymentId(self, paymentId):
4237 
    """
4238 
    Parameters:
4239 
     - paymentId
4240 
    """
4241 
    self.send_getSettlementForPaymentId(paymentId)
4242 
    return self.recv_getSettlementForPaymentId()
4243 
 
4244 
  def send_getSettlementForPaymentId(self, paymentId):
4245 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4246 
    args = getSettlementForPaymentId_args()
4247 
    args.paymentId = paymentId
4248 
    args.write(self._oprot)
4249 
    self._oprot.writeMessageEnd()
4250 
    self._oprot.trans.flush()
4251 
 
4252 
  def recv_getSettlementForPaymentId(self, ):
4253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4254 
    if mtype == TMessageType.EXCEPTION:
4255 
      x = TApplicationException()
4256 
      x.read(self._iprot)
4257 
      self._iprot.readMessageEnd()
4258 
      raise x
4259 
    result = getSettlementForPaymentId_result()
4260 
    result.read(self._iprot)
4261 
    self._iprot.readMessageEnd()
4262 
    if result.success is not None:
4263 
      return result.success
4264 
    if result.ex is not None:
4265 
      raise result.ex
4266 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4267 
 
4268 
  def getEBSSettlementSummaries(self, ):
4269 
    self.send_getEBSSettlementSummaries()
4270 
    return self.recv_getEBSSettlementSummaries()
4271 
 
4272 
  def send_getEBSSettlementSummaries(self, ):
4273 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4274 
    args = getEBSSettlementSummaries_args()
4275 
    args.write(self._oprot)
4276 
    self._oprot.writeMessageEnd()
4277 
    self._oprot.trans.flush()
4278 
 
4279 
  def recv_getEBSSettlementSummaries(self, ):
4280 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4281 
    if mtype == TMessageType.EXCEPTION:
4282 
      x = TApplicationException()
4283 
      x.read(self._iprot)
4284 
      self._iprot.readMessageEnd()
4285 
      raise x
4286 
    result = getEBSSettlementSummaries_result()
4287 
    result.read(self._iprot)
4288 
    self._iprot.readMessageEnd()
4289 
    if result.success is not None:
4290 
      return result.success
4291 
    if result.ex is not None:
4292 
      raise result.ex
4293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4294 
 
4295 
  def markEBSSettlementUploaded(self, settlementId):
4296 
    """
4297 
    Parameters:
4298 
     - settlementId
4299 
    """
4300 
    self.send_markEBSSettlementUploaded(settlementId)
4301 
    self.recv_markEBSSettlementUploaded()
4302 
 
4303 
  def send_markEBSSettlementUploaded(self, settlementId):
4304 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4305 
    args = markEBSSettlementUploaded_args()
4306 
    args.settlementId = settlementId
4307 
    args.write(self._oprot)
4308 
    self._oprot.writeMessageEnd()
4309 
    self._oprot.trans.flush()
4310 
 
4311 
  def recv_markEBSSettlementUploaded(self, ):
4312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4313 
    if mtype == TMessageType.EXCEPTION:
4314 
      x = TApplicationException()
4315 
      x.read(self._iprot)
4316 
      self._iprot.readMessageEnd()
4317 
      raise x
4318 
    result = markEBSSettlementUploaded_result()
4319 
    result.read(self._iprot)
4320 
    self._iprot.readMessageEnd()
4321 
    if result.ex is not None:
4322 
      raise result.ex
4323 
    return
4324 
 
4325 
  def getEBSSettlementDate(self, settlementId):
4326 
    """
4327 
    Parameters:
4328 
     - settlementId
4329 
    """
4330 
    self.send_getEBSSettlementDate(settlementId)
4331 
    return self.recv_getEBSSettlementDate()
4332 
 
4333 
  def send_getEBSSettlementDate(self, settlementId):
4334 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4335 
    args = getEBSSettlementDate_args()
4336 
    args.settlementId = settlementId
4337 
    args.write(self._oprot)
4338 
    self._oprot.writeMessageEnd()
4339 
    self._oprot.trans.flush()
4340 
 
4341 
  def recv_getEBSSettlementDate(self, ):
4342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4343 
    if mtype == TMessageType.EXCEPTION:
4344 
      x = TApplicationException()
4345 
      x.read(self._iprot)
4346 
      self._iprot.readMessageEnd()
4347 
      raise x
4348 
    result = getEBSSettlementDate_result()
4349 
    result.read(self._iprot)
4350 
    self._iprot.readMessageEnd()
4351 
    if result.success is not None:
4352 
      return result.success
4353 
    if result.ex is not None:
4354 
      raise result.ex
4355 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4356 
 
4715 varun.gupt 4357 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4358 
    """
4359 
    Parameters:
4360 
     - settlementDateFrom
4361 
     - settlementDateTo
4362 
     - isRefund
4363 
    """
4364 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4365 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4366 
 
4715 varun.gupt 4367 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4368 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4369 
    args = getSettlementsByDate_args()
4370 
    args.settlementDateFrom = settlementDateFrom
4371 
    args.settlementDateTo = settlementDateTo
4372 
    args.isRefund = isRefund
4373 
    args.write(self._oprot)
4374 
    self._oprot.writeMessageEnd()
4375 
    self._oprot.trans.flush()
4376 
 
4377 
  def recv_getSettlementsByDate(self, ):
4378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4379 
    if mtype == TMessageType.EXCEPTION:
4380 
      x = TApplicationException()
4381 
      x.read(self._iprot)
4382 
      self._iprot.readMessageEnd()
4383 
      raise x
4384 
    result = getSettlementsByDate_result()
4385 
    result.read(self._iprot)
4386 
    self._iprot.readMessageEnd()
4387 
    if result.success is not None:
4388 
      return result.success
4389 
    if result.ex is not None:
4390 
      raise result.ex
4391 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4392 
 
4393 
  def getReshippedOrderIds(self, orderIds):
4394 
    """
4395 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4396 
 
4397 
    Parameters:
4398 
     - orderIds
4399 
    """
4400 
    self.send_getReshippedOrderIds(orderIds)
4401 
    return self.recv_getReshippedOrderIds()
4402 
 
4403 
  def send_getReshippedOrderIds(self, orderIds):
4404 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4405 
    args = getReshippedOrderIds_args()
4406 
    args.orderIds = orderIds
4407 
    args.write(self._oprot)
4408 
    self._oprot.writeMessageEnd()
4409 
    self._oprot.trans.flush()
4410 
 
4411 
  def recv_getReshippedOrderIds(self, ):
4412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4413 
    if mtype == TMessageType.EXCEPTION:
4414 
      x = TApplicationException()
4415 
      x.read(self._iprot)
4416 
      self._iprot.readMessageEnd()
4417 
      raise x
4418 
    result = getReshippedOrderIds_result()
4419 
    result.read(self._iprot)
4420 
    self._iprot.readMessageEnd()
4421 
    if result.success is not None:
4422 
      return result.success
4423 
    if result.ex is not None:
4424 
      raise result.ex
4425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4426 
 
4757 mandeep.dh 4427 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4428 
    """
4429 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
4430 
    the quantities for which the PO is raised.
4715 varun.gupt 4431 
 
4757 mandeep.dh 4432 
    Parameters:
4433 
     - itemIdQuantityMap
4434 
     - purchaseOrderId
4435 
     - warehouseId
4436 
    """
4437 
    self.send_updateOrdersAsPORaised(itemIdQuantityMap, purchaseOrderId, warehouseId)
4438 
    self.recv_updateOrdersAsPORaised()
4439 
 
4440 
  def send_updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4441 
    self._oprot.writeMessageBegin('updateOrdersAsPORaised', TMessageType.CALL, self._seqid)
4442 
    args = updateOrdersAsPORaised_args()
4443 
    args.itemIdQuantityMap = itemIdQuantityMap
4444 
    args.purchaseOrderId = purchaseOrderId
4445 
    args.warehouseId = warehouseId
4446 
    args.write(self._oprot)
4447 
    self._oprot.writeMessageEnd()
4448 
    self._oprot.trans.flush()
4449 
 
4450 
  def recv_updateOrdersAsPORaised(self, ):
4451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4452 
    if mtype == TMessageType.EXCEPTION:
4453 
      x = TApplicationException()
4454 
      x.read(self._iprot)
4455 
      self._iprot.readMessageEnd()
4456 
      raise x
4457 
    result = updateOrdersAsPORaised_result()
4458 
    result.read(self._iprot)
4459 
    self._iprot.readMessageEnd()
4460 
    if result.ex is not None:
4461 
      raise result.ex
4462 
    return
4463 
 
4464 
 
3376 rajveer 4465 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4466 
  def __init__(self, handler):
3376 rajveer 4467 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4468 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4469 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4470 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4471 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4472 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4473 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4474 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4475 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4476 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4477 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4478 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4479 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4480 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4481 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4482 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4483 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4484 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4485 
    self._processMap["createOrder"] = Processor.process_createOrder
4486 
    self._processMap["getOrder"] = Processor.process_getOrder
4487 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 4488 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4489 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4490 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4491 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4492 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4493 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4494 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4495 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4496 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4497 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4498 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4499 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4500 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4501 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
759 chandransh 4502 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 4503 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4504 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 4505 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 4506 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 4507 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 4508 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 4509 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 4510 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 4511 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 4512 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4513 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4514 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4515 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4516 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4517 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4518 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4741 phani.kuma 4519 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
2616 chandransh 4520 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 4521 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 4522 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 4523 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
4524 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 4525 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 4526 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 4527 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 4528 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 4529 
    self._processMap["changeItem"] = Processor.process_changeItem
4530 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 4531 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 4532 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 4533 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
4534 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 4535 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 4536 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 4537 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
4538 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
4539 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 4540 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 4541 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 4542 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 4543 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 4544 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
4545 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
4546 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 4547 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 4548 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 4549 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 4550 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 4551 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 4552 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 4553 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 4554 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
4555 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
4556 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
4557 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
4558 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
4559 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
4560 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 4561 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
4562 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4757 mandeep.dh 4563 
    self._processMap["updateOrdersAsPORaised"] = Processor.process_updateOrdersAsPORaised
94 ashish 4564 
 
4565 
  def process(self, iprot, oprot):
4566 
    (name, type, seqid) = iprot.readMessageBegin()
4567 
    if name not in self._processMap:
4568 
      iprot.skip(TType.STRUCT)
4569 
      iprot.readMessageEnd()
4570 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4571 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4572 
      x.write(oprot)
4573 
      oprot.writeMessageEnd()
4574 
      oprot.trans.flush()
4575 
      return
4576 
    else:
4577 
      self._processMap[name](self, seqid, iprot, oprot)
4578 
    return True
4579 
 
4580 
  def process_createTransaction(self, seqid, iprot, oprot):
4581 
    args = createTransaction_args()
4582 
    args.read(iprot)
4583 
    iprot.readMessageEnd()
4584 
    result = createTransaction_result()
4585 
    try:
132 ashish 4586 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 4587 
    except TransactionServiceException, ex:
4588 
      result.ex = ex
4589 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
4590 
    result.write(oprot)
4591 
    oprot.writeMessageEnd()
4592 
    oprot.trans.flush()
4593 
 
4594 
  def process_getTransaction(self, seqid, iprot, oprot):
4595 
    args = getTransaction_args()
4596 
    args.read(iprot)
4597 
    iprot.readMessageEnd()
4598 
    result = getTransaction_result()
4599 
    try:
4600 
      result.success = self._handler.getTransaction(args.id)
4601 
    except TransactionServiceException, ex:
4602 
      result.ex = ex
4603 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
4604 
    result.write(oprot)
4605 
    oprot.writeMessageEnd()
4606 
    oprot.trans.flush()
4607 
 
4608 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
4609 
    args = getTransactionsForCustomer_args()
4610 
    args.read(iprot)
4611 
    iprot.readMessageEnd()
4612 
    result = getTransactionsForCustomer_result()
4613 
    try:
4614 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
4615 
    except TransactionServiceException, ex:
4616 
      result.ex = ex
4617 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
4618 
    result.write(oprot)
4619 
    oprot.writeMessageEnd()
4620 
    oprot.trans.flush()
4621 
 
132 ashish 4622 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
4623 
    args = getTransactionsForShoppingCartId_args()
4624 
    args.read(iprot)
4625 
    iprot.readMessageEnd()
4626 
    result = getTransactionsForShoppingCartId_result()
4627 
    try:
4628 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
4629 
    except TransactionServiceException, ex:
4630 
      result.ex = ex
4631 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
4632 
    result.write(oprot)
4633 
    oprot.writeMessageEnd()
4634 
    oprot.trans.flush()
4635 
 
94 ashish 4636 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
4637 
    args = getTransactionStatus_args()
4638 
    args.read(iprot)
4639 
    iprot.readMessageEnd()
4640 
    result = getTransactionStatus_result()
4641 
    try:
4642 
      result.success = self._handler.getTransactionStatus(args.transactionId)
4643 
    except TransactionServiceException, ex:
4644 
      result.ex = ex
4645 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
4646 
    result.write(oprot)
4647 
    oprot.writeMessageEnd()
4648 
    oprot.trans.flush()
4649 
 
4650 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
4651 
    args = changeTransactionStatus_args()
4652 
    args.read(iprot)
4653 
    iprot.readMessageEnd()
4654 
    result = changeTransactionStatus_result()
4655 
    try:
4656 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
4657 
    except TransactionServiceException, ex:
4658 
      result.ex = ex
4659 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
4660 
    result.write(oprot)
4661 
    oprot.writeMessageEnd()
4662 
    oprot.trans.flush()
4663 
 
1398 varun.gupt 4664 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
4665 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 4666 
    args.read(iprot)
4667 
    iprot.readMessageEnd()
1398 varun.gupt 4668 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 4669 
    try:
1398 varun.gupt 4670 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 4671 
    except TransactionServiceException, ex:
4672 
      result.ex = ex
1398 varun.gupt 4673 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 4674 
    result.write(oprot)
4675 
    oprot.writeMessageEnd()
4676 
    oprot.trans.flush()
4677 
 
483 rajveer 4678 
  def process_getAllOrders(self, seqid, iprot, oprot):
4679 
    args = getAllOrders_args()
94 ashish 4680 
    args.read(iprot)
4681 
    iprot.readMessageEnd()
483 rajveer 4682 
    result = getAllOrders_result()
94 ashish 4683 
    try:
483 rajveer 4684 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 4685 
    except TransactionServiceException, ex:
4686 
      result.ex = ex
483 rajveer 4687 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 4688 
    result.write(oprot)
4689 
    oprot.writeMessageEnd()
4690 
    oprot.trans.flush()
4691 
 
4133 chandransh 4692 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
4693 
    args = getOrdersInBatch_args()
4694 
    args.read(iprot)
4695 
    iprot.readMessageEnd()
4696 
    result = getOrdersInBatch_result()
4697 
    try:
4698 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
4699 
    except TransactionServiceException, ex:
4700 
      result.ex = ex
4701 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
4702 
    result.write(oprot)
4703 
    oprot.writeMessageEnd()
4704 
    oprot.trans.flush()
4705 
 
4706 
  def process_getOrderCount(self, seqid, iprot, oprot):
4707 
    args = getOrderCount_args()
4708 
    args.read(iprot)
4709 
    iprot.readMessageEnd()
4710 
    result = getOrderCount_result()
4711 
    try:
4712 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
4713 
    except TransactionServiceException, ex:
4714 
      result.ex = ex
4715 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
4716 
    result.write(oprot)
4717 
    oprot.writeMessageEnd()
4718 
    oprot.trans.flush()
4719 
 
999 varun.gupt 4720 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
4721 
    args = getOrdersByBillingDate_args()
4722 
    args.read(iprot)
4723 
    iprot.readMessageEnd()
4724 
    result = getOrdersByBillingDate_result()
4725 
    try:
4726 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
4727 
    except TransactionServiceException, ex:
4728 
      result.ex = ex
4729 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
4730 
    result.write(oprot)
4731 
    oprot.writeMessageEnd()
4732 
    oprot.trans.flush()
4733 
 
3427 chandransh 4734 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
4735 
    args = getOrdersByShippingDate_args()
4736 
    args.read(iprot)
4737 
    iprot.readMessageEnd()
4738 
    result = getOrdersByShippingDate_result()
4739 
    try:
3451 chandransh 4740 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 4741 
    except TransactionServiceException, ex:
4742 
      result.ex = ex
4743 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
4744 
    result.write(oprot)
4745 
    oprot.writeMessageEnd()
4746 
    oprot.trans.flush()
4747 
 
1382 varun.gupt 4748 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
4749 
    args = getReturnableOrdersForCustomer_args()
4750 
    args.read(iprot)
4751 
    iprot.readMessageEnd()
4752 
    result = getReturnableOrdersForCustomer_result()
4753 
    try:
4754 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
4755 
    except TransactionServiceException, ex:
4756 
      result.ex = ex
4757 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
4758 
    result.write(oprot)
4759 
    oprot.writeMessageEnd()
4760 
    oprot.trans.flush()
4761 
 
4762 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
4763 
    args = getCancellableOrdersForCustomer_args()
4764 
    args.read(iprot)
4765 
    iprot.readMessageEnd()
4766 
    result = getCancellableOrdersForCustomer_result()
4767 
    try:
4768 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
4769 
    except TransactionServiceException, ex:
4770 
      result.ex = ex
4771 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
4772 
    result.write(oprot)
4773 
    oprot.writeMessageEnd()
4774 
    oprot.trans.flush()
4775 
 
483 rajveer 4776 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
4777 
    args = changeOrderStatus_args()
94 ashish 4778 
    args.read(iprot)
4779 
    iprot.readMessageEnd()
483 rajveer 4780 
    result = changeOrderStatus_result()
94 ashish 4781 
    try:
483 rajveer 4782 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 4783 
    except TransactionServiceException, ex:
4784 
      result.ex = ex
483 rajveer 4785 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 4786 
    result.write(oprot)
4787 
    oprot.writeMessageEnd()
4788 
    oprot.trans.flush()
4789 
 
483 rajveer 4790 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
4791 
    args = getOrdersForTransaction_args()
94 ashish 4792 
    args.read(iprot)
4793 
    iprot.readMessageEnd()
483 rajveer 4794 
    result = getOrdersForTransaction_result()
94 ashish 4795 
    try:
1528 ankur.sing 4796 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 4797 
    except TransactionServiceException, ex:
4798 
      result.ex = ex
483 rajveer 4799 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 4800 
    result.write(oprot)
4801 
    oprot.writeMessageEnd()
4802 
    oprot.trans.flush()
4803 
 
483 rajveer 4804 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
4805 
    args = getOrdersForCustomer_args()
94 ashish 4806 
    args.read(iprot)
4807 
    iprot.readMessageEnd()
483 rajveer 4808 
    result = getOrdersForCustomer_result()
94 ashish 4809 
    try:
3014 chandransh 4810 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 4811 
    except TransactionServiceException, ex:
4812 
      result.ex = ex
483 rajveer 4813 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 4814 
    result.write(oprot)
4815 
    oprot.writeMessageEnd()
4816 
    oprot.trans.flush()
4817 
 
483 rajveer 4818 
  def process_createOrder(self, seqid, iprot, oprot):
4819 
    args = createOrder_args()
94 ashish 4820 
    args.read(iprot)
4821 
    iprot.readMessageEnd()
483 rajveer 4822 
    result = createOrder_result()
94 ashish 4823 
    try:
483 rajveer 4824 
      result.success = self._handler.createOrder(args.order)
94 ashish 4825 
    except TransactionServiceException, ex:
4826 
      result.ex = ex
483 rajveer 4827 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 4828 
    result.write(oprot)
4829 
    oprot.writeMessageEnd()
4830 
    oprot.trans.flush()
4831 
 
483 rajveer 4832 
  def process_getOrder(self, seqid, iprot, oprot):
4833 
    args = getOrder_args()
94 ashish 4834 
    args.read(iprot)
4835 
    iprot.readMessageEnd()
483 rajveer 4836 
    result = getOrder_result()
94 ashish 4837 
    try:
483 rajveer 4838 
      result.success = self._handler.getOrder(args.id)
94 ashish 4839 
    except TransactionServiceException, ex:
4840 
      result.ex = ex
483 rajveer 4841 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4842 
    result.write(oprot)
4843 
    oprot.writeMessageEnd()
4844 
    oprot.trans.flush()
4845 
 
483 rajveer 4846 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4847 
    args = getLineItemsForOrder_args()
94 ashish 4848 
    args.read(iprot)
4849 
    iprot.readMessageEnd()
483 rajveer 4850 
    result = getLineItemsForOrder_result()
94 ashish 4851 
    try:
483 rajveer 4852 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4853 
    except TransactionServiceException, ex:
4854 
      result.ex = ex
483 rajveer 4855 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4856 
    result.write(oprot)
4857 
    oprot.writeMessageEnd()
4858 
    oprot.trans.flush()
4859 
 
1528 ankur.sing 4860 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4861 
    args = getOrderForCustomer_args()
4862 
    args.read(iprot)
4863 
    iprot.readMessageEnd()
4864 
    result = getOrderForCustomer_result()
4865 
    try:
4866 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4867 
    except TransactionServiceException, ex:
4868 
      result.ex = ex
4869 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4870 
    result.write(oprot)
4871 
    oprot.writeMessageEnd()
4872 
    oprot.trans.flush()
4873 
 
3064 chandransh 4874 
  def process_getAlerts(self, seqid, iprot, oprot):
4875 
    args = getAlerts_args()
4876 
    args.read(iprot)
4877 
    iprot.readMessageEnd()
4878 
    result = getAlerts_result()
4444 rajveer 4879 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4880 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4881 
    result.write(oprot)
4882 
    oprot.writeMessageEnd()
4883 
    oprot.trans.flush()
4884 
 
4394 rajveer 4885 
  def process_addAlert(self, seqid, iprot, oprot):
4886 
    args = addAlert_args()
3064 chandransh 4887 
    args.read(iprot)
4888 
    iprot.readMessageEnd()
4394 rajveer 4889 
    result = addAlert_result()
4444 rajveer 4890 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4891 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4892 
    result.write(oprot)
4893 
    oprot.writeMessageEnd()
4894 
    oprot.trans.flush()
4895 
 
4444 rajveer 4896 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4897 
    args = markAlertsAsSeen_args()
4898 
    args.read(iprot)
4899 
    iprot.readMessageEnd()
4900 
    result = markAlertsAsSeen_result()
4901 
    self._handler.markAlertsAsSeen(args.warehouseId)
4902 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4903 
    result.write(oprot)
4904 
    oprot.writeMessageEnd()
4905 
    oprot.trans.flush()
4906 
 
3064 chandransh 4907 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4908 
    args = getValidOrderCount_args()
4909 
    args.read(iprot)
4910 
    iprot.readMessageEnd()
4911 
    result = getValidOrderCount_result()
4912 
    result.success = self._handler.getValidOrderCount()
4913 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4914 
    result.write(oprot)
4915 
    oprot.writeMessageEnd()
4916 
    oprot.trans.flush()
4917 
 
4918 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4919 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4920 
    args.read(iprot)
4921 
    iprot.readMessageEnd()
4922 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4923 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4924 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4925 
    result.write(oprot)
4926 
    oprot.writeMessageEnd()
4927 
    oprot.trans.flush()
4928 
 
4929 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4930 
    args = getValidOrdersAmountRange_args()
4931 
    args.read(iprot)
4932 
    iprot.readMessageEnd()
4933 
    result = getValidOrdersAmountRange_result()
4934 
    result.success = self._handler.getValidOrdersAmountRange()
4935 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4936 
    result.write(oprot)
4937 
    oprot.writeMessageEnd()
4938 
    oprot.trans.flush()
4939 
 
4940 
  def process_getValidOrders(self, seqid, iprot, oprot):
4941 
    args = getValidOrders_args()
4942 
    args.read(iprot)
4943 
    iprot.readMessageEnd()
4944 
    result = getValidOrders_result()
4945 
    result.success = self._handler.getValidOrders(args.limit)
4946 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4947 
    result.write(oprot)
4948 
    oprot.writeMessageEnd()
4949 
    oprot.trans.flush()
4950 
 
1220 chandransh 4951 
  def process_batchOrders(self, seqid, iprot, oprot):
4952 
    args = batchOrders_args()
4953 
    args.read(iprot)
4954 
    iprot.readMessageEnd()
4955 
    result = batchOrders_result()
4956 
    try:
4957 
      result.success = self._handler.batchOrders(args.warehouseId)
4958 
    except TransactionServiceException, ex:
4959 
      result.ex = ex
4960 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4961 
    result.write(oprot)
4962 
    oprot.writeMessageEnd()
4963 
    oprot.trans.flush()
4964 
 
1208 chandransh 4965 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4966 
    args = markOrderAsOutOfStock_args()
4967 
    args.read(iprot)
4968 
    iprot.readMessageEnd()
4969 
    result = markOrderAsOutOfStock_result()
4970 
    try:
4971 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4972 
    except TransactionServiceException, ex:
4973 
      result.ex = ex
4974 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4975 
    result.write(oprot)
4976 
    oprot.writeMessageEnd()
4977 
    oprot.trans.flush()
4978 
 
3064 chandransh 4979 
  def process_verifyOrder(self, seqid, iprot, oprot):
4980 
    args = verifyOrder_args()
759 chandransh 4981 
    args.read(iprot)
4982 
    iprot.readMessageEnd()
3064 chandransh 4983 
    result = verifyOrder_result()
759 chandransh 4984 
    try:
3064 chandransh 4985 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4986 
    except TransactionServiceException, ex:
4987 
      result.ex = ex
3064 chandransh 4988 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4989 
    result.write(oprot)
4990 
    oprot.writeMessageEnd()
4991 
    oprot.trans.flush()
4992 
 
3064 chandransh 4993 
  def process_acceptOrder(self, seqid, iprot, oprot):
4994 
    args = acceptOrder_args()
1113 chandransh 4995 
    args.read(iprot)
4996 
    iprot.readMessageEnd()
3064 chandransh 4997 
    result = acceptOrder_result()
1113 chandransh 4998 
    try:
3064 chandransh 4999 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5000 
    except TransactionServiceException, ex:
5001 
      result.ex = ex
3064 chandransh 5002 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5003 
    result.write(oprot)
5004 
    oprot.writeMessageEnd()
5005 
    oprot.trans.flush()
5006 
 
3064 chandransh 5007 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5008 
    args = addBillingDetails_args()
1135 chandransh 5009 
    args.read(iprot)
5010 
    iprot.readMessageEnd()
3064 chandransh 5011 
    result = addBillingDetails_result()
1135 chandransh 5012 
    try:
4763 rajveer 5013 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.serialNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.vendorId, args.authorize)
1135 chandransh 5014 
    except TransactionServiceException, ex:
5015 
      result.ex = ex
3064 chandransh 5016 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5017 
    result.write(oprot)
5018 
    oprot.writeMessageEnd()
5019 
    oprot.trans.flush()
5020 
 
4579 rajveer 5021 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5022 
    args = addInvoiceNumber_args()
5023 
    args.read(iprot)
5024 
    iprot.readMessageEnd()
5025 
    result = addInvoiceNumber_result()
5026 
    try:
4763 rajveer 5027 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5028 
    except TransactionServiceException, ex:
5029 
      result.ex = ex
5030 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5031 
    result.write(oprot)
5032 
    oprot.writeMessageEnd()
5033 
    oprot.trans.flush()
5034 
 
3064 chandransh 5035 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
5036 
    args = markOrdersAsManifested_args()
1408 ankur.sing 5037 
    args.read(iprot)
5038 
    iprot.readMessageEnd()
3064 chandransh 5039 
    result = markOrdersAsManifested_result()
5040 
    try:
5041 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
5042 
    except TransactionServiceException, ex:
5043 
      result.ex = ex
5044 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 5045 
    result.write(oprot)
5046 
    oprot.writeMessageEnd()
5047 
    oprot.trans.flush()
5048 
 
4410 rajveer 5049 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5050 
    args = markOrdersAsShippedFromWarehouse_args()
5051 
    args.read(iprot)
5052 
    iprot.readMessageEnd()
5053 
    result = markOrdersAsShippedFromWarehouse_result()
5054 
    try:
4789 rajveer 5055 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5056 
    except TransactionServiceException, ex:
5057 
      result.ex = ex
5058 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5059 
    result.write(oprot)
5060 
    oprot.writeMessageEnd()
5061 
    oprot.trans.flush()
5062 
 
3064 chandransh 5063 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5064 
    args = markOrdersAsPickedUp_args()
304 ashish 5065 
    args.read(iprot)
5066 
    iprot.readMessageEnd()
3064 chandransh 5067 
    result = markOrdersAsPickedUp_result()
5068 
    try:
5069 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
5070 
    except TransactionServiceException, ex:
5071 
      result.ex = ex
5072 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5073 
    result.write(oprot)
5074 
    oprot.writeMessageEnd()
5075 
    oprot.trans.flush()
94 ashish 5076 
 
3064 chandransh 5077 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5078 
    args = markOrdersAsDelivered_args()
304 ashish 5079 
    args.read(iprot)
5080 
    iprot.readMessageEnd()
3064 chandransh 5081 
    result = markOrdersAsDelivered_result()
5082 
    try:
5083 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5084 
    except TransactionServiceException, ex:
5085 
      result.ex = ex
5086 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5087 
    result.write(oprot)
5088 
    oprot.writeMessageEnd()
5089 
    oprot.trans.flush()
5090 
 
3064 chandransh 5091 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
5092 
    args = markOrdersAsFailed_args()
1596 ankur.sing 5093 
    args.read(iprot)
5094 
    iprot.readMessageEnd()
3064 chandransh 5095 
    result = markOrdersAsFailed_result()
5096 
    try:
5097 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
5098 
    except TransactionServiceException, ex:
5099 
      result.ex = ex
5100 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 5101 
    result.write(oprot)
5102 
    oprot.writeMessageEnd()
5103 
    oprot.trans.flush()
304 ashish 5104 
 
3064 chandransh 5105 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5106 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5107 
    args.read(iprot)
5108 
    iprot.readMessageEnd()
3064 chandransh 5109 
    result = updateNonDeliveryReason_result()
5110 
    try:
4581 phani.kuma 5111 
      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5112 
    except TransactionServiceException, ex:
5113 
      result.ex = ex
5114 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5115 
    result.write(oprot)
5116 
    oprot.writeMessageEnd()
5117 
    oprot.trans.flush()
1596 ankur.sing 5118 
 
3064 chandransh 5119 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5120 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5121 
    args.read(iprot)
5122 
    iprot.readMessageEnd()
3064 chandransh 5123 
    result = getUndeliveredOrders_result()
5124 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5125 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5126 
    result.write(oprot)
5127 
    oprot.writeMessageEnd()
5128 
    oprot.trans.flush()
5129 
 
4783 phani.kuma 5130 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5131 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5132 
    args.read(iprot)
5133 
    iprot.readMessageEnd()
5134 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5135 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5136 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5137 
    result.write(oprot)
5138 
    oprot.writeMessageEnd()
5139 
    oprot.trans.flush()
5140 
 
2536 chandransh 5141 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5142 
    args = toggleDOAFlag_args()
5143 
    args.read(iprot)
5144 
    iprot.readMessageEnd()
5145 
    result = toggleDOAFlag_result()
5146 
    try:
5147 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5148 
    except TransactionServiceException, ex:
5149 
      result.ex = ex
5150 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5151 
    result.write(oprot)
5152 
    oprot.writeMessageEnd()
5153 
    oprot.trans.flush()
1886 ankur.sing 5154 
 
4712 rajveer 5155 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5156 
    args = markOrderAsDelivered_args()
5157 
    args.read(iprot)
5158 
    iprot.readMessageEnd()
5159 
    result = markOrderAsDelivered_result()
5160 
    try:
5161 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5162 
    except TransactionServiceException, ex:
5163 
      result.ex = ex
5164 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5165 
    result.write(oprot)
5166 
    oprot.writeMessageEnd()
5167 
    oprot.trans.flush()
5168 
 
4454 rajveer 5169 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5170 
    args = markOrderDoaRequestReceived_args()
5171 
    args.read(iprot)
5172 
    iprot.readMessageEnd()
5173 
    result = markOrderDoaRequestReceived_result()
5174 
    try:
5175 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5176 
    except TransactionServiceException, ex:
5177 
      result.ex = ex
5178 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5179 
    result.write(oprot)
5180 
    oprot.writeMessageEnd()
5181 
    oprot.trans.flush()
5182 
 
5183 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5184 
    args = markOrderDoaRequestAuthorized_args()
5185 
    args.read(iprot)
5186 
    iprot.readMessageEnd()
5187 
    result = markOrderDoaRequestAuthorized_result()
5188 
    try:
5189 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5190 
    except TransactionServiceException, ex:
5191 
      result.ex = ex
5192 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5193 
    result.write(oprot)
5194 
    oprot.writeMessageEnd()
5195 
    oprot.trans.flush()
5196 
 
4488 rajveer 5197 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5198 
    args = markOrderReturnRequestReceived_args()
5199 
    args.read(iprot)
5200 
    iprot.readMessageEnd()
5201 
    result = markOrderReturnRequestReceived_result()
5202 
    try:
5203 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5204 
    except TransactionServiceException, ex:
5205 
      result.ex = ex
5206 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5207 
    result.write(oprot)
5208 
    oprot.writeMessageEnd()
5209 
    oprot.trans.flush()
5210 
 
5211 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5212 
    args = markOrderReturnRequestAuthorized_args()
5213 
    args.read(iprot)
5214 
    iprot.readMessageEnd()
5215 
    result = markOrderReturnRequestAuthorized_result()
5216 
    try:
5217 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5218 
    except TransactionServiceException, ex:
5219 
      result.ex = ex
5220 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5221 
    result.write(oprot)
5222 
    oprot.writeMessageEnd()
5223 
    oprot.trans.flush()
5224 
 
2536 chandransh 5225 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5226 
    args = requestPickupNumber_args()
5227 
    args.read(iprot)
5228 
    iprot.readMessageEnd()
5229 
    result = requestPickupNumber_result()
5230 
    try:
4579 rajveer 5231 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5232 
    except TransactionServiceException, ex:
5233 
      result.ex = ex
5234 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5235 
    result.write(oprot)
5236 
    oprot.writeMessageEnd()
5237 
    oprot.trans.flush()
5238 
 
5239 
  def process_authorizePickup(self, seqid, iprot, oprot):
5240 
    args = authorizePickup_args()
5241 
    args.read(iprot)
5242 
    iprot.readMessageEnd()
5243 
    result = authorizePickup_result()
5244 
    try:
4602 rajveer 5245 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5246 
    except TransactionServiceException, ex:
5247 
      result.ex = ex
5248 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5249 
    result.write(oprot)
5250 
    oprot.writeMessageEnd()
5251 
    oprot.trans.flush()
5252 
 
2764 chandransh 5253 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5254 
    args = markDoasAsPickedUp_args()
5255 
    args.read(iprot)
5256 
    iprot.readMessageEnd()
5257 
    result = markDoasAsPickedUp_result()
5258 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
5259 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5260 
    result.write(oprot)
5261 
    oprot.writeMessageEnd()
5262 
    oprot.trans.flush()
5263 
 
4741 phani.kuma 5264 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5265 
    args = markReturnOrdersAsPickedUp_args()
5266 
    args.read(iprot)
5267 
    iprot.readMessageEnd()
5268 
    result = markReturnOrdersAsPickedUp_result()
5269 
    result.success = self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
5270 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5271 
    result.write(oprot)
5272 
    oprot.writeMessageEnd()
5273 
    oprot.trans.flush()
5274 
 
2616 chandransh 5275 
  def process_receiveReturn(self, seqid, iprot, oprot):
5276 
    args = receiveReturn_args()
2591 chandransh 5277 
    args.read(iprot)
5278 
    iprot.readMessageEnd()
2616 chandransh 5279 
    result = receiveReturn_result()
2591 chandransh 5280 
    try:
4479 rajveer 5281 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5282 
    except TransactionServiceException, ex:
5283 
      result.ex = ex
2616 chandransh 5284 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5285 
    result.write(oprot)
5286 
    oprot.writeMessageEnd()
5287 
    oprot.trans.flush()
2536 chandransh 5288 
 
2591 chandransh 5289 
  def process_validateDoa(self, seqid, iprot, oprot):
5290 
    args = validateDoa_args()
5291 
    args.read(iprot)
5292 
    iprot.readMessageEnd()
5293 
    result = validateDoa_result()
5294 
    try:
5295 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5296 
    except TransactionServiceException, ex:
5297 
      result.ex = ex
5298 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5299 
    result.write(oprot)
5300 
    oprot.writeMessageEnd()
5301 
    oprot.trans.flush()
5302 
 
4495 rajveer 5303 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5304 
    args = validateReturnProduct_args()
5305 
    args.read(iprot)
5306 
    iprot.readMessageEnd()
5307 
    result = validateReturnProduct_result()
5308 
    try:
5309 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5310 
    except TransactionServiceException, ex:
5311 
      result.ex = ex
5312 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5313 
    result.write(oprot)
5314 
    oprot.writeMessageEnd()
5315 
    oprot.trans.flush()
5316 
 
2616 chandransh 5317 
  def process_reshipOrder(self, seqid, iprot, oprot):
5318 
    args = reshipOrder_args()
5319 
    args.read(iprot)
5320 
    iprot.readMessageEnd()
5321 
    result = reshipOrder_result()
5322 
    try:
5323 
      result.success = self._handler.reshipOrder(args.orderId)
5324 
    except TransactionServiceException, ex:
5325 
      result.ex = ex
5326 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5327 
    result.write(oprot)
5328 
    oprot.writeMessageEnd()
5329 
    oprot.trans.flush()
2591 chandransh 5330 
 
2616 chandransh 5331 
  def process_refundOrder(self, seqid, iprot, oprot):
5332 
    args = refundOrder_args()
5333 
    args.read(iprot)
5334 
    iprot.readMessageEnd()
5335 
    result = refundOrder_result()
5336 
    try:
3226 chandransh 5337 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5338 
    except TransactionServiceException, ex:
5339 
      result.ex = ex
5340 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5341 
    result.write(oprot)
5342 
    oprot.writeMessageEnd()
5343 
    oprot.trans.flush()
5344 
 
2690 chandransh 5345 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5346 
    args = getReturnOrders_args()
5347 
    args.read(iprot)
5348 
    iprot.readMessageEnd()
5349 
    result = getReturnOrders_result()
5350 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5351 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5352 
    result.write(oprot)
5353 
    oprot.writeMessageEnd()
5354 
    oprot.trans.flush()
2616 chandransh 5355 
 
2700 chandransh 5356 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5357 
    args = getReturnOrder_args()
5358 
    args.read(iprot)
5359 
    iprot.readMessageEnd()
5360 
    result = getReturnOrder_result()
5361 
    try:
5362 
      result.success = self._handler.getReturnOrder(args.id)
5363 
    except TransactionServiceException, ex:
5364 
      result.ex = ex
5365 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5366 
    result.write(oprot)
5367 
    oprot.writeMessageEnd()
5368 
    oprot.trans.flush()
5369 
 
2690 chandransh 5370 
  def process_processReturn(self, seqid, iprot, oprot):
5371 
    args = processReturn_args()
5372 
    args.read(iprot)
5373 
    iprot.readMessageEnd()
5374 
    result = processReturn_result()
5375 
    try:
5376 
      self._handler.processReturn(args.returnOrderId)
5377 
    except TransactionServiceException, ex:
5378 
      result.ex = ex
5379 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5380 
    result.write(oprot)
5381 
    oprot.writeMessageEnd()
5382 
    oprot.trans.flush()
5383 
 
3451 chandransh 5384 
  def process_updateWeight(self, seqid, iprot, oprot):
5385 
    args = updateWeight_args()
5386 
    args.read(iprot)
5387 
    iprot.readMessageEnd()
5388 
    result = updateWeight_result()
5389 
    try:
5390 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5391 
    except TransactionServiceException, ex:
5392 
      result.ex = ex
5393 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5394 
    result.write(oprot)
5395 
    oprot.writeMessageEnd()
5396 
    oprot.trans.flush()
2819 chandransh 5397 
 
3469 chandransh 5398 
  def process_changeItem(self, seqid, iprot, oprot):
5399 
    args = changeItem_args()
5400 
    args.read(iprot)
5401 
    iprot.readMessageEnd()
5402 
    result = changeItem_result()
5403 
    try:
5404 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5405 
    except TransactionServiceException, ex:
5406 
      result.ex = ex
5407 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5408 
    result.write(oprot)
5409 
    oprot.writeMessageEnd()
5410 
    oprot.trans.flush()
3451 chandransh 5411 
 
3469 chandransh 5412 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
5413 
    args = shiftToWarehouse_args()
5414 
    args.read(iprot)
5415 
    iprot.readMessageEnd()
5416 
    result = shiftToWarehouse_result()
5417 
    try:
5418 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
5419 
    except TransactionServiceException, ex:
5420 
      result.ex = ex
5421 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
5422 
    result.write(oprot)
5423 
    oprot.writeMessageEnd()
5424 
    oprot.trans.flush()
5425 
 
3553 chandransh 5426 
  def process_addDelayReason(self, seqid, iprot, oprot):
5427 
    args = addDelayReason_args()
5428 
    args.read(iprot)
5429 
    iprot.readMessageEnd()
5430 
    result = addDelayReason_result()
5431 
    try:
4647 rajveer 5432 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 5433 
    except TransactionServiceException, ex:
5434 
      result.ex = ex
5435 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
5436 
    result.write(oprot)
5437 
    oprot.writeMessageEnd()
5438 
    oprot.trans.flush()
3469 chandransh 5439 
 
3956 chandransh 5440 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
5441 
    args = reconcileCodCollection_args()
5442 
    args.read(iprot)
5443 
    iprot.readMessageEnd()
5444 
    result = reconcileCodCollection_result()
5445 
    try:
5446 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
5447 
    except TransactionServiceException, ex:
5448 
      result.ex = ex
5449 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
5450 
    result.write(oprot)
5451 
    oprot.writeMessageEnd()
5452 
    oprot.trans.flush()
3553 chandransh 5453 
 
4008 mandeep.dh 5454 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
5455 
    args = getTransactionsRequiringExtraProcessing_args()
5456 
    args.read(iprot)
5457 
    iprot.readMessageEnd()
5458 
    result = getTransactionsRequiringExtraProcessing_result()
5459 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
5460 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
5461 
    result.write(oprot)
5462 
    oprot.writeMessageEnd()
5463 
    oprot.trans.flush()
3956 chandransh 5464 
 
4008 mandeep.dh 5465 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
5466 
    args = markTransactionAsProcessed_args()
5467 
    args.read(iprot)
5468 
    iprot.readMessageEnd()
5469 
    result = markTransactionAsProcessed_result()
5470 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
5471 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
5472 
    result.write(oprot)
5473 
    oprot.writeMessageEnd()
5474 
    oprot.trans.flush()
5475 
 
4018 chandransh 5476 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
5477 
    args = getItemWiseRiskyOrdersCount_args()
5478 
    args.read(iprot)
5479 
    iprot.readMessageEnd()
5480 
    result = getItemWiseRiskyOrdersCount_result()
5481 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
5482 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
5483 
    result.write(oprot)
5484 
    oprot.writeMessageEnd()
5485 
    oprot.trans.flush()
4008 mandeep.dh 5486 
 
4295 varun.gupt 5487 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
5488 
    args = getOrdersForItemIds_args()
5489 
    args.read(iprot)
5490 
    iprot.readMessageEnd()
5491 
    result = getOrdersForItemIds_result()
5492 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
5493 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
5494 
    result.write(oprot)
5495 
    oprot.writeMessageEnd()
5496 
    oprot.trans.flush()
5497 
 
4247 rajveer 5498 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
5499 
    args = markOrderCancellationRequestReceived_args()
5500 
    args.read(iprot)
5501 
    iprot.readMessageEnd()
5502 
    result = markOrderCancellationRequestReceived_result()
5503 
    try:
5504 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
5505 
    except TransactionServiceException, ex:
5506 
      result.ex = ex
5507 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
5508 
    result.write(oprot)
5509 
    oprot.writeMessageEnd()
5510 
    oprot.trans.flush()
4018 chandransh 5511 
 
4247 rajveer 5512 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
5513 
    args = markOrderCancellationRequestConfirmed_args()
5514 
    args.read(iprot)
5515 
    iprot.readMessageEnd()
5516 
    result = markOrderCancellationRequestConfirmed_result()
5517 
    try:
5518 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
5519 
    except TransactionServiceException, ex:
5520 
      result.ex = ex
5521 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
5522 
    result.write(oprot)
5523 
    oprot.writeMessageEnd()
5524 
    oprot.trans.flush()
5525 
 
5526 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
5527 
    args = markOrderCancellationRequestDenied_args()
5528 
    args.read(iprot)
5529 
    iprot.readMessageEnd()
5530 
    result = markOrderCancellationRequestDenied_result()
5531 
    try:
5532 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
5533 
    except TransactionServiceException, ex:
5534 
      result.ex = ex
5535 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
5536 
    result.write(oprot)
5537 
    oprot.writeMessageEnd()
5538 
    oprot.trans.flush()
5539 
 
4258 rajveer 5540 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
5541 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 5542 
    args.read(iprot)
5543 
    iprot.readMessageEnd()
4258 rajveer 5544 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 5545 
    try:
4258 rajveer 5546 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 5547 
    except TransactionServiceException, ex:
5548 
      result.ex = ex
4258 rajveer 5549 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 5550 
    result.write(oprot)
5551 
    oprot.writeMessageEnd()
5552 
    oprot.trans.flush()
5553 
 
4259 anupam.sin 5554 
  def process_refundTransaction(self, seqid, iprot, oprot):
5555 
    args = refundTransaction_args()
5556 
    args.read(iprot)
5557 
    iprot.readMessageEnd()
5558 
    result = refundTransaction_result()
5559 
    try:
5560 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
5561 
    except TransactionServiceException, ex:
5562 
      result.ex = ex
5563 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
5564 
    result.write(oprot)
5565 
    oprot.writeMessageEnd()
5566 
    oprot.trans.flush()
4247 rajveer 5567 
 
4324 mandeep.dh 5568 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
5569 
    args = updateShipmentAddress_args()
5570 
    args.read(iprot)
5571 
    iprot.readMessageEnd()
5572 
    result = updateShipmentAddress_result()
5573 
    try:
5574 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
5575 
    except TransactionServiceException, ex:
5576 
      result.ex = ex
5577 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
5578 
    result.write(oprot)
5579 
    oprot.writeMessageEnd()
5580 
    oprot.trans.flush()
5581 
 
4285 rajveer 5582 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
5583 
    args = acceptOrdersForItemId_args()
5584 
    args.read(iprot)
5585 
    iprot.readMessageEnd()
5586 
    result = acceptOrdersForItemId_result()
5587 
    try:
5588 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
5589 
    except TransactionServiceException, ex:
5590 
      result.ex = ex
5591 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
5592 
    result.write(oprot)
5593 
    oprot.writeMessageEnd()
5594 
    oprot.trans.flush()
4259 anupam.sin 5595 
 
4303 rajveer 5596 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
5597 
    args = markOrdersAsPORaised_args()
5598 
    args.read(iprot)
5599 
    iprot.readMessageEnd()
5600 
    result = markOrdersAsPORaised_result()
5601 
    try:
4369 rajveer 5602 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5603 
    except TransactionServiceException, ex:
5604 
      result.ex = ex
5605 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
5606 
    result.write(oprot)
5607 
    oprot.writeMessageEnd()
5608 
    oprot.trans.flush()
4285 rajveer 5609 
 
4303 rajveer 5610 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
5611 
    args = markOrdersAsReversalInitiated_args()
5612 
    args.read(iprot)
5613 
    iprot.readMessageEnd()
5614 
    result = markOrdersAsReversalInitiated_result()
5615 
    try:
4369 rajveer 5616 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5617 
    except TransactionServiceException, ex:
5618 
      result.ex = ex
5619 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
5620 
    result.write(oprot)
5621 
    oprot.writeMessageEnd()
5622 
    oprot.trans.flush()
5623 
 
5624 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
5625 
    args = markOrdersAsNotAvailabke_args()
5626 
    args.read(iprot)
5627 
    iprot.readMessageEnd()
5628 
    result = markOrdersAsNotAvailabke_result()
5629 
    try:
4369 rajveer 5630 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 5631 
    except TransactionServiceException, ex:
5632 
      result.ex = ex
5633 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
5634 
    result.write(oprot)
5635 
    oprot.writeMessageEnd()
5636 
    oprot.trans.flush()
5637 
 
4369 rajveer 5638 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
5639 
    args = markOrdersAsTimeout_args()
5640 
    args.read(iprot)
5641 
    iprot.readMessageEnd()
5642 
    result = markOrdersAsTimeout_result()
5643 
    try:
5644 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
5645 
    except TransactionServiceException, ex:
5646 
      result.ex = ex
5647 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
5648 
    result.write(oprot)
5649 
    oprot.writeMessageEnd()
5650 
    oprot.trans.flush()
4303 rajveer 5651 
 
4662 rajveer 5652 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
5653 
    args = markOrderAsLostInTransit_args()
5654 
    args.read(iprot)
5655 
    iprot.readMessageEnd()
5656 
    result = markOrderAsLostInTransit_result()
5657 
    try:
5658 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
5659 
    except TransactionServiceException, ex:
5660 
      result.ex = ex
5661 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
5662 
    result.write(oprot)
5663 
    oprot.writeMessageEnd()
5664 
    oprot.trans.flush()
5665 
 
4386 anupam.sin 5666 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
5667 
    args = getOrderForAwb_args()
5668 
    args.read(iprot)
5669 
    iprot.readMessageEnd()
5670 
    result = getOrderForAwb_result()
5671 
    try:
5672 
      result.success = self._handler.getOrderForAwb(args.awb)
5673 
    except TransactionServiceException, ex:
5674 
      result.ex = ex
5675 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
5676 
    result.write(oprot)
5677 
    oprot.writeMessageEnd()
5678 
    oprot.trans.flush()
4369 rajveer 5679 
 
4506 phani.kuma 5680 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
5681 
    args = getOrdersForProviderForStatus_args()
5682 
    args.read(iprot)
5683 
    iprot.readMessageEnd()
5684 
    result = getOrdersForProviderForStatus_result()
5685 
    try:
5686 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
5687 
    except TransactionServiceException, ex:
5688 
      result.ex = ex
5689 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
5690 
    result.write(oprot)
5691 
    oprot.writeMessageEnd()
5692 
    oprot.trans.flush()
4386 anupam.sin 5693 
 
4600 varun.gupt 5694 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
5695 
    args = getBilledOrdersForVendor_args()
5696 
    args.read(iprot)
5697 
    iprot.readMessageEnd()
5698 
    result = getBilledOrdersForVendor_result()
5699 
    try:
5700 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
5701 
    except TransactionServiceException, ex:
5702 
      result.ex = ex
5703 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
5704 
    result.write(oprot)
5705 
    oprot.writeMessageEnd()
5706 
    oprot.trans.flush()
4506 phani.kuma 5707 
 
4607 rajveer 5708 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
5709 
    args = getSlippedSippingDateOrders_args()
5710 
    args.read(iprot)
5711 
    iprot.readMessageEnd()
5712 
    result = getSlippedSippingDateOrders_result()
5713 
    try:
5714 
      result.success = self._handler.getSlippedSippingDateOrders()
5715 
    except TransactionServiceException, ex:
5716 
      result.ex = ex
5717 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
5718 
    result.write(oprot)
5719 
    oprot.writeMessageEnd()
5720 
    oprot.trans.flush()
5721 
 
4709 rajveer 5722 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
5723 
    args = getCancelledOrders_args()
5724 
    args.read(iprot)
5725 
    iprot.readMessageEnd()
5726 
    result = getCancelledOrders_result()
5727 
    try:
5728 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
5729 
    except TransactionServiceException, ex:
5730 
      result.ex = ex
5731 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
5732 
    result.write(oprot)
5733 
    oprot.writeMessageEnd()
5734 
    oprot.trans.flush()
5735 
 
4600 varun.gupt 5736 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
5737 
    args = saveBluedartSettlements_args()
5738 
    args.read(iprot)
5739 
    iprot.readMessageEnd()
5740 
    result = saveBluedartSettlements_result()
5741 
    try:
5742 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
5743 
    except TransactionServiceException, ex:
5744 
      result.ex = ex
5745 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
5746 
    result.write(oprot)
5747 
    oprot.writeMessageEnd()
5748 
    oprot.trans.flush()
5749 
 
5750 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
5751 
    args = savePaymentSettlements_args()
5752 
    args.read(iprot)
5753 
    iprot.readMessageEnd()
5754 
    result = savePaymentSettlements_result()
5755 
    try:
5756 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.paymentId, args.serviceTax, args.otherCharges, args.netCollection)
5757 
    except TransactionServiceException, ex:
5758 
      result.ex = ex
5759 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
5760 
    result.write(oprot)
5761 
    oprot.writeMessageEnd()
5762 
    oprot.trans.flush()
5763 
 
5764 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
5765 
    args = saveEBSSettlementSummary_args()
5766 
    args.read(iprot)
5767 
    iprot.readMessageEnd()
5768 
    result = saveEBSSettlementSummary_result()
5769 
    try:
5770 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
5771 
    except TransactionServiceException, ex:
5772 
      result.ex = ex
5773 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
5774 
    result.write(oprot)
5775 
    oprot.writeMessageEnd()
5776 
    oprot.trans.flush()
5777 
 
5778 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
5779 
    args = getSettlementForPaymentId_args()
5780 
    args.read(iprot)
5781 
    iprot.readMessageEnd()
5782 
    result = getSettlementForPaymentId_result()
5783 
    try:
5784 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
5785 
    except TransactionServiceException, ex:
5786 
      result.ex = ex
5787 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
5788 
    result.write(oprot)
5789 
    oprot.writeMessageEnd()
5790 
    oprot.trans.flush()
5791 
 
5792 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
5793 
    args = getEBSSettlementSummaries_args()
5794 
    args.read(iprot)
5795 
    iprot.readMessageEnd()
5796 
    result = getEBSSettlementSummaries_result()
5797 
    try:
5798 
      result.success = self._handler.getEBSSettlementSummaries()
5799 
    except TransactionServiceException, ex:
5800 
      result.ex = ex
5801 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
5802 
    result.write(oprot)
5803 
    oprot.writeMessageEnd()
5804 
    oprot.trans.flush()
5805 
 
5806 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
5807 
    args = markEBSSettlementUploaded_args()
5808 
    args.read(iprot)
5809 
    iprot.readMessageEnd()
5810 
    result = markEBSSettlementUploaded_result()
5811 
    try:
5812 
      self._handler.markEBSSettlementUploaded(args.settlementId)
5813 
    except TransactionServiceException, ex:
5814 
      result.ex = ex
5815 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
5816 
    result.write(oprot)
5817 
    oprot.writeMessageEnd()
5818 
    oprot.trans.flush()
5819 
 
5820 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
5821 
    args = getEBSSettlementDate_args()
5822 
    args.read(iprot)
5823 
    iprot.readMessageEnd()
5824 
    result = getEBSSettlementDate_result()
5825 
    try:
5826 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
5827 
    except TransactionServiceException, ex:
5828 
      result.ex = ex
5829 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
5830 
    result.write(oprot)
5831 
    oprot.writeMessageEnd()
5832 
    oprot.trans.flush()
5833 
 
4715 varun.gupt 5834 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
5835 
    args = getSettlementsByDate_args()
5836 
    args.read(iprot)
5837 
    iprot.readMessageEnd()
5838 
    result = getSettlementsByDate_result()
5839 
    try:
5840 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
5841 
    except TransactionServiceException, ex:
5842 
      result.ex = ex
5843 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
5844 
    result.write(oprot)
5845 
    oprot.writeMessageEnd()
5846 
    oprot.trans.flush()
4600 varun.gupt 5847 
 
4715 varun.gupt 5848 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
5849 
    args = getReshippedOrderIds_args()
5850 
    args.read(iprot)
5851 
    iprot.readMessageEnd()
5852 
    result = getReshippedOrderIds_result()
5853 
    try:
5854 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
5855 
    except TransactionServiceException, ex:
5856 
      result.ex = ex
5857 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
5858 
    result.write(oprot)
5859 
    oprot.writeMessageEnd()
5860 
    oprot.trans.flush()
5861 
 
4757 mandeep.dh 5862 
  def process_updateOrdersAsPORaised(self, seqid, iprot, oprot):
5863 
    args = updateOrdersAsPORaised_args()
5864 
    args.read(iprot)
5865 
    iprot.readMessageEnd()
5866 
    result = updateOrdersAsPORaised_result()
5867 
    try:
5868 
      self._handler.updateOrdersAsPORaised(args.itemIdQuantityMap, args.purchaseOrderId, args.warehouseId)
5869 
    except TransactionServiceException, ex:
5870 
      result.ex = ex
5871 
    oprot.writeMessageBegin("updateOrdersAsPORaised", TMessageType.REPLY, seqid)
5872 
    result.write(oprot)
5873 
    oprot.writeMessageEnd()
5874 
    oprot.trans.flush()
4715 varun.gupt 5875 
 
4757 mandeep.dh 5876 
 
94 ashish 5877 
# HELPER FUNCTIONS AND STRUCTURES
5878 
 
5879 
class createTransaction_args:
5880 
  """
5881 
  Attributes:
5882 
   - transaction
5883 
  """
5884 
 
5885 
  thrift_spec = (
5886 
    None, # 0
5887 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
5888 
  )
5889 
 
5890 
  def __init__(self, transaction=None,):
5891 
    self.transaction = transaction
5892 
 
5893 
  def read(self, iprot):
5894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5896 
      return
5897 
    iprot.readStructBegin()
5898 
    while True:
5899 
      (fname, ftype, fid) = iprot.readFieldBegin()
5900 
      if ftype == TType.STOP:
5901 
        break
5902 
      if fid == 1:
5903 
        if ftype == TType.STRUCT:
5904 
          self.transaction = Transaction()
5905 
          self.transaction.read(iprot)
5906 
        else:
5907 
          iprot.skip(ftype)
5908 
      else:
5909 
        iprot.skip(ftype)
5910 
      iprot.readFieldEnd()
5911 
    iprot.readStructEnd()
5912 
 
5913 
  def write(self, oprot):
5914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5916 
      return
5917 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 5918 
    if self.transaction is not None:
94 ashish 5919 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
5920 
      self.transaction.write(oprot)
5921 
      oprot.writeFieldEnd()
5922 
    oprot.writeFieldStop()
5923 
    oprot.writeStructEnd()
5924 
 
3431 rajveer 5925 
  def validate(self):
5926 
    return
5927 
 
5928 
 
94 ashish 5929 
  def __repr__(self):
5930 
    L = ['%s=%r' % (key, value)
5931 
      for key, value in self.__dict__.iteritems()]
5932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5933 
 
5934 
  def __eq__(self, other):
5935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5936 
 
5937 
  def __ne__(self, other):
5938 
    return not (self == other)
5939 
 
5940 
class createTransaction_result:
5941 
  """
5942 
  Attributes:
132 ashish 5943 
   - success
94 ashish 5944 
   - ex
5945 
  """
5946 
 
5947 
  thrift_spec = (
132 ashish 5948 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5949 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5950 
  )
5951 
 
132 ashish 5952 
  def __init__(self, success=None, ex=None,):
5953 
    self.success = success
94 ashish 5954 
    self.ex = ex
5955 
 
5956 
  def read(self, iprot):
5957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5959 
      return
5960 
    iprot.readStructBegin()
5961 
    while True:
5962 
      (fname, ftype, fid) = iprot.readFieldBegin()
5963 
      if ftype == TType.STOP:
5964 
        break
132 ashish 5965 
      if fid == 0:
5966 
        if ftype == TType.I64:
5967 
          self.success = iprot.readI64();
5968 
        else:
5969 
          iprot.skip(ftype)
5970 
      elif fid == 1:
94 ashish 5971 
        if ftype == TType.STRUCT:
5972 
          self.ex = TransactionServiceException()
5973 
          self.ex.read(iprot)
5974 
        else:
5975 
          iprot.skip(ftype)
5976 
      else:
5977 
        iprot.skip(ftype)
5978 
      iprot.readFieldEnd()
5979 
    iprot.readStructEnd()
5980 
 
5981 
  def write(self, oprot):
5982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5984 
      return
5985 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 5986 
    if self.success is not None:
132 ashish 5987 
      oprot.writeFieldBegin('success', TType.I64, 0)
5988 
      oprot.writeI64(self.success)
5989 
      oprot.writeFieldEnd()
3431 rajveer 5990 
    if self.ex is not None:
94 ashish 5991 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5992 
      self.ex.write(oprot)
5993 
      oprot.writeFieldEnd()
5994 
    oprot.writeFieldStop()
5995 
    oprot.writeStructEnd()
5996 
 
3431 rajveer 5997 
  def validate(self):
5998 
    return
5999 
 
6000 
 
94 ashish 6001 
  def __repr__(self):
6002 
    L = ['%s=%r' % (key, value)
6003 
      for key, value in self.__dict__.iteritems()]
6004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6005 
 
6006 
  def __eq__(self, other):
6007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6008 
 
6009 
  def __ne__(self, other):
6010 
    return not (self == other)
6011 
 
6012 
class getTransaction_args:
6013 
  """
6014 
  Attributes:
6015 
   - id
6016 
  """
6017 
 
6018 
  thrift_spec = (
6019 
    None, # 0
6020 
    (1, TType.I64, 'id', None, None, ), # 1
6021 
  )
6022 
 
6023 
  def __init__(self, id=None,):
6024 
    self.id = id
6025 
 
6026 
  def read(self, iprot):
6027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6029 
      return
6030 
    iprot.readStructBegin()
6031 
    while True:
6032 
      (fname, ftype, fid) = iprot.readFieldBegin()
6033 
      if ftype == TType.STOP:
6034 
        break
6035 
      if fid == 1:
6036 
        if ftype == TType.I64:
6037 
          self.id = iprot.readI64();
6038 
        else:
6039 
          iprot.skip(ftype)
6040 
      else:
6041 
        iprot.skip(ftype)
6042 
      iprot.readFieldEnd()
6043 
    iprot.readStructEnd()
6044 
 
6045 
  def write(self, oprot):
6046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6048 
      return
6049 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6050 
    if self.id is not None:
94 ashish 6051 
      oprot.writeFieldBegin('id', TType.I64, 1)
6052 
      oprot.writeI64(self.id)
6053 
      oprot.writeFieldEnd()
6054 
    oprot.writeFieldStop()
6055 
    oprot.writeStructEnd()
6056 
 
3431 rajveer 6057 
  def validate(self):
6058 
    return
6059 
 
6060 
 
94 ashish 6061 
  def __repr__(self):
6062 
    L = ['%s=%r' % (key, value)
6063 
      for key, value in self.__dict__.iteritems()]
6064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6065 
 
6066 
  def __eq__(self, other):
6067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6068 
 
6069 
  def __ne__(self, other):
6070 
    return not (self == other)
6071 
 
6072 
class getTransaction_result:
6073 
  """
6074 
  Attributes:
6075 
   - success
6076 
   - ex
6077 
  """
6078 
 
6079 
  thrift_spec = (
6080 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6081 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6082 
  )
6083 
 
6084 
  def __init__(self, success=None, ex=None,):
6085 
    self.success = success
6086 
    self.ex = ex
6087 
 
6088 
  def read(self, iprot):
6089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6091 
      return
6092 
    iprot.readStructBegin()
6093 
    while True:
6094 
      (fname, ftype, fid) = iprot.readFieldBegin()
6095 
      if ftype == TType.STOP:
6096 
        break
6097 
      if fid == 0:
6098 
        if ftype == TType.STRUCT:
6099 
          self.success = Transaction()
6100 
          self.success.read(iprot)
6101 
        else:
6102 
          iprot.skip(ftype)
6103 
      elif fid == 1:
6104 
        if ftype == TType.STRUCT:
6105 
          self.ex = TransactionServiceException()
6106 
          self.ex.read(iprot)
6107 
        else:
6108 
          iprot.skip(ftype)
6109 
      else:
6110 
        iprot.skip(ftype)
6111 
      iprot.readFieldEnd()
6112 
    iprot.readStructEnd()
6113 
 
6114 
  def write(self, oprot):
6115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6117 
      return
6118 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6119 
    if self.success is not None:
94 ashish 6120 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6121 
      self.success.write(oprot)
6122 
      oprot.writeFieldEnd()
3431 rajveer 6123 
    if self.ex is not None:
94 ashish 6124 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6125 
      self.ex.write(oprot)
6126 
      oprot.writeFieldEnd()
6127 
    oprot.writeFieldStop()
6128 
    oprot.writeStructEnd()
6129 
 
3431 rajveer 6130 
  def validate(self):
6131 
    return
6132 
 
6133 
 
94 ashish 6134 
  def __repr__(self):
6135 
    L = ['%s=%r' % (key, value)
6136 
      for key, value in self.__dict__.iteritems()]
6137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6138 
 
6139 
  def __eq__(self, other):
6140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6141 
 
6142 
  def __ne__(self, other):
6143 
    return not (self == other)
6144 
 
6145 
class getTransactionsForCustomer_args:
6146 
  """
6147 
  Attributes:
6148 
   - customerId
6149 
   - from_date
6150 
   - to_date
6151 
   - status
6152 
  """
6153 
 
6154 
  thrift_spec = (
6155 
    None, # 0
6156 
    (1, TType.I64, 'customerId', None, None, ), # 1
6157 
    (2, TType.I64, 'from_date', None, None, ), # 2
6158 
    (3, TType.I64, 'to_date', None, None, ), # 3
6159 
    (4, TType.I32, 'status', None, None, ), # 4
6160 
  )
6161 
 
6162 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6163 
    self.customerId = customerId
6164 
    self.from_date = from_date
6165 
    self.to_date = to_date
6166 
    self.status = status
6167 
 
6168 
  def read(self, iprot):
6169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6171 
      return
6172 
    iprot.readStructBegin()
6173 
    while True:
6174 
      (fname, ftype, fid) = iprot.readFieldBegin()
6175 
      if ftype == TType.STOP:
6176 
        break
6177 
      if fid == 1:
6178 
        if ftype == TType.I64:
6179 
          self.customerId = iprot.readI64();
6180 
        else:
6181 
          iprot.skip(ftype)
6182 
      elif fid == 2:
6183 
        if ftype == TType.I64:
6184 
          self.from_date = iprot.readI64();
6185 
        else:
6186 
          iprot.skip(ftype)
6187 
      elif fid == 3:
6188 
        if ftype == TType.I64:
6189 
          self.to_date = iprot.readI64();
6190 
        else:
6191 
          iprot.skip(ftype)
6192 
      elif fid == 4:
6193 
        if ftype == TType.I32:
6194 
          self.status = iprot.readI32();
6195 
        else:
6196 
          iprot.skip(ftype)
6197 
      else:
6198 
        iprot.skip(ftype)
6199 
      iprot.readFieldEnd()
6200 
    iprot.readStructEnd()
6201 
 
6202 
  def write(self, oprot):
6203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6205 
      return
6206 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6207 
    if self.customerId is not None:
94 ashish 6208 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6209 
      oprot.writeI64(self.customerId)
6210 
      oprot.writeFieldEnd()
3431 rajveer 6211 
    if self.from_date is not None:
94 ashish 6212 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6213 
      oprot.writeI64(self.from_date)
6214 
      oprot.writeFieldEnd()
3431 rajveer 6215 
    if self.to_date is not None:
94 ashish 6216 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6217 
      oprot.writeI64(self.to_date)
6218 
      oprot.writeFieldEnd()
3431 rajveer 6219 
    if self.status is not None:
94 ashish 6220 
      oprot.writeFieldBegin('status', TType.I32, 4)
6221 
      oprot.writeI32(self.status)
6222 
      oprot.writeFieldEnd()
6223 
    oprot.writeFieldStop()
6224 
    oprot.writeStructEnd()
6225 
 
3431 rajveer 6226 
  def validate(self):
6227 
    return
6228 
 
6229 
 
94 ashish 6230 
  def __repr__(self):
6231 
    L = ['%s=%r' % (key, value)
6232 
      for key, value in self.__dict__.iteritems()]
6233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6234 
 
6235 
  def __eq__(self, other):
6236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6237 
 
6238 
  def __ne__(self, other):
6239 
    return not (self == other)
6240 
 
6241 
class getTransactionsForCustomer_result:
6242 
  """
6243 
  Attributes:
6244 
   - success
6245 
   - ex
6246 
  """
6247 
 
6248 
  thrift_spec = (
6249 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6250 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6251 
  )
6252 
 
6253 
  def __init__(self, success=None, ex=None,):
6254 
    self.success = success
6255 
    self.ex = ex
6256 
 
6257 
  def read(self, iprot):
6258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6260 
      return
6261 
    iprot.readStructBegin()
6262 
    while True:
6263 
      (fname, ftype, fid) = iprot.readFieldBegin()
6264 
      if ftype == TType.STOP:
6265 
        break
6266 
      if fid == 0:
6267 
        if ftype == TType.LIST:
6268 
          self.success = []
685 chandransh 6269 
          (_etype17, _size14) = iprot.readListBegin()
6270 
          for _i18 in xrange(_size14):
6271 
            _elem19 = Transaction()
6272 
            _elem19.read(iprot)
6273 
            self.success.append(_elem19)
94 ashish 6274 
          iprot.readListEnd()
6275 
        else:
6276 
          iprot.skip(ftype)
6277 
      elif fid == 1:
6278 
        if ftype == TType.STRUCT:
6279 
          self.ex = TransactionServiceException()
6280 
          self.ex.read(iprot)
6281 
        else:
6282 
          iprot.skip(ftype)
6283 
      else:
6284 
        iprot.skip(ftype)
6285 
      iprot.readFieldEnd()
6286 
    iprot.readStructEnd()
6287 
 
6288 
  def write(self, oprot):
6289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6291 
      return
6292 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6293 
    if self.success is not None:
94 ashish 6294 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6295 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6296 
      for iter20 in self.success:
6297 
        iter20.write(oprot)
94 ashish 6298 
      oprot.writeListEnd()
6299 
      oprot.writeFieldEnd()
3431 rajveer 6300 
    if self.ex is not None:
94 ashish 6301 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6302 
      self.ex.write(oprot)
6303 
      oprot.writeFieldEnd()
6304 
    oprot.writeFieldStop()
6305 
    oprot.writeStructEnd()
6306 
 
3431 rajveer 6307 
  def validate(self):
6308 
    return
6309 
 
6310 
 
94 ashish 6311 
  def __repr__(self):
6312 
    L = ['%s=%r' % (key, value)
6313 
      for key, value in self.__dict__.iteritems()]
6314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6315 
 
6316 
  def __eq__(self, other):
6317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6318 
 
6319 
  def __ne__(self, other):
6320 
    return not (self == other)
6321 
 
132 ashish 6322 
class getTransactionsForShoppingCartId_args:
6323 
  """
6324 
  Attributes:
6325 
   - shoppingCartId
6326 
  """
6327 
 
6328 
  thrift_spec = (
6329 
    None, # 0
6330 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
6331 
  )
6332 
 
6333 
  def __init__(self, shoppingCartId=None,):
6334 
    self.shoppingCartId = shoppingCartId
6335 
 
6336 
  def read(self, iprot):
6337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6339 
      return
6340 
    iprot.readStructBegin()
6341 
    while True:
6342 
      (fname, ftype, fid) = iprot.readFieldBegin()
6343 
      if ftype == TType.STOP:
6344 
        break
6345 
      if fid == 1:
6346 
        if ftype == TType.I64:
6347 
          self.shoppingCartId = iprot.readI64();
6348 
        else:
6349 
          iprot.skip(ftype)
6350 
      else:
6351 
        iprot.skip(ftype)
6352 
      iprot.readFieldEnd()
6353 
    iprot.readStructEnd()
6354 
 
6355 
  def write(self, oprot):
6356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6358 
      return
6359 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 6360 
    if self.shoppingCartId is not None:
132 ashish 6361 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
6362 
      oprot.writeI64(self.shoppingCartId)
6363 
      oprot.writeFieldEnd()
6364 
    oprot.writeFieldStop()
6365 
    oprot.writeStructEnd()
6366 
 
3431 rajveer 6367 
  def validate(self):
6368 
    return
6369 
 
6370 
 
132 ashish 6371 
  def __repr__(self):
6372 
    L = ['%s=%r' % (key, value)
6373 
      for key, value in self.__dict__.iteritems()]
6374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6375 
 
6376 
  def __eq__(self, other):
6377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6378 
 
6379 
  def __ne__(self, other):
6380 
    return not (self == other)
6381 
 
6382 
class getTransactionsForShoppingCartId_result:
6383 
  """
6384 
  Attributes:
6385 
   - success
6386 
   - ex
6387 
  """
6388 
 
6389 
  thrift_spec = (
6390 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6391 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6392 
  )
6393 
 
6394 
  def __init__(self, success=None, ex=None,):
6395 
    self.success = success
6396 
    self.ex = ex
6397 
 
6398 
  def read(self, iprot):
6399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6401 
      return
6402 
    iprot.readStructBegin()
6403 
    while True:
6404 
      (fname, ftype, fid) = iprot.readFieldBegin()
6405 
      if ftype == TType.STOP:
6406 
        break
6407 
      if fid == 0:
6408 
        if ftype == TType.LIST:
6409 
          self.success = []
685 chandransh 6410 
          (_etype24, _size21) = iprot.readListBegin()
6411 
          for _i25 in xrange(_size21):
6412 
            _elem26 = Transaction()
6413 
            _elem26.read(iprot)
6414 
            self.success.append(_elem26)
132 ashish 6415 
          iprot.readListEnd()
6416 
        else:
6417 
          iprot.skip(ftype)
6418 
      elif fid == 1:
6419 
        if ftype == TType.STRUCT:
6420 
          self.ex = TransactionServiceException()
6421 
          self.ex.read(iprot)
6422 
        else:
6423 
          iprot.skip(ftype)
6424 
      else:
6425 
        iprot.skip(ftype)
6426 
      iprot.readFieldEnd()
6427 
    iprot.readStructEnd()
6428 
 
6429 
  def write(self, oprot):
6430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6432 
      return
6433 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 6434 
    if self.success is not None:
132 ashish 6435 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6436 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 6437 
      for iter27 in self.success:
6438 
        iter27.write(oprot)
132 ashish 6439 
      oprot.writeListEnd()
6440 
      oprot.writeFieldEnd()
3431 rajveer 6441 
    if self.ex is not None:
132 ashish 6442 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6443 
      self.ex.write(oprot)
6444 
      oprot.writeFieldEnd()
6445 
    oprot.writeFieldStop()
6446 
    oprot.writeStructEnd()
6447 
 
3431 rajveer 6448 
  def validate(self):
6449 
    return
6450 
 
6451 
 
132 ashish 6452 
  def __repr__(self):
6453 
    L = ['%s=%r' % (key, value)
6454 
      for key, value in self.__dict__.iteritems()]
6455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6456 
 
6457 
  def __eq__(self, other):
6458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6459 
 
6460 
  def __ne__(self, other):
6461 
    return not (self == other)
6462 
 
94 ashish 6463 
class getTransactionStatus_args:
6464 
  """
6465 
  Attributes:
6466 
   - transactionId
6467 
  """
6468 
 
6469 
  thrift_spec = (
6470 
    None, # 0
6471 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6472 
  )
6473 
 
6474 
  def __init__(self, transactionId=None,):
6475 
    self.transactionId = transactionId
6476 
 
6477 
  def read(self, iprot):
6478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6480 
      return
6481 
    iprot.readStructBegin()
6482 
    while True:
6483 
      (fname, ftype, fid) = iprot.readFieldBegin()
6484 
      if ftype == TType.STOP:
6485 
        break
6486 
      if fid == 1:
6487 
        if ftype == TType.I64:
6488 
          self.transactionId = iprot.readI64();
6489 
        else:
6490 
          iprot.skip(ftype)
6491 
      else:
6492 
        iprot.skip(ftype)
6493 
      iprot.readFieldEnd()
6494 
    iprot.readStructEnd()
6495 
 
6496 
  def write(self, oprot):
6497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6499 
      return
6500 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 6501 
    if self.transactionId is not None:
94 ashish 6502 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6503 
      oprot.writeI64(self.transactionId)
6504 
      oprot.writeFieldEnd()
6505 
    oprot.writeFieldStop()
6506 
    oprot.writeStructEnd()
6507 
 
3431 rajveer 6508 
  def validate(self):
6509 
    return
6510 
 
6511 
 
94 ashish 6512 
  def __repr__(self):
6513 
    L = ['%s=%r' % (key, value)
6514 
      for key, value in self.__dict__.iteritems()]
6515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6516 
 
6517 
  def __eq__(self, other):
6518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6519 
 
6520 
  def __ne__(self, other):
6521 
    return not (self == other)
6522 
 
6523 
class getTransactionStatus_result:
6524 
  """
6525 
  Attributes:
6526 
   - success
6527 
   - ex
6528 
  """
6529 
 
6530 
  thrift_spec = (
6531 
    (0, TType.I32, 'success', None, None, ), # 0
6532 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6533 
  )
6534 
 
6535 
  def __init__(self, success=None, ex=None,):
6536 
    self.success = success
6537 
    self.ex = ex
6538 
 
6539 
  def read(self, iprot):
6540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6542 
      return
6543 
    iprot.readStructBegin()
6544 
    while True:
6545 
      (fname, ftype, fid) = iprot.readFieldBegin()
6546 
      if ftype == TType.STOP:
6547 
        break
6548 
      if fid == 0:
6549 
        if ftype == TType.I32:
6550 
          self.success = iprot.readI32();
6551 
        else:
6552 
          iprot.skip(ftype)
6553 
      elif fid == 1:
6554 
        if ftype == TType.STRUCT:
6555 
          self.ex = TransactionServiceException()
6556 
          self.ex.read(iprot)
6557 
        else:
6558 
          iprot.skip(ftype)
6559 
      else:
6560 
        iprot.skip(ftype)
6561 
      iprot.readFieldEnd()
6562 
    iprot.readStructEnd()
6563 
 
6564 
  def write(self, oprot):
6565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6567 
      return
6568 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 6569 
    if self.success is not None:
94 ashish 6570 
      oprot.writeFieldBegin('success', TType.I32, 0)
6571 
      oprot.writeI32(self.success)
6572 
      oprot.writeFieldEnd()
3431 rajveer 6573 
    if self.ex is not None:
94 ashish 6574 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6575 
      self.ex.write(oprot)
6576 
      oprot.writeFieldEnd()
6577 
    oprot.writeFieldStop()
6578 
    oprot.writeStructEnd()
6579 
 
3431 rajveer 6580 
  def validate(self):
6581 
    return
6582 
 
6583 
 
94 ashish 6584 
  def __repr__(self):
6585 
    L = ['%s=%r' % (key, value)
6586 
      for key, value in self.__dict__.iteritems()]
6587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6588 
 
6589 
  def __eq__(self, other):
6590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6591 
 
6592 
  def __ne__(self, other):
6593 
    return not (self == other)
6594 
 
6595 
class changeTransactionStatus_args:
6596 
  """
6597 
  Attributes:
6598 
   - transactionId
6599 
   - status
6600 
   - description
6601 
  """
6602 
 
6603 
  thrift_spec = (
6604 
    None, # 0
6605 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6606 
    (2, TType.I32, 'status', None, None, ), # 2
6607 
    (3, TType.STRING, 'description', None, None, ), # 3
6608 
  )
6609 
 
6610 
  def __init__(self, transactionId=None, status=None, description=None,):
6611 
    self.transactionId = transactionId
6612 
    self.status = status
6613 
    self.description = description
6614 
 
6615 
  def read(self, iprot):
6616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6618 
      return
6619 
    iprot.readStructBegin()
6620 
    while True:
6621 
      (fname, ftype, fid) = iprot.readFieldBegin()
6622 
      if ftype == TType.STOP:
6623 
        break
6624 
      if fid == 1:
6625 
        if ftype == TType.I64:
6626 
          self.transactionId = iprot.readI64();
6627 
        else:
6628 
          iprot.skip(ftype)
6629 
      elif fid == 2:
6630 
        if ftype == TType.I32:
6631 
          self.status = iprot.readI32();
6632 
        else:
6633 
          iprot.skip(ftype)
6634 
      elif fid == 3:
6635 
        if ftype == TType.STRING:
6636 
          self.description = iprot.readString();
6637 
        else:
6638 
          iprot.skip(ftype)
6639 
      else:
6640 
        iprot.skip(ftype)
6641 
      iprot.readFieldEnd()
6642 
    iprot.readStructEnd()
6643 
 
6644 
  def write(self, oprot):
6645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6647 
      return
6648 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 6649 
    if self.transactionId is not None:
94 ashish 6650 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6651 
      oprot.writeI64(self.transactionId)
6652 
      oprot.writeFieldEnd()
3431 rajveer 6653 
    if self.status is not None:
94 ashish 6654 
      oprot.writeFieldBegin('status', TType.I32, 2)
6655 
      oprot.writeI32(self.status)
6656 
      oprot.writeFieldEnd()
3431 rajveer 6657 
    if self.description is not None:
94 ashish 6658 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6659 
      oprot.writeString(self.description)
6660 
      oprot.writeFieldEnd()
6661 
    oprot.writeFieldStop()
6662 
    oprot.writeStructEnd()
6663 
 
3431 rajveer 6664 
  def validate(self):
6665 
    return
6666 
 
6667 
 
94 ashish 6668 
  def __repr__(self):
6669 
    L = ['%s=%r' % (key, value)
6670 
      for key, value in self.__dict__.iteritems()]
6671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6672 
 
6673 
  def __eq__(self, other):
6674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6675 
 
6676 
  def __ne__(self, other):
6677 
    return not (self == other)
6678 
 
6679 
class changeTransactionStatus_result:
6680 
  """
6681 
  Attributes:
6682 
   - success
6683 
   - ex
6684 
  """
6685 
 
6686 
  thrift_spec = (
6687 
    (0, TType.BOOL, 'success', None, None, ), # 0
6688 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6689 
  )
6690 
 
6691 
  def __init__(self, success=None, ex=None,):
6692 
    self.success = success
6693 
    self.ex = ex
6694 
 
6695 
  def read(self, iprot):
6696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6698 
      return
6699 
    iprot.readStructBegin()
6700 
    while True:
6701 
      (fname, ftype, fid) = iprot.readFieldBegin()
6702 
      if ftype == TType.STOP:
6703 
        break
6704 
      if fid == 0:
6705 
        if ftype == TType.BOOL:
6706 
          self.success = iprot.readBool();
6707 
        else:
6708 
          iprot.skip(ftype)
6709 
      elif fid == 1:
6710 
        if ftype == TType.STRUCT:
6711 
          self.ex = TransactionServiceException()
6712 
          self.ex.read(iprot)
6713 
        else:
6714 
          iprot.skip(ftype)
6715 
      else:
6716 
        iprot.skip(ftype)
6717 
      iprot.readFieldEnd()
6718 
    iprot.readStructEnd()
6719 
 
6720 
  def write(self, oprot):
6721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6723 
      return
6724 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 6725 
    if self.success is not None:
94 ashish 6726 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6727 
      oprot.writeBool(self.success)
6728 
      oprot.writeFieldEnd()
3431 rajveer 6729 
    if self.ex is not None:
94 ashish 6730 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6731 
      self.ex.write(oprot)
6732 
      oprot.writeFieldEnd()
6733 
    oprot.writeFieldStop()
6734 
    oprot.writeStructEnd()
6735 
 
3431 rajveer 6736 
  def validate(self):
6737 
    return
6738 
 
6739 
 
94 ashish 6740 
  def __repr__(self):
6741 
    L = ['%s=%r' % (key, value)
6742 
      for key, value in self.__dict__.iteritems()]
6743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6744 
 
6745 
  def __eq__(self, other):
6746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6747 
 
6748 
  def __ne__(self, other):
6749 
    return not (self == other)
6750 
 
1398 varun.gupt 6751 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 6752 
  """
6753 
  Attributes:
6754 
   - transactionId
6755 
  """
6756 
 
6757 
  thrift_spec = (
6758 
    None, # 0
6759 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6760 
  )
6761 
 
6762 
  def __init__(self, transactionId=None,):
6763 
    self.transactionId = transactionId
6764 
 
6765 
  def read(self, iprot):
6766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6768 
      return
6769 
    iprot.readStructBegin()
6770 
    while True:
6771 
      (fname, ftype, fid) = iprot.readFieldBegin()
6772 
      if ftype == TType.STOP:
6773 
        break
6774 
      if fid == 1:
6775 
        if ftype == TType.I64:
6776 
          self.transactionId = iprot.readI64();
6777 
        else:
6778 
          iprot.skip(ftype)
6779 
      else:
6780 
        iprot.skip(ftype)
6781 
      iprot.readFieldEnd()
6782 
    iprot.readStructEnd()
6783 
 
6784 
  def write(self, oprot):
6785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6787 
      return
1398 varun.gupt 6788 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 6789 
    if self.transactionId is not None:
1382 varun.gupt 6790 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6791 
      oprot.writeI64(self.transactionId)
6792 
      oprot.writeFieldEnd()
6793 
    oprot.writeFieldStop()
6794 
    oprot.writeStructEnd()
6795 
 
3431 rajveer 6796 
  def validate(self):
6797 
    return
6798 
 
6799 
 
1382 varun.gupt 6800 
  def __repr__(self):
6801 
    L = ['%s=%r' % (key, value)
6802 
      for key, value in self.__dict__.iteritems()]
6803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6804 
 
6805 
  def __eq__(self, other):
6806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6807 
 
6808 
  def __ne__(self, other):
6809 
    return not (self == other)
6810 
 
1398 varun.gupt 6811 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 6812 
  """
6813 
  Attributes:
6814 
   - success
6815 
   - ex
6816 
  """
6817 
 
6818 
  thrift_spec = (
6819 
    (0, TType.BOOL, 'success', None, None, ), # 0
6820 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6821 
  )
6822 
 
6823 
  def __init__(self, success=None, ex=None,):
6824 
    self.success = success
6825 
    self.ex = ex
6826 
 
6827 
  def read(self, iprot):
6828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6830 
      return
6831 
    iprot.readStructBegin()
6832 
    while True:
6833 
      (fname, ftype, fid) = iprot.readFieldBegin()
6834 
      if ftype == TType.STOP:
6835 
        break
6836 
      if fid == 0:
6837 
        if ftype == TType.BOOL:
6838 
          self.success = iprot.readBool();
6839 
        else:
6840 
          iprot.skip(ftype)
6841 
      elif fid == 1:
6842 
        if ftype == TType.STRUCT:
6843 
          self.ex = TransactionServiceException()
6844 
          self.ex.read(iprot)
6845 
        else:
6846 
          iprot.skip(ftype)
6847 
      else:
6848 
        iprot.skip(ftype)
6849 
      iprot.readFieldEnd()
6850 
    iprot.readStructEnd()
6851 
 
6852 
  def write(self, oprot):
6853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6855 
      return
1398 varun.gupt 6856 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 6857 
    if self.success is not None:
1382 varun.gupt 6858 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6859 
      oprot.writeBool(self.success)
6860 
      oprot.writeFieldEnd()
3431 rajveer 6861 
    if self.ex is not None:
1382 varun.gupt 6862 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6863 
      self.ex.write(oprot)
6864 
      oprot.writeFieldEnd()
6865 
    oprot.writeFieldStop()
6866 
    oprot.writeStructEnd()
6867 
 
3431 rajveer 6868 
  def validate(self):
6869 
    return
6870 
 
6871 
 
1382 varun.gupt 6872 
  def __repr__(self):
6873 
    L = ['%s=%r' % (key, value)
6874 
      for key, value in self.__dict__.iteritems()]
6875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6876 
 
6877 
  def __eq__(self, other):
6878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6879 
 
6880 
  def __ne__(self, other):
6881 
    return not (self == other)
6882 
 
483 rajveer 6883 
class getAllOrders_args:
94 ashish 6884 
  """
6885 
  Attributes:
483 rajveer 6886 
   - status
6887 
   - from_date
6888 
   - to_date
6889 
   - warehouse_id
94 ashish 6890 
  """
6891 
 
6892 
  thrift_spec = (
6893 
    None, # 0
483 rajveer 6894 
    (1, TType.I32, 'status', None, None, ), # 1
6895 
    (2, TType.I64, 'from_date', None, None, ), # 2
6896 
    (3, TType.I64, 'to_date', None, None, ), # 3
6897 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 6898 
  )
6899 
 
483 rajveer 6900 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
6901 
    self.status = status
6902 
    self.from_date = from_date
6903 
    self.to_date = to_date
6904 
    self.warehouse_id = warehouse_id
94 ashish 6905 
 
6906 
  def read(self, iprot):
6907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6909 
      return
6910 
    iprot.readStructBegin()
6911 
    while True:
6912 
      (fname, ftype, fid) = iprot.readFieldBegin()
6913 
      if ftype == TType.STOP:
6914 
        break
6915 
      if fid == 1:
483 rajveer 6916 
        if ftype == TType.I32:
6917 
          self.status = iprot.readI32();
94 ashish 6918 
        else:
6919 
          iprot.skip(ftype)
483 rajveer 6920 
      elif fid == 2:
6921 
        if ftype == TType.I64:
6922 
          self.from_date = iprot.readI64();
94 ashish 6923 
        else:
6924 
          iprot.skip(ftype)
483 rajveer 6925 
      elif fid == 3:
6926 
        if ftype == TType.I64:
6927 
          self.to_date = iprot.readI64();
94 ashish 6928 
        else:
6929 
          iprot.skip(ftype)
483 rajveer 6930 
      elif fid == 4:
94 ashish 6931 
        if ftype == TType.I64:
483 rajveer 6932 
          self.warehouse_id = iprot.readI64();
94 ashish 6933 
        else:
6934 
          iprot.skip(ftype)
6935 
      else:
6936 
        iprot.skip(ftype)
6937 
      iprot.readFieldEnd()
6938 
    iprot.readStructEnd()
6939 
 
6940 
  def write(self, oprot):
6941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6943 
      return
483 rajveer 6944 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 6945 
    if self.status is not None:
483 rajveer 6946 
      oprot.writeFieldBegin('status', TType.I32, 1)
6947 
      oprot.writeI32(self.status)
94 ashish 6948 
      oprot.writeFieldEnd()
3431 rajveer 6949 
    if self.from_date is not None:
483 rajveer 6950 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6951 
      oprot.writeI64(self.from_date)
94 ashish 6952 
      oprot.writeFieldEnd()
3431 rajveer 6953 
    if self.to_date is not None:
483 rajveer 6954 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6955 
      oprot.writeI64(self.to_date)
94 ashish 6956 
      oprot.writeFieldEnd()
3431 rajveer 6957 
    if self.warehouse_id is not None:
483 rajveer 6958 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6959 
      oprot.writeI64(self.warehouse_id)
94 ashish 6960 
      oprot.writeFieldEnd()
6961 
    oprot.writeFieldStop()
6962 
    oprot.writeStructEnd()
6963 
 
3431 rajveer 6964 
  def validate(self):
6965 
    return
6966 
 
6967 
 
94 ashish 6968 
  def __repr__(self):
6969 
    L = ['%s=%r' % (key, value)
6970 
      for key, value in self.__dict__.iteritems()]
6971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6972 
 
6973 
  def __eq__(self, other):
6974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6975 
 
6976 
  def __ne__(self, other):
6977 
    return not (self == other)
6978 
 
483 rajveer 6979 
class getAllOrders_result:
94 ashish 6980 
  """
6981 
  Attributes:
6982 
   - success
6983 
   - ex
6984 
  """
6985 
 
6986 
  thrift_spec = (
483 rajveer 6987 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 6988 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6989 
  )
6990 
 
6991 
  def __init__(self, success=None, ex=None,):
6992 
    self.success = success
6993 
    self.ex = ex
6994 
 
6995 
  def read(self, iprot):
6996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6998 
      return
6999 
    iprot.readStructBegin()
7000 
    while True:
7001 
      (fname, ftype, fid) = iprot.readFieldBegin()
7002 
      if ftype == TType.STOP:
7003 
        break
7004 
      if fid == 0:
483 rajveer 7005 
        if ftype == TType.LIST:
7006 
          self.success = []
685 chandransh 7007 
          (_etype31, _size28) = iprot.readListBegin()
7008 
          for _i32 in xrange(_size28):
7009 
            _elem33 = Order()
7010 
            _elem33.read(iprot)
7011 
            self.success.append(_elem33)
483 rajveer 7012 
          iprot.readListEnd()
94 ashish 7013 
        else:
7014 
          iprot.skip(ftype)
7015 
      elif fid == 1:
7016 
        if ftype == TType.STRUCT:
7017 
          self.ex = TransactionServiceException()
7018 
          self.ex.read(iprot)
7019 
        else:
7020 
          iprot.skip(ftype)
7021 
      else:
7022 
        iprot.skip(ftype)
7023 
      iprot.readFieldEnd()
7024 
    iprot.readStructEnd()
7025 
 
7026 
  def write(self, oprot):
7027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7029 
      return
483 rajveer 7030 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7031 
    if self.success is not None:
483 rajveer 7032 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7033 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 7034 
      for iter34 in self.success:
7035 
        iter34.write(oprot)
483 rajveer 7036 
      oprot.writeListEnd()
94 ashish 7037 
      oprot.writeFieldEnd()
3431 rajveer 7038 
    if self.ex is not None:
94 ashish 7039 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7040 
      self.ex.write(oprot)
7041 
      oprot.writeFieldEnd()
7042 
    oprot.writeFieldStop()
7043 
    oprot.writeStructEnd()
7044 
 
3431 rajveer 7045 
  def validate(self):
7046 
    return
7047 
 
7048 
 
94 ashish 7049 
  def __repr__(self):
7050 
    L = ['%s=%r' % (key, value)
7051 
      for key, value in self.__dict__.iteritems()]
7052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7053 
 
7054 
  def __eq__(self, other):
7055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7056 
 
7057 
  def __ne__(self, other):
7058 
    return not (self == other)
7059 
 
4133 chandransh 7060 
class getOrdersInBatch_args:
7061 
  """
7062 
  Attributes:
7063 
   - statuses
7064 
   - offset
7065 
   - limit
7066 
   - warehouse_id
7067 
  """
7068 
 
7069 
  thrift_spec = (
7070 
    None, # 0
7071 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7072 
    (2, TType.I64, 'offset', None, None, ), # 2
7073 
    (3, TType.I64, 'limit', None, None, ), # 3
7074 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7075 
  )
7076 
 
7077 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7078 
    self.statuses = statuses
7079 
    self.offset = offset
7080 
    self.limit = limit
7081 
    self.warehouse_id = warehouse_id
7082 
 
7083 
  def read(self, iprot):
7084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7086 
      return
7087 
    iprot.readStructBegin()
7088 
    while True:
7089 
      (fname, ftype, fid) = iprot.readFieldBegin()
7090 
      if ftype == TType.STOP:
7091 
        break
7092 
      if fid == 1:
7093 
        if ftype == TType.LIST:
7094 
          self.statuses = []
7095 
          (_etype38, _size35) = iprot.readListBegin()
7096 
          for _i39 in xrange(_size35):
7097 
            _elem40 = iprot.readI32();
7098 
            self.statuses.append(_elem40)
7099 
          iprot.readListEnd()
7100 
        else:
7101 
          iprot.skip(ftype)
7102 
      elif fid == 2:
7103 
        if ftype == TType.I64:
7104 
          self.offset = iprot.readI64();
7105 
        else:
7106 
          iprot.skip(ftype)
7107 
      elif fid == 3:
7108 
        if ftype == TType.I64:
7109 
          self.limit = iprot.readI64();
7110 
        else:
7111 
          iprot.skip(ftype)
7112 
      elif fid == 4:
7113 
        if ftype == TType.I64:
7114 
          self.warehouse_id = iprot.readI64();
7115 
        else:
7116 
          iprot.skip(ftype)
7117 
      else:
7118 
        iprot.skip(ftype)
7119 
      iprot.readFieldEnd()
7120 
    iprot.readStructEnd()
7121 
 
7122 
  def write(self, oprot):
7123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7125 
      return
7126 
    oprot.writeStructBegin('getOrdersInBatch_args')
7127 
    if self.statuses is not None:
7128 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7129 
      oprot.writeListBegin(TType.I32, len(self.statuses))
7130 
      for iter41 in self.statuses:
7131 
        oprot.writeI32(iter41)
7132 
      oprot.writeListEnd()
7133 
      oprot.writeFieldEnd()
7134 
    if self.offset is not None:
7135 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7136 
      oprot.writeI64(self.offset)
7137 
      oprot.writeFieldEnd()
7138 
    if self.limit is not None:
7139 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7140 
      oprot.writeI64(self.limit)
7141 
      oprot.writeFieldEnd()
7142 
    if self.warehouse_id is not None:
7143 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7144 
      oprot.writeI64(self.warehouse_id)
7145 
      oprot.writeFieldEnd()
7146 
    oprot.writeFieldStop()
7147 
    oprot.writeStructEnd()
7148 
 
7149 
  def validate(self):
7150 
    return
7151 
 
7152 
 
7153 
  def __repr__(self):
7154 
    L = ['%s=%r' % (key, value)
7155 
      for key, value in self.__dict__.iteritems()]
7156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7157 
 
7158 
  def __eq__(self, other):
7159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7160 
 
7161 
  def __ne__(self, other):
7162 
    return not (self == other)
7163 
 
7164 
class getOrdersInBatch_result:
7165 
  """
7166 
  Attributes:
7167 
   - success
7168 
   - ex
7169 
  """
7170 
 
7171 
  thrift_spec = (
7172 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7173 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7174 
  )
7175 
 
7176 
  def __init__(self, success=None, ex=None,):
7177 
    self.success = success
7178 
    self.ex = ex
7179 
 
7180 
  def read(self, iprot):
7181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7183 
      return
7184 
    iprot.readStructBegin()
7185 
    while True:
7186 
      (fname, ftype, fid) = iprot.readFieldBegin()
7187 
      if ftype == TType.STOP:
7188 
        break
7189 
      if fid == 0:
7190 
        if ftype == TType.LIST:
7191 
          self.success = []
7192 
          (_etype45, _size42) = iprot.readListBegin()
7193 
          for _i46 in xrange(_size42):
7194 
            _elem47 = Order()
7195 
            _elem47.read(iprot)
7196 
            self.success.append(_elem47)
7197 
          iprot.readListEnd()
7198 
        else:
7199 
          iprot.skip(ftype)
7200 
      elif fid == 1:
7201 
        if ftype == TType.STRUCT:
7202 
          self.ex = TransactionServiceException()
7203 
          self.ex.read(iprot)
7204 
        else:
7205 
          iprot.skip(ftype)
7206 
      else:
7207 
        iprot.skip(ftype)
7208 
      iprot.readFieldEnd()
7209 
    iprot.readStructEnd()
7210 
 
7211 
  def write(self, oprot):
7212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7214 
      return
7215 
    oprot.writeStructBegin('getOrdersInBatch_result')
7216 
    if self.success is not None:
7217 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7218 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7219 
      for iter48 in self.success:
7220 
        iter48.write(oprot)
7221 
      oprot.writeListEnd()
7222 
      oprot.writeFieldEnd()
7223 
    if self.ex is not None:
7224 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7225 
      self.ex.write(oprot)
7226 
      oprot.writeFieldEnd()
7227 
    oprot.writeFieldStop()
7228 
    oprot.writeStructEnd()
7229 
 
7230 
  def validate(self):
7231 
    return
7232 
 
7233 
 
7234 
  def __repr__(self):
7235 
    L = ['%s=%r' % (key, value)
7236 
      for key, value in self.__dict__.iteritems()]
7237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7238 
 
7239 
  def __eq__(self, other):
7240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7241 
 
7242 
  def __ne__(self, other):
7243 
    return not (self == other)
7244 
 
7245 
class getOrderCount_args:
7246 
  """
7247 
  Attributes:
7248 
   - statuses
7249 
   - warehouseId
7250 
  """
7251 
 
7252 
  thrift_spec = (
7253 
    None, # 0
7254 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7255 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7256 
  )
7257 
 
7258 
  def __init__(self, statuses=None, warehouseId=None,):
7259 
    self.statuses = statuses
7260 
    self.warehouseId = warehouseId
7261 
 
7262 
  def read(self, iprot):
7263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7265 
      return
7266 
    iprot.readStructBegin()
7267 
    while True:
7268 
      (fname, ftype, fid) = iprot.readFieldBegin()
7269 
      if ftype == TType.STOP:
7270 
        break
7271 
      if fid == 1:
7272 
        if ftype == TType.LIST:
7273 
          self.statuses = []
7274 
          (_etype52, _size49) = iprot.readListBegin()
7275 
          for _i53 in xrange(_size49):
7276 
            _elem54 = iprot.readI32();
7277 
            self.statuses.append(_elem54)
7278 
          iprot.readListEnd()
7279 
        else:
7280 
          iprot.skip(ftype)
7281 
      elif fid == 2:
7282 
        if ftype == TType.I64:
7283 
          self.warehouseId = iprot.readI64();
7284 
        else:
7285 
          iprot.skip(ftype)
7286 
      else:
7287 
        iprot.skip(ftype)
7288 
      iprot.readFieldEnd()
7289 
    iprot.readStructEnd()
7290 
 
7291 
  def write(self, oprot):
7292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7294 
      return
7295 
    oprot.writeStructBegin('getOrderCount_args')
7296 
    if self.statuses is not None:
7297 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7298 
      oprot.writeListBegin(TType.I32, len(self.statuses))
7299 
      for iter55 in self.statuses:
7300 
        oprot.writeI32(iter55)
7301 
      oprot.writeListEnd()
7302 
      oprot.writeFieldEnd()
7303 
    if self.warehouseId is not None:
7304 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7305 
      oprot.writeI64(self.warehouseId)
7306 
      oprot.writeFieldEnd()
7307 
    oprot.writeFieldStop()
7308 
    oprot.writeStructEnd()
7309 
 
7310 
  def validate(self):
7311 
    return
7312 
 
7313 
 
7314 
  def __repr__(self):
7315 
    L = ['%s=%r' % (key, value)
7316 
      for key, value in self.__dict__.iteritems()]
7317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7318 
 
7319 
  def __eq__(self, other):
7320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7321 
 
7322 
  def __ne__(self, other):
7323 
    return not (self == other)
7324 
 
7325 
class getOrderCount_result:
7326 
  """
7327 
  Attributes:
7328 
   - success
7329 
   - ex
7330 
  """
7331 
 
7332 
  thrift_spec = (
7333 
    (0, TType.I32, 'success', None, None, ), # 0
7334 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7335 
  )
7336 
 
7337 
  def __init__(self, success=None, ex=None,):
7338 
    self.success = success
7339 
    self.ex = ex
7340 
 
7341 
  def read(self, iprot):
7342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7344 
      return
7345 
    iprot.readStructBegin()
7346 
    while True:
7347 
      (fname, ftype, fid) = iprot.readFieldBegin()
7348 
      if ftype == TType.STOP:
7349 
        break
7350 
      if fid == 0:
7351 
        if ftype == TType.I32:
7352 
          self.success = iprot.readI32();
7353 
        else:
7354 
          iprot.skip(ftype)
7355 
      elif fid == 1:
7356 
        if ftype == TType.STRUCT:
7357 
          self.ex = TransactionServiceException()
7358 
          self.ex.read(iprot)
7359 
        else:
7360 
          iprot.skip(ftype)
7361 
      else:
7362 
        iprot.skip(ftype)
7363 
      iprot.readFieldEnd()
7364 
    iprot.readStructEnd()
7365 
 
7366 
  def write(self, oprot):
7367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7369 
      return
7370 
    oprot.writeStructBegin('getOrderCount_result')
7371 
    if self.success is not None:
7372 
      oprot.writeFieldBegin('success', TType.I32, 0)
7373 
      oprot.writeI32(self.success)
7374 
      oprot.writeFieldEnd()
7375 
    if self.ex is not None:
7376 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7377 
      self.ex.write(oprot)
7378 
      oprot.writeFieldEnd()
7379 
    oprot.writeFieldStop()
7380 
    oprot.writeStructEnd()
7381 
 
7382 
  def validate(self):
7383 
    return
7384 
 
7385 
 
7386 
  def __repr__(self):
7387 
    L = ['%s=%r' % (key, value)
7388 
      for key, value in self.__dict__.iteritems()]
7389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7390 
 
7391 
  def __eq__(self, other):
7392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7393 
 
7394 
  def __ne__(self, other):
7395 
    return not (self == other)
7396 
 
999 varun.gupt 7397 
class getOrdersByBillingDate_args:
7398 
  """
7399 
  Attributes:
7400 
   - status
7401 
   - start_billing_date
7402 
   - end_billing_date
7403 
   - warehouse_id
7404 
  """
7405 
 
7406 
  thrift_spec = (
7407 
    None, # 0
7408 
    (1, TType.I32, 'status', None, None, ), # 1
7409 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
7410 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
7411 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7412 
  )
7413 
 
7414 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
7415 
    self.status = status
7416 
    self.start_billing_date = start_billing_date
7417 
    self.end_billing_date = end_billing_date
7418 
    self.warehouse_id = warehouse_id
7419 
 
7420 
  def read(self, iprot):
7421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7423 
      return
7424 
    iprot.readStructBegin()
7425 
    while True:
7426 
      (fname, ftype, fid) = iprot.readFieldBegin()
7427 
      if ftype == TType.STOP:
7428 
        break
7429 
      if fid == 1:
7430 
        if ftype == TType.I32:
7431 
          self.status = iprot.readI32();
7432 
        else:
7433 
          iprot.skip(ftype)
7434 
      elif fid == 2:
7435 
        if ftype == TType.I64:
7436 
          self.start_billing_date = iprot.readI64();
7437 
        else:
7438 
          iprot.skip(ftype)
7439 
      elif fid == 3:
7440 
        if ftype == TType.I64:
7441 
          self.end_billing_date = iprot.readI64();
7442 
        else:
7443 
          iprot.skip(ftype)
7444 
      elif fid == 4:
7445 
        if ftype == TType.I64:
7446 
          self.warehouse_id = iprot.readI64();
7447 
        else:
7448 
          iprot.skip(ftype)
7449 
      else:
7450 
        iprot.skip(ftype)
7451 
      iprot.readFieldEnd()
7452 
    iprot.readStructEnd()
7453 
 
7454 
  def write(self, oprot):
7455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7457 
      return
7458 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 7459 
    if self.status is not None:
999 varun.gupt 7460 
      oprot.writeFieldBegin('status', TType.I32, 1)
7461 
      oprot.writeI32(self.status)
7462 
      oprot.writeFieldEnd()
3431 rajveer 7463 
    if self.start_billing_date is not None:
999 varun.gupt 7464 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
7465 
      oprot.writeI64(self.start_billing_date)
7466 
      oprot.writeFieldEnd()
3431 rajveer 7467 
    if self.end_billing_date is not None:
999 varun.gupt 7468 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
7469 
      oprot.writeI64(self.end_billing_date)
7470 
      oprot.writeFieldEnd()
3431 rajveer 7471 
    if self.warehouse_id is not None:
999 varun.gupt 7472 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7473 
      oprot.writeI64(self.warehouse_id)
7474 
      oprot.writeFieldEnd()
7475 
    oprot.writeFieldStop()
7476 
    oprot.writeStructEnd()
7477 
 
3431 rajveer 7478 
  def validate(self):
7479 
    return
7480 
 
7481 
 
999 varun.gupt 7482 
  def __repr__(self):
7483 
    L = ['%s=%r' % (key, value)
7484 
      for key, value in self.__dict__.iteritems()]
7485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7486 
 
7487 
  def __eq__(self, other):
7488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7489 
 
7490 
  def __ne__(self, other):
7491 
    return not (self == other)
7492 
 
7493 
class getOrdersByBillingDate_result:
7494 
  """
7495 
  Attributes:
7496 
   - success
7497 
   - ex
7498 
  """
7499 
 
7500 
  thrift_spec = (
7501 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7502 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7503 
  )
7504 
 
7505 
  def __init__(self, success=None, ex=None,):
7506 
    self.success = success
7507 
    self.ex = ex
7508 
 
7509 
  def read(self, iprot):
7510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7512 
      return
7513 
    iprot.readStructBegin()
7514 
    while True:
7515 
      (fname, ftype, fid) = iprot.readFieldBegin()
7516 
      if ftype == TType.STOP:
7517 
        break
7518 
      if fid == 0:
7519 
        if ftype == TType.LIST:
7520 
          self.success = []
4133 chandransh 7521 
          (_etype59, _size56) = iprot.readListBegin()
7522 
          for _i60 in xrange(_size56):
7523 
            _elem61 = Order()
7524 
            _elem61.read(iprot)
7525 
            self.success.append(_elem61)
999 varun.gupt 7526 
          iprot.readListEnd()
7527 
        else:
7528 
          iprot.skip(ftype)
7529 
      elif fid == 1:
7530 
        if ftype == TType.STRUCT:
7531 
          self.ex = TransactionServiceException()
7532 
          self.ex.read(iprot)
7533 
        else:
7534 
          iprot.skip(ftype)
7535 
      else:
7536 
        iprot.skip(ftype)
7537 
      iprot.readFieldEnd()
7538 
    iprot.readStructEnd()
7539 
 
7540 
  def write(self, oprot):
7541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7543 
      return
7544 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 7545 
    if self.success is not None:
999 varun.gupt 7546 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7547 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7548 
      for iter62 in self.success:
7549 
        iter62.write(oprot)
999 varun.gupt 7550 
      oprot.writeListEnd()
7551 
      oprot.writeFieldEnd()
3431 rajveer 7552 
    if self.ex is not None:
999 varun.gupt 7553 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7554 
      self.ex.write(oprot)
7555 
      oprot.writeFieldEnd()
7556 
    oprot.writeFieldStop()
7557 
    oprot.writeStructEnd()
7558 
 
3431 rajveer 7559 
  def validate(self):
7560 
    return
7561 
 
7562 
 
999 varun.gupt 7563 
  def __repr__(self):
7564 
    L = ['%s=%r' % (key, value)
7565 
      for key, value in self.__dict__.iteritems()]
7566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7567 
 
7568 
  def __eq__(self, other):
7569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7570 
 
7571 
  def __ne__(self, other):
7572 
    return not (self == other)
7573 
 
3427 chandransh 7574 
class getOrdersByShippingDate_args:
7575 
  """
7576 
  Attributes:
7577 
   - fromShippingDate
7578 
   - toShippingDate
7579 
   - providerId
7580 
   - warehouseId
3451 chandransh 7581 
   - cod
3427 chandransh 7582 
  """
7583 
 
7584 
  thrift_spec = (
7585 
    None, # 0
7586 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
7587 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
7588 
    (3, TType.I64, 'providerId', None, None, ), # 3
7589 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 7590 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 7591 
  )
7592 
 
3451 chandransh 7593 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 7594 
    self.fromShippingDate = fromShippingDate
7595 
    self.toShippingDate = toShippingDate
7596 
    self.providerId = providerId
7597 
    self.warehouseId = warehouseId
3451 chandransh 7598 
    self.cod = cod
3427 chandransh 7599 
 
7600 
  def read(self, iprot):
7601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7603 
      return
7604 
    iprot.readStructBegin()
7605 
    while True:
7606 
      (fname, ftype, fid) = iprot.readFieldBegin()
7607 
      if ftype == TType.STOP:
7608 
        break
7609 
      if fid == 1:
7610 
        if ftype == TType.I64:
7611 
          self.fromShippingDate = iprot.readI64();
7612 
        else:
7613 
          iprot.skip(ftype)
7614 
      elif fid == 2:
7615 
        if ftype == TType.I64:
7616 
          self.toShippingDate = iprot.readI64();
7617 
        else:
7618 
          iprot.skip(ftype)
7619 
      elif fid == 3:
7620 
        if ftype == TType.I64:
7621 
          self.providerId = iprot.readI64();
7622 
        else:
7623 
          iprot.skip(ftype)
7624 
      elif fid == 4:
7625 
        if ftype == TType.I64:
7626 
          self.warehouseId = iprot.readI64();
7627 
        else:
7628 
          iprot.skip(ftype)
3451 chandransh 7629 
      elif fid == 5:
7630 
        if ftype == TType.BOOL:
7631 
          self.cod = iprot.readBool();
7632 
        else:
7633 
          iprot.skip(ftype)
3427 chandransh 7634 
      else:
7635 
        iprot.skip(ftype)
7636 
      iprot.readFieldEnd()
7637 
    iprot.readStructEnd()
7638 
 
7639 
  def write(self, oprot):
7640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7642 
      return
7643 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 7644 
    if self.fromShippingDate is not None:
3427 chandransh 7645 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
7646 
      oprot.writeI64(self.fromShippingDate)
7647 
      oprot.writeFieldEnd()
3431 rajveer 7648 
    if self.toShippingDate is not None:
3427 chandransh 7649 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
7650 
      oprot.writeI64(self.toShippingDate)
7651 
      oprot.writeFieldEnd()
3431 rajveer 7652 
    if self.providerId is not None:
3427 chandransh 7653 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
7654 
      oprot.writeI64(self.providerId)
7655 
      oprot.writeFieldEnd()
3431 rajveer 7656 
    if self.warehouseId is not None:
3427 chandransh 7657 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
7658 
      oprot.writeI64(self.warehouseId)
7659 
      oprot.writeFieldEnd()
3451 chandransh 7660 
    if self.cod is not None:
7661 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
7662 
      oprot.writeBool(self.cod)
7663 
      oprot.writeFieldEnd()
3427 chandransh 7664 
    oprot.writeFieldStop()
7665 
    oprot.writeStructEnd()
7666 
 
3431 rajveer 7667 
  def validate(self):
7668 
    return
7669 
 
7670 
 
3427 chandransh 7671 
  def __repr__(self):
7672 
    L = ['%s=%r' % (key, value)
7673 
      for key, value in self.__dict__.iteritems()]
7674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7675 
 
7676 
  def __eq__(self, other):
7677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7678 
 
7679 
  def __ne__(self, other):
7680 
    return not (self == other)
7681 
 
7682 
class getOrdersByShippingDate_result:
7683 
  """
7684 
  Attributes:
7685 
   - success
7686 
   - ex
7687 
  """
7688 
 
7689 
  thrift_spec = (
7690 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7691 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7692 
  )
7693 
 
7694 
  def __init__(self, success=None, ex=None,):
7695 
    self.success = success
7696 
    self.ex = ex
7697 
 
7698 
  def read(self, iprot):
7699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7701 
      return
7702 
    iprot.readStructBegin()
7703 
    while True:
7704 
      (fname, ftype, fid) = iprot.readFieldBegin()
7705 
      if ftype == TType.STOP:
7706 
        break
7707 
      if fid == 0:
7708 
        if ftype == TType.LIST:
7709 
          self.success = []
4133 chandransh 7710 
          (_etype66, _size63) = iprot.readListBegin()
7711 
          for _i67 in xrange(_size63):
7712 
            _elem68 = Order()
7713 
            _elem68.read(iprot)
7714 
            self.success.append(_elem68)
3427 chandransh 7715 
          iprot.readListEnd()
7716 
        else:
7717 
          iprot.skip(ftype)
7718 
      elif fid == 1:
7719 
        if ftype == TType.STRUCT:
7720 
          self.ex = TransactionServiceException()
7721 
          self.ex.read(iprot)
7722 
        else:
7723 
          iprot.skip(ftype)
7724 
      else:
7725 
        iprot.skip(ftype)
7726 
      iprot.readFieldEnd()
7727 
    iprot.readStructEnd()
7728 
 
7729 
  def write(self, oprot):
7730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7732 
      return
7733 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 7734 
    if self.success is not None:
3427 chandransh 7735 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7736 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7737 
      for iter69 in self.success:
7738 
        iter69.write(oprot)
3427 chandransh 7739 
      oprot.writeListEnd()
7740 
      oprot.writeFieldEnd()
3431 rajveer 7741 
    if self.ex is not None:
3427 chandransh 7742 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7743 
      self.ex.write(oprot)
7744 
      oprot.writeFieldEnd()
7745 
    oprot.writeFieldStop()
7746 
    oprot.writeStructEnd()
7747 
 
3431 rajveer 7748 
  def validate(self):
7749 
    return
7750 
 
7751 
 
3427 chandransh 7752 
  def __repr__(self):
7753 
    L = ['%s=%r' % (key, value)
7754 
      for key, value in self.__dict__.iteritems()]
7755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7756 
 
7757 
  def __eq__(self, other):
7758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7759 
 
7760 
  def __ne__(self, other):
7761 
    return not (self == other)
7762 
 
1382 varun.gupt 7763 
class getReturnableOrdersForCustomer_args:
7764 
  """
7765 
  Attributes:
7766 
   - customer_id
7767 
   - limit
7768 
  """
7769 
 
7770 
  thrift_spec = (
7771 
    None, # 0
7772 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7773 
    (2, TType.I64, 'limit', None, None, ), # 2
7774 
  )
7775 
 
7776 
  def __init__(self, customer_id=None, limit=None,):
7777 
    self.customer_id = customer_id
7778 
    self.limit = limit
7779 
 
7780 
  def read(self, iprot):
7781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7783 
      return
7784 
    iprot.readStructBegin()
7785 
    while True:
7786 
      (fname, ftype, fid) = iprot.readFieldBegin()
7787 
      if ftype == TType.STOP:
7788 
        break
7789 
      if fid == 1:
7790 
        if ftype == TType.I64:
7791 
          self.customer_id = iprot.readI64();
7792 
        else:
7793 
          iprot.skip(ftype)
7794 
      elif fid == 2:
7795 
        if ftype == TType.I64:
7796 
          self.limit = iprot.readI64();
7797 
        else:
7798 
          iprot.skip(ftype)
7799 
      else:
7800 
        iprot.skip(ftype)
7801 
      iprot.readFieldEnd()
7802 
    iprot.readStructEnd()
7803 
 
7804 
  def write(self, oprot):
7805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7807 
      return
7808 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 7809 
    if self.customer_id is not None:
1382 varun.gupt 7810 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7811 
      oprot.writeI64(self.customer_id)
7812 
      oprot.writeFieldEnd()
3431 rajveer 7813 
    if self.limit is not None:
1382 varun.gupt 7814 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7815 
      oprot.writeI64(self.limit)
7816 
      oprot.writeFieldEnd()
7817 
    oprot.writeFieldStop()
7818 
    oprot.writeStructEnd()
7819 
 
3431 rajveer 7820 
  def validate(self):
7821 
    return
7822 
 
7823 
 
1382 varun.gupt 7824 
  def __repr__(self):
7825 
    L = ['%s=%r' % (key, value)
7826 
      for key, value in self.__dict__.iteritems()]
7827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7828 
 
7829 
  def __eq__(self, other):
7830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7831 
 
7832 
  def __ne__(self, other):
7833 
    return not (self == other)
7834 
 
7835 
class getReturnableOrdersForCustomer_result:
7836 
  """
7837 
  Attributes:
7838 
   - success
7839 
   - ex
7840 
  """
7841 
 
7842 
  thrift_spec = (
7843 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7844 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7845 
  )
7846 
 
7847 
  def __init__(self, success=None, ex=None,):
7848 
    self.success = success
7849 
    self.ex = ex
7850 
 
7851 
  def read(self, iprot):
7852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7854 
      return
7855 
    iprot.readStructBegin()
7856 
    while True:
7857 
      (fname, ftype, fid) = iprot.readFieldBegin()
7858 
      if ftype == TType.STOP:
7859 
        break
7860 
      if fid == 0:
7861 
        if ftype == TType.LIST:
7862 
          self.success = []
4133 chandransh 7863 
          (_etype73, _size70) = iprot.readListBegin()
7864 
          for _i74 in xrange(_size70):
7865 
            _elem75 = iprot.readI64();
7866 
            self.success.append(_elem75)
1382 varun.gupt 7867 
          iprot.readListEnd()
7868 
        else:
7869 
          iprot.skip(ftype)
7870 
      elif fid == 1:
7871 
        if ftype == TType.STRUCT:
7872 
          self.ex = TransactionServiceException()
7873 
          self.ex.read(iprot)
7874 
        else:
7875 
          iprot.skip(ftype)
7876 
      else:
7877 
        iprot.skip(ftype)
7878 
      iprot.readFieldEnd()
7879 
    iprot.readStructEnd()
7880 
 
7881 
  def write(self, oprot):
7882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7884 
      return
7885 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 7886 
    if self.success is not None:
1382 varun.gupt 7887 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7888 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 7889 
      for iter76 in self.success:
7890 
        oprot.writeI64(iter76)
1382 varun.gupt 7891 
      oprot.writeListEnd()
7892 
      oprot.writeFieldEnd()
3431 rajveer 7893 
    if self.ex is not None:
1382 varun.gupt 7894 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7895 
      self.ex.write(oprot)
7896 
      oprot.writeFieldEnd()
7897 
    oprot.writeFieldStop()
7898 
    oprot.writeStructEnd()
7899 
 
3431 rajveer 7900 
  def validate(self):
7901 
    return
7902 
 
7903 
 
1382 varun.gupt 7904 
  def __repr__(self):
7905 
    L = ['%s=%r' % (key, value)
7906 
      for key, value in self.__dict__.iteritems()]
7907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7908 
 
7909 
  def __eq__(self, other):
7910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7911 
 
7912 
  def __ne__(self, other):
7913 
    return not (self == other)
7914 
 
7915 
class getCancellableOrdersForCustomer_args:
7916 
  """
7917 
  Attributes:
7918 
   - customer_id
7919 
   - limit
7920 
  """
7921 
 
7922 
  thrift_spec = (
7923 
    None, # 0
7924 
    (1, TType.I64, 'customer_id', None, None, ), # 1
7925 
    (2, TType.I64, 'limit', None, None, ), # 2
7926 
  )
7927 
 
7928 
  def __init__(self, customer_id=None, limit=None,):
7929 
    self.customer_id = customer_id
7930 
    self.limit = limit
7931 
 
7932 
  def read(self, iprot):
7933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7935 
      return
7936 
    iprot.readStructBegin()
7937 
    while True:
7938 
      (fname, ftype, fid) = iprot.readFieldBegin()
7939 
      if ftype == TType.STOP:
7940 
        break
7941 
      if fid == 1:
7942 
        if ftype == TType.I64:
7943 
          self.customer_id = iprot.readI64();
7944 
        else:
7945 
          iprot.skip(ftype)
7946 
      elif fid == 2:
7947 
        if ftype == TType.I64:
7948 
          self.limit = iprot.readI64();
7949 
        else:
7950 
          iprot.skip(ftype)
7951 
      else:
7952 
        iprot.skip(ftype)
7953 
      iprot.readFieldEnd()
7954 
    iprot.readStructEnd()
7955 
 
7956 
  def write(self, oprot):
7957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7959 
      return
7960 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 7961 
    if self.customer_id is not None:
1382 varun.gupt 7962 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
7963 
      oprot.writeI64(self.customer_id)
7964 
      oprot.writeFieldEnd()
3431 rajveer 7965 
    if self.limit is not None:
1382 varun.gupt 7966 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7967 
      oprot.writeI64(self.limit)
7968 
      oprot.writeFieldEnd()
7969 
    oprot.writeFieldStop()
7970 
    oprot.writeStructEnd()
7971 
 
3431 rajveer 7972 
  def validate(self):
7973 
    return
7974 
 
7975 
 
1382 varun.gupt 7976 
  def __repr__(self):
7977 
    L = ['%s=%r' % (key, value)
7978 
      for key, value in self.__dict__.iteritems()]
7979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7980 
 
7981 
  def __eq__(self, other):
7982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7983 
 
7984 
  def __ne__(self, other):
7985 
    return not (self == other)
7986 
 
7987 
class getCancellableOrdersForCustomer_result:
7988 
  """
7989 
  Attributes:
7990 
   - success
7991 
   - ex
7992 
  """
7993 
 
7994 
  thrift_spec = (
7995 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7996 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7997 
  )
7998 
 
7999 
  def __init__(self, success=None, ex=None,):
8000 
    self.success = success
8001 
    self.ex = ex
8002 
 
8003 
  def read(self, iprot):
8004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8006 
      return
8007 
    iprot.readStructBegin()
8008 
    while True:
8009 
      (fname, ftype, fid) = iprot.readFieldBegin()
8010 
      if ftype == TType.STOP:
8011 
        break
8012 
      if fid == 0:
8013 
        if ftype == TType.LIST:
8014 
          self.success = []
4133 chandransh 8015 
          (_etype80, _size77) = iprot.readListBegin()
8016 
          for _i81 in xrange(_size77):
8017 
            _elem82 = iprot.readI64();
8018 
            self.success.append(_elem82)
1382 varun.gupt 8019 
          iprot.readListEnd()
8020 
        else:
8021 
          iprot.skip(ftype)
8022 
      elif fid == 1:
8023 
        if ftype == TType.STRUCT:
8024 
          self.ex = TransactionServiceException()
8025 
          self.ex.read(iprot)
8026 
        else:
8027 
          iprot.skip(ftype)
8028 
      else:
8029 
        iprot.skip(ftype)
8030 
      iprot.readFieldEnd()
8031 
    iprot.readStructEnd()
8032 
 
8033 
  def write(self, oprot):
8034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8036 
      return
8037 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8038 
    if self.success is not None:
1382 varun.gupt 8039 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8040 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 8041 
      for iter83 in self.success:
8042 
        oprot.writeI64(iter83)
1382 varun.gupt 8043 
      oprot.writeListEnd()
8044 
      oprot.writeFieldEnd()
3431 rajveer 8045 
    if self.ex is not None:
1382 varun.gupt 8046 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8047 
      self.ex.write(oprot)
8048 
      oprot.writeFieldEnd()
8049 
    oprot.writeFieldStop()
8050 
    oprot.writeStructEnd()
8051 
 
3431 rajveer 8052 
  def validate(self):
8053 
    return
8054 
 
8055 
 
1382 varun.gupt 8056 
  def __repr__(self):
8057 
    L = ['%s=%r' % (key, value)
8058 
      for key, value in self.__dict__.iteritems()]
8059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8060 
 
8061 
  def __eq__(self, other):
8062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8063 
 
8064 
  def __ne__(self, other):
8065 
    return not (self == other)
8066 
 
483 rajveer 8067 
class changeOrderStatus_args:
94 ashish 8068 
  """
8069 
  Attributes:
483 rajveer 8070 
   - orderId
8071 
   - status
8072 
   - description
94 ashish 8073 
  """
8074 
 
8075 
  thrift_spec = (
8076 
    None, # 0
483 rajveer 8077 
    (1, TType.I64, 'orderId', None, None, ), # 1
8078 
    (2, TType.I32, 'status', None, None, ), # 2
8079 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8080 
  )
8081 
 
483 rajveer 8082 
  def __init__(self, orderId=None, status=None, description=None,):
8083 
    self.orderId = orderId
8084 
    self.status = status
8085 
    self.description = description
94 ashish 8086 
 
8087 
  def read(self, iprot):
8088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8090 
      return
8091 
    iprot.readStructBegin()
8092 
    while True:
8093 
      (fname, ftype, fid) = iprot.readFieldBegin()
8094 
      if ftype == TType.STOP:
8095 
        break
8096 
      if fid == 1:
8097 
        if ftype == TType.I64:
483 rajveer 8098 
          self.orderId = iprot.readI64();
94 ashish 8099 
        else:
8100 
          iprot.skip(ftype)
8101 
      elif fid == 2:
483 rajveer 8102 
        if ftype == TType.I32:
8103 
          self.status = iprot.readI32();
94 ashish 8104 
        else:
8105 
          iprot.skip(ftype)
483 rajveer 8106 
      elif fid == 3:
8107 
        if ftype == TType.STRING:
8108 
          self.description = iprot.readString();
8109 
        else:
8110 
          iprot.skip(ftype)
94 ashish 8111 
      else:
8112 
        iprot.skip(ftype)
8113 
      iprot.readFieldEnd()
8114 
    iprot.readStructEnd()
8115 
 
8116 
  def write(self, oprot):
8117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8119 
      return
483 rajveer 8120 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8121 
    if self.orderId is not None:
483 rajveer 8122 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8123 
      oprot.writeI64(self.orderId)
94 ashish 8124 
      oprot.writeFieldEnd()
3431 rajveer 8125 
    if self.status is not None:
483 rajveer 8126 
      oprot.writeFieldBegin('status', TType.I32, 2)
8127 
      oprot.writeI32(self.status)
94 ashish 8128 
      oprot.writeFieldEnd()
3431 rajveer 8129 
    if self.description is not None:
483 rajveer 8130 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8131 
      oprot.writeString(self.description)
8132 
      oprot.writeFieldEnd()
94 ashish 8133 
    oprot.writeFieldStop()
8134 
    oprot.writeStructEnd()
8135 
 
3431 rajveer 8136 
  def validate(self):
8137 
    return
8138 
 
8139 
 
94 ashish 8140 
  def __repr__(self):
8141 
    L = ['%s=%r' % (key, value)
8142 
      for key, value in self.__dict__.iteritems()]
8143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8144 
 
8145 
  def __eq__(self, other):
8146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8147 
 
8148 
  def __ne__(self, other):
8149 
    return not (self == other)
8150 
 
483 rajveer 8151 
class changeOrderStatus_result:
94 ashish 8152 
  """
8153 
  Attributes:
8154 
   - success
8155 
   - ex
8156 
  """
8157 
 
8158 
  thrift_spec = (
8159 
    (0, TType.BOOL, 'success', None, None, ), # 0
8160 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8161 
  )
8162 
 
8163 
  def __init__(self, success=None, ex=None,):
8164 
    self.success = success
8165 
    self.ex = ex
8166 
 
8167 
  def read(self, iprot):
8168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8170 
      return
8171 
    iprot.readStructBegin()
8172 
    while True:
8173 
      (fname, ftype, fid) = iprot.readFieldBegin()
8174 
      if ftype == TType.STOP:
8175 
        break
8176 
      if fid == 0:
8177 
        if ftype == TType.BOOL:
8178 
          self.success = iprot.readBool();
8179 
        else:
8180 
          iprot.skip(ftype)
8181 
      elif fid == 1:
8182 
        if ftype == TType.STRUCT:
8183 
          self.ex = TransactionServiceException()
8184 
          self.ex.read(iprot)
8185 
        else:
8186 
          iprot.skip(ftype)
8187 
      else:
8188 
        iprot.skip(ftype)
8189 
      iprot.readFieldEnd()
8190 
    iprot.readStructEnd()
8191 
 
8192 
  def write(self, oprot):
8193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8195 
      return
483 rajveer 8196 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8197 
    if self.success is not None:
94 ashish 8198 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8199 
      oprot.writeBool(self.success)
8200 
      oprot.writeFieldEnd()
3431 rajveer 8201 
    if self.ex is not None:
94 ashish 8202 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8203 
      self.ex.write(oprot)
8204 
      oprot.writeFieldEnd()
8205 
    oprot.writeFieldStop()
8206 
    oprot.writeStructEnd()
8207 
 
3431 rajveer 8208 
  def validate(self):
8209 
    return
8210 
 
8211 
 
94 ashish 8212 
  def __repr__(self):
8213 
    L = ['%s=%r' % (key, value)
8214 
      for key, value in self.__dict__.iteritems()]
8215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8216 
 
8217 
  def __eq__(self, other):
8218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8219 
 
8220 
  def __ne__(self, other):
8221 
    return not (self == other)
8222 
 
3064 chandransh 8223 
class getOrdersForTransaction_args:
494 rajveer 8224 
  """
8225 
  Attributes:
3064 chandransh 8226 
   - transactionId
8227 
   - customerId
494 rajveer 8228 
  """
8229 
 
8230 
  thrift_spec = (
8231 
    None, # 0
3064 chandransh 8232 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8233 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8234 
  )
8235 
 
3064 chandransh 8236 
  def __init__(self, transactionId=None, customerId=None,):
8237 
    self.transactionId = transactionId
8238 
    self.customerId = customerId
494 rajveer 8239 
 
8240 
  def read(self, iprot):
8241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8243 
      return
8244 
    iprot.readStructBegin()
8245 
    while True:
8246 
      (fname, ftype, fid) = iprot.readFieldBegin()
8247 
      if ftype == TType.STOP:
8248 
        break
8249 
      if fid == 1:
8250 
        if ftype == TType.I64:
3064 chandransh 8251 
          self.transactionId = iprot.readI64();
494 rajveer 8252 
        else:
8253 
          iprot.skip(ftype)
8254 
      elif fid == 2:
3064 chandransh 8255 
        if ftype == TType.I64:
8256 
          self.customerId = iprot.readI64();
494 rajveer 8257 
        else:
8258 
          iprot.skip(ftype)
8259 
      else:
8260 
        iprot.skip(ftype)
8261 
      iprot.readFieldEnd()
8262 
    iprot.readStructEnd()
8263 
 
8264 
  def write(self, oprot):
8265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8267 
      return
3064 chandransh 8268 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8269 
    if self.transactionId is not None:
3064 chandransh 8270 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8271 
      oprot.writeI64(self.transactionId)
494 rajveer 8272 
      oprot.writeFieldEnd()
3431 rajveer 8273 
    if self.customerId is not None:
3064 chandransh 8274 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8275 
      oprot.writeI64(self.customerId)
494 rajveer 8276 
      oprot.writeFieldEnd()
8277 
    oprot.writeFieldStop()
8278 
    oprot.writeStructEnd()
8279 
 
3431 rajveer 8280 
  def validate(self):
8281 
    return
8282 
 
8283 
 
494 rajveer 8284 
  def __repr__(self):
8285 
    L = ['%s=%r' % (key, value)
8286 
      for key, value in self.__dict__.iteritems()]
8287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8288 
 
8289 
  def __eq__(self, other):
8290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8291 
 
8292 
  def __ne__(self, other):
8293 
    return not (self == other)
8294 
 
3064 chandransh 8295 
class getOrdersForTransaction_result:
494 rajveer 8296 
  """
8297 
  Attributes:
8298 
   - success
8299 
   - ex
8300 
  """
8301 
 
8302 
  thrift_spec = (
3064 chandransh 8303 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8304 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8305 
  )
8306 
 
8307 
  def __init__(self, success=None, ex=None,):
8308 
    self.success = success
8309 
    self.ex = ex
8310 
 
8311 
  def read(self, iprot):
8312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8314 
      return
8315 
    iprot.readStructBegin()
8316 
    while True:
8317 
      (fname, ftype, fid) = iprot.readFieldBegin()
8318 
      if ftype == TType.STOP:
8319 
        break
8320 
      if fid == 0:
3064 chandransh 8321 
        if ftype == TType.LIST:
8322 
          self.success = []
4133 chandransh 8323 
          (_etype87, _size84) = iprot.readListBegin()
8324 
          for _i88 in xrange(_size84):
8325 
            _elem89 = Order()
8326 
            _elem89.read(iprot)
8327 
            self.success.append(_elem89)
3064 chandransh 8328 
          iprot.readListEnd()
494 rajveer 8329 
        else:
8330 
          iprot.skip(ftype)
8331 
      elif fid == 1:
8332 
        if ftype == TType.STRUCT:
8333 
          self.ex = TransactionServiceException()
8334 
          self.ex.read(iprot)
8335 
        else:
8336 
          iprot.skip(ftype)
8337 
      else:
8338 
        iprot.skip(ftype)
8339 
      iprot.readFieldEnd()
8340 
    iprot.readStructEnd()
8341 
 
8342 
  def write(self, oprot):
8343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8345 
      return
3064 chandransh 8346 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 8347 
    if self.success is not None:
3064 chandransh 8348 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8349 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8350 
      for iter90 in self.success:
8351 
        iter90.write(oprot)
3064 chandransh 8352 
      oprot.writeListEnd()
494 rajveer 8353 
      oprot.writeFieldEnd()
3431 rajveer 8354 
    if self.ex is not None:
494 rajveer 8355 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8356 
      self.ex.write(oprot)
8357 
      oprot.writeFieldEnd()
8358 
    oprot.writeFieldStop()
8359 
    oprot.writeStructEnd()
8360 
 
3431 rajveer 8361 
  def validate(self):
8362 
    return
8363 
 
8364 
 
494 rajveer 8365 
  def __repr__(self):
8366 
    L = ['%s=%r' % (key, value)
8367 
      for key, value in self.__dict__.iteritems()]
8368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8369 
 
8370 
  def __eq__(self, other):
8371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8372 
 
8373 
  def __ne__(self, other):
8374 
    return not (self == other)
8375 
 
3064 chandransh 8376 
class getOrdersForCustomer_args:
1149 chandransh 8377 
  """
8378 
  Attributes:
3064 chandransh 8379 
   - customerId
8380 
   - from_date
8381 
   - to_date
8382 
   - statuses
1149 chandransh 8383 
  """
8384 
 
8385 
  thrift_spec = (
8386 
    None, # 0
3064 chandransh 8387 
    (1, TType.I64, 'customerId', None, None, ), # 1
8388 
    (2, TType.I64, 'from_date', None, None, ), # 2
8389 
    (3, TType.I64, 'to_date', None, None, ), # 3
8390 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 8391 
  )
8392 
 
3064 chandransh 8393 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
8394 
    self.customerId = customerId
8395 
    self.from_date = from_date
8396 
    self.to_date = to_date
8397 
    self.statuses = statuses
1149 chandransh 8398 
 
8399 
  def read(self, iprot):
8400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8402 
      return
8403 
    iprot.readStructBegin()
8404 
    while True:
8405 
      (fname, ftype, fid) = iprot.readFieldBegin()
8406 
      if ftype == TType.STOP:
8407 
        break
8408 
      if fid == 1:
8409 
        if ftype == TType.I64:
3064 chandransh 8410 
          self.customerId = iprot.readI64();
1149 chandransh 8411 
        else:
8412 
          iprot.skip(ftype)
8413 
      elif fid == 2:
8414 
        if ftype == TType.I64:
3064 chandransh 8415 
          self.from_date = iprot.readI64();
1149 chandransh 8416 
        else:
8417 
          iprot.skip(ftype)
2783 chandransh 8418 
      elif fid == 3:
8419 
        if ftype == TType.I64:
3064 chandransh 8420 
          self.to_date = iprot.readI64();
2783 chandransh 8421 
        else:
8422 
          iprot.skip(ftype)
8423 
      elif fid == 4:
3064 chandransh 8424 
        if ftype == TType.LIST:
8425 
          self.statuses = []
4133 chandransh 8426 
          (_etype94, _size91) = iprot.readListBegin()
8427 
          for _i95 in xrange(_size91):
8428 
            _elem96 = iprot.readI32();
8429 
            self.statuses.append(_elem96)
3064 chandransh 8430 
          iprot.readListEnd()
2783 chandransh 8431 
        else:
8432 
          iprot.skip(ftype)
1149 chandransh 8433 
      else:
8434 
        iprot.skip(ftype)
8435 
      iprot.readFieldEnd()
8436 
    iprot.readStructEnd()
8437 
 
8438 
  def write(self, oprot):
8439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8441 
      return
3064 chandransh 8442 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 8443 
    if self.customerId is not None:
3064 chandransh 8444 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8445 
      oprot.writeI64(self.customerId)
1149 chandransh 8446 
      oprot.writeFieldEnd()
3431 rajveer 8447 
    if self.from_date is not None:
3064 chandransh 8448 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8449 
      oprot.writeI64(self.from_date)
1149 chandransh 8450 
      oprot.writeFieldEnd()
3431 rajveer 8451 
    if self.to_date is not None:
3064 chandransh 8452 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8453 
      oprot.writeI64(self.to_date)
2783 chandransh 8454 
      oprot.writeFieldEnd()
3431 rajveer 8455 
    if self.statuses is not None:
3064 chandransh 8456 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
8457 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 8458 
      for iter97 in self.statuses:
8459 
        oprot.writeI32(iter97)
3064 chandransh 8460 
      oprot.writeListEnd()
2783 chandransh 8461 
      oprot.writeFieldEnd()
1149 chandransh 8462 
    oprot.writeFieldStop()
8463 
    oprot.writeStructEnd()
8464 
 
3431 rajveer 8465 
  def validate(self):
8466 
    return
8467 
 
8468 
 
1149 chandransh 8469 
  def __repr__(self):
8470 
    L = ['%s=%r' % (key, value)
8471 
      for key, value in self.__dict__.iteritems()]
8472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8473 
 
8474 
  def __eq__(self, other):
8475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8476 
 
8477 
  def __ne__(self, other):
8478 
    return not (self == other)
8479 
 
3064 chandransh 8480 
class getOrdersForCustomer_result:
1149 chandransh 8481 
  """
8482 
  Attributes:
8483 
   - success
8484 
   - ex
8485 
  """
8486 
 
8487 
  thrift_spec = (
3064 chandransh 8488 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 8489 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8490 
  )
8491 
 
8492 
  def __init__(self, success=None, ex=None,):
8493 
    self.success = success
8494 
    self.ex = ex
8495 
 
8496 
  def read(self, iprot):
8497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8499 
      return
8500 
    iprot.readStructBegin()
8501 
    while True:
8502 
      (fname, ftype, fid) = iprot.readFieldBegin()
8503 
      if ftype == TType.STOP:
8504 
        break
8505 
      if fid == 0:
3064 chandransh 8506 
        if ftype == TType.LIST:
8507 
          self.success = []
4133 chandransh 8508 
          (_etype101, _size98) = iprot.readListBegin()
8509 
          for _i102 in xrange(_size98):
8510 
            _elem103 = Order()
8511 
            _elem103.read(iprot)
8512 
            self.success.append(_elem103)
3064 chandransh 8513 
          iprot.readListEnd()
1149 chandransh 8514 
        else:
8515 
          iprot.skip(ftype)
8516 
      elif fid == 1:
8517 
        if ftype == TType.STRUCT:
8518 
          self.ex = TransactionServiceException()
8519 
          self.ex.read(iprot)
8520 
        else:
8521 
          iprot.skip(ftype)
8522 
      else:
8523 
        iprot.skip(ftype)
8524 
      iprot.readFieldEnd()
8525 
    iprot.readStructEnd()
8526 
 
8527 
  def write(self, oprot):
8528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8530 
      return
3064 chandransh 8531 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 8532 
    if self.success is not None:
3064 chandransh 8533 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8534 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8535 
      for iter104 in self.success:
8536 
        iter104.write(oprot)
3064 chandransh 8537 
      oprot.writeListEnd()
1149 chandransh 8538 
      oprot.writeFieldEnd()
3431 rajveer 8539 
    if self.ex is not None:
1149 chandransh 8540 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8541 
      self.ex.write(oprot)
8542 
      oprot.writeFieldEnd()
8543 
    oprot.writeFieldStop()
8544 
    oprot.writeStructEnd()
8545 
 
3431 rajveer 8546 
  def validate(self):
8547 
    return
8548 
 
8549 
 
1149 chandransh 8550 
  def __repr__(self):
8551 
    L = ['%s=%r' % (key, value)
8552 
      for key, value in self.__dict__.iteritems()]
8553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8554 
 
8555 
  def __eq__(self, other):
8556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8557 
 
8558 
  def __ne__(self, other):
8559 
    return not (self == other)
8560 
 
3064 chandransh 8561 
class createOrder_args:
921 rajveer 8562 
  """
8563 
  Attributes:
3064 chandransh 8564 
   - order
921 rajveer 8565 
  """
8566 
 
8567 
  thrift_spec = (
8568 
    None, # 0
3064 chandransh 8569 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 8570 
  )
8571 
 
3064 chandransh 8572 
  def __init__(self, order=None,):
8573 
    self.order = order
921 rajveer 8574 
 
8575 
  def read(self, iprot):
8576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8578 
      return
8579 
    iprot.readStructBegin()
8580 
    while True:
8581 
      (fname, ftype, fid) = iprot.readFieldBegin()
8582 
      if ftype == TType.STOP:
8583 
        break
8584 
      if fid == 1:
3064 chandransh 8585 
        if ftype == TType.STRUCT:
8586 
          self.order = Order()
8587 
          self.order.read(iprot)
921 rajveer 8588 
        else:
8589 
          iprot.skip(ftype)
8590 
      else:
8591 
        iprot.skip(ftype)
8592 
      iprot.readFieldEnd()
8593 
    iprot.readStructEnd()
8594 
 
8595 
  def write(self, oprot):
8596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8598 
      return
3064 chandransh 8599 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 8600 
    if self.order is not None:
3064 chandransh 8601 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
8602 
      self.order.write(oprot)
921 rajveer 8603 
      oprot.writeFieldEnd()
8604 
    oprot.writeFieldStop()
8605 
    oprot.writeStructEnd()
8606 
 
3431 rajveer 8607 
  def validate(self):
8608 
    return
8609 
 
8610 
 
921 rajveer 8611 
  def __repr__(self):
8612 
    L = ['%s=%r' % (key, value)
8613 
      for key, value in self.__dict__.iteritems()]
8614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8615 
 
8616 
  def __eq__(self, other):
8617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8618 
 
8619 
  def __ne__(self, other):
8620 
    return not (self == other)
8621 
 
3064 chandransh 8622 
class createOrder_result:
921 rajveer 8623 
  """
8624 
  Attributes:
8625 
   - success
8626 
   - ex
8627 
  """
8628 
 
8629 
  thrift_spec = (
3064 chandransh 8630 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 8631 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8632 
  )
8633 
 
8634 
  def __init__(self, success=None, ex=None,):
8635 
    self.success = success
8636 
    self.ex = ex
8637 
 
8638 
  def read(self, iprot):
8639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8641 
      return
8642 
    iprot.readStructBegin()
8643 
    while True:
8644 
      (fname, ftype, fid) = iprot.readFieldBegin()
8645 
      if ftype == TType.STOP:
8646 
        break
8647 
      if fid == 0:
3064 chandransh 8648 
        if ftype == TType.I64:
8649 
          self.success = iprot.readI64();
921 rajveer 8650 
        else:
8651 
          iprot.skip(ftype)
8652 
      elif fid == 1:
8653 
        if ftype == TType.STRUCT:
8654 
          self.ex = TransactionServiceException()
8655 
          self.ex.read(iprot)
8656 
        else:
8657 
          iprot.skip(ftype)
8658 
      else:
8659 
        iprot.skip(ftype)
8660 
      iprot.readFieldEnd()
8661 
    iprot.readStructEnd()
8662 
 
8663 
  def write(self, oprot):
8664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8666 
      return
3064 chandransh 8667 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 8668 
    if self.success is not None:
3064 chandransh 8669 
      oprot.writeFieldBegin('success', TType.I64, 0)
8670 
      oprot.writeI64(self.success)
921 rajveer 8671 
      oprot.writeFieldEnd()
3431 rajveer 8672 
    if self.ex is not None:
921 rajveer 8673 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8674 
      self.ex.write(oprot)
8675 
      oprot.writeFieldEnd()
8676 
    oprot.writeFieldStop()
8677 
    oprot.writeStructEnd()
8678 
 
3431 rajveer 8679 
  def validate(self):
8680 
    return
8681 
 
8682 
 
921 rajveer 8683 
  def __repr__(self):
8684 
    L = ['%s=%r' % (key, value)
8685 
      for key, value in self.__dict__.iteritems()]
8686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8687 
 
8688 
  def __eq__(self, other):
8689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8690 
 
8691 
  def __ne__(self, other):
8692 
    return not (self == other)
8693 
 
3064 chandransh 8694 
class getOrder_args:
921 rajveer 8695 
  """
8696 
  Attributes:
3064 chandransh 8697 
   - id
921 rajveer 8698 
  """
8699 
 
8700 
  thrift_spec = (
8701 
    None, # 0
3064 chandransh 8702 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 8703 
  )
8704 
 
3064 chandransh 8705 
  def __init__(self, id=None,):
8706 
    self.id = id
921 rajveer 8707 
 
8708 
  def read(self, iprot):
8709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8711 
      return
8712 
    iprot.readStructBegin()
8713 
    while True:
8714 
      (fname, ftype, fid) = iprot.readFieldBegin()
8715 
      if ftype == TType.STOP:
8716 
        break
8717 
      if fid == 1:
8718 
        if ftype == TType.I64:
3064 chandransh 8719 
          self.id = iprot.readI64();
921 rajveer 8720 
        else:
8721 
          iprot.skip(ftype)
8722 
      else:
8723 
        iprot.skip(ftype)
8724 
      iprot.readFieldEnd()
8725 
    iprot.readStructEnd()
8726 
 
8727 
  def write(self, oprot):
8728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8730 
      return
3064 chandransh 8731 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 8732 
    if self.id is not None:
3064 chandransh 8733 
      oprot.writeFieldBegin('id', TType.I64, 1)
8734 
      oprot.writeI64(self.id)
921 rajveer 8735 
      oprot.writeFieldEnd()
8736 
    oprot.writeFieldStop()
8737 
    oprot.writeStructEnd()
8738 
 
3431 rajveer 8739 
  def validate(self):
8740 
    return
8741 
 
8742 
 
921 rajveer 8743 
  def __repr__(self):
8744 
    L = ['%s=%r' % (key, value)
8745 
      for key, value in self.__dict__.iteritems()]
8746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8747 
 
8748 
  def __eq__(self, other):
8749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8750 
 
8751 
  def __ne__(self, other):
8752 
    return not (self == other)
8753 
 
3064 chandransh 8754 
class getOrder_result:
921 rajveer 8755 
  """
8756 
  Attributes:
8757 
   - success
8758 
   - ex
8759 
  """
8760 
 
8761 
  thrift_spec = (
3064 chandransh 8762 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 8763 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8764 
  )
8765 
 
8766 
  def __init__(self, success=None, ex=None,):
8767 
    self.success = success
8768 
    self.ex = ex
8769 
 
8770 
  def read(self, iprot):
8771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8773 
      return
8774 
    iprot.readStructBegin()
8775 
    while True:
8776 
      (fname, ftype, fid) = iprot.readFieldBegin()
8777 
      if ftype == TType.STOP:
8778 
        break
8779 
      if fid == 0:
3064 chandransh 8780 
        if ftype == TType.STRUCT:
8781 
          self.success = Order()
8782 
          self.success.read(iprot)
921 rajveer 8783 
        else:
8784 
          iprot.skip(ftype)
8785 
      elif fid == 1:
8786 
        if ftype == TType.STRUCT:
8787 
          self.ex = TransactionServiceException()
8788 
          self.ex.read(iprot)
8789 
        else:
8790 
          iprot.skip(ftype)
8791 
      else:
8792 
        iprot.skip(ftype)
8793 
      iprot.readFieldEnd()
8794 
    iprot.readStructEnd()
8795 
 
8796 
  def write(self, oprot):
8797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8799 
      return
3064 chandransh 8800 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 8801 
    if self.success is not None:
3064 chandransh 8802 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8803 
      self.success.write(oprot)
921 rajveer 8804 
      oprot.writeFieldEnd()
3431 rajveer 8805 
    if self.ex is not None:
921 rajveer 8806 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8807 
      self.ex.write(oprot)
8808 
      oprot.writeFieldEnd()
8809 
    oprot.writeFieldStop()
8810 
    oprot.writeStructEnd()
8811 
 
3431 rajveer 8812 
  def validate(self):
8813 
    return
8814 
 
8815 
 
921 rajveer 8816 
  def __repr__(self):
8817 
    L = ['%s=%r' % (key, value)
8818 
      for key, value in self.__dict__.iteritems()]
8819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8820 
 
8821 
  def __eq__(self, other):
8822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8823 
 
8824 
  def __ne__(self, other):
8825 
    return not (self == other)
8826 
 
3064 chandransh 8827 
class getLineItemsForOrder_args:
94 ashish 8828 
  """
8829 
  Attributes:
3064 chandransh 8830 
   - orderId
94 ashish 8831 
  """
8832 
 
8833 
  thrift_spec = (
8834 
    None, # 0
3064 chandransh 8835 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 8836 
  )
8837 
 
3064 chandransh 8838 
  def __init__(self, orderId=None,):
8839 
    self.orderId = orderId
94 ashish 8840 
 
8841 
  def read(self, iprot):
8842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8844 
      return
8845 
    iprot.readStructBegin()
8846 
    while True:
8847 
      (fname, ftype, fid) = iprot.readFieldBegin()
8848 
      if ftype == TType.STOP:
8849 
        break
8850 
      if fid == 1:
8851 
        if ftype == TType.I64:
3064 chandransh 8852 
          self.orderId = iprot.readI64();
94 ashish 8853 
        else:
8854 
          iprot.skip(ftype)
8855 
      else:
8856 
        iprot.skip(ftype)
8857 
      iprot.readFieldEnd()
8858 
    iprot.readStructEnd()
8859 
 
8860 
  def write(self, oprot):
8861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8863 
      return
3064 chandransh 8864 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 8865 
    if self.orderId is not None:
3064 chandransh 8866 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8867 
      oprot.writeI64(self.orderId)
94 ashish 8868 
      oprot.writeFieldEnd()
8869 
    oprot.writeFieldStop()
8870 
    oprot.writeStructEnd()
8871 
 
3431 rajveer 8872 
  def validate(self):
8873 
    return
8874 
 
8875 
 
94 ashish 8876 
  def __repr__(self):
8877 
    L = ['%s=%r' % (key, value)
8878 
      for key, value in self.__dict__.iteritems()]
8879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8880 
 
8881 
  def __eq__(self, other):
8882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8883 
 
8884 
  def __ne__(self, other):
8885 
    return not (self == other)
8886 
 
3064 chandransh 8887 
class getLineItemsForOrder_result:
94 ashish 8888 
  """
8889 
  Attributes:
8890 
   - success
8891 
   - ex
8892 
  """
8893 
 
8894 
  thrift_spec = (
3064 chandransh 8895 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 8896 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8897 
  )
8898 
 
8899 
  def __init__(self, success=None, ex=None,):
8900 
    self.success = success
8901 
    self.ex = ex
8902 
 
8903 
  def read(self, iprot):
8904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8906 
      return
8907 
    iprot.readStructBegin()
8908 
    while True:
8909 
      (fname, ftype, fid) = iprot.readFieldBegin()
8910 
      if ftype == TType.STOP:
8911 
        break
8912 
      if fid == 0:
483 rajveer 8913 
        if ftype == TType.LIST:
8914 
          self.success = []
4133 chandransh 8915 
          (_etype108, _size105) = iprot.readListBegin()
8916 
          for _i109 in xrange(_size105):
8917 
            _elem110 = LineItem()
8918 
            _elem110.read(iprot)
8919 
            self.success.append(_elem110)
483 rajveer 8920 
          iprot.readListEnd()
94 ashish 8921 
        else:
8922 
          iprot.skip(ftype)
8923 
      elif fid == 1:
8924 
        if ftype == TType.STRUCT:
8925 
          self.ex = TransactionServiceException()
8926 
          self.ex.read(iprot)
8927 
        else:
8928 
          iprot.skip(ftype)
8929 
      else:
8930 
        iprot.skip(ftype)
8931 
      iprot.readFieldEnd()
8932 
    iprot.readStructEnd()
8933 
 
8934 
  def write(self, oprot):
8935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8937 
      return
3064 chandransh 8938 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 8939 
    if self.success is not None:
483 rajveer 8940 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8941 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8942 
      for iter111 in self.success:
8943 
        iter111.write(oprot)
483 rajveer 8944 
      oprot.writeListEnd()
94 ashish 8945 
      oprot.writeFieldEnd()
3431 rajveer 8946 
    if self.ex is not None:
94 ashish 8947 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8948 
      self.ex.write(oprot)
8949 
      oprot.writeFieldEnd()
8950 
    oprot.writeFieldStop()
8951 
    oprot.writeStructEnd()
8952 
 
3431 rajveer 8953 
  def validate(self):
8954 
    return
8955 
 
8956 
 
94 ashish 8957 
  def __repr__(self):
8958 
    L = ['%s=%r' % (key, value)
8959 
      for key, value in self.__dict__.iteritems()]
8960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8961 
 
8962 
  def __eq__(self, other):
8963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8964 
 
8965 
  def __ne__(self, other):
8966 
    return not (self == other)
8967 
 
3064 chandransh 8968 
class getOrderForCustomer_args:
94 ashish 8969 
  """
8970 
  Attributes:
3064 chandransh 8971 
   - orderId
483 rajveer 8972 
   - customerId
94 ashish 8973 
  """
8974 
 
8975 
  thrift_spec = (
8976 
    None, # 0
3064 chandransh 8977 
    (1, TType.I64, 'orderId', None, None, ), # 1
8978 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 8979 
  )
8980 
 
3064 chandransh 8981 
  def __init__(self, orderId=None, customerId=None,):
8982 
    self.orderId = orderId
483 rajveer 8983 
    self.customerId = customerId
94 ashish 8984 
 
8985 
  def read(self, iprot):
8986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8988 
      return
8989 
    iprot.readStructBegin()
8990 
    while True:
8991 
      (fname, ftype, fid) = iprot.readFieldBegin()
8992 
      if ftype == TType.STOP:
8993 
        break
8994 
      if fid == 1:
8995 
        if ftype == TType.I64:
3064 chandransh 8996 
          self.orderId = iprot.readI64();
94 ashish 8997 
        else:
8998 
          iprot.skip(ftype)
8999 
      elif fid == 2:
9000 
        if ftype == TType.I64:
3064 chandransh 9001 
          self.customerId = iprot.readI64();
94 ashish 9002 
        else:
9003 
          iprot.skip(ftype)
9004 
      else:
9005 
        iprot.skip(ftype)
9006 
      iprot.readFieldEnd()
9007 
    iprot.readStructEnd()
9008 
 
9009 
  def write(self, oprot):
9010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9012 
      return
3064 chandransh 9013 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 9014 
    if self.orderId is not None:
3064 chandransh 9015 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9016 
      oprot.writeI64(self.orderId)
9017 
      oprot.writeFieldEnd()
3431 rajveer 9018 
    if self.customerId is not None:
3064 chandransh 9019 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 9020 
      oprot.writeI64(self.customerId)
94 ashish 9021 
      oprot.writeFieldEnd()
9022 
    oprot.writeFieldStop()
9023 
    oprot.writeStructEnd()
9024 
 
3431 rajveer 9025 
  def validate(self):
9026 
    return
9027 
 
9028 
 
94 ashish 9029 
  def __repr__(self):
9030 
    L = ['%s=%r' % (key, value)
9031 
      for key, value in self.__dict__.iteritems()]
9032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9033 
 
9034 
  def __eq__(self, other):
9035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9036 
 
9037 
  def __ne__(self, other):
9038 
    return not (self == other)
9039 
 
3064 chandransh 9040 
class getOrderForCustomer_result:
94 ashish 9041 
  """
9042 
  Attributes:
9043 
   - success
9044 
   - ex
9045 
  """
9046 
 
9047 
  thrift_spec = (
3064 chandransh 9048 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 9049 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9050 
  )
9051 
 
9052 
  def __init__(self, success=None, ex=None,):
9053 
    self.success = success
9054 
    self.ex = ex
9055 
 
9056 
  def read(self, iprot):
9057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9059 
      return
9060 
    iprot.readStructBegin()
9061 
    while True:
9062 
      (fname, ftype, fid) = iprot.readFieldBegin()
9063 
      if ftype == TType.STOP:
9064 
        break
9065 
      if fid == 0:
3064 chandransh 9066 
        if ftype == TType.STRUCT:
9067 
          self.success = Order()
9068 
          self.success.read(iprot)
94 ashish 9069 
        else:
9070 
          iprot.skip(ftype)
9071 
      elif fid == 1:
9072 
        if ftype == TType.STRUCT:
9073 
          self.ex = TransactionServiceException()
9074 
          self.ex.read(iprot)
9075 
        else:
9076 
          iprot.skip(ftype)
9077 
      else:
9078 
        iprot.skip(ftype)
9079 
      iprot.readFieldEnd()
9080 
    iprot.readStructEnd()
9081 
 
9082 
  def write(self, oprot):
9083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9085 
      return
3064 chandransh 9086 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 9087 
    if self.success is not None:
3064 chandransh 9088 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9089 
      self.success.write(oprot)
94 ashish 9090 
      oprot.writeFieldEnd()
3431 rajveer 9091 
    if self.ex is not None:
94 ashish 9092 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9093 
      self.ex.write(oprot)
9094 
      oprot.writeFieldEnd()
9095 
    oprot.writeFieldStop()
9096 
    oprot.writeStructEnd()
9097 
 
3431 rajveer 9098 
  def validate(self):
9099 
    return
9100 
 
9101 
 
94 ashish 9102 
  def __repr__(self):
9103 
    L = ['%s=%r' % (key, value)
9104 
      for key, value in self.__dict__.iteritems()]
9105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9106 
 
9107 
  def __eq__(self, other):
9108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9109 
 
9110 
  def __ne__(self, other):
9111 
    return not (self == other)
9112 
 
3064 chandransh 9113 
class getAlerts_args:
94 ashish 9114 
  """
9115 
  Attributes:
4394 rajveer 9116 
   - type
4444 rajveer 9117 
   - warehouseId
4394 rajveer 9118 
   - status
9119 
   - timestamp
94 ashish 9120 
  """
9121 
 
9122 
  thrift_spec = (
9123 
    None, # 0
4394 rajveer 9124 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9125 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9126 
    (3, TType.I64, 'status', None, None, ), # 3
9127 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 9128 
  )
9129 
 
4444 rajveer 9130 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 9131 
    self.type = type
4444 rajveer 9132 
    self.warehouseId = warehouseId
4394 rajveer 9133 
    self.status = status
9134 
    self.timestamp = timestamp
94 ashish 9135 
 
9136 
  def read(self, iprot):
9137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9139 
      return
9140 
    iprot.readStructBegin()
9141 
    while True:
9142 
      (fname, ftype, fid) = iprot.readFieldBegin()
9143 
      if ftype == TType.STOP:
9144 
        break
9145 
      if fid == 1:
3064 chandransh 9146 
        if ftype == TType.I64:
4394 rajveer 9147 
          self.type = iprot.readI64();
94 ashish 9148 
        else:
9149 
          iprot.skip(ftype)
3064 chandransh 9150 
      elif fid == 2:
4394 rajveer 9151 
        if ftype == TType.I64:
4444 rajveer 9152 
          self.warehouseId = iprot.readI64();
3064 chandransh 9153 
        else:
9154 
          iprot.skip(ftype)
4394 rajveer 9155 
      elif fid == 3:
9156 
        if ftype == TType.I64:
4444 rajveer 9157 
          self.status = iprot.readI64();
9158 
        else:
9159 
          iprot.skip(ftype)
9160 
      elif fid == 4:
9161 
        if ftype == TType.I64:
4394 rajveer 9162 
          self.timestamp = iprot.readI64();
9163 
        else:
9164 
          iprot.skip(ftype)
94 ashish 9165 
      else:
9166 
        iprot.skip(ftype)
9167 
      iprot.readFieldEnd()
9168 
    iprot.readStructEnd()
9169 
 
9170 
  def write(self, oprot):
9171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9173 
      return
3064 chandransh 9174 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 9175 
    if self.type is not None:
9176 
      oprot.writeFieldBegin('type', TType.I64, 1)
9177 
      oprot.writeI64(self.type)
94 ashish 9178 
      oprot.writeFieldEnd()
4444 rajveer 9179 
    if self.warehouseId is not None:
9180 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9181 
      oprot.writeI64(self.warehouseId)
9182 
      oprot.writeFieldEnd()
4394 rajveer 9183 
    if self.status is not None:
4444 rajveer 9184 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 9185 
      oprot.writeI64(self.status)
3064 chandransh 9186 
      oprot.writeFieldEnd()
4394 rajveer 9187 
    if self.timestamp is not None:
4444 rajveer 9188 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 9189 
      oprot.writeI64(self.timestamp)
9190 
      oprot.writeFieldEnd()
94 ashish 9191 
    oprot.writeFieldStop()
9192 
    oprot.writeStructEnd()
9193 
 
3431 rajveer 9194 
  def validate(self):
9195 
    return
9196 
 
9197 
 
94 ashish 9198 
  def __repr__(self):
9199 
    L = ['%s=%r' % (key, value)
9200 
      for key, value in self.__dict__.iteritems()]
9201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9202 
 
9203 
  def __eq__(self, other):
9204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9205 
 
9206 
  def __ne__(self, other):
9207 
    return not (self == other)
9208 
 
3064 chandransh 9209 
class getAlerts_result:
94 ashish 9210 
  """
9211 
  Attributes:
9212 
   - success
9213 
  """
9214 
 
9215 
  thrift_spec = (
3064 chandransh 9216 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 9217 
  )
9218 
 
3064 chandransh 9219 
  def __init__(self, success=None,):
94 ashish 9220 
    self.success = success
9221 
 
9222 
  def read(self, iprot):
9223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9225 
      return
9226 
    iprot.readStructBegin()
9227 
    while True:
9228 
      (fname, ftype, fid) = iprot.readFieldBegin()
9229 
      if ftype == TType.STOP:
9230 
        break
9231 
      if fid == 0:
3064 chandransh 9232 
        if ftype == TType.LIST:
9233 
          self.success = []
4133 chandransh 9234 
          (_etype115, _size112) = iprot.readListBegin()
9235 
          for _i116 in xrange(_size112):
9236 
            _elem117 = Alert()
9237 
            _elem117.read(iprot)
9238 
            self.success.append(_elem117)
3064 chandransh 9239 
          iprot.readListEnd()
94 ashish 9240 
        else:
9241 
          iprot.skip(ftype)
9242 
      else:
9243 
        iprot.skip(ftype)
9244 
      iprot.readFieldEnd()
9245 
    iprot.readStructEnd()
9246 
 
9247 
  def write(self, oprot):
9248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9250 
      return
3064 chandransh 9251 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 9252 
    if self.success is not None:
3064 chandransh 9253 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9254 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9255 
      for iter118 in self.success:
9256 
        iter118.write(oprot)
3064 chandransh 9257 
      oprot.writeListEnd()
94 ashish 9258 
      oprot.writeFieldEnd()
9259 
    oprot.writeFieldStop()
9260 
    oprot.writeStructEnd()
9261 
 
3431 rajveer 9262 
  def validate(self):
9263 
    return
9264 
 
9265 
 
94 ashish 9266 
  def __repr__(self):
9267 
    L = ['%s=%r' % (key, value)
9268 
      for key, value in self.__dict__.iteritems()]
9269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9270 
 
9271 
  def __eq__(self, other):
9272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9273 
 
9274 
  def __ne__(self, other):
9275 
    return not (self == other)
9276 
 
4394 rajveer 9277 
class addAlert_args:
94 ashish 9278 
  """
9279 
  Attributes:
3064 chandransh 9280 
   - type
4444 rajveer 9281 
   - warehouseId
4394 rajveer 9282 
   - description
94 ashish 9283 
  """
9284 
 
9285 
  thrift_spec = (
9286 
    None, # 0
4394 rajveer 9287 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9288 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9289 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9290 
  )
9291 
 
4444 rajveer 9292 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 9293 
    self.type = type
4444 rajveer 9294 
    self.warehouseId = warehouseId
4394 rajveer 9295 
    self.description = description
94 ashish 9296 
 
9297 
  def read(self, iprot):
9298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9300 
      return
9301 
    iprot.readStructBegin()
9302 
    while True:
9303 
      (fname, ftype, fid) = iprot.readFieldBegin()
9304 
      if ftype == TType.STOP:
9305 
        break
9306 
      if fid == 1:
9307 
        if ftype == TType.I64:
4394 rajveer 9308 
          self.type = iprot.readI64();
94 ashish 9309 
        else:
9310 
          iprot.skip(ftype)
3064 chandransh 9311 
      elif fid == 2:
4444 rajveer 9312 
        if ftype == TType.I64:
9313 
          self.warehouseId = iprot.readI64();
9314 
        else:
9315 
          iprot.skip(ftype)
9316 
      elif fid == 3:
3064 chandransh 9317 
        if ftype == TType.STRING:
4394 rajveer 9318 
          self.description = iprot.readString();
3064 chandransh 9319 
        else:
9320 
          iprot.skip(ftype)
94 ashish 9321 
      else:
9322 
        iprot.skip(ftype)
9323 
      iprot.readFieldEnd()
9324 
    iprot.readStructEnd()
9325 
 
9326 
  def write(self, oprot):
9327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9329 
      return
4394 rajveer 9330 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 9331 
    if self.type is not None:
4394 rajveer 9332 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 9333 
      oprot.writeI64(self.type)
9334 
      oprot.writeFieldEnd()
4444 rajveer 9335 
    if self.warehouseId is not None:
9336 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9337 
      oprot.writeI64(self.warehouseId)
9338 
      oprot.writeFieldEnd()
4394 rajveer 9339 
    if self.description is not None:
4444 rajveer 9340 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 9341 
      oprot.writeString(self.description)
3064 chandransh 9342 
      oprot.writeFieldEnd()
94 ashish 9343 
    oprot.writeFieldStop()
9344 
    oprot.writeStructEnd()
9345 
 
3431 rajveer 9346 
  def validate(self):
9347 
    return
9348 
 
9349 
 
94 ashish 9350 
  def __repr__(self):
9351 
    L = ['%s=%r' % (key, value)
9352 
      for key, value in self.__dict__.iteritems()]
9353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9354 
 
9355 
  def __eq__(self, other):
9356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9357 
 
9358 
  def __ne__(self, other):
9359 
    return not (self == other)
9360 
 
4394 rajveer 9361 
class addAlert_result:
3064 chandransh 9362 
 
9363 
  thrift_spec = (
9364 
  )
9365 
 
9366 
  def read(self, iprot):
9367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9369 
      return
9370 
    iprot.readStructBegin()
9371 
    while True:
9372 
      (fname, ftype, fid) = iprot.readFieldBegin()
9373 
      if ftype == TType.STOP:
9374 
        break
9375 
      else:
9376 
        iprot.skip(ftype)
9377 
      iprot.readFieldEnd()
9378 
    iprot.readStructEnd()
9379 
 
9380 
  def write(self, oprot):
9381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9383 
      return
4394 rajveer 9384 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 9385 
    oprot.writeFieldStop()
9386 
    oprot.writeStructEnd()
9387 
 
3431 rajveer 9388 
  def validate(self):
9389 
    return
9390 
 
9391 
 
3064 chandransh 9392 
  def __repr__(self):
9393 
    L = ['%s=%r' % (key, value)
9394 
      for key, value in self.__dict__.iteritems()]
9395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9396 
 
9397 
  def __eq__(self, other):
9398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9399 
 
9400 
  def __ne__(self, other):
9401 
    return not (self == other)
9402 
 
4444 rajveer 9403 
class markAlertsAsSeen_args:
9404 
  """
9405 
  Attributes:
9406 
   - warehouseId
9407 
  """
9408 
 
9409 
  thrift_spec = (
9410 
    None, # 0
9411 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9412 
  )
9413 
 
9414 
  def __init__(self, warehouseId=None,):
9415 
    self.warehouseId = warehouseId
9416 
 
9417 
  def read(self, iprot):
9418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9420 
      return
9421 
    iprot.readStructBegin()
9422 
    while True:
9423 
      (fname, ftype, fid) = iprot.readFieldBegin()
9424 
      if ftype == TType.STOP:
9425 
        break
9426 
      if fid == 1:
9427 
        if ftype == TType.I64:
9428 
          self.warehouseId = iprot.readI64();
9429 
        else:
9430 
          iprot.skip(ftype)
9431 
      else:
9432 
        iprot.skip(ftype)
9433 
      iprot.readFieldEnd()
9434 
    iprot.readStructEnd()
9435 
 
9436 
  def write(self, oprot):
9437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9439 
      return
9440 
    oprot.writeStructBegin('markAlertsAsSeen_args')
9441 
    if self.warehouseId is not None:
9442 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9443 
      oprot.writeI64(self.warehouseId)
9444 
      oprot.writeFieldEnd()
9445 
    oprot.writeFieldStop()
9446 
    oprot.writeStructEnd()
9447 
 
9448 
  def validate(self):
9449 
    return
9450 
 
9451 
 
9452 
  def __repr__(self):
9453 
    L = ['%s=%r' % (key, value)
9454 
      for key, value in self.__dict__.iteritems()]
9455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9456 
 
9457 
  def __eq__(self, other):
9458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9459 
 
9460 
  def __ne__(self, other):
9461 
    return not (self == other)
9462 
 
9463 
class markAlertsAsSeen_result:
9464 
 
9465 
  thrift_spec = (
9466 
  )
9467 
 
9468 
  def read(self, iprot):
9469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9471 
      return
9472 
    iprot.readStructBegin()
9473 
    while True:
9474 
      (fname, ftype, fid) = iprot.readFieldBegin()
9475 
      if ftype == TType.STOP:
9476 
        break
9477 
      else:
9478 
        iprot.skip(ftype)
9479 
      iprot.readFieldEnd()
9480 
    iprot.readStructEnd()
9481 
 
9482 
  def write(self, oprot):
9483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9485 
      return
9486 
    oprot.writeStructBegin('markAlertsAsSeen_result')
9487 
    oprot.writeFieldStop()
9488 
    oprot.writeStructEnd()
9489 
 
9490 
  def validate(self):
9491 
    return
9492 
 
9493 
 
9494 
  def __repr__(self):
9495 
    L = ['%s=%r' % (key, value)
9496 
      for key, value in self.__dict__.iteritems()]
9497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9498 
 
9499 
  def __eq__(self, other):
9500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9501 
 
9502 
  def __ne__(self, other):
9503 
    return not (self == other)
9504 
 
3064 chandransh 9505 
class getValidOrderCount_args:
9506 
 
9507 
  thrift_spec = (
9508 
  )
9509 
 
9510 
  def read(self, iprot):
9511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9513 
      return
9514 
    iprot.readStructBegin()
9515 
    while True:
9516 
      (fname, ftype, fid) = iprot.readFieldBegin()
9517 
      if ftype == TType.STOP:
9518 
        break
9519 
      else:
9520 
        iprot.skip(ftype)
9521 
      iprot.readFieldEnd()
9522 
    iprot.readStructEnd()
9523 
 
9524 
  def write(self, oprot):
9525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9527 
      return
9528 
    oprot.writeStructBegin('getValidOrderCount_args')
9529 
    oprot.writeFieldStop()
9530 
    oprot.writeStructEnd()
9531 
 
3431 rajveer 9532 
  def validate(self):
9533 
    return
9534 
 
9535 
 
3064 chandransh 9536 
  def __repr__(self):
9537 
    L = ['%s=%r' % (key, value)
9538 
      for key, value in self.__dict__.iteritems()]
9539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9540 
 
9541 
  def __eq__(self, other):
9542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9543 
 
9544 
  def __ne__(self, other):
9545 
    return not (self == other)
9546 
 
9547 
class getValidOrderCount_result:
94 ashish 9548 
  """
9549 
  Attributes:
9550 
   - success
9551 
  """
9552 
 
9553 
  thrift_spec = (
3064 chandransh 9554 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9555 
  )
9556 
 
3064 chandransh 9557 
  def __init__(self, success=None,):
94 ashish 9558 
    self.success = success
9559 
 
9560 
  def read(self, iprot):
9561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9563 
      return
9564 
    iprot.readStructBegin()
9565 
    while True:
9566 
      (fname, ftype, fid) = iprot.readFieldBegin()
9567 
      if ftype == TType.STOP:
9568 
        break
9569 
      if fid == 0:
3064 chandransh 9570 
        if ftype == TType.I64:
9571 
          self.success = iprot.readI64();
94 ashish 9572 
        else:
9573 
          iprot.skip(ftype)
9574 
      else:
9575 
        iprot.skip(ftype)
9576 
      iprot.readFieldEnd()
9577 
    iprot.readStructEnd()
9578 
 
9579 
  def write(self, oprot):
9580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9582 
      return
3064 chandransh 9583 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 9584 
    if self.success is not None:
3064 chandransh 9585 
      oprot.writeFieldBegin('success', TType.I64, 0)
9586 
      oprot.writeI64(self.success)
94 ashish 9587 
      oprot.writeFieldEnd()
9588 
    oprot.writeFieldStop()
9589 
    oprot.writeStructEnd()
9590 
 
3431 rajveer 9591 
  def validate(self):
9592 
    return
9593 
 
9594 
 
94 ashish 9595 
  def __repr__(self):
9596 
    L = ['%s=%r' % (key, value)
9597 
      for key, value in self.__dict__.iteritems()]
9598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9599 
 
9600 
  def __eq__(self, other):
9601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9602 
 
9603 
  def __ne__(self, other):
9604 
    return not (self == other)
9605 
 
3064 chandransh 9606 
class getNoOfCustomersWithSuccessfulTransaction_args:
9607 
 
9608 
  thrift_spec = (
9609 
  )
9610 
 
9611 
  def read(self, iprot):
9612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9614 
      return
9615 
    iprot.readStructBegin()
9616 
    while True:
9617 
      (fname, ftype, fid) = iprot.readFieldBegin()
9618 
      if ftype == TType.STOP:
9619 
        break
9620 
      else:
9621 
        iprot.skip(ftype)
9622 
      iprot.readFieldEnd()
9623 
    iprot.readStructEnd()
9624 
 
9625 
  def write(self, oprot):
9626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9628 
      return
9629 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
9630 
    oprot.writeFieldStop()
9631 
    oprot.writeStructEnd()
9632 
 
3431 rajveer 9633 
  def validate(self):
9634 
    return
9635 
 
9636 
 
3064 chandransh 9637 
  def __repr__(self):
9638 
    L = ['%s=%r' % (key, value)
9639 
      for key, value in self.__dict__.iteritems()]
9640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9641 
 
9642 
  def __eq__(self, other):
9643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9644 
 
9645 
  def __ne__(self, other):
9646 
    return not (self == other)
9647 
 
9648 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 9649 
  """
9650 
  Attributes:
3064 chandransh 9651 
   - success
94 ashish 9652 
  """
9653 
 
9654 
  thrift_spec = (
3064 chandransh 9655 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9656 
  )
9657 
 
3064 chandransh 9658 
  def __init__(self, success=None,):
9659 
    self.success = success
94 ashish 9660 
 
9661 
  def read(self, iprot):
9662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9664 
      return
9665 
    iprot.readStructBegin()
9666 
    while True:
9667 
      (fname, ftype, fid) = iprot.readFieldBegin()
9668 
      if ftype == TType.STOP:
9669 
        break
3064 chandransh 9670 
      if fid == 0:
94 ashish 9671 
        if ftype == TType.I64:
3064 chandransh 9672 
          self.success = iprot.readI64();
94 ashish 9673 
        else:
9674 
          iprot.skip(ftype)
9675 
      else:
9676 
        iprot.skip(ftype)
9677 
      iprot.readFieldEnd()
9678 
    iprot.readStructEnd()
9679 
 
9680 
  def write(self, oprot):
9681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9683 
      return
3064 chandransh 9684 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 9685 
    if self.success is not None:
3064 chandransh 9686 
      oprot.writeFieldBegin('success', TType.I64, 0)
9687 
      oprot.writeI64(self.success)
94 ashish 9688 
      oprot.writeFieldEnd()
9689 
    oprot.writeFieldStop()
9690 
    oprot.writeStructEnd()
9691 
 
3431 rajveer 9692 
  def validate(self):
9693 
    return
9694 
 
9695 
 
94 ashish 9696 
  def __repr__(self):
9697 
    L = ['%s=%r' % (key, value)
9698 
      for key, value in self.__dict__.iteritems()]
9699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9700 
 
9701 
  def __eq__(self, other):
9702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9703 
 
9704 
  def __ne__(self, other):
9705 
    return not (self == other)
9706 
 
3064 chandransh 9707 
class getValidOrdersAmountRange_args:
9708 
 
9709 
  thrift_spec = (
9710 
  )
9711 
 
9712 
  def read(self, iprot):
9713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9715 
      return
9716 
    iprot.readStructBegin()
9717 
    while True:
9718 
      (fname, ftype, fid) = iprot.readFieldBegin()
9719 
      if ftype == TType.STOP:
9720 
        break
9721 
      else:
9722 
        iprot.skip(ftype)
9723 
      iprot.readFieldEnd()
9724 
    iprot.readStructEnd()
9725 
 
9726 
  def write(self, oprot):
9727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9729 
      return
9730 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
9731 
    oprot.writeFieldStop()
9732 
    oprot.writeStructEnd()
9733 
 
3431 rajveer 9734 
  def validate(self):
9735 
    return
9736 
 
9737 
 
3064 chandransh 9738 
  def __repr__(self):
9739 
    L = ['%s=%r' % (key, value)
9740 
      for key, value in self.__dict__.iteritems()]
9741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9742 
 
9743 
  def __eq__(self, other):
9744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9745 
 
9746 
  def __ne__(self, other):
9747 
    return not (self == other)
9748 
 
9749 
class getValidOrdersAmountRange_result:
94 ashish 9750 
  """
9751 
  Attributes:
9752 
   - success
9753 
  """
9754 
 
9755 
  thrift_spec = (
3064 chandransh 9756 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 9757 
  )
9758 
 
3064 chandransh 9759 
  def __init__(self, success=None,):
94 ashish 9760 
    self.success = success
9761 
 
9762 
  def read(self, iprot):
9763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9765 
      return
9766 
    iprot.readStructBegin()
9767 
    while True:
9768 
      (fname, ftype, fid) = iprot.readFieldBegin()
9769 
      if ftype == TType.STOP:
9770 
        break
9771 
      if fid == 0:
483 rajveer 9772 
        if ftype == TType.LIST:
9773 
          self.success = []
4133 chandransh 9774 
          (_etype122, _size119) = iprot.readListBegin()
9775 
          for _i123 in xrange(_size119):
9776 
            _elem124 = iprot.readDouble();
9777 
            self.success.append(_elem124)
483 rajveer 9778 
          iprot.readListEnd()
94 ashish 9779 
        else:
9780 
          iprot.skip(ftype)
9781 
      else:
9782 
        iprot.skip(ftype)
9783 
      iprot.readFieldEnd()
9784 
    iprot.readStructEnd()
9785 
 
9786 
  def write(self, oprot):
9787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9789 
      return
3064 chandransh 9790 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 9791 
    if self.success is not None:
483 rajveer 9792 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 9793 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 9794 
      for iter125 in self.success:
9795 
        oprot.writeDouble(iter125)
483 rajveer 9796 
      oprot.writeListEnd()
94 ashish 9797 
      oprot.writeFieldEnd()
9798 
    oprot.writeFieldStop()
9799 
    oprot.writeStructEnd()
9800 
 
3431 rajveer 9801 
  def validate(self):
9802 
    return
9803 
 
9804 
 
94 ashish 9805 
  def __repr__(self):
9806 
    L = ['%s=%r' % (key, value)
9807 
      for key, value in self.__dict__.iteritems()]
9808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9809 
 
9810 
  def __eq__(self, other):
9811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9812 
 
9813 
  def __ne__(self, other):
9814 
    return not (self == other)
9815 
 
3064 chandransh 9816 
class getValidOrders_args:
1528 ankur.sing 9817 
  """
9818 
  Attributes:
3064 chandransh 9819 
   - limit
1528 ankur.sing 9820 
  """
9821 
 
9822 
  thrift_spec = (
9823 
    None, # 0
3064 chandransh 9824 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 9825 
  )
9826 
 
3064 chandransh 9827 
  def __init__(self, limit=None,):
9828 
    self.limit = limit
1528 ankur.sing 9829 
 
9830 
  def read(self, iprot):
9831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9833 
      return
9834 
    iprot.readStructBegin()
9835 
    while True:
9836 
      (fname, ftype, fid) = iprot.readFieldBegin()
9837 
      if ftype == TType.STOP:
9838 
        break
9839 
      if fid == 1:
9840 
        if ftype == TType.I64:
3064 chandransh 9841 
          self.limit = iprot.readI64();
1528 ankur.sing 9842 
        else:
9843 
          iprot.skip(ftype)
9844 
      else:
9845 
        iprot.skip(ftype)
9846 
      iprot.readFieldEnd()
9847 
    iprot.readStructEnd()
9848 
 
9849 
  def write(self, oprot):
9850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9852 
      return
3064 chandransh 9853 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 9854 
    if self.limit is not None:
3064 chandransh 9855 
      oprot.writeFieldBegin('limit', TType.I64, 1)
9856 
      oprot.writeI64(self.limit)
1528 ankur.sing 9857 
      oprot.writeFieldEnd()
9858 
    oprot.writeFieldStop()
9859 
    oprot.writeStructEnd()
9860 
 
3431 rajveer 9861 
  def validate(self):
9862 
    return
9863 
 
9864 
 
1528 ankur.sing 9865 
  def __repr__(self):
9866 
    L = ['%s=%r' % (key, value)
9867 
      for key, value in self.__dict__.iteritems()]
9868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9869 
 
9870 
  def __eq__(self, other):
9871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9872 
 
9873 
  def __ne__(self, other):
9874 
    return not (self == other)
9875 
 
3064 chandransh 9876 
class getValidOrders_result:
1528 ankur.sing 9877 
  """
9878 
  Attributes:
9879 
   - success
9880 
  """
9881 
 
9882 
  thrift_spec = (
3064 chandransh 9883 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 9884 
  )
9885 
 
3064 chandransh 9886 
  def __init__(self, success=None,):
1528 ankur.sing 9887 
    self.success = success
9888 
 
9889 
  def read(self, iprot):
9890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9892 
      return
9893 
    iprot.readStructBegin()
9894 
    while True:
9895 
      (fname, ftype, fid) = iprot.readFieldBegin()
9896 
      if ftype == TType.STOP:
9897 
        break
9898 
      if fid == 0:
3064 chandransh 9899 
        if ftype == TType.LIST:
9900 
          self.success = []
4133 chandransh 9901 
          (_etype129, _size126) = iprot.readListBegin()
9902 
          for _i130 in xrange(_size126):
9903 
            _elem131 = Order()
9904 
            _elem131.read(iprot)
9905 
            self.success.append(_elem131)
3064 chandransh 9906 
          iprot.readListEnd()
1528 ankur.sing 9907 
        else:
9908 
          iprot.skip(ftype)
9909 
      else:
9910 
        iprot.skip(ftype)
9911 
      iprot.readFieldEnd()
9912 
    iprot.readStructEnd()
9913 
 
9914 
  def write(self, oprot):
9915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9917 
      return
3064 chandransh 9918 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 9919 
    if self.success is not None:
3064 chandransh 9920 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9921 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9922 
      for iter132 in self.success:
9923 
        iter132.write(oprot)
3064 chandransh 9924 
      oprot.writeListEnd()
1528 ankur.sing 9925 
      oprot.writeFieldEnd()
9926 
    oprot.writeFieldStop()
9927 
    oprot.writeStructEnd()
9928 
 
3431 rajveer 9929 
  def validate(self):
9930 
    return
9931 
 
9932 
 
1528 ankur.sing 9933 
  def __repr__(self):
9934 
    L = ['%s=%r' % (key, value)
9935 
      for key, value in self.__dict__.iteritems()]
9936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9937 
 
9938 
  def __eq__(self, other):
9939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9940 
 
9941 
  def __ne__(self, other):
9942 
    return not (self == other)
9943 
 
1220 chandransh 9944 
class batchOrders_args:
9945 
  """
9946 
  Attributes:
9947 
   - warehouseId
9948 
  """
9949 
 
9950 
  thrift_spec = (
9951 
    None, # 0
9952 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9953 
  )
9954 
 
9955 
  def __init__(self, warehouseId=None,):
9956 
    self.warehouseId = warehouseId
9957 
 
9958 
  def read(self, iprot):
9959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9961 
      return
9962 
    iprot.readStructBegin()
9963 
    while True:
9964 
      (fname, ftype, fid) = iprot.readFieldBegin()
9965 
      if ftype == TType.STOP:
9966 
        break
9967 
      if fid == 1:
9968 
        if ftype == TType.I64:
9969 
          self.warehouseId = iprot.readI64();
9970 
        else:
9971 
          iprot.skip(ftype)
9972 
      else:
9973 
        iprot.skip(ftype)
9974 
      iprot.readFieldEnd()
9975 
    iprot.readStructEnd()
9976 
 
9977 
  def write(self, oprot):
9978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9980 
      return
9981 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 9982 
    if self.warehouseId is not None:
1220 chandransh 9983 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9984 
      oprot.writeI64(self.warehouseId)
9985 
      oprot.writeFieldEnd()
9986 
    oprot.writeFieldStop()
9987 
    oprot.writeStructEnd()
9988 
 
3431 rajveer 9989 
  def validate(self):
9990 
    return
9991 
 
9992 
 
1220 chandransh 9993 
  def __repr__(self):
9994 
    L = ['%s=%r' % (key, value)
9995 
      for key, value in self.__dict__.iteritems()]
9996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9997 
 
9998 
  def __eq__(self, other):
9999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10000 
 
10001 
  def __ne__(self, other):
10002 
    return not (self == other)
10003 
 
10004 
class batchOrders_result:
10005 
  """
10006 
  Attributes:
10007 
   - success
10008 
   - ex
10009 
  """
10010 
 
10011 
  thrift_spec = (
10012 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10013 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10014 
  )
10015 
 
10016 
  def __init__(self, success=None, ex=None,):
10017 
    self.success = success
10018 
    self.ex = ex
10019 
 
10020 
  def read(self, iprot):
10021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10023 
      return
10024 
    iprot.readStructBegin()
10025 
    while True:
10026 
      (fname, ftype, fid) = iprot.readFieldBegin()
10027 
      if ftype == TType.STOP:
10028 
        break
10029 
      if fid == 0:
10030 
        if ftype == TType.LIST:
10031 
          self.success = []
4133 chandransh 10032 
          (_etype136, _size133) = iprot.readListBegin()
10033 
          for _i137 in xrange(_size133):
10034 
            _elem138 = Order()
10035 
            _elem138.read(iprot)
10036 
            self.success.append(_elem138)
1220 chandransh 10037 
          iprot.readListEnd()
10038 
        else:
10039 
          iprot.skip(ftype)
10040 
      elif fid == 1:
10041 
        if ftype == TType.STRUCT:
10042 
          self.ex = TransactionServiceException()
10043 
          self.ex.read(iprot)
10044 
        else:
10045 
          iprot.skip(ftype)
10046 
      else:
10047 
        iprot.skip(ftype)
10048 
      iprot.readFieldEnd()
10049 
    iprot.readStructEnd()
10050 
 
10051 
  def write(self, oprot):
10052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10054 
      return
10055 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 10056 
    if self.success is not None:
1220 chandransh 10057 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10058 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10059 
      for iter139 in self.success:
10060 
        iter139.write(oprot)
1220 chandransh 10061 
      oprot.writeListEnd()
10062 
      oprot.writeFieldEnd()
3431 rajveer 10063 
    if self.ex is not None:
1220 chandransh 10064 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10065 
      self.ex.write(oprot)
10066 
      oprot.writeFieldEnd()
10067 
    oprot.writeFieldStop()
10068 
    oprot.writeStructEnd()
10069 
 
3431 rajveer 10070 
  def validate(self):
10071 
    return
10072 
 
10073 
 
1220 chandransh 10074 
  def __repr__(self):
10075 
    L = ['%s=%r' % (key, value)
10076 
      for key, value in self.__dict__.iteritems()]
10077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10078 
 
10079 
  def __eq__(self, other):
10080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10081 
 
10082 
  def __ne__(self, other):
10083 
    return not (self == other)
10084 
 
1208 chandransh 10085 
class markOrderAsOutOfStock_args:
10086 
  """
10087 
  Attributes:
10088 
   - orderId
10089 
  """
10090 
 
10091 
  thrift_spec = (
10092 
    None, # 0
10093 
    (1, TType.I64, 'orderId', None, None, ), # 1
10094 
  )
10095 
 
10096 
  def __init__(self, orderId=None,):
10097 
    self.orderId = orderId
10098 
 
10099 
  def read(self, iprot):
10100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10102 
      return
10103 
    iprot.readStructBegin()
10104 
    while True:
10105 
      (fname, ftype, fid) = iprot.readFieldBegin()
10106 
      if ftype == TType.STOP:
10107 
        break
10108 
      if fid == 1:
10109 
        if ftype == TType.I64:
10110 
          self.orderId = iprot.readI64();
10111 
        else:
10112 
          iprot.skip(ftype)
10113 
      else:
10114 
        iprot.skip(ftype)
10115 
      iprot.readFieldEnd()
10116 
    iprot.readStructEnd()
10117 
 
10118 
  def write(self, oprot):
10119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10121 
      return
10122 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 10123 
    if self.orderId is not None:
1208 chandransh 10124 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10125 
      oprot.writeI64(self.orderId)
10126 
      oprot.writeFieldEnd()
10127 
    oprot.writeFieldStop()
10128 
    oprot.writeStructEnd()
10129 
 
3431 rajveer 10130 
  def validate(self):
10131 
    return
10132 
 
10133 
 
1208 chandransh 10134 
  def __repr__(self):
10135 
    L = ['%s=%r' % (key, value)
10136 
      for key, value in self.__dict__.iteritems()]
10137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10138 
 
10139 
  def __eq__(self, other):
10140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10141 
 
10142 
  def __ne__(self, other):
10143 
    return not (self == other)
10144 
 
10145 
class markOrderAsOutOfStock_result:
10146 
  """
10147 
  Attributes:
10148 
   - success
10149 
   - ex
10150 
  """
10151 
 
10152 
  thrift_spec = (
10153 
    (0, TType.BOOL, 'success', None, None, ), # 0
10154 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10155 
  )
10156 
 
10157 
  def __init__(self, success=None, ex=None,):
10158 
    self.success = success
10159 
    self.ex = ex
10160 
 
10161 
  def read(self, iprot):
10162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10164 
      return
10165 
    iprot.readStructBegin()
10166 
    while True:
10167 
      (fname, ftype, fid) = iprot.readFieldBegin()
10168 
      if ftype == TType.STOP:
10169 
        break
10170 
      if fid == 0:
10171 
        if ftype == TType.BOOL:
10172 
          self.success = iprot.readBool();
10173 
        else:
10174 
          iprot.skip(ftype)
10175 
      elif fid == 1:
10176 
        if ftype == TType.STRUCT:
10177 
          self.ex = TransactionServiceException()
10178 
          self.ex.read(iprot)
10179 
        else:
10180 
          iprot.skip(ftype)
10181 
      else:
10182 
        iprot.skip(ftype)
10183 
      iprot.readFieldEnd()
10184 
    iprot.readStructEnd()
10185 
 
10186 
  def write(self, oprot):
10187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10189 
      return
10190 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 10191 
    if self.success is not None:
1208 chandransh 10192 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10193 
      oprot.writeBool(self.success)
10194 
      oprot.writeFieldEnd()
3431 rajveer 10195 
    if self.ex is not None:
1208 chandransh 10196 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10197 
      self.ex.write(oprot)
10198 
      oprot.writeFieldEnd()
10199 
    oprot.writeFieldStop()
10200 
    oprot.writeStructEnd()
10201 
 
3431 rajveer 10202 
  def validate(self):
10203 
    return
10204 
 
10205 
 
1208 chandransh 10206 
  def __repr__(self):
10207 
    L = ['%s=%r' % (key, value)
10208 
      for key, value in self.__dict__.iteritems()]
10209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10210 
 
10211 
  def __eq__(self, other):
10212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10213 
 
10214 
  def __ne__(self, other):
10215 
    return not (self == other)
10216 
 
3064 chandransh 10217 
class verifyOrder_args:
759 chandransh 10218 
  """
10219 
  Attributes:
3064 chandransh 10220 
   - orderId
759 chandransh 10221 
  """
10222 
 
10223 
  thrift_spec = (
10224 
    None, # 0
3064 chandransh 10225 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 10226 
  )
10227 
 
3064 chandransh 10228 
  def __init__(self, orderId=None,):
10229 
    self.orderId = orderId
759 chandransh 10230 
 
10231 
  def read(self, iprot):
10232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10234 
      return
10235 
    iprot.readStructBegin()
10236 
    while True:
10237 
      (fname, ftype, fid) = iprot.readFieldBegin()
10238 
      if ftype == TType.STOP:
10239 
        break
10240 
      if fid == 1:
10241 
        if ftype == TType.I64:
3064 chandransh 10242 
          self.orderId = iprot.readI64();
759 chandransh 10243 
        else:
10244 
          iprot.skip(ftype)
10245 
      else:
10246 
        iprot.skip(ftype)
10247 
      iprot.readFieldEnd()
10248 
    iprot.readStructEnd()
10249 
 
10250 
  def write(self, oprot):
10251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10253 
      return
3064 chandransh 10254 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 10255 
    if self.orderId is not None:
3064 chandransh 10256 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10257 
      oprot.writeI64(self.orderId)
759 chandransh 10258 
      oprot.writeFieldEnd()
10259 
    oprot.writeFieldStop()
10260 
    oprot.writeStructEnd()
10261 
 
3431 rajveer 10262 
  def validate(self):
10263 
    return
10264 
 
10265 
 
759 chandransh 10266 
  def __repr__(self):
10267 
    L = ['%s=%r' % (key, value)
10268 
      for key, value in self.__dict__.iteritems()]
10269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10270 
 
10271 
  def __eq__(self, other):
10272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10273 
 
10274 
  def __ne__(self, other):
10275 
    return not (self == other)
10276 
 
3064 chandransh 10277 
class verifyOrder_result:
759 chandransh 10278 
  """
10279 
  Attributes:
10280 
   - success
10281 
   - ex
10282 
  """
10283 
 
10284 
  thrift_spec = (
10285 
    (0, TType.BOOL, 'success', None, None, ), # 0
10286 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10287 
  )
10288 
 
10289 
  def __init__(self, success=None, ex=None,):
10290 
    self.success = success
10291 
    self.ex = ex
10292 
 
10293 
  def read(self, iprot):
10294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10296 
      return
10297 
    iprot.readStructBegin()
10298 
    while True:
10299 
      (fname, ftype, fid) = iprot.readFieldBegin()
10300 
      if ftype == TType.STOP:
10301 
        break
10302 
      if fid == 0:
10303 
        if ftype == TType.BOOL:
10304 
          self.success = iprot.readBool();
10305 
        else:
10306 
          iprot.skip(ftype)
10307 
      elif fid == 1:
10308 
        if ftype == TType.STRUCT:
10309 
          self.ex = TransactionServiceException()
10310 
          self.ex.read(iprot)
10311 
        else:
10312 
          iprot.skip(ftype)
10313 
      else:
10314 
        iprot.skip(ftype)
10315 
      iprot.readFieldEnd()
10316 
    iprot.readStructEnd()
10317 
 
10318 
  def write(self, oprot):
10319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10321 
      return
3064 chandransh 10322 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 10323 
    if self.success is not None:
759 chandransh 10324 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10325 
      oprot.writeBool(self.success)
10326 
      oprot.writeFieldEnd()
3431 rajveer 10327 
    if self.ex is not None:
759 chandransh 10328 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10329 
      self.ex.write(oprot)
10330 
      oprot.writeFieldEnd()
10331 
    oprot.writeFieldStop()
10332 
    oprot.writeStructEnd()
10333 
 
3431 rajveer 10334 
  def validate(self):
10335 
    return
10336 
 
10337 
 
759 chandransh 10338 
  def __repr__(self):
10339 
    L = ['%s=%r' % (key, value)
10340 
      for key, value in self.__dict__.iteritems()]
10341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10342 
 
10343 
  def __eq__(self, other):
10344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10345 
 
10346 
  def __ne__(self, other):
10347 
    return not (self == other)
10348 
 
3064 chandransh 10349 
class acceptOrder_args:
1113 chandransh 10350 
  """
10351 
  Attributes:
3064 chandransh 10352 
   - orderId
1113 chandransh 10353 
  """
10354 
 
10355 
  thrift_spec = (
10356 
    None, # 0
3064 chandransh 10357 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 10358 
  )
10359 
 
3064 chandransh 10360 
  def __init__(self, orderId=None,):
10361 
    self.orderId = orderId
1113 chandransh 10362 
 
10363 
  def read(self, iprot):
10364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10366 
      return
10367 
    iprot.readStructBegin()
10368 
    while True:
10369 
      (fname, ftype, fid) = iprot.readFieldBegin()
10370 
      if ftype == TType.STOP:
10371 
        break
10372 
      if fid == 1:
10373 
        if ftype == TType.I64:
3064 chandransh 10374 
          self.orderId = iprot.readI64();
1113 chandransh 10375 
        else:
10376 
          iprot.skip(ftype)
10377 
      else:
10378 
        iprot.skip(ftype)
10379 
      iprot.readFieldEnd()
10380 
    iprot.readStructEnd()
10381 
 
10382 
  def write(self, oprot):
10383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10385 
      return
3064 chandransh 10386 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 10387 
    if self.orderId is not None:
3064 chandransh 10388 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10389 
      oprot.writeI64(self.orderId)
1113 chandransh 10390 
      oprot.writeFieldEnd()
10391 
    oprot.writeFieldStop()
10392 
    oprot.writeStructEnd()
10393 
 
3431 rajveer 10394 
  def validate(self):
10395 
    return
10396 
 
10397 
 
1113 chandransh 10398 
  def __repr__(self):
10399 
    L = ['%s=%r' % (key, value)
10400 
      for key, value in self.__dict__.iteritems()]
10401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10402 
 
10403 
  def __eq__(self, other):
10404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10405 
 
10406 
  def __ne__(self, other):
10407 
    return not (self == other)
10408 
 
3064 chandransh 10409 
class acceptOrder_result:
1113 chandransh 10410 
  """
10411 
  Attributes:
10412 
   - success
10413 
   - ex
10414 
  """
10415 
 
10416 
  thrift_spec = (
3064 chandransh 10417 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 10418 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10419 
  )
10420 
 
10421 
  def __init__(self, success=None, ex=None,):
10422 
    self.success = success
10423 
    self.ex = ex
10424 
 
10425 
  def read(self, iprot):
10426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10428 
      return
10429 
    iprot.readStructBegin()
10430 
    while True:
10431 
      (fname, ftype, fid) = iprot.readFieldBegin()
10432 
      if ftype == TType.STOP:
10433 
        break
10434 
      if fid == 0:
3064 chandransh 10435 
        if ftype == TType.BOOL:
10436 
          self.success = iprot.readBool();
1113 chandransh 10437 
        else:
10438 
          iprot.skip(ftype)
10439 
      elif fid == 1:
10440 
        if ftype == TType.STRUCT:
10441 
          self.ex = TransactionServiceException()
10442 
          self.ex.read(iprot)
10443 
        else:
10444 
          iprot.skip(ftype)
10445 
      else:
10446 
        iprot.skip(ftype)
10447 
      iprot.readFieldEnd()
10448 
    iprot.readStructEnd()
10449 
 
10450 
  def write(self, oprot):
10451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10453 
      return
3064 chandransh 10454 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 10455 
    if self.success is not None:
3064 chandransh 10456 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10457 
      oprot.writeBool(self.success)
1113 chandransh 10458 
      oprot.writeFieldEnd()
3431 rajveer 10459 
    if self.ex is not None:
1113 chandransh 10460 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10461 
      self.ex.write(oprot)
10462 
      oprot.writeFieldEnd()
10463 
    oprot.writeFieldStop()
10464 
    oprot.writeStructEnd()
10465 
 
3431 rajveer 10466 
  def validate(self):
10467 
    return
10468 
 
10469 
 
1113 chandransh 10470 
  def __repr__(self):
10471 
    L = ['%s=%r' % (key, value)
10472 
      for key, value in self.__dict__.iteritems()]
10473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10474 
 
10475 
  def __eq__(self, other):
10476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10477 
 
10478 
  def __ne__(self, other):
10479 
    return not (self == other)
10480 
 
3064 chandransh 10481 
class addBillingDetails_args:
1135 chandransh 10482 
  """
10483 
  Attributes:
3064 chandransh 10484 
   - orderId
10485 
   - invoice_number
4658 mandeep.dh 10486 
   - serialNumber
4283 anupam.sin 10487 
   - itemNumber
3064 chandransh 10488 
   - billed_by
4264 rajveer 10489 
   - jacketNumber
4283 anupam.sin 10490 
   - billingType
10491 
   - vendorId
4763 rajveer 10492 
   - authorize
1135 chandransh 10493 
  """
10494 
 
10495 
  thrift_spec = (
10496 
    None, # 0
3064 chandransh 10497 
    (1, TType.I64, 'orderId', None, None, ), # 1
10498 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 10499 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 10500 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
10501 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
10502 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
10503 
    (7, TType.I64, 'billingType', None, None, ), # 7
10504 
    (8, TType.I64, 'vendorId', None, None, ), # 8
4763 rajveer 10505 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 10506 
  )
10507 
 
4763 rajveer 10508 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None, authorize=None,):
3064 chandransh 10509 
    self.orderId = orderId
10510 
    self.invoice_number = invoice_number
4658 mandeep.dh 10511 
    self.serialNumber = serialNumber
4283 anupam.sin 10512 
    self.itemNumber = itemNumber
3064 chandransh 10513 
    self.billed_by = billed_by
4264 rajveer 10514 
    self.jacketNumber = jacketNumber
4283 anupam.sin 10515 
    self.billingType = billingType
10516 
    self.vendorId = vendorId
4763 rajveer 10517 
    self.authorize = authorize
1135 chandransh 10518 
 
10519 
  def read(self, iprot):
10520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10522 
      return
10523 
    iprot.readStructBegin()
10524 
    while True:
10525 
      (fname, ftype, fid) = iprot.readFieldBegin()
10526 
      if ftype == TType.STOP:
10527 
        break
10528 
      if fid == 1:
10529 
        if ftype == TType.I64:
3064 chandransh 10530 
          self.orderId = iprot.readI64();
1135 chandransh 10531 
        else:
10532 
          iprot.skip(ftype)
10533 
      elif fid == 2:
3064 chandransh 10534 
        if ftype == TType.STRING:
10535 
          self.invoice_number = iprot.readString();
1135 chandransh 10536 
        else:
10537 
          iprot.skip(ftype)
3064 chandransh 10538 
      elif fid == 3:
4658 mandeep.dh 10539 
        if ftype == TType.STRING:
10540 
          self.serialNumber = iprot.readString();
3064 chandransh 10541 
        else:
10542 
          iprot.skip(ftype)
10543 
      elif fid == 4:
10544 
        if ftype == TType.STRING:
10545 
          self.itemNumber = iprot.readString();
10546 
        else:
10547 
          iprot.skip(ftype)
10548 
      elif fid == 5:
10549 
        if ftype == TType.STRING:
4283 anupam.sin 10550 
          self.billed_by = iprot.readString();
3064 chandransh 10551 
        else:
10552 
          iprot.skip(ftype)
10553 
      elif fid == 6:
10554 
        if ftype == TType.I64:
4283 anupam.sin 10555 
          self.jacketNumber = iprot.readI64();
10556 
        else:
10557 
          iprot.skip(ftype)
10558 
      elif fid == 7:
10559 
        if ftype == TType.I64:
3064 chandransh 10560 
          self.billingType = iprot.readI64();
10561 
        else:
10562 
          iprot.skip(ftype)
4283 anupam.sin 10563 
      elif fid == 8:
10564 
        if ftype == TType.I64:
10565 
          self.vendorId = iprot.readI64();
10566 
        else:
10567 
          iprot.skip(ftype)
4763 rajveer 10568 
      elif fid == 9:
10569 
        if ftype == TType.BOOL:
10570 
          self.authorize = iprot.readBool();
10571 
        else:
10572 
          iprot.skip(ftype)
1246 chandransh 10573 
      else:
10574 
        iprot.skip(ftype)
10575 
      iprot.readFieldEnd()
10576 
    iprot.readStructEnd()
10577 
 
10578 
  def write(self, oprot):
10579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10581 
      return
4283 anupam.sin 10582 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 10583 
    if self.orderId is not None:
3064 chandransh 10584 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10585 
      oprot.writeI64(self.orderId)
1246 chandransh 10586 
      oprot.writeFieldEnd()
4283 anupam.sin 10587 
    if self.invoice_number is not None:
10588 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
10589 
      oprot.writeString(self.invoice_number)
1246 chandransh 10590 
      oprot.writeFieldEnd()
4658 mandeep.dh 10591 
    if self.serialNumber is not None:
10592 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
10593 
      oprot.writeString(self.serialNumber)
3064 chandransh 10594 
      oprot.writeFieldEnd()
3431 rajveer 10595 
    if self.itemNumber is not None:
3064 chandransh 10596 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
10597 
      oprot.writeString(self.itemNumber)
10598 
      oprot.writeFieldEnd()
4283 anupam.sin 10599 
    if self.billed_by is not None:
10600 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
10601 
      oprot.writeString(self.billed_by)
3064 chandransh 10602 
      oprot.writeFieldEnd()
4283 anupam.sin 10603 
    if self.jacketNumber is not None:
10604 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
10605 
      oprot.writeI64(self.jacketNumber)
10606 
      oprot.writeFieldEnd()
3431 rajveer 10607 
    if self.billingType is not None:
4283 anupam.sin 10608 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 10609 
      oprot.writeI64(self.billingType)
10610 
      oprot.writeFieldEnd()
4283 anupam.sin 10611 
    if self.vendorId is not None:
10612 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
10613 
      oprot.writeI64(self.vendorId)
10614 
      oprot.writeFieldEnd()
4763 rajveer 10615 
    if self.authorize is not None:
10616 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
10617 
      oprot.writeBool(self.authorize)
10618 
      oprot.writeFieldEnd()
1246 chandransh 10619 
    oprot.writeFieldStop()
10620 
    oprot.writeStructEnd()
10621 
 
3431 rajveer 10622 
  def validate(self):
10623 
    return
10624 
 
10625 
 
1246 chandransh 10626 
  def __repr__(self):
10627 
    L = ['%s=%r' % (key, value)
10628 
      for key, value in self.__dict__.iteritems()]
10629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10630 
 
10631 
  def __eq__(self, other):
10632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10633 
 
10634 
  def __ne__(self, other):
10635 
    return not (self == other)
10636 
 
4283 anupam.sin 10637 
class addBillingDetails_result:
1246 chandransh 10638 
  """
10639 
  Attributes:
3064 chandransh 10640 
   - success
1246 chandransh 10641 
   - ex
10642 
  """
10643 
 
10644 
  thrift_spec = (
3064 chandransh 10645 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 10646 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10647 
  )
10648 
 
3064 chandransh 10649 
  def __init__(self, success=None, ex=None,):
10650 
    self.success = success
1246 chandransh 10651 
    self.ex = ex
10652 
 
10653 
  def read(self, iprot):
10654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10656 
      return
10657 
    iprot.readStructBegin()
10658 
    while True:
10659 
      (fname, ftype, fid) = iprot.readFieldBegin()
10660 
      if ftype == TType.STOP:
10661 
        break
3064 chandransh 10662 
      if fid == 0:
10663 
        if ftype == TType.BOOL:
10664 
          self.success = iprot.readBool();
10665 
        else:
10666 
          iprot.skip(ftype)
10667 
      elif fid == 1:
1246 chandransh 10668 
        if ftype == TType.STRUCT:
10669 
          self.ex = TransactionServiceException()
10670 
          self.ex.read(iprot)
10671 
        else:
10672 
          iprot.skip(ftype)
10673 
      else:
10674 
        iprot.skip(ftype)
10675 
      iprot.readFieldEnd()
10676 
    iprot.readStructEnd()
10677 
 
10678 
  def write(self, oprot):
10679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10681 
      return
4283 anupam.sin 10682 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 10683 
    if self.success is not None:
3064 chandransh 10684 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10685 
      oprot.writeBool(self.success)
10686 
      oprot.writeFieldEnd()
3431 rajveer 10687 
    if self.ex is not None:
1246 chandransh 10688 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10689 
      self.ex.write(oprot)
10690 
      oprot.writeFieldEnd()
10691 
    oprot.writeFieldStop()
10692 
    oprot.writeStructEnd()
10693 
 
3431 rajveer 10694 
  def validate(self):
10695 
    return
10696 
 
10697 
 
1246 chandransh 10698 
  def __repr__(self):
10699 
    L = ['%s=%r' % (key, value)
10700 
      for key, value in self.__dict__.iteritems()]
10701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10702 
 
10703 
  def __eq__(self, other):
10704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10705 
 
10706 
  def __ne__(self, other):
10707 
    return not (self == other)
10708 
 
4579 rajveer 10709 
class addInvoiceNumber_args:
10710 
  """
10711 
  Attributes:
10712 
   - orderId
10713 
   - invoiceNumber
4763 rajveer 10714 
   - color
4579 rajveer 10715 
  """
10716 
 
10717 
  thrift_spec = (
10718 
    None, # 0
10719 
    (1, TType.I64, 'orderId', None, None, ), # 1
10720 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 10721 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 10722 
  )
10723 
 
4763 rajveer 10724 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 10725 
    self.orderId = orderId
10726 
    self.invoiceNumber = invoiceNumber
4763 rajveer 10727 
    self.color = color
4579 rajveer 10728 
 
10729 
  def read(self, iprot):
10730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10732 
      return
10733 
    iprot.readStructBegin()
10734 
    while True:
10735 
      (fname, ftype, fid) = iprot.readFieldBegin()
10736 
      if ftype == TType.STOP:
10737 
        break
10738 
      if fid == 1:
10739 
        if ftype == TType.I64:
10740 
          self.orderId = iprot.readI64();
10741 
        else:
10742 
          iprot.skip(ftype)
10743 
      elif fid == 2:
10744 
        if ftype == TType.STRING:
10745 
          self.invoiceNumber = iprot.readString();
10746 
        else:
10747 
          iprot.skip(ftype)
4763 rajveer 10748 
      elif fid == 3:
10749 
        if ftype == TType.STRING:
10750 
          self.color = iprot.readString();
10751 
        else:
10752 
          iprot.skip(ftype)
4579 rajveer 10753 
      else:
10754 
        iprot.skip(ftype)
10755 
      iprot.readFieldEnd()
10756 
    iprot.readStructEnd()
10757 
 
10758 
  def write(self, oprot):
10759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10761 
      return
10762 
    oprot.writeStructBegin('addInvoiceNumber_args')
10763 
    if self.orderId is not None:
10764 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10765 
      oprot.writeI64(self.orderId)
10766 
      oprot.writeFieldEnd()
10767 
    if self.invoiceNumber is not None:
10768 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
10769 
      oprot.writeString(self.invoiceNumber)
10770 
      oprot.writeFieldEnd()
4763 rajveer 10771 
    if self.color is not None:
10772 
      oprot.writeFieldBegin('color', TType.STRING, 3)
10773 
      oprot.writeString(self.color)
10774 
      oprot.writeFieldEnd()
4579 rajveer 10775 
    oprot.writeFieldStop()
10776 
    oprot.writeStructEnd()
10777 
 
10778 
  def validate(self):
10779 
    return
10780 
 
10781 
 
10782 
  def __repr__(self):
10783 
    L = ['%s=%r' % (key, value)
10784 
      for key, value in self.__dict__.iteritems()]
10785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10786 
 
10787 
  def __eq__(self, other):
10788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10789 
 
10790 
  def __ne__(self, other):
10791 
    return not (self == other)
10792 
 
10793 
class addInvoiceNumber_result:
10794 
  """
10795 
  Attributes:
10796 
   - ex
10797 
  """
10798 
 
10799 
  thrift_spec = (
10800 
    None, # 0
10801 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10802 
  )
10803 
 
10804 
  def __init__(self, ex=None,):
10805 
    self.ex = ex
10806 
 
10807 
  def read(self, iprot):
10808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10810 
      return
10811 
    iprot.readStructBegin()
10812 
    while True:
10813 
      (fname, ftype, fid) = iprot.readFieldBegin()
10814 
      if ftype == TType.STOP:
10815 
        break
10816 
      if fid == 1:
10817 
        if ftype == TType.STRUCT:
10818 
          self.ex = TransactionServiceException()
10819 
          self.ex.read(iprot)
10820 
        else:
10821 
          iprot.skip(ftype)
10822 
      else:
10823 
        iprot.skip(ftype)
10824 
      iprot.readFieldEnd()
10825 
    iprot.readStructEnd()
10826 
 
10827 
  def write(self, oprot):
10828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10830 
      return
10831 
    oprot.writeStructBegin('addInvoiceNumber_result')
10832 
    if self.ex is not None:
10833 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10834 
      self.ex.write(oprot)
10835 
      oprot.writeFieldEnd()
10836 
    oprot.writeFieldStop()
10837 
    oprot.writeStructEnd()
10838 
 
10839 
  def validate(self):
10840 
    return
10841 
 
10842 
 
10843 
  def __repr__(self):
10844 
    L = ['%s=%r' % (key, value)
10845 
      for key, value in self.__dict__.iteritems()]
10846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10847 
 
10848 
  def __eq__(self, other):
10849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10850 
 
10851 
  def __ne__(self, other):
10852 
    return not (self == other)
10853 
 
3064 chandransh 10854 
class markOrdersAsManifested_args:
1408 ankur.sing 10855 
  """
10856 
  Attributes:
3064 chandransh 10857 
   - warehouseId
1408 ankur.sing 10858 
   - providerId
3064 chandransh 10859 
   - cod
1408 ankur.sing 10860 
  """
10861 
 
10862 
  thrift_spec = (
10863 
    None, # 0
3064 chandransh 10864 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10865 
    (2, TType.I64, 'providerId', None, None, ), # 2
10866 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 10867 
  )
10868 
 
3064 chandransh 10869 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
10870 
    self.warehouseId = warehouseId
1408 ankur.sing 10871 
    self.providerId = providerId
3064 chandransh 10872 
    self.cod = cod
1408 ankur.sing 10873 
 
10874 
  def read(self, iprot):
10875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10877 
      return
10878 
    iprot.readStructBegin()
10879 
    while True:
10880 
      (fname, ftype, fid) = iprot.readFieldBegin()
10881 
      if ftype == TType.STOP:
10882 
        break
10883 
      if fid == 1:
10884 
        if ftype == TType.I64:
3064 chandransh 10885 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 10886 
        else:
10887 
          iprot.skip(ftype)
10888 
      elif fid == 2:
10889 
        if ftype == TType.I64:
3064 chandransh 10890 
          self.providerId = iprot.readI64();
1408 ankur.sing 10891 
        else:
10892 
          iprot.skip(ftype)
3064 chandransh 10893 
      elif fid == 3:
10894 
        if ftype == TType.BOOL:
10895 
          self.cod = iprot.readBool();
10896 
        else:
10897 
          iprot.skip(ftype)
1408 ankur.sing 10898 
      else:
10899 
        iprot.skip(ftype)
10900 
      iprot.readFieldEnd()
10901 
    iprot.readStructEnd()
10902 
 
10903 
  def write(self, oprot):
10904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10906 
      return
3064 chandransh 10907 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 10908 
    if self.warehouseId is not None:
3064 chandransh 10909 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10910 
      oprot.writeI64(self.warehouseId)
10911 
      oprot.writeFieldEnd()
3431 rajveer 10912 
    if self.providerId is not None:
3064 chandransh 10913 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 10914 
      oprot.writeI64(self.providerId)
10915 
      oprot.writeFieldEnd()
3431 rajveer 10916 
    if self.cod is not None:
3064 chandransh 10917 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
10918 
      oprot.writeBool(self.cod)
1408 ankur.sing 10919 
      oprot.writeFieldEnd()
10920 
    oprot.writeFieldStop()
10921 
    oprot.writeStructEnd()
10922 
 
3431 rajveer 10923 
  def validate(self):
10924 
    return
10925 
 
10926 
 
1408 ankur.sing 10927 
  def __repr__(self):
10928 
    L = ['%s=%r' % (key, value)
10929 
      for key, value in self.__dict__.iteritems()]
10930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10931 
 
10932 
  def __eq__(self, other):
10933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10934 
 
10935 
  def __ne__(self, other):
10936 
    return not (self == other)
10937 
 
3064 chandransh 10938 
class markOrdersAsManifested_result:
1408 ankur.sing 10939 
  """
10940 
  Attributes:
10941 
   - success
3064 chandransh 10942 
   - ex
1408 ankur.sing 10943 
  """
10944 
 
10945 
  thrift_spec = (
3064 chandransh 10946 
    (0, TType.BOOL, 'success', None, None, ), # 0
10947 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 10948 
  )
10949 
 
3064 chandransh 10950 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 10951 
    self.success = success
3064 chandransh 10952 
    self.ex = ex
1408 ankur.sing 10953 
 
10954 
  def read(self, iprot):
10955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10957 
      return
10958 
    iprot.readStructBegin()
10959 
    while True:
10960 
      (fname, ftype, fid) = iprot.readFieldBegin()
10961 
      if ftype == TType.STOP:
10962 
        break
10963 
      if fid == 0:
3064 chandransh 10964 
        if ftype == TType.BOOL:
10965 
          self.success = iprot.readBool();
1408 ankur.sing 10966 
        else:
10967 
          iprot.skip(ftype)
3064 chandransh 10968 
      elif fid == 1:
10969 
        if ftype == TType.STRUCT:
10970 
          self.ex = TransactionServiceException()
10971 
          self.ex.read(iprot)
10972 
        else:
10973 
          iprot.skip(ftype)
1408 ankur.sing 10974 
      else:
10975 
        iprot.skip(ftype)
10976 
      iprot.readFieldEnd()
10977 
    iprot.readStructEnd()
10978 
 
10979 
  def write(self, oprot):
10980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10982 
      return
3064 chandransh 10983 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 10984 
    if self.success is not None:
3064 chandransh 10985 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10986 
      oprot.writeBool(self.success)
1408 ankur.sing 10987 
      oprot.writeFieldEnd()
3431 rajveer 10988 
    if self.ex is not None:
3064 chandransh 10989 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10990 
      self.ex.write(oprot)
10991 
      oprot.writeFieldEnd()
1408 ankur.sing 10992 
    oprot.writeFieldStop()
10993 
    oprot.writeStructEnd()
10994 
 
3431 rajveer 10995 
  def validate(self):
10996 
    return
10997 
 
10998 
 
1408 ankur.sing 10999 
  def __repr__(self):
11000 
    L = ['%s=%r' % (key, value)
11001 
      for key, value in self.__dict__.iteritems()]
11002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11003 
 
11004 
  def __eq__(self, other):
11005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11006 
 
11007 
  def __ne__(self, other):
11008 
    return not (self == other)
11009 
 
4410 rajveer 11010 
class markOrdersAsShippedFromWarehouse_args:
11011 
  """
11012 
  Attributes:
11013 
   - warehouseId
11014 
   - providerId
11015 
   - cod
4789 rajveer 11016 
   - orderIds
4410 rajveer 11017 
  """
11018 
 
11019 
  thrift_spec = (
11020 
    None, # 0
11021 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11022 
    (2, TType.I64, 'providerId', None, None, ), # 2
11023 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4789 rajveer 11024 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
4410 rajveer 11025 
  )
11026 
 
4789 rajveer 11027 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
4410 rajveer 11028 
    self.warehouseId = warehouseId
11029 
    self.providerId = providerId
11030 
    self.cod = cod
4789 rajveer 11031 
    self.orderIds = orderIds
4410 rajveer 11032 
 
11033 
  def read(self, iprot):
11034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11036 
      return
11037 
    iprot.readStructBegin()
11038 
    while True:
11039 
      (fname, ftype, fid) = iprot.readFieldBegin()
11040 
      if ftype == TType.STOP:
11041 
        break
11042 
      if fid == 1:
11043 
        if ftype == TType.I64:
11044 
          self.warehouseId = iprot.readI64();
11045 
        else:
11046 
          iprot.skip(ftype)
11047 
      elif fid == 2:
11048 
        if ftype == TType.I64:
11049 
          self.providerId = iprot.readI64();
11050 
        else:
11051 
          iprot.skip(ftype)
11052 
      elif fid == 3:
11053 
        if ftype == TType.BOOL:
11054 
          self.cod = iprot.readBool();
11055 
        else:
11056 
          iprot.skip(ftype)
4789 rajveer 11057 
      elif fid == 4:
11058 
        if ftype == TType.LIST:
11059 
          self.orderIds = []
11060 
          (_etype143, _size140) = iprot.readListBegin()
11061 
          for _i144 in xrange(_size140):
11062 
            _elem145 = iprot.readI64();
11063 
            self.orderIds.append(_elem145)
11064 
          iprot.readListEnd()
11065 
        else:
11066 
          iprot.skip(ftype)
4410 rajveer 11067 
      else:
11068 
        iprot.skip(ftype)
11069 
      iprot.readFieldEnd()
11070 
    iprot.readStructEnd()
11071 
 
11072 
  def write(self, oprot):
11073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11075 
      return
11076 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
11077 
    if self.warehouseId is not None:
11078 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11079 
      oprot.writeI64(self.warehouseId)
11080 
      oprot.writeFieldEnd()
11081 
    if self.providerId is not None:
11082 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
11083 
      oprot.writeI64(self.providerId)
11084 
      oprot.writeFieldEnd()
11085 
    if self.cod is not None:
11086 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11087 
      oprot.writeBool(self.cod)
11088 
      oprot.writeFieldEnd()
4789 rajveer 11089 
    if self.orderIds is not None:
11090 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
11091 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
11092 
      for iter146 in self.orderIds:
11093 
        oprot.writeI64(iter146)
11094 
      oprot.writeListEnd()
11095 
      oprot.writeFieldEnd()
4410 rajveer 11096 
    oprot.writeFieldStop()
11097 
    oprot.writeStructEnd()
11098 
 
11099 
  def validate(self):
11100 
    return
11101 
 
11102 
 
11103 
  def __repr__(self):
11104 
    L = ['%s=%r' % (key, value)
11105 
      for key, value in self.__dict__.iteritems()]
11106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11107 
 
11108 
  def __eq__(self, other):
11109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11110 
 
11111 
  def __ne__(self, other):
11112 
    return not (self == other)
11113 
 
11114 
class markOrdersAsShippedFromWarehouse_result:
11115 
  """
11116 
  Attributes:
11117 
   - success
11118 
   - ex
11119 
  """
11120 
 
11121 
  thrift_spec = (
11122 
    (0, TType.BOOL, 'success', None, None, ), # 0
11123 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11124 
  )
11125 
 
11126 
  def __init__(self, success=None, ex=None,):
11127 
    self.success = success
11128 
    self.ex = ex
11129 
 
11130 
  def read(self, iprot):
11131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11133 
      return
11134 
    iprot.readStructBegin()
11135 
    while True:
11136 
      (fname, ftype, fid) = iprot.readFieldBegin()
11137 
      if ftype == TType.STOP:
11138 
        break
11139 
      if fid == 0:
11140 
        if ftype == TType.BOOL:
11141 
          self.success = iprot.readBool();
11142 
        else:
11143 
          iprot.skip(ftype)
11144 
      elif fid == 1:
11145 
        if ftype == TType.STRUCT:
11146 
          self.ex = TransactionServiceException()
11147 
          self.ex.read(iprot)
11148 
        else:
11149 
          iprot.skip(ftype)
11150 
      else:
11151 
        iprot.skip(ftype)
11152 
      iprot.readFieldEnd()
11153 
    iprot.readStructEnd()
11154 
 
11155 
  def write(self, oprot):
11156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11158 
      return
11159 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
11160 
    if self.success is not None:
11161 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11162 
      oprot.writeBool(self.success)
11163 
      oprot.writeFieldEnd()
11164 
    if self.ex is not None:
11165 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11166 
      self.ex.write(oprot)
11167 
      oprot.writeFieldEnd()
11168 
    oprot.writeFieldStop()
11169 
    oprot.writeStructEnd()
11170 
 
11171 
  def validate(self):
11172 
    return
11173 
 
11174 
 
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 markOrdersAsPickedUp_args:
304 ashish 11187 
  """
11188 
  Attributes:
3064 chandransh 11189 
   - providerId
11190 
   - pickupDetails
304 ashish 11191 
  """
94 ashish 11192 
 
304 ashish 11193 
  thrift_spec = (
11194 
    None, # 0
3064 chandransh 11195 
    (1, TType.I64, 'providerId', None, None, ), # 1
11196 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11197 
  )
11198 
 
3064 chandransh 11199 
  def __init__(self, providerId=None, pickupDetails=None,):
11200 
    self.providerId = providerId
11201 
    self.pickupDetails = pickupDetails
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.pickupDetails = {}
4789 rajveer 11220 
          (_ktype148, _vtype149, _size147 ) = iprot.readMapBegin()
11221 
          for _i151 in xrange(_size147):
11222 
            _key152 = iprot.readString();
11223 
            _val153 = iprot.readString();
11224 
            self.pickupDetails[_key152] = _val153
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('markOrdersAsPickedUp_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.pickupDetails is not None:
3064 chandransh 11243 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11244 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4789 rajveer 11245 
      for kiter154,viter155 in self.pickupDetails.items():
11246 
        oprot.writeString(kiter154)
11247 
        oprot.writeString(viter155)
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 markOrdersAsPickedUp_result:
304 ashish 11269 
  """
11270 
  Attributes:
11271 
   - success
3064 chandransh 11272 
   - ex
304 ashish 11273 
  """
11274 
 
11275 
  thrift_spec = (
3064 chandransh 11276 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11277 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11278 
  )
11279 
 
3064 chandransh 11280 
  def __init__(self, success=None, ex=None,):
304 ashish 11281 
    self.success = success
3064 chandransh 11282 
    self.ex = ex
304 ashish 11283 
 
11284 
  def read(self, iprot):
11285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11287 
      return
11288 
    iprot.readStructBegin()
11289 
    while True:
11290 
      (fname, ftype, fid) = iprot.readFieldBegin()
11291 
      if ftype == TType.STOP:
11292 
        break
11293 
      if fid == 0:
11294 
        if ftype == TType.LIST:
11295 
          self.success = []
4789 rajveer 11296 
          (_etype159, _size156) = iprot.readListBegin()
11297 
          for _i160 in xrange(_size156):
11298 
            _elem161 = Order()
11299 
            _elem161.read(iprot)
11300 
            self.success.append(_elem161)
304 ashish 11301 
          iprot.readListEnd()
11302 
        else:
11303 
          iprot.skip(ftype)
3064 chandransh 11304 
      elif fid == 1:
11305 
        if ftype == TType.STRUCT:
11306 
          self.ex = TransactionServiceException()
11307 
          self.ex.read(iprot)
11308 
        else:
11309 
          iprot.skip(ftype)
304 ashish 11310 
      else:
11311 
        iprot.skip(ftype)
11312 
      iprot.readFieldEnd()
11313 
    iprot.readStructEnd()
11314 
 
11315 
  def write(self, oprot):
11316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11318 
      return
3064 chandransh 11319 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 11320 
    if self.success is not None:
304 ashish 11321 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11322 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4789 rajveer 11323 
      for iter162 in self.success:
11324 
        iter162.write(oprot)
304 ashish 11325 
      oprot.writeListEnd()
11326 
      oprot.writeFieldEnd()
3431 rajveer 11327 
    if self.ex is not None:
3064 chandransh 11328 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11329 
      self.ex.write(oprot)
11330 
      oprot.writeFieldEnd()
304 ashish 11331 
    oprot.writeFieldStop()
11332 
    oprot.writeStructEnd()
11333 
 
3431 rajveer 11334 
  def validate(self):
11335 
    return
11336 
 
11337 
 
304 ashish 11338 
  def __repr__(self):
11339 
    L = ['%s=%r' % (key, value)
11340 
      for key, value in self.__dict__.iteritems()]
11341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11342 
 
11343 
  def __eq__(self, other):
11344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11345 
 
11346 
  def __ne__(self, other):
11347 
    return not (self == other)
11348 
 
3064 chandransh 11349 
class markOrdersAsDelivered_args:
304 ashish 11350 
  """
11351 
  Attributes:
3064 chandransh 11352 
   - providerId
11353 
   - deliveredOrders
304 ashish 11354 
  """
11355 
 
11356 
  thrift_spec = (
11357 
    None, # 0
3064 chandransh 11358 
    (1, TType.I64, 'providerId', None, None, ), # 1
11359 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 11360 
  )
11361 
 
3064 chandransh 11362 
  def __init__(self, providerId=None, deliveredOrders=None,):
11363 
    self.providerId = providerId
11364 
    self.deliveredOrders = deliveredOrders
304 ashish 11365 
 
11366 
  def read(self, iprot):
11367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11369 
      return
11370 
    iprot.readStructBegin()
11371 
    while True:
11372 
      (fname, ftype, fid) = iprot.readFieldBegin()
11373 
      if ftype == TType.STOP:
11374 
        break
11375 
      if fid == 1:
11376 
        if ftype == TType.I64:
3064 chandransh 11377 
          self.providerId = iprot.readI64();
304 ashish 11378 
        else:
11379 
          iprot.skip(ftype)
11380 
      elif fid == 2:
3064 chandransh 11381 
        if ftype == TType.MAP:
11382 
          self.deliveredOrders = {}
4789 rajveer 11383 
          (_ktype164, _vtype165, _size163 ) = iprot.readMapBegin()
11384 
          for _i167 in xrange(_size163):
11385 
            _key168 = iprot.readString();
11386 
            _val169 = iprot.readString();
11387 
            self.deliveredOrders[_key168] = _val169
3064 chandransh 11388 
          iprot.readMapEnd()
304 ashish 11389 
        else:
11390 
          iprot.skip(ftype)
11391 
      else:
11392 
        iprot.skip(ftype)
11393 
      iprot.readFieldEnd()
11394 
    iprot.readStructEnd()
11395 
 
11396 
  def write(self, oprot):
11397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11399 
      return
3064 chandransh 11400 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 11401 
    if self.providerId is not None:
3064 chandransh 11402 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11403 
      oprot.writeI64(self.providerId)
304 ashish 11404 
      oprot.writeFieldEnd()
3431 rajveer 11405 
    if self.deliveredOrders is not None:
3064 chandransh 11406 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
11407 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4789 rajveer 11408 
      for kiter170,viter171 in self.deliveredOrders.items():
11409 
        oprot.writeString(kiter170)
11410 
        oprot.writeString(viter171)
3064 chandransh 11411 
      oprot.writeMapEnd()
304 ashish 11412 
      oprot.writeFieldEnd()
11413 
    oprot.writeFieldStop()
11414 
    oprot.writeStructEnd()
11415 
 
3431 rajveer 11416 
  def validate(self):
11417 
    return
11418 
 
11419 
 
304 ashish 11420 
  def __repr__(self):
11421 
    L = ['%s=%r' % (key, value)
11422 
      for key, value in self.__dict__.iteritems()]
11423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11424 
 
11425 
  def __eq__(self, other):
11426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11427 
 
11428 
  def __ne__(self, other):
11429 
    return not (self == other)
11430 
 
3064 chandransh 11431 
class markOrdersAsDelivered_result:
11432 
  """
11433 
  Attributes:
11434 
   - ex
11435 
  """
304 ashish 11436 
 
11437 
  thrift_spec = (
3064 chandransh 11438 
    None, # 0
11439 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 11440 
  )
11441 
 
3064 chandransh 11442 
  def __init__(self, ex=None,):
11443 
    self.ex = ex
304 ashish 11444 
 
1596 ankur.sing 11445 
  def read(self, iprot):
11446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11448 
      return
11449 
    iprot.readStructBegin()
11450 
    while True:
11451 
      (fname, ftype, fid) = iprot.readFieldBegin()
11452 
      if ftype == TType.STOP:
11453 
        break
3064 chandransh 11454 
      if fid == 1:
11455 
        if ftype == TType.STRUCT:
11456 
          self.ex = TransactionServiceException()
11457 
          self.ex.read(iprot)
11458 
        else:
11459 
          iprot.skip(ftype)
1596 ankur.sing 11460 
      else:
11461 
        iprot.skip(ftype)
11462 
      iprot.readFieldEnd()
11463 
    iprot.readStructEnd()
11464 
 
11465 
  def write(self, oprot):
11466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11468 
      return
3064 chandransh 11469 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 11470 
    if self.ex is not None:
3064 chandransh 11471 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11472 
      self.ex.write(oprot)
11473 
      oprot.writeFieldEnd()
1596 ankur.sing 11474 
    oprot.writeFieldStop()
11475 
    oprot.writeStructEnd()
11476 
 
3431 rajveer 11477 
  def validate(self):
11478 
    return
11479 
 
11480 
 
1596 ankur.sing 11481 
  def __repr__(self):
11482 
    L = ['%s=%r' % (key, value)
11483 
      for key, value in self.__dict__.iteritems()]
11484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11485 
 
11486 
  def __eq__(self, other):
11487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11488 
 
11489 
  def __ne__(self, other):
11490 
    return not (self == other)
11491 
 
3064 chandransh 11492 
class markOrdersAsFailed_args:
1596 ankur.sing 11493 
  """
11494 
  Attributes:
3064 chandransh 11495 
   - providerId
11496 
   - returnedOrders
1596 ankur.sing 11497 
  """
11498 
 
11499 
  thrift_spec = (
3064 chandransh 11500 
    None, # 0
11501 
    (1, TType.I64, 'providerId', None, None, ), # 1
11502 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 11503 
  )
11504 
 
3064 chandransh 11505 
  def __init__(self, providerId=None, returnedOrders=None,):
11506 
    self.providerId = providerId
11507 
    self.returnedOrders = returnedOrders
1596 ankur.sing 11508 
 
11509 
  def read(self, iprot):
11510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11512 
      return
11513 
    iprot.readStructBegin()
11514 
    while True:
11515 
      (fname, ftype, fid) = iprot.readFieldBegin()
11516 
      if ftype == TType.STOP:
11517 
        break
3064 chandransh 11518 
      if fid == 1:
1596 ankur.sing 11519 
        if ftype == TType.I64:
3064 chandransh 11520 
          self.providerId = iprot.readI64();
1596 ankur.sing 11521 
        else:
11522 
          iprot.skip(ftype)
3064 chandransh 11523 
      elif fid == 2:
11524 
        if ftype == TType.MAP:
11525 
          self.returnedOrders = {}
4789 rajveer 11526 
          (_ktype173, _vtype174, _size172 ) = iprot.readMapBegin()
11527 
          for _i176 in xrange(_size172):
11528 
            _key177 = iprot.readString();
11529 
            _val178 = iprot.readString();
11530 
            self.returnedOrders[_key177] = _val178
3064 chandransh 11531 
          iprot.readMapEnd()
11532 
        else:
11533 
          iprot.skip(ftype)
1596 ankur.sing 11534 
      else:
11535 
        iprot.skip(ftype)
11536 
      iprot.readFieldEnd()
11537 
    iprot.readStructEnd()
11538 
 
11539 
  def write(self, oprot):
11540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11542 
      return
3064 chandransh 11543 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 11544 
    if self.providerId is not None:
3064 chandransh 11545 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11546 
      oprot.writeI64(self.providerId)
1596 ankur.sing 11547 
      oprot.writeFieldEnd()
3431 rajveer 11548 
    if self.returnedOrders is not None:
3064 chandransh 11549 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
11550 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4789 rajveer 11551 
      for kiter179,viter180 in self.returnedOrders.items():
11552 
        oprot.writeString(kiter179)
11553 
        oprot.writeString(viter180)
3064 chandransh 11554 
      oprot.writeMapEnd()
11555 
      oprot.writeFieldEnd()
1596 ankur.sing 11556 
    oprot.writeFieldStop()
11557 
    oprot.writeStructEnd()
11558 
 
3431 rajveer 11559 
  def validate(self):
11560 
    return
11561 
 
11562 
 
1596 ankur.sing 11563 
  def __repr__(self):
11564 
    L = ['%s=%r' % (key, value)
11565 
      for key, value in self.__dict__.iteritems()]
11566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11567 
 
11568 
  def __eq__(self, other):
11569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11570 
 
11571 
  def __ne__(self, other):
11572 
    return not (self == other)
11573 
 
3064 chandransh 11574 
class markOrdersAsFailed_result:
11575 
  """
11576 
  Attributes:
11577 
   - ex
11578 
  """
1596 ankur.sing 11579 
 
1627 ankur.sing 11580 
  thrift_spec = (
3064 chandransh 11581 
    None, # 0
11582 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11583 
  )
11584 
 
3064 chandransh 11585 
  def __init__(self, ex=None,):
11586 
    self.ex = ex
11587 
 
1627 ankur.sing 11588 
  def read(self, iprot):
11589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11591 
      return
11592 
    iprot.readStructBegin()
11593 
    while True:
11594 
      (fname, ftype, fid) = iprot.readFieldBegin()
11595 
      if ftype == TType.STOP:
11596 
        break
3064 chandransh 11597 
      if fid == 1:
11598 
        if ftype == TType.STRUCT:
11599 
          self.ex = TransactionServiceException()
11600 
          self.ex.read(iprot)
11601 
        else:
11602 
          iprot.skip(ftype)
1627 ankur.sing 11603 
      else:
11604 
        iprot.skip(ftype)
11605 
      iprot.readFieldEnd()
11606 
    iprot.readStructEnd()
11607 
 
11608 
  def write(self, oprot):
11609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11611 
      return
3064 chandransh 11612 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 11613 
    if self.ex is not None:
3064 chandransh 11614 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11615 
      self.ex.write(oprot)
11616 
      oprot.writeFieldEnd()
1627 ankur.sing 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 updateNonDeliveryReason_args:
1627 ankur.sing 11636 
  """
11637 
  Attributes:
3064 chandransh 11638 
   - providerId
11639 
   - undeliveredOrders
1627 ankur.sing 11640 
  """
11641 
 
11642 
  thrift_spec = (
3064 chandransh 11643 
    None, # 0
11644 
    (1, TType.I64, 'providerId', None, None, ), # 1
11645 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 11646 
  )
11647 
 
3064 chandransh 11648 
  def __init__(self, providerId=None, undeliveredOrders=None,):
11649 
    self.providerId = providerId
11650 
    self.undeliveredOrders = undeliveredOrders
1627 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
3064 chandransh 11661 
      if fid == 1:
1627 ankur.sing 11662 
        if ftype == TType.I64:
3064 chandransh 11663 
          self.providerId = iprot.readI64();
1627 ankur.sing 11664 
        else:
11665 
          iprot.skip(ftype)
3064 chandransh 11666 
      elif fid == 2:
11667 
        if ftype == TType.MAP:
11668 
          self.undeliveredOrders = {}
4789 rajveer 11669 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
11670 
          for _i185 in xrange(_size181):
11671 
            _key186 = iprot.readString();
11672 
            _val187 = iprot.readString();
11673 
            self.undeliveredOrders[_key186] = _val187
3064 chandransh 11674 
          iprot.readMapEnd()
11675 
        else:
11676 
          iprot.skip(ftype)
1627 ankur.sing 11677 
      else:
11678 
        iprot.skip(ftype)
11679 
      iprot.readFieldEnd()
11680 
    iprot.readStructEnd()
11681 
 
11682 
  def write(self, oprot):
11683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11685 
      return
3064 chandransh 11686 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 11687 
    if self.providerId is not None:
3064 chandransh 11688 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11689 
      oprot.writeI64(self.providerId)
1627 ankur.sing 11690 
      oprot.writeFieldEnd()
3431 rajveer 11691 
    if self.undeliveredOrders is not None:
3064 chandransh 11692 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
11693 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4789 rajveer 11694 
      for kiter188,viter189 in self.undeliveredOrders.items():
11695 
        oprot.writeString(kiter188)
11696 
        oprot.writeString(viter189)
3064 chandransh 11697 
      oprot.writeMapEnd()
11698 
      oprot.writeFieldEnd()
1627 ankur.sing 11699 
    oprot.writeFieldStop()
11700 
    oprot.writeStructEnd()
11701 
 
3431 rajveer 11702 
  def validate(self):
11703 
    return
11704 
 
11705 
 
1627 ankur.sing 11706 
  def __repr__(self):
11707 
    L = ['%s=%r' % (key, value)
11708 
      for key, value in self.__dict__.iteritems()]
11709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11710 
 
11711 
  def __eq__(self, other):
11712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11713 
 
11714 
  def __ne__(self, other):
11715 
    return not (self == other)
11716 
 
3064 chandransh 11717 
class updateNonDeliveryReason_result:
1627 ankur.sing 11718 
  """
11719 
  Attributes:
4581 phani.kuma 11720 
   - success
3064 chandransh 11721 
   - ex
1627 ankur.sing 11722 
  """
11723 
 
11724 
  thrift_spec = (
4581 phani.kuma 11725 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3064 chandransh 11726 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 11727 
  )
11728 
 
4581 phani.kuma 11729 
  def __init__(self, success=None, ex=None,):
11730 
    self.success = success
3064 chandransh 11731 
    self.ex = ex
1627 ankur.sing 11732 
 
11733 
  def read(self, iprot):
11734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11736 
      return
11737 
    iprot.readStructBegin()
11738 
    while True:
11739 
      (fname, ftype, fid) = iprot.readFieldBegin()
11740 
      if ftype == TType.STOP:
11741 
        break
4581 phani.kuma 11742 
      if fid == 0:
11743 
        if ftype == TType.LIST:
11744 
          self.success = []
4789 rajveer 11745 
          (_etype193, _size190) = iprot.readListBegin()
11746 
          for _i194 in xrange(_size190):
11747 
            _elem195 = Order()
11748 
            _elem195.read(iprot)
11749 
            self.success.append(_elem195)
4581 phani.kuma 11750 
          iprot.readListEnd()
11751 
        else:
11752 
          iprot.skip(ftype)
11753 
      elif fid == 1:
3064 chandransh 11754 
        if ftype == TType.STRUCT:
11755 
          self.ex = TransactionServiceException()
11756 
          self.ex.read(iprot)
1627 ankur.sing 11757 
        else:
11758 
          iprot.skip(ftype)
11759 
      else:
11760 
        iprot.skip(ftype)
11761 
      iprot.readFieldEnd()
11762 
    iprot.readStructEnd()
11763 
 
11764 
  def write(self, oprot):
11765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11767 
      return
3064 chandransh 11768 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
4581 phani.kuma 11769 
    if self.success is not None:
11770 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11771 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4789 rajveer 11772 
      for iter196 in self.success:
11773 
        iter196.write(oprot)
4581 phani.kuma 11774 
      oprot.writeListEnd()
11775 
      oprot.writeFieldEnd()
3431 rajveer 11776 
    if self.ex is not None:
3064 chandransh 11777 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11778 
      self.ex.write(oprot)
1627 ankur.sing 11779 
      oprot.writeFieldEnd()
11780 
    oprot.writeFieldStop()
11781 
    oprot.writeStructEnd()
11782 
 
3431 rajveer 11783 
  def validate(self):
11784 
    return
11785 
 
11786 
 
1627 ankur.sing 11787 
  def __repr__(self):
11788 
    L = ['%s=%r' % (key, value)
11789 
      for key, value in self.__dict__.iteritems()]
11790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11791 
 
11792 
  def __eq__(self, other):
11793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11794 
 
11795 
  def __ne__(self, other):
11796 
    return not (self == other)
11797 
 
3064 chandransh 11798 
class getUndeliveredOrders_args:
1886 ankur.sing 11799 
  """
11800 
  Attributes:
3064 chandransh 11801 
   - providerId
11802 
   - warehouseId
1886 ankur.sing 11803 
  """
1627 ankur.sing 11804 
 
1886 ankur.sing 11805 
  thrift_spec = (
11806 
    None, # 0
3064 chandransh 11807 
    (1, TType.I64, 'providerId', None, None, ), # 1
11808 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 11809 
  )
11810 
 
3064 chandransh 11811 
  def __init__(self, providerId=None, warehouseId=None,):
11812 
    self.providerId = providerId
11813 
    self.warehouseId = warehouseId
1886 ankur.sing 11814 
 
11815 
  def read(self, iprot):
11816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11818 
      return
11819 
    iprot.readStructBegin()
11820 
    while True:
11821 
      (fname, ftype, fid) = iprot.readFieldBegin()
11822 
      if ftype == TType.STOP:
11823 
        break
11824 
      if fid == 1:
11825 
        if ftype == TType.I64:
3064 chandransh 11826 
          self.providerId = iprot.readI64();
1886 ankur.sing 11827 
        else:
11828 
          iprot.skip(ftype)
3064 chandransh 11829 
      elif fid == 2:
11830 
        if ftype == TType.I64:
11831 
          self.warehouseId = iprot.readI64();
11832 
        else:
11833 
          iprot.skip(ftype)
1886 ankur.sing 11834 
      else:
11835 
        iprot.skip(ftype)
11836 
      iprot.readFieldEnd()
11837 
    iprot.readStructEnd()
11838 
 
11839 
  def write(self, oprot):
11840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11842 
      return
3064 chandransh 11843 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 11844 
    if self.providerId is not None:
3064 chandransh 11845 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11846 
      oprot.writeI64(self.providerId)
1886 ankur.sing 11847 
      oprot.writeFieldEnd()
3431 rajveer 11848 
    if self.warehouseId is not None:
3064 chandransh 11849 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11850 
      oprot.writeI64(self.warehouseId)
11851 
      oprot.writeFieldEnd()
1886 ankur.sing 11852 
    oprot.writeFieldStop()
11853 
    oprot.writeStructEnd()
11854 
 
3431 rajveer 11855 
  def validate(self):
11856 
    return
11857 
 
11858 
 
1886 ankur.sing 11859 
  def __repr__(self):
11860 
    L = ['%s=%r' % (key, value)
11861 
      for key, value in self.__dict__.iteritems()]
11862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11863 
 
11864 
  def __eq__(self, other):
11865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11866 
 
11867 
  def __ne__(self, other):
11868 
    return not (self == other)
11869 
 
3064 chandransh 11870 
class getUndeliveredOrders_result:
1886 ankur.sing 11871 
  """
11872 
  Attributes:
11873 
   - success
11874 
  """
11875 
 
11876 
  thrift_spec = (
11877 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11878 
  )
11879 
 
11880 
  def __init__(self, success=None,):
11881 
    self.success = success
11882 
 
11883 
  def read(self, iprot):
11884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11886 
      return
11887 
    iprot.readStructBegin()
11888 
    while True:
11889 
      (fname, ftype, fid) = iprot.readFieldBegin()
11890 
      if ftype == TType.STOP:
11891 
        break
11892 
      if fid == 0:
11893 
        if ftype == TType.LIST:
11894 
          self.success = []
4789 rajveer 11895 
          (_etype200, _size197) = iprot.readListBegin()
11896 
          for _i201 in xrange(_size197):
11897 
            _elem202 = Order()
11898 
            _elem202.read(iprot)
11899 
            self.success.append(_elem202)
1886 ankur.sing 11900 
          iprot.readListEnd()
11901 
        else:
11902 
          iprot.skip(ftype)
11903 
      else:
11904 
        iprot.skip(ftype)
11905 
      iprot.readFieldEnd()
11906 
    iprot.readStructEnd()
11907 
 
11908 
  def write(self, oprot):
11909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11911 
      return
3064 chandransh 11912 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 11913 
    if self.success is not None:
1886 ankur.sing 11914 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11915 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4789 rajveer 11916 
      for iter203 in self.success:
11917 
        iter203.write(oprot)
1886 ankur.sing 11918 
      oprot.writeListEnd()
11919 
      oprot.writeFieldEnd()
11920 
    oprot.writeFieldStop()
11921 
    oprot.writeStructEnd()
11922 
 
3431 rajveer 11923 
  def validate(self):
11924 
    return
11925 
 
11926 
 
1886 ankur.sing 11927 
  def __repr__(self):
11928 
    L = ['%s=%r' % (key, value)
11929 
      for key, value in self.__dict__.iteritems()]
11930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11931 
 
11932 
  def __eq__(self, other):
11933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11934 
 
11935 
  def __ne__(self, other):
11936 
    return not (self == other)
11937 
 
4783 phani.kuma 11938 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
11939 
 
11940 
  thrift_spec = (
11941 
  )
11942 
 
11943 
  def read(self, iprot):
11944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11946 
      return
11947 
    iprot.readStructBegin()
11948 
    while True:
11949 
      (fname, ftype, fid) = iprot.readFieldBegin()
11950 
      if ftype == TType.STOP:
11951 
        break
11952 
      else:
11953 
        iprot.skip(ftype)
11954 
      iprot.readFieldEnd()
11955 
    iprot.readStructEnd()
11956 
 
11957 
  def write(self, oprot):
11958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11960 
      return
11961 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
11962 
    oprot.writeFieldStop()
11963 
    oprot.writeStructEnd()
11964 
 
11965 
  def validate(self):
11966 
    return
11967 
 
11968 
 
11969 
  def __repr__(self):
11970 
    L = ['%s=%r' % (key, value)
11971 
      for key, value in self.__dict__.iteritems()]
11972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11973 
 
11974 
  def __eq__(self, other):
11975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11976 
 
11977 
  def __ne__(self, other):
11978 
    return not (self == other)
11979 
 
11980 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
11981 
  """
11982 
  Attributes:
11983 
   - success
11984 
  """
11985 
 
11986 
  thrift_spec = (
11987 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11988 
  )
11989 
 
11990 
  def __init__(self, success=None,):
11991 
    self.success = success
11992 
 
11993 
  def read(self, iprot):
11994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11996 
      return
11997 
    iprot.readStructBegin()
11998 
    while True:
11999 
      (fname, ftype, fid) = iprot.readFieldBegin()
12000 
      if ftype == TType.STOP:
12001 
        break
12002 
      if fid == 0:
12003 
        if ftype == TType.LIST:
12004 
          self.success = []
4789 rajveer 12005 
          (_etype207, _size204) = iprot.readListBegin()
12006 
          for _i208 in xrange(_size204):
12007 
            _elem209 = Order()
12008 
            _elem209.read(iprot)
12009 
            self.success.append(_elem209)
4783 phani.kuma 12010 
          iprot.readListEnd()
12011 
        else:
12012 
          iprot.skip(ftype)
12013 
      else:
12014 
        iprot.skip(ftype)
12015 
      iprot.readFieldEnd()
12016 
    iprot.readStructEnd()
12017 
 
12018 
  def write(self, oprot):
12019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12021 
      return
12022 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
12023 
    if self.success is not None:
12024 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12025 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4789 rajveer 12026 
      for iter210 in self.success:
12027 
        iter210.write(oprot)
4783 phani.kuma 12028 
      oprot.writeListEnd()
12029 
      oprot.writeFieldEnd()
12030 
    oprot.writeFieldStop()
12031 
    oprot.writeStructEnd()
12032 
 
12033 
  def validate(self):
12034 
    return
12035 
 
12036 
 
12037 
  def __repr__(self):
12038 
    L = ['%s=%r' % (key, value)
12039 
      for key, value in self.__dict__.iteritems()]
12040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12041 
 
12042 
  def __eq__(self, other):
12043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12044 
 
12045 
  def __ne__(self, other):
12046 
    return not (self == other)
12047 
 
2536 chandransh 12048 
class toggleDOAFlag_args:
12049 
  """
12050 
  Attributes:
12051 
   - orderId
12052 
  """
1886 ankur.sing 12053 
 
2536 chandransh 12054 
  thrift_spec = (
12055 
    None, # 0
12056 
    (1, TType.I64, 'orderId', None, None, ), # 1
12057 
  )
12058 
 
12059 
  def __init__(self, orderId=None,):
12060 
    self.orderId = orderId
12061 
 
12062 
  def read(self, iprot):
12063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12065 
      return
12066 
    iprot.readStructBegin()
12067 
    while True:
12068 
      (fname, ftype, fid) = iprot.readFieldBegin()
12069 
      if ftype == TType.STOP:
12070 
        break
12071 
      if fid == 1:
12072 
        if ftype == TType.I64:
12073 
          self.orderId = iprot.readI64();
12074 
        else:
12075 
          iprot.skip(ftype)
12076 
      else:
12077 
        iprot.skip(ftype)
12078 
      iprot.readFieldEnd()
12079 
    iprot.readStructEnd()
12080 
 
12081 
  def write(self, oprot):
12082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12084 
      return
12085 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 12086 
    if self.orderId is not None:
2536 chandransh 12087 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12088 
      oprot.writeI64(self.orderId)
12089 
      oprot.writeFieldEnd()
12090 
    oprot.writeFieldStop()
12091 
    oprot.writeStructEnd()
12092 
 
3431 rajveer 12093 
  def validate(self):
12094 
    return
12095 
 
12096 
 
2536 chandransh 12097 
  def __repr__(self):
12098 
    L = ['%s=%r' % (key, value)
12099 
      for key, value in self.__dict__.iteritems()]
12100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12101 
 
12102 
  def __eq__(self, other):
12103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12104 
 
12105 
  def __ne__(self, other):
12106 
    return not (self == other)
12107 
 
12108 
class toggleDOAFlag_result:
12109 
  """
12110 
  Attributes:
12111 
   - success
12112 
   - ex
12113 
  """
12114 
 
12115 
  thrift_spec = (
12116 
    (0, TType.BOOL, 'success', None, None, ), # 0
12117 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12118 
  )
12119 
 
12120 
  def __init__(self, success=None, ex=None,):
12121 
    self.success = success
12122 
    self.ex = ex
12123 
 
12124 
  def read(self, iprot):
12125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12127 
      return
12128 
    iprot.readStructBegin()
12129 
    while True:
12130 
      (fname, ftype, fid) = iprot.readFieldBegin()
12131 
      if ftype == TType.STOP:
12132 
        break
12133 
      if fid == 0:
12134 
        if ftype == TType.BOOL:
12135 
          self.success = iprot.readBool();
12136 
        else:
12137 
          iprot.skip(ftype)
12138 
      elif fid == 1:
12139 
        if ftype == TType.STRUCT:
12140 
          self.ex = TransactionServiceException()
12141 
          self.ex.read(iprot)
12142 
        else:
12143 
          iprot.skip(ftype)
12144 
      else:
12145 
        iprot.skip(ftype)
12146 
      iprot.readFieldEnd()
12147 
    iprot.readStructEnd()
12148 
 
12149 
  def write(self, oprot):
12150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12152 
      return
12153 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 12154 
    if self.success is not None:
2536 chandransh 12155 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12156 
      oprot.writeBool(self.success)
12157 
      oprot.writeFieldEnd()
3431 rajveer 12158 
    if self.ex is not None:
2536 chandransh 12159 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12160 
      self.ex.write(oprot)
12161 
      oprot.writeFieldEnd()
12162 
    oprot.writeFieldStop()
12163 
    oprot.writeStructEnd()
12164 
 
3431 rajveer 12165 
  def validate(self):
12166 
    return
12167 
 
12168 
 
2536 chandransh 12169 
  def __repr__(self):
12170 
    L = ['%s=%r' % (key, value)
12171 
      for key, value in self.__dict__.iteritems()]
12172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12173 
 
12174 
  def __eq__(self, other):
12175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12176 
 
12177 
  def __ne__(self, other):
12178 
    return not (self == other)
12179 
 
4712 rajveer 12180 
class markOrderAsDelivered_args:
12181 
  """
12182 
  Attributes:
12183 
   - orderId
12184 
   - deliveryTimestamp
12185 
   - receiver
12186 
  """
12187 
 
12188 
  thrift_spec = None
12189 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
12190 
    self.orderId = orderId
12191 
    self.deliveryTimestamp = deliveryTimestamp
12192 
    self.receiver = receiver
12193 
 
12194 
  def read(self, iprot):
12195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12197 
      return
12198 
    iprot.readStructBegin()
12199 
    while True:
12200 
      (fname, ftype, fid) = iprot.readFieldBegin()
12201 
      if ftype == TType.STOP:
12202 
        break
12203 
      if fid == 1:
12204 
        if ftype == TType.I64:
12205 
          self.orderId = iprot.readI64();
12206 
        else:
12207 
          iprot.skip(ftype)
12208 
      elif fid == 2:
12209 
        if ftype == TType.I64:
12210 
          self.deliveryTimestamp = iprot.readI64();
12211 
        else:
12212 
          iprot.skip(ftype)
12213 
      elif fid == -1:
12214 
        if ftype == TType.STRING:
12215 
          self.receiver = iprot.readString();
12216 
        else:
12217 
          iprot.skip(ftype)
12218 
      else:
12219 
        iprot.skip(ftype)
12220 
      iprot.readFieldEnd()
12221 
    iprot.readStructEnd()
12222 
 
12223 
  def write(self, oprot):
12224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12226 
      return
12227 
    oprot.writeStructBegin('markOrderAsDelivered_args')
12228 
    if self.receiver is not None:
12229 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
12230 
      oprot.writeString(self.receiver)
12231 
      oprot.writeFieldEnd()
12232 
    if self.orderId is not None:
12233 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12234 
      oprot.writeI64(self.orderId)
12235 
      oprot.writeFieldEnd()
12236 
    if self.deliveryTimestamp is not None:
12237 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
12238 
      oprot.writeI64(self.deliveryTimestamp)
12239 
      oprot.writeFieldEnd()
12240 
    oprot.writeFieldStop()
12241 
    oprot.writeStructEnd()
12242 
 
12243 
  def validate(self):
12244 
    return
12245 
 
12246 
 
12247 
  def __repr__(self):
12248 
    L = ['%s=%r' % (key, value)
12249 
      for key, value in self.__dict__.iteritems()]
12250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12251 
 
12252 
  def __eq__(self, other):
12253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12254 
 
12255 
  def __ne__(self, other):
12256 
    return not (self == other)
12257 
 
12258 
class markOrderAsDelivered_result:
12259 
  """
12260 
  Attributes:
12261 
   - ex
12262 
  """
12263 
 
12264 
  thrift_spec = (
12265 
    None, # 0
12266 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12267 
  )
12268 
 
12269 
  def __init__(self, ex=None,):
12270 
    self.ex = ex
12271 
 
12272 
  def read(self, iprot):
12273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12275 
      return
12276 
    iprot.readStructBegin()
12277 
    while True:
12278 
      (fname, ftype, fid) = iprot.readFieldBegin()
12279 
      if ftype == TType.STOP:
12280 
        break
12281 
      if fid == 1:
12282 
        if ftype == TType.STRUCT:
12283 
          self.ex = TransactionServiceException()
12284 
          self.ex.read(iprot)
12285 
        else:
12286 
          iprot.skip(ftype)
12287 
      else:
12288 
        iprot.skip(ftype)
12289 
      iprot.readFieldEnd()
12290 
    iprot.readStructEnd()
12291 
 
12292 
  def write(self, oprot):
12293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12295 
      return
12296 
    oprot.writeStructBegin('markOrderAsDelivered_result')
12297 
    if self.ex is not None:
12298 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12299 
      self.ex.write(oprot)
12300 
      oprot.writeFieldEnd()
12301 
    oprot.writeFieldStop()
12302 
    oprot.writeStructEnd()
12303 
 
12304 
  def validate(self):
12305 
    return
12306 
 
12307 
 
12308 
  def __repr__(self):
12309 
    L = ['%s=%r' % (key, value)
12310 
      for key, value in self.__dict__.iteritems()]
12311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12312 
 
12313 
  def __eq__(self, other):
12314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12315 
 
12316 
  def __ne__(self, other):
12317 
    return not (self == other)
12318 
 
4454 rajveer 12319 
class markOrderDoaRequestReceived_args:
12320 
  """
12321 
  Attributes:
12322 
   - orderId
12323 
  """
12324 
 
12325 
  thrift_spec = (
12326 
    None, # 0
12327 
    (1, TType.I64, 'orderId', None, None, ), # 1
12328 
  )
12329 
 
12330 
  def __init__(self, orderId=None,):
12331 
    self.orderId = orderId
12332 
 
12333 
  def read(self, iprot):
12334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12336 
      return
12337 
    iprot.readStructBegin()
12338 
    while True:
12339 
      (fname, ftype, fid) = iprot.readFieldBegin()
12340 
      if ftype == TType.STOP:
12341 
        break
12342 
      if fid == 1:
12343 
        if ftype == TType.I64:
12344 
          self.orderId = iprot.readI64();
12345 
        else:
12346 
          iprot.skip(ftype)
12347 
      else:
12348 
        iprot.skip(ftype)
12349 
      iprot.readFieldEnd()
12350 
    iprot.readStructEnd()
12351 
 
12352 
  def write(self, oprot):
12353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12355 
      return
12356 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
12357 
    if self.orderId is not None:
12358 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12359 
      oprot.writeI64(self.orderId)
12360 
      oprot.writeFieldEnd()
12361 
    oprot.writeFieldStop()
12362 
    oprot.writeStructEnd()
12363 
 
12364 
  def validate(self):
12365 
    return
12366 
 
12367 
 
12368 
  def __repr__(self):
12369 
    L = ['%s=%r' % (key, value)
12370 
      for key, value in self.__dict__.iteritems()]
12371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12372 
 
12373 
  def __eq__(self, other):
12374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12375 
 
12376 
  def __ne__(self, other):
12377 
    return not (self == other)
12378 
 
12379 
class markOrderDoaRequestReceived_result:
12380 
  """
12381 
  Attributes:
12382 
   - success
12383 
   - ex
12384 
  """
12385 
 
12386 
  thrift_spec = (
12387 
    (0, TType.BOOL, 'success', None, None, ), # 0
12388 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12389 
  )
12390 
 
12391 
  def __init__(self, success=None, ex=None,):
12392 
    self.success = success
12393 
    self.ex = ex
12394 
 
12395 
  def read(self, iprot):
12396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12398 
      return
12399 
    iprot.readStructBegin()
12400 
    while True:
12401 
      (fname, ftype, fid) = iprot.readFieldBegin()
12402 
      if ftype == TType.STOP:
12403 
        break
12404 
      if fid == 0:
12405 
        if ftype == TType.BOOL:
12406 
          self.success = iprot.readBool();
12407 
        else:
12408 
          iprot.skip(ftype)
12409 
      elif fid == 1:
12410 
        if ftype == TType.STRUCT:
12411 
          self.ex = TransactionServiceException()
12412 
          self.ex.read(iprot)
12413 
        else:
12414 
          iprot.skip(ftype)
12415 
      else:
12416 
        iprot.skip(ftype)
12417 
      iprot.readFieldEnd()
12418 
    iprot.readStructEnd()
12419 
 
12420 
  def write(self, oprot):
12421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12423 
      return
12424 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
12425 
    if self.success is not None:
12426 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12427 
      oprot.writeBool(self.success)
12428 
      oprot.writeFieldEnd()
12429 
    if self.ex is not None:
12430 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12431 
      self.ex.write(oprot)
12432 
      oprot.writeFieldEnd()
12433 
    oprot.writeFieldStop()
12434 
    oprot.writeStructEnd()
12435 
 
12436 
  def validate(self):
12437 
    return
12438 
 
12439 
 
12440 
  def __repr__(self):
12441 
    L = ['%s=%r' % (key, value)
12442 
      for key, value in self.__dict__.iteritems()]
12443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12444 
 
12445 
  def __eq__(self, other):
12446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12447 
 
12448 
  def __ne__(self, other):
12449 
    return not (self == other)
12450 
 
12451 
class markOrderDoaRequestAuthorized_args:
12452 
  """
12453 
  Attributes:
12454 
   - orderId
12455 
   - isAuthorized
12456 
  """
12457 
 
12458 
  thrift_spec = (
12459 
    None, # 0
12460 
    (1, TType.I64, 'orderId', None, None, ), # 1
12461 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12462 
  )
12463 
 
12464 
  def __init__(self, orderId=None, isAuthorized=None,):
12465 
    self.orderId = orderId
12466 
    self.isAuthorized = isAuthorized
12467 
 
12468 
  def read(self, iprot):
12469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12471 
      return
12472 
    iprot.readStructBegin()
12473 
    while True:
12474 
      (fname, ftype, fid) = iprot.readFieldBegin()
12475 
      if ftype == TType.STOP:
12476 
        break
12477 
      if fid == 1:
12478 
        if ftype == TType.I64:
12479 
          self.orderId = iprot.readI64();
12480 
        else:
12481 
          iprot.skip(ftype)
12482 
      elif fid == 2:
12483 
        if ftype == TType.BOOL:
12484 
          self.isAuthorized = iprot.readBool();
12485 
        else:
12486 
          iprot.skip(ftype)
12487 
      else:
12488 
        iprot.skip(ftype)
12489 
      iprot.readFieldEnd()
12490 
    iprot.readStructEnd()
12491 
 
12492 
  def write(self, oprot):
12493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12495 
      return
12496 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
12497 
    if self.orderId is not None:
12498 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12499 
      oprot.writeI64(self.orderId)
12500 
      oprot.writeFieldEnd()
12501 
    if self.isAuthorized is not None:
12502 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12503 
      oprot.writeBool(self.isAuthorized)
12504 
      oprot.writeFieldEnd()
12505 
    oprot.writeFieldStop()
12506 
    oprot.writeStructEnd()
12507 
 
12508 
  def validate(self):
12509 
    return
12510 
 
12511 
 
12512 
  def __repr__(self):
12513 
    L = ['%s=%r' % (key, value)
12514 
      for key, value in self.__dict__.iteritems()]
12515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12516 
 
12517 
  def __eq__(self, other):
12518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12519 
 
12520 
  def __ne__(self, other):
12521 
    return not (self == other)
12522 
 
12523 
class markOrderDoaRequestAuthorized_result:
12524 
  """
12525 
  Attributes:
12526 
   - success
12527 
   - ex
12528 
  """
12529 
 
12530 
  thrift_spec = (
12531 
    (0, TType.BOOL, 'success', None, None, ), # 0
12532 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12533 
  )
12534 
 
12535 
  def __init__(self, success=None, ex=None,):
12536 
    self.success = success
12537 
    self.ex = ex
12538 
 
12539 
  def read(self, iprot):
12540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12542 
      return
12543 
    iprot.readStructBegin()
12544 
    while True:
12545 
      (fname, ftype, fid) = iprot.readFieldBegin()
12546 
      if ftype == TType.STOP:
12547 
        break
12548 
      if fid == 0:
12549 
        if ftype == TType.BOOL:
12550 
          self.success = iprot.readBool();
12551 
        else:
12552 
          iprot.skip(ftype)
12553 
      elif fid == 1:
12554 
        if ftype == TType.STRUCT:
12555 
          self.ex = TransactionServiceException()
12556 
          self.ex.read(iprot)
12557 
        else:
12558 
          iprot.skip(ftype)
12559 
      else:
12560 
        iprot.skip(ftype)
12561 
      iprot.readFieldEnd()
12562 
    iprot.readStructEnd()
12563 
 
12564 
  def write(self, oprot):
12565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12567 
      return
12568 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
12569 
    if self.success is not None:
12570 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12571 
      oprot.writeBool(self.success)
12572 
      oprot.writeFieldEnd()
12573 
    if self.ex is not None:
12574 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12575 
      self.ex.write(oprot)
12576 
      oprot.writeFieldEnd()
12577 
    oprot.writeFieldStop()
12578 
    oprot.writeStructEnd()
12579 
 
12580 
  def validate(self):
12581 
    return
12582 
 
12583 
 
12584 
  def __repr__(self):
12585 
    L = ['%s=%r' % (key, value)
12586 
      for key, value in self.__dict__.iteritems()]
12587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12588 
 
12589 
  def __eq__(self, other):
12590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12591 
 
12592 
  def __ne__(self, other):
12593 
    return not (self == other)
12594 
 
4488 rajveer 12595 
class markOrderReturnRequestReceived_args:
12596 
  """
12597 
  Attributes:
12598 
   - orderId
12599 
  """
12600 
 
12601 
  thrift_spec = (
12602 
    None, # 0
12603 
    (1, TType.I64, 'orderId', None, None, ), # 1
12604 
  )
12605 
 
12606 
  def __init__(self, orderId=None,):
12607 
    self.orderId = orderId
12608 
 
12609 
  def read(self, iprot):
12610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12612 
      return
12613 
    iprot.readStructBegin()
12614 
    while True:
12615 
      (fname, ftype, fid) = iprot.readFieldBegin()
12616 
      if ftype == TType.STOP:
12617 
        break
12618 
      if fid == 1:
12619 
        if ftype == TType.I64:
12620 
          self.orderId = iprot.readI64();
12621 
        else:
12622 
          iprot.skip(ftype)
12623 
      else:
12624 
        iprot.skip(ftype)
12625 
      iprot.readFieldEnd()
12626 
    iprot.readStructEnd()
12627 
 
12628 
  def write(self, oprot):
12629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12631 
      return
12632 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
12633 
    if self.orderId is not None:
12634 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12635 
      oprot.writeI64(self.orderId)
12636 
      oprot.writeFieldEnd()
12637 
    oprot.writeFieldStop()
12638 
    oprot.writeStructEnd()
12639 
 
12640 
  def validate(self):
12641 
    return
12642 
 
12643 
 
12644 
  def __repr__(self):
12645 
    L = ['%s=%r' % (key, value)
12646 
      for key, value in self.__dict__.iteritems()]
12647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12648 
 
12649 
  def __eq__(self, other):
12650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12651 
 
12652 
  def __ne__(self, other):
12653 
    return not (self == other)
12654 
 
12655 
class markOrderReturnRequestReceived_result:
12656 
  """
12657 
  Attributes:
12658 
   - success
12659 
   - ex
12660 
  """
12661 
 
12662 
  thrift_spec = (
12663 
    (0, TType.BOOL, 'success', None, None, ), # 0
12664 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12665 
  )
12666 
 
12667 
  def __init__(self, success=None, ex=None,):
12668 
    self.success = success
12669 
    self.ex = ex
12670 
 
12671 
  def read(self, iprot):
12672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12674 
      return
12675 
    iprot.readStructBegin()
12676 
    while True:
12677 
      (fname, ftype, fid) = iprot.readFieldBegin()
12678 
      if ftype == TType.STOP:
12679 
        break
12680 
      if fid == 0:
12681 
        if ftype == TType.BOOL:
12682 
          self.success = iprot.readBool();
12683 
        else:
12684 
          iprot.skip(ftype)
12685 
      elif fid == 1:
12686 
        if ftype == TType.STRUCT:
12687 
          self.ex = TransactionServiceException()
12688 
          self.ex.read(iprot)
12689 
        else:
12690 
          iprot.skip(ftype)
12691 
      else:
12692 
        iprot.skip(ftype)
12693 
      iprot.readFieldEnd()
12694 
    iprot.readStructEnd()
12695 
 
12696 
  def write(self, oprot):
12697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12699 
      return
12700 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
12701 
    if self.success is not None:
12702 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12703 
      oprot.writeBool(self.success)
12704 
      oprot.writeFieldEnd()
12705 
    if self.ex is not None:
12706 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12707 
      self.ex.write(oprot)
12708 
      oprot.writeFieldEnd()
12709 
    oprot.writeFieldStop()
12710 
    oprot.writeStructEnd()
12711 
 
12712 
  def validate(self):
12713 
    return
12714 
 
12715 
 
12716 
  def __repr__(self):
12717 
    L = ['%s=%r' % (key, value)
12718 
      for key, value in self.__dict__.iteritems()]
12719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12720 
 
12721 
  def __eq__(self, other):
12722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12723 
 
12724 
  def __ne__(self, other):
12725 
    return not (self == other)
12726 
 
12727 
class markOrderReturnRequestAuthorized_args:
12728 
  """
12729 
  Attributes:
12730 
   - orderId
12731 
   - isAuthorized
12732 
  """
12733 
 
12734 
  thrift_spec = (
12735 
    None, # 0
12736 
    (1, TType.I64, 'orderId', None, None, ), # 1
12737 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
12738 
  )
12739 
 
12740 
  def __init__(self, orderId=None, isAuthorized=None,):
12741 
    self.orderId = orderId
12742 
    self.isAuthorized = isAuthorized
12743 
 
12744 
  def read(self, iprot):
12745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12747 
      return
12748 
    iprot.readStructBegin()
12749 
    while True:
12750 
      (fname, ftype, fid) = iprot.readFieldBegin()
12751 
      if ftype == TType.STOP:
12752 
        break
12753 
      if fid == 1:
12754 
        if ftype == TType.I64:
12755 
          self.orderId = iprot.readI64();
12756 
        else:
12757 
          iprot.skip(ftype)
12758 
      elif fid == 2:
12759 
        if ftype == TType.BOOL:
12760 
          self.isAuthorized = iprot.readBool();
12761 
        else:
12762 
          iprot.skip(ftype)
12763 
      else:
12764 
        iprot.skip(ftype)
12765 
      iprot.readFieldEnd()
12766 
    iprot.readStructEnd()
12767 
 
12768 
  def write(self, oprot):
12769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12771 
      return
12772 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
12773 
    if self.orderId is not None:
12774 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12775 
      oprot.writeI64(self.orderId)
12776 
      oprot.writeFieldEnd()
12777 
    if self.isAuthorized is not None:
12778 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
12779 
      oprot.writeBool(self.isAuthorized)
12780 
      oprot.writeFieldEnd()
12781 
    oprot.writeFieldStop()
12782 
    oprot.writeStructEnd()
12783 
 
12784 
  def validate(self):
12785 
    return
12786 
 
12787 
 
12788 
  def __repr__(self):
12789 
    L = ['%s=%r' % (key, value)
12790 
      for key, value in self.__dict__.iteritems()]
12791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12792 
 
12793 
  def __eq__(self, other):
12794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12795 
 
12796 
  def __ne__(self, other):
12797 
    return not (self == other)
12798 
 
12799 
class markOrderReturnRequestAuthorized_result:
12800 
  """
12801 
  Attributes:
12802 
   - success
12803 
   - ex
12804 
  """
12805 
 
12806 
  thrift_spec = (
12807 
    (0, TType.BOOL, 'success', None, None, ), # 0
12808 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12809 
  )
12810 
 
12811 
  def __init__(self, success=None, ex=None,):
12812 
    self.success = success
12813 
    self.ex = ex
12814 
 
12815 
  def read(self, iprot):
12816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12818 
      return
12819 
    iprot.readStructBegin()
12820 
    while True:
12821 
      (fname, ftype, fid) = iprot.readFieldBegin()
12822 
      if ftype == TType.STOP:
12823 
        break
12824 
      if fid == 0:
12825 
        if ftype == TType.BOOL:
12826 
          self.success = iprot.readBool();
12827 
        else:
12828 
          iprot.skip(ftype)
12829 
      elif fid == 1:
12830 
        if ftype == TType.STRUCT:
12831 
          self.ex = TransactionServiceException()
12832 
          self.ex.read(iprot)
12833 
        else:
12834 
          iprot.skip(ftype)
12835 
      else:
12836 
        iprot.skip(ftype)
12837 
      iprot.readFieldEnd()
12838 
    iprot.readStructEnd()
12839 
 
12840 
  def write(self, oprot):
12841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12843 
      return
12844 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
12845 
    if self.success is not None:
12846 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12847 
      oprot.writeBool(self.success)
12848 
      oprot.writeFieldEnd()
12849 
    if self.ex is not None:
12850 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12851 
      self.ex.write(oprot)
12852 
      oprot.writeFieldEnd()
12853 
    oprot.writeFieldStop()
12854 
    oprot.writeStructEnd()
12855 
 
12856 
  def validate(self):
12857 
    return
12858 
 
12859 
 
12860 
  def __repr__(self):
12861 
    L = ['%s=%r' % (key, value)
12862 
      for key, value in self.__dict__.iteritems()]
12863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12864 
 
12865 
  def __eq__(self, other):
12866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12867 
 
12868 
  def __ne__(self, other):
12869 
    return not (self == other)
12870 
 
2536 chandransh 12871 
class requestPickupNumber_args:
12872 
  """
12873 
  Attributes:
12874 
   - orderId
4579 rajveer 12875 
   - providerId
2536 chandransh 12876 
  """
12877 
 
12878 
  thrift_spec = (
12879 
    None, # 0
12880 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 12881 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 12882 
  )
12883 
 
4579 rajveer 12884 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 12885 
    self.orderId = orderId
4579 rajveer 12886 
    self.providerId = providerId
2536 chandransh 12887 
 
12888 
  def read(self, iprot):
12889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12891 
      return
12892 
    iprot.readStructBegin()
12893 
    while True:
12894 
      (fname, ftype, fid) = iprot.readFieldBegin()
12895 
      if ftype == TType.STOP:
12896 
        break
12897 
      if fid == 1:
12898 
        if ftype == TType.I64:
12899 
          self.orderId = iprot.readI64();
12900 
        else:
12901 
          iprot.skip(ftype)
4579 rajveer 12902 
      elif fid == 2:
12903 
        if ftype == TType.I64:
12904 
          self.providerId = iprot.readI64();
12905 
        else:
12906 
          iprot.skip(ftype)
2536 chandransh 12907 
      else:
12908 
        iprot.skip(ftype)
12909 
      iprot.readFieldEnd()
12910 
    iprot.readStructEnd()
12911 
 
12912 
  def write(self, oprot):
12913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12915 
      return
12916 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 12917 
    if self.orderId is not None:
2536 chandransh 12918 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12919 
      oprot.writeI64(self.orderId)
12920 
      oprot.writeFieldEnd()
4579 rajveer 12921 
    if self.providerId is not None:
12922 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
12923 
      oprot.writeI64(self.providerId)
12924 
      oprot.writeFieldEnd()
2536 chandransh 12925 
    oprot.writeFieldStop()
12926 
    oprot.writeStructEnd()
12927 
 
3431 rajveer 12928 
  def validate(self):
12929 
    return
12930 
 
12931 
 
2536 chandransh 12932 
  def __repr__(self):
12933 
    L = ['%s=%r' % (key, value)
12934 
      for key, value in self.__dict__.iteritems()]
12935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12936 
 
12937 
  def __eq__(self, other):
12938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12939 
 
12940 
  def __ne__(self, other):
12941 
    return not (self == other)
12942 
 
12943 
class requestPickupNumber_result:
12944 
  """
12945 
  Attributes:
12946 
   - success
12947 
   - ex
12948 
  """
12949 
 
12950 
  thrift_spec = (
12951 
    (0, TType.BOOL, 'success', None, None, ), # 0
12952 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12953 
  )
12954 
 
12955 
  def __init__(self, success=None, ex=None,):
12956 
    self.success = success
12957 
    self.ex = ex
12958 
 
12959 
  def read(self, iprot):
12960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12962 
      return
12963 
    iprot.readStructBegin()
12964 
    while True:
12965 
      (fname, ftype, fid) = iprot.readFieldBegin()
12966 
      if ftype == TType.STOP:
12967 
        break
12968 
      if fid == 0:
12969 
        if ftype == TType.BOOL:
12970 
          self.success = iprot.readBool();
12971 
        else:
12972 
          iprot.skip(ftype)
12973 
      elif fid == 1:
12974 
        if ftype == TType.STRUCT:
12975 
          self.ex = TransactionServiceException()
12976 
          self.ex.read(iprot)
12977 
        else:
12978 
          iprot.skip(ftype)
12979 
      else:
12980 
        iprot.skip(ftype)
12981 
      iprot.readFieldEnd()
12982 
    iprot.readStructEnd()
12983 
 
12984 
  def write(self, oprot):
12985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12987 
      return
12988 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 12989 
    if self.success is not None:
2536 chandransh 12990 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12991 
      oprot.writeBool(self.success)
12992 
      oprot.writeFieldEnd()
3431 rajveer 12993 
    if self.ex is not None:
2536 chandransh 12994 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12995 
      self.ex.write(oprot)
12996 
      oprot.writeFieldEnd()
12997 
    oprot.writeFieldStop()
12998 
    oprot.writeStructEnd()
12999 
 
3431 rajveer 13000 
  def validate(self):
13001 
    return
13002 
 
13003 
 
2536 chandransh 13004 
  def __repr__(self):
13005 
    L = ['%s=%r' % (key, value)
13006 
      for key, value in self.__dict__.iteritems()]
13007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13008 
 
13009 
  def __eq__(self, other):
13010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13011 
 
13012 
  def __ne__(self, other):
13013 
    return not (self == other)
13014 
 
13015 
class authorizePickup_args:
13016 
  """
13017 
  Attributes:
13018 
   - orderId
13019 
   - pickupNumber
4602 rajveer 13020 
   - providerId
2536 chandransh 13021 
  """
13022 
 
13023 
  thrift_spec = (
13024 
    None, # 0
13025 
    (1, TType.I64, 'orderId', None, None, ), # 1
13026 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 13027 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 13028 
  )
13029 
 
4602 rajveer 13030 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 13031 
    self.orderId = orderId
13032 
    self.pickupNumber = pickupNumber
4602 rajveer 13033 
    self.providerId = providerId
2536 chandransh 13034 
 
13035 
  def read(self, iprot):
13036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13038 
      return
13039 
    iprot.readStructBegin()
13040 
    while True:
13041 
      (fname, ftype, fid) = iprot.readFieldBegin()
13042 
      if ftype == TType.STOP:
13043 
        break
13044 
      if fid == 1:
13045 
        if ftype == TType.I64:
13046 
          self.orderId = iprot.readI64();
13047 
        else:
13048 
          iprot.skip(ftype)
13049 
      elif fid == 2:
13050 
        if ftype == TType.STRING:
13051 
          self.pickupNumber = iprot.readString();
13052 
        else:
13053 
          iprot.skip(ftype)
4602 rajveer 13054 
      elif fid == 3:
13055 
        if ftype == TType.I64:
13056 
          self.providerId = iprot.readI64();
13057 
        else:
13058 
          iprot.skip(ftype)
2536 chandransh 13059 
      else:
13060 
        iprot.skip(ftype)
13061 
      iprot.readFieldEnd()
13062 
    iprot.readStructEnd()
13063 
 
13064 
  def write(self, oprot):
13065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13067 
      return
13068 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 13069 
    if self.orderId is not None:
2536 chandransh 13070 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13071 
      oprot.writeI64(self.orderId)
13072 
      oprot.writeFieldEnd()
3431 rajveer 13073 
    if self.pickupNumber is not None:
2536 chandransh 13074 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
13075 
      oprot.writeString(self.pickupNumber)
13076 
      oprot.writeFieldEnd()
4602 rajveer 13077 
    if self.providerId is not None:
13078 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
13079 
      oprot.writeI64(self.providerId)
13080 
      oprot.writeFieldEnd()
2536 chandransh 13081 
    oprot.writeFieldStop()
13082 
    oprot.writeStructEnd()
13083 
 
3431 rajveer 13084 
  def validate(self):
13085 
    return
13086 
 
13087 
 
2536 chandransh 13088 
  def __repr__(self):
13089 
    L = ['%s=%r' % (key, value)
13090 
      for key, value in self.__dict__.iteritems()]
13091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13092 
 
13093 
  def __eq__(self, other):
13094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13095 
 
13096 
  def __ne__(self, other):
13097 
    return not (self == other)
13098 
 
13099 
class authorizePickup_result:
13100 
  """
13101 
  Attributes:
13102 
   - success
13103 
   - ex
13104 
  """
13105 
 
13106 
  thrift_spec = (
13107 
    (0, TType.BOOL, 'success', None, None, ), # 0
13108 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13109 
  )
13110 
 
13111 
  def __init__(self, success=None, ex=None,):
13112 
    self.success = success
13113 
    self.ex = ex
13114 
 
13115 
  def read(self, iprot):
13116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13118 
      return
13119 
    iprot.readStructBegin()
13120 
    while True:
13121 
      (fname, ftype, fid) = iprot.readFieldBegin()
13122 
      if ftype == TType.STOP:
13123 
        break
13124 
      if fid == 0:
13125 
        if ftype == TType.BOOL:
13126 
          self.success = iprot.readBool();
13127 
        else:
13128 
          iprot.skip(ftype)
13129 
      elif fid == 1:
13130 
        if ftype == TType.STRUCT:
13131 
          self.ex = TransactionServiceException()
13132 
          self.ex.read(iprot)
13133 
        else:
13134 
          iprot.skip(ftype)
13135 
      else:
13136 
        iprot.skip(ftype)
13137 
      iprot.readFieldEnd()
13138 
    iprot.readStructEnd()
13139 
 
13140 
  def write(self, oprot):
13141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13143 
      return
13144 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 13145 
    if self.success is not None:
2536 chandransh 13146 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13147 
      oprot.writeBool(self.success)
13148 
      oprot.writeFieldEnd()
3431 rajveer 13149 
    if self.ex is not None:
2536 chandransh 13150 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13151 
      self.ex.write(oprot)
13152 
      oprot.writeFieldEnd()
13153 
    oprot.writeFieldStop()
13154 
    oprot.writeStructEnd()
13155 
 
3431 rajveer 13156 
  def validate(self):
13157 
    return
13158 
 
13159 
 
2536 chandransh 13160 
  def __repr__(self):
13161 
    L = ['%s=%r' % (key, value)
13162 
      for key, value in self.__dict__.iteritems()]
13163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13164 
 
13165 
  def __eq__(self, other):
13166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13167 
 
13168 
  def __ne__(self, other):
13169 
    return not (self == other)
13170 
 
2764 chandransh 13171 
class markDoasAsPickedUp_args:
13172 
  """
13173 
  Attributes:
13174 
   - providerId
13175 
   - pickupDetails
13176 
  """
13177 
 
13178 
  thrift_spec = (
13179 
    None, # 0
13180 
    (1, TType.I64, 'providerId', None, None, ), # 1
13181 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
13182 
  )
13183 
 
13184 
  def __init__(self, providerId=None, pickupDetails=None,):
13185 
    self.providerId = providerId
13186 
    self.pickupDetails = pickupDetails
13187 
 
13188 
  def read(self, iprot):
13189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13191 
      return
13192 
    iprot.readStructBegin()
13193 
    while True:
13194 
      (fname, ftype, fid) = iprot.readFieldBegin()
13195 
      if ftype == TType.STOP:
13196 
        break
13197 
      if fid == 1:
13198 
        if ftype == TType.I64:
13199 
          self.providerId = iprot.readI64();
13200 
        else:
13201 
          iprot.skip(ftype)
13202 
      elif fid == 2:
13203 
        if ftype == TType.MAP:
13204 
          self.pickupDetails = {}
4789 rajveer 13205 
          (_ktype212, _vtype213, _size211 ) = iprot.readMapBegin()
13206 
          for _i215 in xrange(_size211):
13207 
            _key216 = iprot.readString();
13208 
            _val217 = iprot.readString();
13209 
            self.pickupDetails[_key216] = _val217
2764 chandransh 13210 
          iprot.readMapEnd()
13211 
        else:
13212 
          iprot.skip(ftype)
13213 
      else:
13214 
        iprot.skip(ftype)
13215 
      iprot.readFieldEnd()
13216 
    iprot.readStructEnd()
13217 
 
13218 
  def write(self, oprot):
13219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13221 
      return
13222 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 13223 
    if self.providerId is not None:
2764 chandransh 13224 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13225 
      oprot.writeI64(self.providerId)
13226 
      oprot.writeFieldEnd()
3431 rajveer 13227 
    if self.pickupDetails is not None:
2764 chandransh 13228 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13229 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4789 rajveer 13230 
      for kiter218,viter219 in self.pickupDetails.items():
13231 
        oprot.writeString(kiter218)
13232 
        oprot.writeString(viter219)
2764 chandransh 13233 
      oprot.writeMapEnd()
13234 
      oprot.writeFieldEnd()
13235 
    oprot.writeFieldStop()
13236 
    oprot.writeStructEnd()
13237 
 
3431 rajveer 13238 
  def validate(self):
13239 
    return
13240 
 
13241 
 
2764 chandransh 13242 
  def __repr__(self):
13243 
    L = ['%s=%r' % (key, value)
13244 
      for key, value in self.__dict__.iteritems()]
13245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13246 
 
13247 
  def __eq__(self, other):
13248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13249 
 
13250 
  def __ne__(self, other):
13251 
    return not (self == other)
13252 
 
13253 
class markDoasAsPickedUp_result:
13254 
  """
13255 
  Attributes:
13256 
   - success
13257 
  """
13258 
 
13259 
  thrift_spec = (
13260 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13261 
  )
13262 
 
13263 
  def __init__(self, success=None,):
13264 
    self.success = success
13265 
 
13266 
  def read(self, iprot):
13267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13269 
      return
13270 
    iprot.readStructBegin()
13271 
    while True:
13272 
      (fname, ftype, fid) = iprot.readFieldBegin()
13273 
      if ftype == TType.STOP:
13274 
        break
13275 
      if fid == 0:
13276 
        if ftype == TType.LIST:
13277 
          self.success = []
4789 rajveer 13278 
          (_etype223, _size220) = iprot.readListBegin()
13279 
          for _i224 in xrange(_size220):
13280 
            _elem225 = Order()
13281 
            _elem225.read(iprot)
13282 
            self.success.append(_elem225)
2764 chandransh 13283 
          iprot.readListEnd()
13284 
        else:
13285 
          iprot.skip(ftype)
13286 
      else:
13287 
        iprot.skip(ftype)
13288 
      iprot.readFieldEnd()
13289 
    iprot.readStructEnd()
13290 
 
13291 
  def write(self, oprot):
13292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13294 
      return
13295 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 13296 
    if self.success is not None:
2764 chandransh 13297 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13298 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4789 rajveer 13299 
      for iter226 in self.success:
13300 
        iter226.write(oprot)
2764 chandransh 13301 
      oprot.writeListEnd()
13302 
      oprot.writeFieldEnd()
13303 
    oprot.writeFieldStop()
13304 
    oprot.writeStructEnd()
13305 
 
3431 rajveer 13306 
  def validate(self):
13307 
    return
13308 
 
13309 
 
2764 chandransh 13310 
  def __repr__(self):
13311 
    L = ['%s=%r' % (key, value)
13312 
      for key, value in self.__dict__.iteritems()]
13313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13314 
 
13315 
  def __eq__(self, other):
13316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13317 
 
13318 
  def __ne__(self, other):
13319 
    return not (self == other)
13320 
 
4741 phani.kuma 13321 
class markReturnOrdersAsPickedUp_args:
13322 
  """
13323 
  Attributes:
13324 
   - providerId
13325 
   - pickupDetails
13326 
  """
13327 
 
13328 
  thrift_spec = (
13329 
    None, # 0
13330 
    (1, TType.I64, 'providerId', None, None, ), # 1
13331 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
13332 
  )
13333 
 
13334 
  def __init__(self, providerId=None, pickupDetails=None,):
13335 
    self.providerId = providerId
13336 
    self.pickupDetails = pickupDetails
13337 
 
13338 
  def read(self, iprot):
13339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13341 
      return
13342 
    iprot.readStructBegin()
13343 
    while True:
13344 
      (fname, ftype, fid) = iprot.readFieldBegin()
13345 
      if ftype == TType.STOP:
13346 
        break
13347 
      if fid == 1:
13348 
        if ftype == TType.I64:
13349 
          self.providerId = iprot.readI64();
13350 
        else:
13351 
          iprot.skip(ftype)
13352 
      elif fid == 2:
13353 
        if ftype == TType.MAP:
13354 
          self.pickupDetails = {}
4789 rajveer 13355 
          (_ktype228, _vtype229, _size227 ) = iprot.readMapBegin()
13356 
          for _i231 in xrange(_size227):
13357 
            _key232 = iprot.readString();
13358 
            _val233 = iprot.readString();
13359 
            self.pickupDetails[_key232] = _val233
4741 phani.kuma 13360 
          iprot.readMapEnd()
13361 
        else:
13362 
          iprot.skip(ftype)
13363 
      else:
13364 
        iprot.skip(ftype)
13365 
      iprot.readFieldEnd()
13366 
    iprot.readStructEnd()
13367 
 
13368 
  def write(self, oprot):
13369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13371 
      return
13372 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
13373 
    if self.providerId is not None:
13374 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13375 
      oprot.writeI64(self.providerId)
13376 
      oprot.writeFieldEnd()
13377 
    if self.pickupDetails is not None:
13378 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13379 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4789 rajveer 13380 
      for kiter234,viter235 in self.pickupDetails.items():
13381 
        oprot.writeString(kiter234)
13382 
        oprot.writeString(viter235)
4741 phani.kuma 13383 
      oprot.writeMapEnd()
13384 
      oprot.writeFieldEnd()
13385 
    oprot.writeFieldStop()
13386 
    oprot.writeStructEnd()
13387 
 
13388 
  def validate(self):
13389 
    return
13390 
 
13391 
 
13392 
  def __repr__(self):
13393 
    L = ['%s=%r' % (key, value)
13394 
      for key, value in self.__dict__.iteritems()]
13395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13396 
 
13397 
  def __eq__(self, other):
13398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13399 
 
13400 
  def __ne__(self, other):
13401 
    return not (self == other)
13402 
 
13403 
class markReturnOrdersAsPickedUp_result:
13404 
  """
13405 
  Attributes:
13406 
   - success
13407 
  """
13408 
 
13409 
  thrift_spec = (
13410 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13411 
  )
13412 
 
13413 
  def __init__(self, success=None,):
13414 
    self.success = success
13415 
 
13416 
  def read(self, iprot):
13417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13419 
      return
13420 
    iprot.readStructBegin()
13421 
    while True:
13422 
      (fname, ftype, fid) = iprot.readFieldBegin()
13423 
      if ftype == TType.STOP:
13424 
        break
13425 
      if fid == 0:
13426 
        if ftype == TType.LIST:
13427 
          self.success = []
4789 rajveer 13428 
          (_etype239, _size236) = iprot.readListBegin()
13429 
          for _i240 in xrange(_size236):
13430 
            _elem241 = Order()
13431 
            _elem241.read(iprot)
13432 
            self.success.append(_elem241)
4741 phani.kuma 13433 
          iprot.readListEnd()
13434 
        else:
13435 
          iprot.skip(ftype)
13436 
      else:
13437 
        iprot.skip(ftype)
13438 
      iprot.readFieldEnd()
13439 
    iprot.readStructEnd()
13440 
 
13441 
  def write(self, oprot):
13442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13444 
      return
13445 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
13446 
    if self.success is not None:
13447 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13448 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4789 rajveer 13449 
      for iter242 in self.success:
13450 
        iter242.write(oprot)
4741 phani.kuma 13451 
      oprot.writeListEnd()
13452 
      oprot.writeFieldEnd()
13453 
    oprot.writeFieldStop()
13454 
    oprot.writeStructEnd()
13455 
 
13456 
  def validate(self):
13457 
    return
13458 
 
13459 
 
13460 
  def __repr__(self):
13461 
    L = ['%s=%r' % (key, value)
13462 
      for key, value in self.__dict__.iteritems()]
13463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13464 
 
13465 
  def __eq__(self, other):
13466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13467 
 
13468 
  def __ne__(self, other):
13469 
    return not (self == other)
13470 
 
2616 chandransh 13471 
class receiveReturn_args:
2591 chandransh 13472 
  """
13473 
  Attributes:
13474 
   - orderId
4479 rajveer 13475 
   - receiveCondition
2591 chandransh 13476 
  """
2536 chandransh 13477 
 
2591 chandransh 13478 
  thrift_spec = (
13479 
    None, # 0
13480 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 13481 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 13482 
  )
13483 
 
4479 rajveer 13484 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 13485 
    self.orderId = orderId
4479 rajveer 13486 
    self.receiveCondition = receiveCondition
2591 chandransh 13487 
 
13488 
  def read(self, iprot):
13489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13491 
      return
13492 
    iprot.readStructBegin()
13493 
    while True:
13494 
      (fname, ftype, fid) = iprot.readFieldBegin()
13495 
      if ftype == TType.STOP:
13496 
        break
13497 
      if fid == 1:
13498 
        if ftype == TType.I64:
13499 
          self.orderId = iprot.readI64();
13500 
        else:
13501 
          iprot.skip(ftype)
4479 rajveer 13502 
      elif fid == 2:
13503 
        if ftype == TType.I64:
13504 
          self.receiveCondition = iprot.readI64();
13505 
        else:
13506 
          iprot.skip(ftype)
2591 chandransh 13507 
      else:
13508 
        iprot.skip(ftype)
13509 
      iprot.readFieldEnd()
13510 
    iprot.readStructEnd()
13511 
 
13512 
  def write(self, oprot):
13513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13515 
      return
2616 chandransh 13516 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 13517 
    if self.orderId is not None:
2591 chandransh 13518 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13519 
      oprot.writeI64(self.orderId)
13520 
      oprot.writeFieldEnd()
4479 rajveer 13521 
    if self.receiveCondition is not None:
13522 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
13523 
      oprot.writeI64(self.receiveCondition)
13524 
      oprot.writeFieldEnd()
2591 chandransh 13525 
    oprot.writeFieldStop()
13526 
    oprot.writeStructEnd()
13527 
 
3431 rajveer 13528 
  def validate(self):
13529 
    return
13530 
 
13531 
 
2591 chandransh 13532 
  def __repr__(self):
13533 
    L = ['%s=%r' % (key, value)
13534 
      for key, value in self.__dict__.iteritems()]
13535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13536 
 
13537 
  def __eq__(self, other):
13538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13539 
 
13540 
  def __ne__(self, other):
13541 
    return not (self == other)
13542 
 
2616 chandransh 13543 
class receiveReturn_result:
2591 chandransh 13544 
  """
13545 
  Attributes:
13546 
   - success
13547 
   - ex
13548 
  """
13549 
 
13550 
  thrift_spec = (
13551 
    (0, TType.BOOL, 'success', None, None, ), # 0
13552 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13553 
  )
13554 
 
13555 
  def __init__(self, success=None, ex=None,):
13556 
    self.success = success
13557 
    self.ex = ex
13558 
 
13559 
  def read(self, iprot):
13560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13562 
      return
13563 
    iprot.readStructBegin()
13564 
    while True:
13565 
      (fname, ftype, fid) = iprot.readFieldBegin()
13566 
      if ftype == TType.STOP:
13567 
        break
13568 
      if fid == 0:
13569 
        if ftype == TType.BOOL:
13570 
          self.success = iprot.readBool();
13571 
        else:
13572 
          iprot.skip(ftype)
13573 
      elif fid == 1:
13574 
        if ftype == TType.STRUCT:
13575 
          self.ex = TransactionServiceException()
13576 
          self.ex.read(iprot)
13577 
        else:
13578 
          iprot.skip(ftype)
13579 
      else:
13580 
        iprot.skip(ftype)
13581 
      iprot.readFieldEnd()
13582 
    iprot.readStructEnd()
13583 
 
13584 
  def write(self, oprot):
13585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13587 
      return
2616 chandransh 13588 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 13589 
    if self.success is not None:
2591 chandransh 13590 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13591 
      oprot.writeBool(self.success)
13592 
      oprot.writeFieldEnd()
3431 rajveer 13593 
    if self.ex is not None:
2591 chandransh 13594 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13595 
      self.ex.write(oprot)
13596 
      oprot.writeFieldEnd()
13597 
    oprot.writeFieldStop()
13598 
    oprot.writeStructEnd()
13599 
 
3431 rajveer 13600 
  def validate(self):
13601 
    return
13602 
 
13603 
 
2591 chandransh 13604 
  def __repr__(self):
13605 
    L = ['%s=%r' % (key, value)
13606 
      for key, value in self.__dict__.iteritems()]
13607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13608 
 
13609 
  def __eq__(self, other):
13610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13611 
 
13612 
  def __ne__(self, other):
13613 
    return not (self == other)
13614 
 
13615 
class validateDoa_args:
13616 
  """
13617 
  Attributes:
13618 
   - orderId
13619 
   - isValid
13620 
  """
13621 
 
13622 
  thrift_spec = (
13623 
    None, # 0
13624 
    (1, TType.I64, 'orderId', None, None, ), # 1
13625 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
13626 
  )
13627 
 
13628 
  def __init__(self, orderId=None, isValid=None,):
13629 
    self.orderId = orderId
13630 
    self.isValid = isValid
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)
13646 
      elif fid == 2:
13647 
        if ftype == TType.BOOL:
13648 
          self.isValid = iprot.readBool();
13649 
        else:
13650 
          iprot.skip(ftype)
13651 
      else:
13652 
        iprot.skip(ftype)
13653 
      iprot.readFieldEnd()
13654 
    iprot.readStructEnd()
13655 
 
13656 
  def write(self, oprot):
13657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13659 
      return
13660 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 13661 
    if self.orderId is not None:
2591 chandransh 13662 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13663 
      oprot.writeI64(self.orderId)
13664 
      oprot.writeFieldEnd()
3431 rajveer 13665 
    if self.isValid is not None:
2591 chandransh 13666 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
13667 
      oprot.writeBool(self.isValid)
13668 
      oprot.writeFieldEnd()
13669 
    oprot.writeFieldStop()
13670 
    oprot.writeStructEnd()
13671 
 
3431 rajveer 13672 
  def validate(self):
13673 
    return
13674 
 
13675 
 
2591 chandransh 13676 
  def __repr__(self):
13677 
    L = ['%s=%r' % (key, value)
13678 
      for key, value in self.__dict__.iteritems()]
13679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13680 
 
13681 
  def __eq__(self, other):
13682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13683 
 
13684 
  def __ne__(self, other):
13685 
    return not (self == other)
13686 
 
13687 
class validateDoa_result:
13688 
  """
13689 
  Attributes:
13690 
   - success
13691 
   - ex
13692 
  """
13693 
 
13694 
  thrift_spec = (
13695 
    (0, TType.BOOL, 'success', None, None, ), # 0
13696 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13697 
  )
13698 
 
13699 
  def __init__(self, success=None, ex=None,):
13700 
    self.success = success
13701 
    self.ex = ex
13702 
 
13703 
  def read(self, iprot):
13704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13706 
      return
13707 
    iprot.readStructBegin()
13708 
    while True:
13709 
      (fname, ftype, fid) = iprot.readFieldBegin()
13710 
      if ftype == TType.STOP:
13711 
        break
13712 
      if fid == 0:
13713 
        if ftype == TType.BOOL:
13714 
          self.success = iprot.readBool();
13715 
        else:
13716 
          iprot.skip(ftype)
13717 
      elif fid == 1:
13718 
        if ftype == TType.STRUCT:
13719 
          self.ex = TransactionServiceException()
13720 
          self.ex.read(iprot)
13721 
        else:
13722 
          iprot.skip(ftype)
13723 
      else:
13724 
        iprot.skip(ftype)
13725 
      iprot.readFieldEnd()
13726 
    iprot.readStructEnd()
13727 
 
13728 
  def write(self, oprot):
13729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13731 
      return
13732 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 13733 
    if self.success is not None:
2591 chandransh 13734 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13735 
      oprot.writeBool(self.success)
13736 
      oprot.writeFieldEnd()
3431 rajveer 13737 
    if self.ex is not None:
2591 chandransh 13738 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13739 
      self.ex.write(oprot)
13740 
      oprot.writeFieldEnd()
13741 
    oprot.writeFieldStop()
13742 
    oprot.writeStructEnd()
13743 
 
3431 rajveer 13744 
  def validate(self):
13745 
    return
13746 
 
13747 
 
2591 chandransh 13748 
  def __repr__(self):
13749 
    L = ['%s=%r' % (key, value)
13750 
      for key, value in self.__dict__.iteritems()]
13751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13752 
 
13753 
  def __eq__(self, other):
13754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13755 
 
13756 
  def __ne__(self, other):
13757 
    return not (self == other)
13758 
 
4495 rajveer 13759 
class validateReturnProduct_args:
13760 
  """
13761 
  Attributes:
13762 
   - orderId
13763 
   - isUsable
13764 
  """
13765 
 
13766 
  thrift_spec = (
13767 
    None, # 0
13768 
    (1, TType.I64, 'orderId', None, None, ), # 1
13769 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
13770 
  )
13771 
 
13772 
  def __init__(self, orderId=None, isUsable=None,):
13773 
    self.orderId = orderId
13774 
    self.isUsable = isUsable
13775 
 
13776 
  def read(self, iprot):
13777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13779 
      return
13780 
    iprot.readStructBegin()
13781 
    while True:
13782 
      (fname, ftype, fid) = iprot.readFieldBegin()
13783 
      if ftype == TType.STOP:
13784 
        break
13785 
      if fid == 1:
13786 
        if ftype == TType.I64:
13787 
          self.orderId = iprot.readI64();
13788 
        else:
13789 
          iprot.skip(ftype)
13790 
      elif fid == 2:
13791 
        if ftype == TType.BOOL:
13792 
          self.isUsable = iprot.readBool();
13793 
        else:
13794 
          iprot.skip(ftype)
13795 
      else:
13796 
        iprot.skip(ftype)
13797 
      iprot.readFieldEnd()
13798 
    iprot.readStructEnd()
13799 
 
13800 
  def write(self, oprot):
13801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13803 
      return
13804 
    oprot.writeStructBegin('validateReturnProduct_args')
13805 
    if self.orderId is not None:
13806 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13807 
      oprot.writeI64(self.orderId)
13808 
      oprot.writeFieldEnd()
13809 
    if self.isUsable is not None:
13810 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
13811 
      oprot.writeBool(self.isUsable)
13812 
      oprot.writeFieldEnd()
13813 
    oprot.writeFieldStop()
13814 
    oprot.writeStructEnd()
13815 
 
13816 
  def validate(self):
13817 
    return
13818 
 
13819 
 
13820 
  def __repr__(self):
13821 
    L = ['%s=%r' % (key, value)
13822 
      for key, value in self.__dict__.iteritems()]
13823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13824 
 
13825 
  def __eq__(self, other):
13826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13827 
 
13828 
  def __ne__(self, other):
13829 
    return not (self == other)
13830 
 
13831 
class validateReturnProduct_result:
13832 
  """
13833 
  Attributes:
13834 
   - success
13835 
   - ex
13836 
  """
13837 
 
13838 
  thrift_spec = (
13839 
    (0, TType.BOOL, 'success', None, None, ), # 0
13840 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13841 
  )
13842 
 
13843 
  def __init__(self, success=None, ex=None,):
13844 
    self.success = success
13845 
    self.ex = ex
13846 
 
13847 
  def read(self, iprot):
13848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13850 
      return
13851 
    iprot.readStructBegin()
13852 
    while True:
13853 
      (fname, ftype, fid) = iprot.readFieldBegin()
13854 
      if ftype == TType.STOP:
13855 
        break
13856 
      if fid == 0:
13857 
        if ftype == TType.BOOL:
13858 
          self.success = iprot.readBool();
13859 
        else:
13860 
          iprot.skip(ftype)
13861 
      elif fid == 1:
13862 
        if ftype == TType.STRUCT:
13863 
          self.ex = TransactionServiceException()
13864 
          self.ex.read(iprot)
13865 
        else:
13866 
          iprot.skip(ftype)
13867 
      else:
13868 
        iprot.skip(ftype)
13869 
      iprot.readFieldEnd()
13870 
    iprot.readStructEnd()
13871 
 
13872 
  def write(self, oprot):
13873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13875 
      return
13876 
    oprot.writeStructBegin('validateReturnProduct_result')
13877 
    if self.success is not None:
13878 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13879 
      oprot.writeBool(self.success)
13880 
      oprot.writeFieldEnd()
13881 
    if self.ex is not None:
13882 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13883 
      self.ex.write(oprot)
13884 
      oprot.writeFieldEnd()
13885 
    oprot.writeFieldStop()
13886 
    oprot.writeStructEnd()
13887 
 
13888 
  def validate(self):
13889 
    return
13890 
 
13891 
 
13892 
  def __repr__(self):
13893 
    L = ['%s=%r' % (key, value)
13894 
      for key, value in self.__dict__.iteritems()]
13895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13896 
 
13897 
  def __eq__(self, other):
13898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13899 
 
13900 
  def __ne__(self, other):
13901 
    return not (self == other)
13902 
 
2616 chandransh 13903 
class reshipOrder_args:
13904 
  """
13905 
  Attributes:
13906 
   - orderId
13907 
  """
2591 chandransh 13908 
 
2616 chandransh 13909 
  thrift_spec = (
13910 
    None, # 0
13911 
    (1, TType.I64, 'orderId', None, None, ), # 1
13912 
  )
13913 
 
13914 
  def __init__(self, orderId=None,):
13915 
    self.orderId = orderId
13916 
 
13917 
  def read(self, iprot):
13918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13920 
      return
13921 
    iprot.readStructBegin()
13922 
    while True:
13923 
      (fname, ftype, fid) = iprot.readFieldBegin()
13924 
      if ftype == TType.STOP:
13925 
        break
13926 
      if fid == 1:
13927 
        if ftype == TType.I64:
13928 
          self.orderId = iprot.readI64();
13929 
        else:
13930 
          iprot.skip(ftype)
13931 
      else:
13932 
        iprot.skip(ftype)
13933 
      iprot.readFieldEnd()
13934 
    iprot.readStructEnd()
13935 
 
13936 
  def write(self, oprot):
13937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13939 
      return
13940 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 13941 
    if self.orderId is not None:
2616 chandransh 13942 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13943 
      oprot.writeI64(self.orderId)
13944 
      oprot.writeFieldEnd()
13945 
    oprot.writeFieldStop()
13946 
    oprot.writeStructEnd()
13947 
 
3431 rajveer 13948 
  def validate(self):
13949 
    return
13950 
 
13951 
 
2616 chandransh 13952 
  def __repr__(self):
13953 
    L = ['%s=%r' % (key, value)
13954 
      for key, value in self.__dict__.iteritems()]
13955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13956 
 
13957 
  def __eq__(self, other):
13958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13959 
 
13960 
  def __ne__(self, other):
13961 
    return not (self == other)
13962 
 
13963 
class reshipOrder_result:
13964 
  """
13965 
  Attributes:
13966 
   - success
13967 
   - ex
13968 
  """
13969 
 
13970 
  thrift_spec = (
13971 
    (0, TType.I64, 'success', None, None, ), # 0
13972 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13973 
  )
13974 
 
13975 
  def __init__(self, success=None, ex=None,):
13976 
    self.success = success
13977 
    self.ex = ex
13978 
 
13979 
  def read(self, iprot):
13980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13982 
      return
13983 
    iprot.readStructBegin()
13984 
    while True:
13985 
      (fname, ftype, fid) = iprot.readFieldBegin()
13986 
      if ftype == TType.STOP:
13987 
        break
13988 
      if fid == 0:
13989 
        if ftype == TType.I64:
13990 
          self.success = iprot.readI64();
13991 
        else:
13992 
          iprot.skip(ftype)
13993 
      elif fid == 1:
13994 
        if ftype == TType.STRUCT:
13995 
          self.ex = TransactionServiceException()
13996 
          self.ex.read(iprot)
13997 
        else:
13998 
          iprot.skip(ftype)
13999 
      else:
14000 
        iprot.skip(ftype)
14001 
      iprot.readFieldEnd()
14002 
    iprot.readStructEnd()
14003 
 
14004 
  def write(self, oprot):
14005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14007 
      return
14008 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 14009 
    if self.success is not None:
2616 chandransh 14010 
      oprot.writeFieldBegin('success', TType.I64, 0)
14011 
      oprot.writeI64(self.success)
14012 
      oprot.writeFieldEnd()
3431 rajveer 14013 
    if self.ex is not None:
2616 chandransh 14014 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14015 
      self.ex.write(oprot)
14016 
      oprot.writeFieldEnd()
14017 
    oprot.writeFieldStop()
14018 
    oprot.writeStructEnd()
14019 
 
3431 rajveer 14020 
  def validate(self):
14021 
    return
14022 
 
14023 
 
2616 chandransh 14024 
  def __repr__(self):
14025 
    L = ['%s=%r' % (key, value)
14026 
      for key, value in self.__dict__.iteritems()]
14027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14028 
 
14029 
  def __eq__(self, other):
14030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14031 
 
14032 
  def __ne__(self, other):
14033 
    return not (self == other)
14034 
 
14035 
class refundOrder_args:
14036 
  """
14037 
  Attributes:
14038 
   - orderId
3226 chandransh 14039 
   - refundedBy
14040 
   - reason
2616 chandransh 14041 
  """
14042 
 
14043 
  thrift_spec = (
14044 
    None, # 0
14045 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 14046 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
14047 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 14048 
  )
14049 
 
3226 chandransh 14050 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 14051 
    self.orderId = orderId
3226 chandransh 14052 
    self.refundedBy = refundedBy
14053 
    self.reason = reason
2616 chandransh 14054 
 
14055 
  def read(self, iprot):
14056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14058 
      return
14059 
    iprot.readStructBegin()
14060 
    while True:
14061 
      (fname, ftype, fid) = iprot.readFieldBegin()
14062 
      if ftype == TType.STOP:
14063 
        break
14064 
      if fid == 1:
14065 
        if ftype == TType.I64:
14066 
          self.orderId = iprot.readI64();
14067 
        else:
14068 
          iprot.skip(ftype)
3226 chandransh 14069 
      elif fid == 2:
14070 
        if ftype == TType.STRING:
14071 
          self.refundedBy = iprot.readString();
14072 
        else:
14073 
          iprot.skip(ftype)
14074 
      elif fid == 3:
14075 
        if ftype == TType.STRING:
14076 
          self.reason = iprot.readString();
14077 
        else:
14078 
          iprot.skip(ftype)
2616 chandransh 14079 
      else:
14080 
        iprot.skip(ftype)
14081 
      iprot.readFieldEnd()
14082 
    iprot.readStructEnd()
14083 
 
14084 
  def write(self, oprot):
14085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14087 
      return
14088 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 14089 
    if self.orderId is not None:
2616 chandransh 14090 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14091 
      oprot.writeI64(self.orderId)
14092 
      oprot.writeFieldEnd()
3431 rajveer 14093 
    if self.refundedBy is not None:
3226 chandransh 14094 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
14095 
      oprot.writeString(self.refundedBy)
14096 
      oprot.writeFieldEnd()
3431 rajveer 14097 
    if self.reason is not None:
3226 chandransh 14098 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14099 
      oprot.writeString(self.reason)
14100 
      oprot.writeFieldEnd()
2616 chandransh 14101 
    oprot.writeFieldStop()
14102 
    oprot.writeStructEnd()
14103 
 
3431 rajveer 14104 
  def validate(self):
14105 
    return
14106 
 
14107 
 
2616 chandransh 14108 
  def __repr__(self):
14109 
    L = ['%s=%r' % (key, value)
14110 
      for key, value in self.__dict__.iteritems()]
14111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14112 
 
14113 
  def __eq__(self, other):
14114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14115 
 
14116 
  def __ne__(self, other):
14117 
    return not (self == other)
14118 
 
14119 
class refundOrder_result:
14120 
  """
14121 
  Attributes:
14122 
   - success
14123 
   - ex
14124 
  """
14125 
 
14126 
  thrift_spec = (
14127 
    (0, TType.BOOL, 'success', None, None, ), # 0
14128 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14129 
  )
14130 
 
14131 
  def __init__(self, success=None, ex=None,):
14132 
    self.success = success
14133 
    self.ex = ex
14134 
 
14135 
  def read(self, iprot):
14136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14138 
      return
14139 
    iprot.readStructBegin()
14140 
    while True:
14141 
      (fname, ftype, fid) = iprot.readFieldBegin()
14142 
      if ftype == TType.STOP:
14143 
        break
14144 
      if fid == 0:
14145 
        if ftype == TType.BOOL:
14146 
          self.success = iprot.readBool();
14147 
        else:
14148 
          iprot.skip(ftype)
14149 
      elif fid == 1:
14150 
        if ftype == TType.STRUCT:
14151 
          self.ex = TransactionServiceException()
14152 
          self.ex.read(iprot)
14153 
        else:
14154 
          iprot.skip(ftype)
14155 
      else:
14156 
        iprot.skip(ftype)
14157 
      iprot.readFieldEnd()
14158 
    iprot.readStructEnd()
14159 
 
14160 
  def write(self, oprot):
14161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14163 
      return
14164 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 14165 
    if self.success is not None:
2616 chandransh 14166 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14167 
      oprot.writeBool(self.success)
14168 
      oprot.writeFieldEnd()
3431 rajveer 14169 
    if self.ex is not None:
2616 chandransh 14170 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14171 
      self.ex.write(oprot)
14172 
      oprot.writeFieldEnd()
14173 
    oprot.writeFieldStop()
14174 
    oprot.writeStructEnd()
14175 
 
3431 rajveer 14176 
  def validate(self):
14177 
    return
14178 
 
14179 
 
2616 chandransh 14180 
  def __repr__(self):
14181 
    L = ['%s=%r' % (key, value)
14182 
      for key, value in self.__dict__.iteritems()]
14183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14184 
 
14185 
  def __eq__(self, other):
14186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14187 
 
14188 
  def __ne__(self, other):
14189 
    return not (self == other)
14190 
 
2690 chandransh 14191 
class getReturnOrders_args:
14192 
  """
14193 
  Attributes:
14194 
   - warehouseId
14195 
   - fromDate
14196 
   - toDate
14197 
  """
2616 chandransh 14198 
 
2690 chandransh 14199 
  thrift_spec = (
14200 
    None, # 0
14201 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14202 
    (2, TType.I64, 'fromDate', None, None, ), # 2
14203 
    (3, TType.I64, 'toDate', None, None, ), # 3
14204 
  )
14205 
 
14206 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
14207 
    self.warehouseId = warehouseId
14208 
    self.fromDate = fromDate
14209 
    self.toDate = toDate
14210 
 
14211 
  def read(self, iprot):
14212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14214 
      return
14215 
    iprot.readStructBegin()
14216 
    while True:
14217 
      (fname, ftype, fid) = iprot.readFieldBegin()
14218 
      if ftype == TType.STOP:
14219 
        break
14220 
      if fid == 1:
14221 
        if ftype == TType.I64:
14222 
          self.warehouseId = iprot.readI64();
14223 
        else:
14224 
          iprot.skip(ftype)
14225 
      elif fid == 2:
14226 
        if ftype == TType.I64:
14227 
          self.fromDate = iprot.readI64();
14228 
        else:
14229 
          iprot.skip(ftype)
14230 
      elif fid == 3:
14231 
        if ftype == TType.I64:
14232 
          self.toDate = iprot.readI64();
14233 
        else:
14234 
          iprot.skip(ftype)
14235 
      else:
14236 
        iprot.skip(ftype)
14237 
      iprot.readFieldEnd()
14238 
    iprot.readStructEnd()
14239 
 
14240 
  def write(self, oprot):
14241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14243 
      return
14244 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 14245 
    if self.warehouseId is not None:
2690 chandransh 14246 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14247 
      oprot.writeI64(self.warehouseId)
14248 
      oprot.writeFieldEnd()
3431 rajveer 14249 
    if self.fromDate is not None:
2690 chandransh 14250 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
14251 
      oprot.writeI64(self.fromDate)
14252 
      oprot.writeFieldEnd()
3431 rajveer 14253 
    if self.toDate is not None:
2690 chandransh 14254 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
14255 
      oprot.writeI64(self.toDate)
14256 
      oprot.writeFieldEnd()
14257 
    oprot.writeFieldStop()
14258 
    oprot.writeStructEnd()
14259 
 
3431 rajveer 14260 
  def validate(self):
14261 
    return
14262 
 
14263 
 
2690 chandransh 14264 
  def __repr__(self):
14265 
    L = ['%s=%r' % (key, value)
14266 
      for key, value in self.__dict__.iteritems()]
14267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14268 
 
14269 
  def __eq__(self, other):
14270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14271 
 
14272 
  def __ne__(self, other):
14273 
    return not (self == other)
14274 
 
14275 
class getReturnOrders_result:
14276 
  """
14277 
  Attributes:
14278 
   - success
14279 
  """
14280 
 
14281 
  thrift_spec = (
14282 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
14283 
  )
14284 
 
14285 
  def __init__(self, success=None,):
14286 
    self.success = success
14287 
 
14288 
  def read(self, iprot):
14289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14291 
      return
14292 
    iprot.readStructBegin()
14293 
    while True:
14294 
      (fname, ftype, fid) = iprot.readFieldBegin()
14295 
      if ftype == TType.STOP:
14296 
        break
14297 
      if fid == 0:
14298 
        if ftype == TType.LIST:
14299 
          self.success = []
4789 rajveer 14300 
          (_etype246, _size243) = iprot.readListBegin()
14301 
          for _i247 in xrange(_size243):
14302 
            _elem248 = ReturnOrder()
14303 
            _elem248.read(iprot)
14304 
            self.success.append(_elem248)
2690 chandransh 14305 
          iprot.readListEnd()
14306 
        else:
14307 
          iprot.skip(ftype)
14308 
      else:
14309 
        iprot.skip(ftype)
14310 
      iprot.readFieldEnd()
14311 
    iprot.readStructEnd()
14312 
 
14313 
  def write(self, oprot):
14314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14316 
      return
14317 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 14318 
    if self.success is not None:
2690 chandransh 14319 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14320 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4789 rajveer 14321 
      for iter249 in self.success:
14322 
        iter249.write(oprot)
2690 chandransh 14323 
      oprot.writeListEnd()
14324 
      oprot.writeFieldEnd()
14325 
    oprot.writeFieldStop()
14326 
    oprot.writeStructEnd()
14327 
 
3431 rajveer 14328 
  def validate(self):
14329 
    return
14330 
 
14331 
 
2690 chandransh 14332 
  def __repr__(self):
14333 
    L = ['%s=%r' % (key, value)
14334 
      for key, value in self.__dict__.iteritems()]
14335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14336 
 
14337 
  def __eq__(self, other):
14338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14339 
 
14340 
  def __ne__(self, other):
14341 
    return not (self == other)
14342 
 
2700 chandransh 14343 
class getReturnOrder_args:
14344 
  """
14345 
  Attributes:
14346 
   - id
14347 
  """
14348 
 
14349 
  thrift_spec = (
14350 
    None, # 0
14351 
    (1, TType.I64, 'id', None, None, ), # 1
14352 
  )
14353 
 
14354 
  def __init__(self, id=None,):
14355 
    self.id = id
14356 
 
14357 
  def read(self, iprot):
14358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14360 
      return
14361 
    iprot.readStructBegin()
14362 
    while True:
14363 
      (fname, ftype, fid) = iprot.readFieldBegin()
14364 
      if ftype == TType.STOP:
14365 
        break
14366 
      if fid == 1:
14367 
        if ftype == TType.I64:
14368 
          self.id = iprot.readI64();
14369 
        else:
14370 
          iprot.skip(ftype)
14371 
      else:
14372 
        iprot.skip(ftype)
14373 
      iprot.readFieldEnd()
14374 
    iprot.readStructEnd()
14375 
 
14376 
  def write(self, oprot):
14377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14379 
      return
14380 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 14381 
    if self.id is not None:
2700 chandransh 14382 
      oprot.writeFieldBegin('id', TType.I64, 1)
14383 
      oprot.writeI64(self.id)
14384 
      oprot.writeFieldEnd()
14385 
    oprot.writeFieldStop()
14386 
    oprot.writeStructEnd()
14387 
 
3431 rajveer 14388 
  def validate(self):
14389 
    return
14390 
 
14391 
 
2700 chandransh 14392 
  def __repr__(self):
14393 
    L = ['%s=%r' % (key, value)
14394 
      for key, value in self.__dict__.iteritems()]
14395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14396 
 
14397 
  def __eq__(self, other):
14398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14399 
 
14400 
  def __ne__(self, other):
14401 
    return not (self == other)
14402 
 
14403 
class getReturnOrder_result:
14404 
  """
14405 
  Attributes:
14406 
   - success
14407 
   - ex
14408 
  """
14409 
 
14410 
  thrift_spec = (
14411 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
14412 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14413 
  )
14414 
 
14415 
  def __init__(self, success=None, ex=None,):
14416 
    self.success = success
14417 
    self.ex = ex
14418 
 
14419 
  def read(self, iprot):
14420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14422 
      return
14423 
    iprot.readStructBegin()
14424 
    while True:
14425 
      (fname, ftype, fid) = iprot.readFieldBegin()
14426 
      if ftype == TType.STOP:
14427 
        break
14428 
      if fid == 0:
14429 
        if ftype == TType.STRUCT:
14430 
          self.success = ReturnOrder()
14431 
          self.success.read(iprot)
14432 
        else:
14433 
          iprot.skip(ftype)
14434 
      elif fid == 1:
14435 
        if ftype == TType.STRUCT:
14436 
          self.ex = TransactionServiceException()
14437 
          self.ex.read(iprot)
14438 
        else:
14439 
          iprot.skip(ftype)
14440 
      else:
14441 
        iprot.skip(ftype)
14442 
      iprot.readFieldEnd()
14443 
    iprot.readStructEnd()
14444 
 
14445 
  def write(self, oprot):
14446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14448 
      return
14449 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 14450 
    if self.success is not None:
2700 chandransh 14451 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14452 
      self.success.write(oprot)
14453 
      oprot.writeFieldEnd()
3431 rajveer 14454 
    if self.ex is not None:
2700 chandransh 14455 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14456 
      self.ex.write(oprot)
14457 
      oprot.writeFieldEnd()
14458 
    oprot.writeFieldStop()
14459 
    oprot.writeStructEnd()
14460 
 
3431 rajveer 14461 
  def validate(self):
14462 
    return
14463 
 
14464 
 
2700 chandransh 14465 
  def __repr__(self):
14466 
    L = ['%s=%r' % (key, value)
14467 
      for key, value in self.__dict__.iteritems()]
14468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14469 
 
14470 
  def __eq__(self, other):
14471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14472 
 
14473 
  def __ne__(self, other):
14474 
    return not (self == other)
14475 
 
2690 chandransh 14476 
class processReturn_args:
14477 
  """
14478 
  Attributes:
14479 
   - returnOrderId
14480 
  """
14481 
 
14482 
  thrift_spec = (
14483 
    None, # 0
14484 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
14485 
  )
14486 
 
14487 
  def __init__(self, returnOrderId=None,):
14488 
    self.returnOrderId = returnOrderId
14489 
 
14490 
  def read(self, iprot):
14491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14493 
      return
14494 
    iprot.readStructBegin()
14495 
    while True:
14496 
      (fname, ftype, fid) = iprot.readFieldBegin()
14497 
      if ftype == TType.STOP:
14498 
        break
14499 
      if fid == 1:
14500 
        if ftype == TType.I64:
14501 
          self.returnOrderId = iprot.readI64();
14502 
        else:
14503 
          iprot.skip(ftype)
14504 
      else:
14505 
        iprot.skip(ftype)
14506 
      iprot.readFieldEnd()
14507 
    iprot.readStructEnd()
14508 
 
14509 
  def write(self, oprot):
14510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14512 
      return
14513 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 14514 
    if self.returnOrderId is not None:
2690 chandransh 14515 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
14516 
      oprot.writeI64(self.returnOrderId)
14517 
      oprot.writeFieldEnd()
14518 
    oprot.writeFieldStop()
14519 
    oprot.writeStructEnd()
14520 
 
3431 rajveer 14521 
  def validate(self):
14522 
    return
14523 
 
14524 
 
2690 chandransh 14525 
  def __repr__(self):
14526 
    L = ['%s=%r' % (key, value)
14527 
      for key, value in self.__dict__.iteritems()]
14528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14529 
 
14530 
  def __eq__(self, other):
14531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14532 
 
14533 
  def __ne__(self, other):
14534 
    return not (self == other)
14535 
 
14536 
class processReturn_result:
14537 
  """
14538 
  Attributes:
14539 
   - ex
14540 
  """
14541 
 
14542 
  thrift_spec = (
14543 
    None, # 0
14544 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14545 
  )
14546 
 
14547 
  def __init__(self, ex=None,):
14548 
    self.ex = ex
14549 
 
14550 
  def read(self, iprot):
14551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14553 
      return
14554 
    iprot.readStructBegin()
14555 
    while True:
14556 
      (fname, ftype, fid) = iprot.readFieldBegin()
14557 
      if ftype == TType.STOP:
14558 
        break
14559 
      if fid == 1:
14560 
        if ftype == TType.STRUCT:
14561 
          self.ex = TransactionServiceException()
14562 
          self.ex.read(iprot)
14563 
        else:
14564 
          iprot.skip(ftype)
14565 
      else:
14566 
        iprot.skip(ftype)
14567 
      iprot.readFieldEnd()
14568 
    iprot.readStructEnd()
14569 
 
14570 
  def write(self, oprot):
14571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14573 
      return
14574 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 14575 
    if self.ex is not None:
2690 chandransh 14576 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14577 
      self.ex.write(oprot)
14578 
      oprot.writeFieldEnd()
14579 
    oprot.writeFieldStop()
14580 
    oprot.writeStructEnd()
14581 
 
3431 rajveer 14582 
  def validate(self):
14583 
    return
14584 
 
14585 
 
2690 chandransh 14586 
  def __repr__(self):
14587 
    L = ['%s=%r' % (key, value)
14588 
      for key, value in self.__dict__.iteritems()]
14589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14590 
 
14591 
  def __eq__(self, other):
14592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14593 
 
14594 
  def __ne__(self, other):
14595 
    return not (self == other)
14596 
 
3451 chandransh 14597 
class updateWeight_args:
14598 
  """
14599 
  Attributes:
14600 
   - orderId
14601 
   - weight
14602 
  """
14603 
 
14604 
  thrift_spec = (
14605 
    None, # 0
14606 
    (1, TType.I64, 'orderId', None, None, ), # 1
14607 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
14608 
  )
14609 
 
14610 
  def __init__(self, orderId=None, weight=None,):
14611 
    self.orderId = orderId
14612 
    self.weight = weight
14613 
 
14614 
  def read(self, iprot):
14615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14617 
      return
14618 
    iprot.readStructBegin()
14619 
    while True:
14620 
      (fname, ftype, fid) = iprot.readFieldBegin()
14621 
      if ftype == TType.STOP:
14622 
        break
14623 
      if fid == 1:
14624 
        if ftype == TType.I64:
14625 
          self.orderId = iprot.readI64();
14626 
        else:
14627 
          iprot.skip(ftype)
14628 
      elif fid == 2:
14629 
        if ftype == TType.DOUBLE:
14630 
          self.weight = iprot.readDouble();
14631 
        else:
14632 
          iprot.skip(ftype)
14633 
      else:
14634 
        iprot.skip(ftype)
14635 
      iprot.readFieldEnd()
14636 
    iprot.readStructEnd()
14637 
 
14638 
  def write(self, oprot):
14639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14641 
      return
14642 
    oprot.writeStructBegin('updateWeight_args')
14643 
    if self.orderId is not None:
14644 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14645 
      oprot.writeI64(self.orderId)
14646 
      oprot.writeFieldEnd()
14647 
    if self.weight is not None:
14648 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
14649 
      oprot.writeDouble(self.weight)
14650 
      oprot.writeFieldEnd()
14651 
    oprot.writeFieldStop()
14652 
    oprot.writeStructEnd()
14653 
 
14654 
  def validate(self):
14655 
    return
14656 
 
14657 
 
14658 
  def __repr__(self):
14659 
    L = ['%s=%r' % (key, value)
14660 
      for key, value in self.__dict__.iteritems()]
14661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14662 
 
14663 
  def __eq__(self, other):
14664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14665 
 
14666 
  def __ne__(self, other):
14667 
    return not (self == other)
14668 
 
14669 
class updateWeight_result:
14670 
  """
14671 
  Attributes:
14672 
   - success
14673 
   - ex
14674 
  """
14675 
 
14676 
  thrift_spec = (
14677 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14678 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14679 
  )
14680 
 
14681 
  def __init__(self, success=None, ex=None,):
14682 
    self.success = success
14683 
    self.ex = ex
14684 
 
14685 
  def read(self, iprot):
14686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14688 
      return
14689 
    iprot.readStructBegin()
14690 
    while True:
14691 
      (fname, ftype, fid) = iprot.readFieldBegin()
14692 
      if ftype == TType.STOP:
14693 
        break
14694 
      if fid == 0:
14695 
        if ftype == TType.STRUCT:
14696 
          self.success = Order()
14697 
          self.success.read(iprot)
14698 
        else:
14699 
          iprot.skip(ftype)
14700 
      elif fid == 1:
14701 
        if ftype == TType.STRUCT:
14702 
          self.ex = TransactionServiceException()
14703 
          self.ex.read(iprot)
14704 
        else:
14705 
          iprot.skip(ftype)
14706 
      else:
14707 
        iprot.skip(ftype)
14708 
      iprot.readFieldEnd()
14709 
    iprot.readStructEnd()
14710 
 
14711 
  def write(self, oprot):
14712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14714 
      return
14715 
    oprot.writeStructBegin('updateWeight_result')
14716 
    if self.success is not None:
14717 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14718 
      self.success.write(oprot)
14719 
      oprot.writeFieldEnd()
14720 
    if self.ex is not None:
14721 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14722 
      self.ex.write(oprot)
14723 
      oprot.writeFieldEnd()
14724 
    oprot.writeFieldStop()
14725 
    oprot.writeStructEnd()
14726 
 
14727 
  def validate(self):
14728 
    return
14729 
 
14730 
 
14731 
  def __repr__(self):
14732 
    L = ['%s=%r' % (key, value)
14733 
      for key, value in self.__dict__.iteritems()]
14734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14735 
 
14736 
  def __eq__(self, other):
14737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14738 
 
14739 
  def __ne__(self, other):
14740 
    return not (self == other)
3469 chandransh 14741 
 
14742 
class changeItem_args:
14743 
  """
14744 
  Attributes:
14745 
   - orderId
14746 
   - itemId
14747 
  """
14748 
 
14749 
  thrift_spec = (
14750 
    None, # 0
14751 
    (1, TType.I64, 'orderId', None, None, ), # 1
14752 
    (2, TType.I64, 'itemId', None, None, ), # 2
14753 
  )
14754 
 
14755 
  def __init__(self, orderId=None, itemId=None,):
14756 
    self.orderId = orderId
14757 
    self.itemId = itemId
14758 
 
14759 
  def read(self, iprot):
14760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14762 
      return
14763 
    iprot.readStructBegin()
14764 
    while True:
14765 
      (fname, ftype, fid) = iprot.readFieldBegin()
14766 
      if ftype == TType.STOP:
14767 
        break
14768 
      if fid == 1:
14769 
        if ftype == TType.I64:
14770 
          self.orderId = iprot.readI64();
14771 
        else:
14772 
          iprot.skip(ftype)
14773 
      elif fid == 2:
14774 
        if ftype == TType.I64:
14775 
          self.itemId = iprot.readI64();
14776 
        else:
14777 
          iprot.skip(ftype)
14778 
      else:
14779 
        iprot.skip(ftype)
14780 
      iprot.readFieldEnd()
14781 
    iprot.readStructEnd()
14782 
 
14783 
  def write(self, oprot):
14784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14786 
      return
14787 
    oprot.writeStructBegin('changeItem_args')
14788 
    if self.orderId is not None:
14789 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14790 
      oprot.writeI64(self.orderId)
14791 
      oprot.writeFieldEnd()
14792 
    if self.itemId is not None:
14793 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14794 
      oprot.writeI64(self.itemId)
14795 
      oprot.writeFieldEnd()
14796 
    oprot.writeFieldStop()
14797 
    oprot.writeStructEnd()
14798 
 
14799 
  def validate(self):
14800 
    return
14801 
 
14802 
 
14803 
  def __repr__(self):
14804 
    L = ['%s=%r' % (key, value)
14805 
      for key, value in self.__dict__.iteritems()]
14806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14807 
 
14808 
  def __eq__(self, other):
14809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14810 
 
14811 
  def __ne__(self, other):
14812 
    return not (self == other)
14813 
 
14814 
class changeItem_result:
14815 
  """
14816 
  Attributes:
14817 
   - success
14818 
   - ex
14819 
  """
14820 
 
14821 
  thrift_spec = (
14822 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14823 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14824 
  )
14825 
 
14826 
  def __init__(self, success=None, ex=None,):
14827 
    self.success = success
14828 
    self.ex = ex
14829 
 
14830 
  def read(self, iprot):
14831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14833 
      return
14834 
    iprot.readStructBegin()
14835 
    while True:
14836 
      (fname, ftype, fid) = iprot.readFieldBegin()
14837 
      if ftype == TType.STOP:
14838 
        break
14839 
      if fid == 0:
14840 
        if ftype == TType.STRUCT:
14841 
          self.success = Order()
14842 
          self.success.read(iprot)
14843 
        else:
14844 
          iprot.skip(ftype)
14845 
      elif fid == 1:
14846 
        if ftype == TType.STRUCT:
14847 
          self.ex = TransactionServiceException()
14848 
          self.ex.read(iprot)
14849 
        else:
14850 
          iprot.skip(ftype)
14851 
      else:
14852 
        iprot.skip(ftype)
14853 
      iprot.readFieldEnd()
14854 
    iprot.readStructEnd()
14855 
 
14856 
  def write(self, oprot):
14857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14859 
      return
14860 
    oprot.writeStructBegin('changeItem_result')
14861 
    if self.success is not None:
14862 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14863 
      self.success.write(oprot)
14864 
      oprot.writeFieldEnd()
14865 
    if self.ex is not None:
14866 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14867 
      self.ex.write(oprot)
14868 
      oprot.writeFieldEnd()
14869 
    oprot.writeFieldStop()
14870 
    oprot.writeStructEnd()
14871 
 
14872 
  def validate(self):
14873 
    return
14874 
 
14875 
 
14876 
  def __repr__(self):
14877 
    L = ['%s=%r' % (key, value)
14878 
      for key, value in self.__dict__.iteritems()]
14879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14880 
 
14881 
  def __eq__(self, other):
14882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14883 
 
14884 
  def __ne__(self, other):
14885 
    return not (self == other)
14886 
 
14887 
class shiftToWarehouse_args:
14888 
  """
14889 
  Attributes:
14890 
   - orderId
14891 
   - warehouseId
14892 
  """
14893 
 
14894 
  thrift_spec = (
14895 
    None, # 0
14896 
    (1, TType.I64, 'orderId', None, None, ), # 1
14897 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
14898 
  )
14899 
 
14900 
  def __init__(self, orderId=None, warehouseId=None,):
14901 
    self.orderId = orderId
14902 
    self.warehouseId = warehouseId
14903 
 
14904 
  def read(self, iprot):
14905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14907 
      return
14908 
    iprot.readStructBegin()
14909 
    while True:
14910 
      (fname, ftype, fid) = iprot.readFieldBegin()
14911 
      if ftype == TType.STOP:
14912 
        break
14913 
      if fid == 1:
14914 
        if ftype == TType.I64:
14915 
          self.orderId = iprot.readI64();
14916 
        else:
14917 
          iprot.skip(ftype)
14918 
      elif fid == 2:
14919 
        if ftype == TType.I64:
14920 
          self.warehouseId = iprot.readI64();
14921 
        else:
14922 
          iprot.skip(ftype)
14923 
      else:
14924 
        iprot.skip(ftype)
14925 
      iprot.readFieldEnd()
14926 
    iprot.readStructEnd()
14927 
 
14928 
  def write(self, oprot):
14929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14931 
      return
14932 
    oprot.writeStructBegin('shiftToWarehouse_args')
14933 
    if self.orderId is not None:
14934 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14935 
      oprot.writeI64(self.orderId)
14936 
      oprot.writeFieldEnd()
14937 
    if self.warehouseId is not None:
14938 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14939 
      oprot.writeI64(self.warehouseId)
14940 
      oprot.writeFieldEnd()
14941 
    oprot.writeFieldStop()
14942 
    oprot.writeStructEnd()
14943 
 
14944 
  def validate(self):
14945 
    return
14946 
 
14947 
 
14948 
  def __repr__(self):
14949 
    L = ['%s=%r' % (key, value)
14950 
      for key, value in self.__dict__.iteritems()]
14951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14952 
 
14953 
  def __eq__(self, other):
14954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14955 
 
14956 
  def __ne__(self, other):
14957 
    return not (self == other)
14958 
 
14959 
class shiftToWarehouse_result:
14960 
  """
14961 
  Attributes:
14962 
   - success
14963 
   - ex
14964 
  """
14965 
 
14966 
  thrift_spec = (
14967 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14968 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14969 
  )
14970 
 
14971 
  def __init__(self, success=None, ex=None,):
14972 
    self.success = success
14973 
    self.ex = ex
14974 
 
14975 
  def read(self, iprot):
14976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14978 
      return
14979 
    iprot.readStructBegin()
14980 
    while True:
14981 
      (fname, ftype, fid) = iprot.readFieldBegin()
14982 
      if ftype == TType.STOP:
14983 
        break
14984 
      if fid == 0:
14985 
        if ftype == TType.STRUCT:
14986 
          self.success = Order()
14987 
          self.success.read(iprot)
14988 
        else:
14989 
          iprot.skip(ftype)
14990 
      elif fid == 1:
14991 
        if ftype == TType.STRUCT:
14992 
          self.ex = TransactionServiceException()
14993 
          self.ex.read(iprot)
14994 
        else:
14995 
          iprot.skip(ftype)
14996 
      else:
14997 
        iprot.skip(ftype)
14998 
      iprot.readFieldEnd()
14999 
    iprot.readStructEnd()
15000 
 
15001 
  def write(self, oprot):
15002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15004 
      return
15005 
    oprot.writeStructBegin('shiftToWarehouse_result')
15006 
    if self.success is not None:
15007 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15008 
      self.success.write(oprot)
15009 
      oprot.writeFieldEnd()
15010 
    if self.ex is not None:
15011 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15012 
      self.ex.write(oprot)
15013 
      oprot.writeFieldEnd()
15014 
    oprot.writeFieldStop()
15015 
    oprot.writeStructEnd()
15016 
 
15017 
  def validate(self):
15018 
    return
15019 
 
15020 
 
15021 
  def __repr__(self):
15022 
    L = ['%s=%r' % (key, value)
15023 
      for key, value in self.__dict__.iteritems()]
15024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15025 
 
15026 
  def __eq__(self, other):
15027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15028 
 
15029 
  def __ne__(self, other):
15030 
    return not (self == other)
3553 chandransh 15031 
 
15032 
class addDelayReason_args:
15033 
  """
15034 
  Attributes:
15035 
   - orderId
15036 
   - delayReason
3986 chandransh 15037 
   - furtherDelay
4647 rajveer 15038 
   - delayReasonText
3553 chandransh 15039 
  """
15040 
 
15041 
  thrift_spec = (
15042 
    None, # 0
15043 
    (1, TType.I64, 'orderId', None, None, ), # 1
15044 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 15045 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 15046 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 15047 
  )
15048 
 
4647 rajveer 15049 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 15050 
    self.orderId = orderId
15051 
    self.delayReason = delayReason
3986 chandransh 15052 
    self.furtherDelay = furtherDelay
4647 rajveer 15053 
    self.delayReasonText = delayReasonText
3553 chandransh 15054 
 
15055 
  def read(self, iprot):
15056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15058 
      return
15059 
    iprot.readStructBegin()
15060 
    while True:
15061 
      (fname, ftype, fid) = iprot.readFieldBegin()
15062 
      if ftype == TType.STOP:
15063 
        break
15064 
      if fid == 1:
15065 
        if ftype == TType.I64:
15066 
          self.orderId = iprot.readI64();
15067 
        else:
15068 
          iprot.skip(ftype)
15069 
      elif fid == 2:
15070 
        if ftype == TType.I32:
15071 
          self.delayReason = iprot.readI32();
15072 
        else:
15073 
          iprot.skip(ftype)
3986 chandransh 15074 
      elif fid == 3:
15075 
        if ftype == TType.I64:
15076 
          self.furtherDelay = iprot.readI64();
15077 
        else:
15078 
          iprot.skip(ftype)
4647 rajveer 15079 
      elif fid == 4:
15080 
        if ftype == TType.STRING:
15081 
          self.delayReasonText = iprot.readString();
15082 
        else:
15083 
          iprot.skip(ftype)
3553 chandransh 15084 
      else:
15085 
        iprot.skip(ftype)
15086 
      iprot.readFieldEnd()
15087 
    iprot.readStructEnd()
15088 
 
15089 
  def write(self, oprot):
15090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15092 
      return
15093 
    oprot.writeStructBegin('addDelayReason_args')
15094 
    if self.orderId is not None:
15095 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15096 
      oprot.writeI64(self.orderId)
15097 
      oprot.writeFieldEnd()
15098 
    if self.delayReason is not None:
15099 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
15100 
      oprot.writeI32(self.delayReason)
15101 
      oprot.writeFieldEnd()
3986 chandransh 15102 
    if self.furtherDelay is not None:
15103 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
15104 
      oprot.writeI64(self.furtherDelay)
15105 
      oprot.writeFieldEnd()
4647 rajveer 15106 
    if self.delayReasonText is not None:
15107 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
15108 
      oprot.writeString(self.delayReasonText)
15109 
      oprot.writeFieldEnd()
3553 chandransh 15110 
    oprot.writeFieldStop()
15111 
    oprot.writeStructEnd()
15112 
 
15113 
  def validate(self):
15114 
    return
15115 
 
15116 
 
15117 
  def __repr__(self):
15118 
    L = ['%s=%r' % (key, value)
15119 
      for key, value in self.__dict__.iteritems()]
15120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15121 
 
15122 
  def __eq__(self, other):
15123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15124 
 
15125 
  def __ne__(self, other):
15126 
    return not (self == other)
15127 
 
15128 
class addDelayReason_result:
15129 
  """
15130 
  Attributes:
15131 
   - success
15132 
   - ex
15133 
  """
15134 
 
15135 
  thrift_spec = (
15136 
    (0, TType.BOOL, 'success', None, None, ), # 0
15137 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15138 
  )
15139 
 
15140 
  def __init__(self, success=None, ex=None,):
15141 
    self.success = success
15142 
    self.ex = ex
15143 
 
15144 
  def read(self, iprot):
15145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15147 
      return
15148 
    iprot.readStructBegin()
15149 
    while True:
15150 
      (fname, ftype, fid) = iprot.readFieldBegin()
15151 
      if ftype == TType.STOP:
15152 
        break
15153 
      if fid == 0:
15154 
        if ftype == TType.BOOL:
15155 
          self.success = iprot.readBool();
15156 
        else:
15157 
          iprot.skip(ftype)
15158 
      elif fid == 1:
15159 
        if ftype == TType.STRUCT:
15160 
          self.ex = TransactionServiceException()
15161 
          self.ex.read(iprot)
15162 
        else:
15163 
          iprot.skip(ftype)
15164 
      else:
15165 
        iprot.skip(ftype)
15166 
      iprot.readFieldEnd()
15167 
    iprot.readStructEnd()
15168 
 
15169 
  def write(self, oprot):
15170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15172 
      return
15173 
    oprot.writeStructBegin('addDelayReason_result')
15174 
    if self.success is not None:
15175 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15176 
      oprot.writeBool(self.success)
15177 
      oprot.writeFieldEnd()
15178 
    if self.ex is not None:
15179 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15180 
      self.ex.write(oprot)
15181 
      oprot.writeFieldEnd()
15182 
    oprot.writeFieldStop()
15183 
    oprot.writeStructEnd()
15184 
 
15185 
  def validate(self):
15186 
    return
15187 
 
15188 
 
15189 
  def __repr__(self):
15190 
    L = ['%s=%r' % (key, value)
15191 
      for key, value in self.__dict__.iteritems()]
15192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15193 
 
15194 
  def __eq__(self, other):
15195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15196 
 
15197 
  def __ne__(self, other):
15198 
    return not (self == other)
3956 chandransh 15199 
 
15200 
class reconcileCodCollection_args:
15201 
  """
15202 
  Attributes:
15203 
   - collectedAmountMap
15204 
   - xferBy
15205 
   - xferTxnId
15206 
   - xferDate
15207 
  """
15208 
 
15209 
  thrift_spec = (
15210 
    None, # 0
15211 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
15212 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
15213 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
15214 
    (4, TType.I64, 'xferDate', None, None, ), # 4
15215 
  )
15216 
 
15217 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
15218 
    self.collectedAmountMap = collectedAmountMap
15219 
    self.xferBy = xferBy
15220 
    self.xferTxnId = xferTxnId
15221 
    self.xferDate = xferDate
15222 
 
15223 
  def read(self, iprot):
15224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15226 
      return
15227 
    iprot.readStructBegin()
15228 
    while True:
15229 
      (fname, ftype, fid) = iprot.readFieldBegin()
15230 
      if ftype == TType.STOP:
15231 
        break
15232 
      if fid == 1:
15233 
        if ftype == TType.MAP:
15234 
          self.collectedAmountMap = {}
4789 rajveer 15235 
          (_ktype251, _vtype252, _size250 ) = iprot.readMapBegin()
15236 
          for _i254 in xrange(_size250):
15237 
            _key255 = iprot.readString();
15238 
            _val256 = iprot.readDouble();
15239 
            self.collectedAmountMap[_key255] = _val256
3956 chandransh 15240 
          iprot.readMapEnd()
15241 
        else:
15242 
          iprot.skip(ftype)
15243 
      elif fid == 2:
15244 
        if ftype == TType.STRING:
15245 
          self.xferBy = iprot.readString();
15246 
        else:
15247 
          iprot.skip(ftype)
15248 
      elif fid == 3:
15249 
        if ftype == TType.STRING:
15250 
          self.xferTxnId = iprot.readString();
15251 
        else:
15252 
          iprot.skip(ftype)
15253 
      elif fid == 4:
15254 
        if ftype == TType.I64:
15255 
          self.xferDate = iprot.readI64();
15256 
        else:
15257 
          iprot.skip(ftype)
15258 
      else:
15259 
        iprot.skip(ftype)
15260 
      iprot.readFieldEnd()
15261 
    iprot.readStructEnd()
15262 
 
15263 
  def write(self, oprot):
15264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15266 
      return
15267 
    oprot.writeStructBegin('reconcileCodCollection_args')
15268 
    if self.collectedAmountMap is not None:
15269 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
15270 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4789 rajveer 15271 
      for kiter257,viter258 in self.collectedAmountMap.items():
15272 
        oprot.writeString(kiter257)
15273 
        oprot.writeDouble(viter258)
3956 chandransh 15274 
      oprot.writeMapEnd()
15275 
      oprot.writeFieldEnd()
15276 
    if self.xferBy is not None:
15277 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
15278 
      oprot.writeString(self.xferBy)
15279 
      oprot.writeFieldEnd()
15280 
    if self.xferTxnId is not None:
15281 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
15282 
      oprot.writeString(self.xferTxnId)
15283 
      oprot.writeFieldEnd()
15284 
    if self.xferDate is not None:
15285 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
15286 
      oprot.writeI64(self.xferDate)
15287 
      oprot.writeFieldEnd()
15288 
    oprot.writeFieldStop()
15289 
    oprot.writeStructEnd()
15290 
 
15291 
  def validate(self):
15292 
    return
15293 
 
15294 
 
15295 
  def __repr__(self):
15296 
    L = ['%s=%r' % (key, value)
15297 
      for key, value in self.__dict__.iteritems()]
15298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15299 
 
15300 
  def __eq__(self, other):
15301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15302 
 
15303 
  def __ne__(self, other):
15304 
    return not (self == other)
15305 
 
15306 
class reconcileCodCollection_result:
15307 
  """
15308 
  Attributes:
15309 
   - success
15310 
   - ex
15311 
  """
15312 
 
15313 
  thrift_spec = (
15314 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15315 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15316 
  )
15317 
 
15318 
  def __init__(self, success=None, ex=None,):
15319 
    self.success = success
15320 
    self.ex = ex
15321 
 
15322 
  def read(self, iprot):
15323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15325 
      return
15326 
    iprot.readStructBegin()
15327 
    while True:
15328 
      (fname, ftype, fid) = iprot.readFieldBegin()
15329 
      if ftype == TType.STOP:
15330 
        break
15331 
      if fid == 0:
15332 
        if ftype == TType.MAP:
15333 
          self.success = {}
4789 rajveer 15334 
          (_ktype260, _vtype261, _size259 ) = iprot.readMapBegin()
15335 
          for _i263 in xrange(_size259):
15336 
            _key264 = iprot.readString();
15337 
            _val265 = iprot.readString();
15338 
            self.success[_key264] = _val265
3956 chandransh 15339 
          iprot.readMapEnd()
15340 
        else:
15341 
          iprot.skip(ftype)
15342 
      elif fid == 1:
15343 
        if ftype == TType.STRUCT:
15344 
          self.ex = TransactionServiceException()
15345 
          self.ex.read(iprot)
15346 
        else:
15347 
          iprot.skip(ftype)
15348 
      else:
15349 
        iprot.skip(ftype)
15350 
      iprot.readFieldEnd()
15351 
    iprot.readStructEnd()
15352 
 
15353 
  def write(self, oprot):
15354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15356 
      return
15357 
    oprot.writeStructBegin('reconcileCodCollection_result')
15358 
    if self.success is not None:
15359 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15360 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4789 rajveer 15361 
      for kiter266,viter267 in self.success.items():
15362 
        oprot.writeString(kiter266)
15363 
        oprot.writeString(viter267)
3956 chandransh 15364 
      oprot.writeMapEnd()
15365 
      oprot.writeFieldEnd()
15366 
    if self.ex is not None:
15367 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15368 
      self.ex.write(oprot)
15369 
      oprot.writeFieldEnd()
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)
4008 mandeep.dh 15387 
 
15388 
class getTransactionsRequiringExtraProcessing_args:
15389 
  """
15390 
  Attributes:
15391 
   - category
15392 
  """
15393 
 
15394 
  thrift_spec = (
15395 
    None, # 0
15396 
    (1, TType.I32, 'category', None, None, ), # 1
15397 
  )
15398 
 
15399 
  def __init__(self, category=None,):
15400 
    self.category = category
15401 
 
15402 
  def read(self, iprot):
15403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15405 
      return
15406 
    iprot.readStructBegin()
15407 
    while True:
15408 
      (fname, ftype, fid) = iprot.readFieldBegin()
15409 
      if ftype == TType.STOP:
15410 
        break
15411 
      if fid == 1:
15412 
        if ftype == TType.I32:
15413 
          self.category = iprot.readI32();
15414 
        else:
15415 
          iprot.skip(ftype)
15416 
      else:
15417 
        iprot.skip(ftype)
15418 
      iprot.readFieldEnd()
15419 
    iprot.readStructEnd()
15420 
 
15421 
  def write(self, oprot):
15422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15424 
      return
15425 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
15426 
    if self.category is not None:
15427 
      oprot.writeFieldBegin('category', TType.I32, 1)
15428 
      oprot.writeI32(self.category)
15429 
      oprot.writeFieldEnd()
15430 
    oprot.writeFieldStop()
15431 
    oprot.writeStructEnd()
15432 
 
15433 
  def validate(self):
15434 
    return
15435 
 
15436 
 
15437 
  def __repr__(self):
15438 
    L = ['%s=%r' % (key, value)
15439 
      for key, value in self.__dict__.iteritems()]
15440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15441 
 
15442 
  def __eq__(self, other):
15443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15444 
 
15445 
  def __ne__(self, other):
15446 
    return not (self == other)
15447 
 
15448 
class getTransactionsRequiringExtraProcessing_result:
15449 
  """
15450 
  Attributes:
15451 
   - success
15452 
  """
15453 
 
15454 
  thrift_spec = (
15455 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15456 
  )
15457 
 
15458 
  def __init__(self, success=None,):
15459 
    self.success = success
15460 
 
15461 
  def read(self, iprot):
15462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15464 
      return
15465 
    iprot.readStructBegin()
15466 
    while True:
15467 
      (fname, ftype, fid) = iprot.readFieldBegin()
15468 
      if ftype == TType.STOP:
15469 
        break
15470 
      if fid == 0:
15471 
        if ftype == TType.LIST:
15472 
          self.success = []
4789 rajveer 15473 
          (_etype271, _size268) = iprot.readListBegin()
15474 
          for _i272 in xrange(_size268):
15475 
            _elem273 = iprot.readI64();
15476 
            self.success.append(_elem273)
4008 mandeep.dh 15477 
          iprot.readListEnd()
15478 
        else:
15479 
          iprot.skip(ftype)
15480 
      else:
15481 
        iprot.skip(ftype)
15482 
      iprot.readFieldEnd()
15483 
    iprot.readStructEnd()
15484 
 
15485 
  def write(self, oprot):
15486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15488 
      return
15489 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
15490 
    if self.success is not None:
15491 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15492 
      oprot.writeListBegin(TType.I64, len(self.success))
4789 rajveer 15493 
      for iter274 in self.success:
15494 
        oprot.writeI64(iter274)
4008 mandeep.dh 15495 
      oprot.writeListEnd()
15496 
      oprot.writeFieldEnd()
15497 
    oprot.writeFieldStop()
15498 
    oprot.writeStructEnd()
15499 
 
15500 
  def validate(self):
15501 
    return
15502 
 
15503 
 
15504 
  def __repr__(self):
15505 
    L = ['%s=%r' % (key, value)
15506 
      for key, value in self.__dict__.iteritems()]
15507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15508 
 
15509 
  def __eq__(self, other):
15510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15511 
 
15512 
  def __ne__(self, other):
15513 
    return not (self == other)
15514 
 
15515 
class markTransactionAsProcessed_args:
15516 
  """
15517 
  Attributes:
15518 
   - transactionId
15519 
   - category
15520 
  """
15521 
 
15522 
  thrift_spec = (
15523 
    None, # 0
15524 
    (1, TType.I64, 'transactionId', None, None, ), # 1
15525 
    (2, TType.I32, 'category', None, None, ), # 2
15526 
  )
15527 
 
15528 
  def __init__(self, transactionId=None, category=None,):
15529 
    self.transactionId = transactionId
15530 
    self.category = category
15531 
 
15532 
  def read(self, iprot):
15533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15535 
      return
15536 
    iprot.readStructBegin()
15537 
    while True:
15538 
      (fname, ftype, fid) = iprot.readFieldBegin()
15539 
      if ftype == TType.STOP:
15540 
        break
15541 
      if fid == 1:
15542 
        if ftype == TType.I64:
15543 
          self.transactionId = iprot.readI64();
15544 
        else:
15545 
          iprot.skip(ftype)
15546 
      elif fid == 2:
15547 
        if ftype == TType.I32:
15548 
          self.category = iprot.readI32();
15549 
        else:
15550 
          iprot.skip(ftype)
15551 
      else:
15552 
        iprot.skip(ftype)
15553 
      iprot.readFieldEnd()
15554 
    iprot.readStructEnd()
15555 
 
15556 
  def write(self, oprot):
15557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15559 
      return
15560 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
15561 
    if self.transactionId is not None:
15562 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
15563 
      oprot.writeI64(self.transactionId)
15564 
      oprot.writeFieldEnd()
15565 
    if self.category is not None:
15566 
      oprot.writeFieldBegin('category', TType.I32, 2)
15567 
      oprot.writeI32(self.category)
15568 
      oprot.writeFieldEnd()
15569 
    oprot.writeFieldStop()
15570 
    oprot.writeStructEnd()
15571 
 
15572 
  def validate(self):
15573 
    return
15574 
 
15575 
 
15576 
  def __repr__(self):
15577 
    L = ['%s=%r' % (key, value)
15578 
      for key, value in self.__dict__.iteritems()]
15579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15580 
 
15581 
  def __eq__(self, other):
15582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15583 
 
15584 
  def __ne__(self, other):
15585 
    return not (self == other)
15586 
 
15587 
class markTransactionAsProcessed_result:
15588 
 
15589 
  thrift_spec = (
15590 
  )
15591 
 
15592 
  def read(self, iprot):
15593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15595 
      return
15596 
    iprot.readStructBegin()
15597 
    while True:
15598 
      (fname, ftype, fid) = iprot.readFieldBegin()
15599 
      if ftype == TType.STOP:
15600 
        break
15601 
      else:
15602 
        iprot.skip(ftype)
15603 
      iprot.readFieldEnd()
15604 
    iprot.readStructEnd()
15605 
 
15606 
  def write(self, oprot):
15607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15609 
      return
15610 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
15611 
    oprot.writeFieldStop()
15612 
    oprot.writeStructEnd()
15613 
 
15614 
  def validate(self):
15615 
    return
15616 
 
15617 
 
15618 
  def __repr__(self):
15619 
    L = ['%s=%r' % (key, value)
15620 
      for key, value in self.__dict__.iteritems()]
15621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15622 
 
15623 
  def __eq__(self, other):
15624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15625 
 
15626 
  def __ne__(self, other):
15627 
    return not (self == other)
4018 chandransh 15628 
 
15629 
class getItemWiseRiskyOrdersCount_args:
15630 
 
15631 
  thrift_spec = (
15632 
  )
15633 
 
15634 
  def read(self, iprot):
15635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15637 
      return
15638 
    iprot.readStructBegin()
15639 
    while True:
15640 
      (fname, ftype, fid) = iprot.readFieldBegin()
15641 
      if ftype == TType.STOP:
15642 
        break
15643 
      else:
15644 
        iprot.skip(ftype)
15645 
      iprot.readFieldEnd()
15646 
    iprot.readStructEnd()
15647 
 
15648 
  def write(self, oprot):
15649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15651 
      return
15652 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
15653 
    oprot.writeFieldStop()
15654 
    oprot.writeStructEnd()
15655 
 
15656 
  def validate(self):
15657 
    return
15658 
 
15659 
 
15660 
  def __repr__(self):
15661 
    L = ['%s=%r' % (key, value)
15662 
      for key, value in self.__dict__.iteritems()]
15663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15664 
 
15665 
  def __eq__(self, other):
15666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15667 
 
15668 
  def __ne__(self, other):
15669 
    return not (self == other)
15670 
 
15671 
class getItemWiseRiskyOrdersCount_result:
15672 
  """
15673 
  Attributes:
15674 
   - success
15675 
  """
15676 
 
15677 
  thrift_spec = (
15678 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
15679 
  )
15680 
 
15681 
  def __init__(self, success=None,):
15682 
    self.success = success
15683 
 
15684 
  def read(self, iprot):
15685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15687 
      return
15688 
    iprot.readStructBegin()
15689 
    while True:
15690 
      (fname, ftype, fid) = iprot.readFieldBegin()
15691 
      if ftype == TType.STOP:
15692 
        break
15693 
      if fid == 0:
15694 
        if ftype == TType.MAP:
15695 
          self.success = {}
4789 rajveer 15696 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
15697 
          for _i279 in xrange(_size275):
15698 
            _key280 = iprot.readI64();
15699 
            _val281 = iprot.readI64();
15700 
            self.success[_key280] = _val281
4018 chandransh 15701 
          iprot.readMapEnd()
15702 
        else:
15703 
          iprot.skip(ftype)
15704 
      else:
15705 
        iprot.skip(ftype)
15706 
      iprot.readFieldEnd()
15707 
    iprot.readStructEnd()
15708 
 
15709 
  def write(self, oprot):
15710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15712 
      return
15713 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
15714 
    if self.success is not None:
15715 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15716 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4789 rajveer 15717 
      for kiter282,viter283 in self.success.items():
15718 
        oprot.writeI64(kiter282)
15719 
        oprot.writeI64(viter283)
4018 chandransh 15720 
      oprot.writeMapEnd()
15721 
      oprot.writeFieldEnd()
15722 
    oprot.writeFieldStop()
15723 
    oprot.writeStructEnd()
15724 
 
15725 
  def validate(self):
15726 
    return
15727 
 
15728 
 
15729 
  def __repr__(self):
15730 
    L = ['%s=%r' % (key, value)
15731 
      for key, value in self.__dict__.iteritems()]
15732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15733 
 
15734 
  def __eq__(self, other):
15735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15736 
 
15737 
  def __ne__(self, other):
15738 
    return not (self == other)
4247 rajveer 15739 
 
4295 varun.gupt 15740 
class getOrdersForItemIds_args:
15741 
  """
15742 
  Attributes:
15743 
   - itemIds
15744 
  """
15745 
 
15746 
  thrift_spec = (
15747 
    None, # 0
15748 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15749 
  )
15750 
 
15751 
  def __init__(self, itemIds=None,):
15752 
    self.itemIds = itemIds
15753 
 
15754 
  def read(self, iprot):
15755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15757 
      return
15758 
    iprot.readStructBegin()
15759 
    while True:
15760 
      (fname, ftype, fid) = iprot.readFieldBegin()
15761 
      if ftype == TType.STOP:
15762 
        break
15763 
      if fid == 1:
15764 
        if ftype == TType.LIST:
15765 
          self.itemIds = []
4789 rajveer 15766 
          (_etype287, _size284) = iprot.readListBegin()
15767 
          for _i288 in xrange(_size284):
15768 
            _elem289 = iprot.readI64();
15769 
            self.itemIds.append(_elem289)
4295 varun.gupt 15770 
          iprot.readListEnd()
15771 
        else:
15772 
          iprot.skip(ftype)
15773 
      else:
15774 
        iprot.skip(ftype)
15775 
      iprot.readFieldEnd()
15776 
    iprot.readStructEnd()
15777 
 
15778 
  def write(self, oprot):
15779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15781 
      return
15782 
    oprot.writeStructBegin('getOrdersForItemIds_args')
15783 
    if self.itemIds is not None:
15784 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15785 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
4789 rajveer 15786 
      for iter290 in self.itemIds:
15787 
        oprot.writeI64(iter290)
4295 varun.gupt 15788 
      oprot.writeListEnd()
15789 
      oprot.writeFieldEnd()
15790 
    oprot.writeFieldStop()
15791 
    oprot.writeStructEnd()
15792 
 
15793 
  def validate(self):
15794 
    return
15795 
 
15796 
 
15797 
  def __repr__(self):
15798 
    L = ['%s=%r' % (key, value)
15799 
      for key, value in self.__dict__.iteritems()]
15800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15801 
 
15802 
  def __eq__(self, other):
15803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15804 
 
15805 
  def __ne__(self, other):
15806 
    return not (self == other)
15807 
 
15808 
class getOrdersForItemIds_result:
15809 
  """
15810 
  Attributes:
15811 
   - success
15812 
  """
15813 
 
15814 
  thrift_spec = (
15815 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15816 
  )
15817 
 
15818 
  def __init__(self, success=None,):
15819 
    self.success = success
15820 
 
15821 
  def read(self, iprot):
15822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15824 
      return
15825 
    iprot.readStructBegin()
15826 
    while True:
15827 
      (fname, ftype, fid) = iprot.readFieldBegin()
15828 
      if ftype == TType.STOP:
15829 
        break
15830 
      if fid == 0:
15831 
        if ftype == TType.LIST:
15832 
          self.success = []
4789 rajveer 15833 
          (_etype294, _size291) = iprot.readListBegin()
15834 
          for _i295 in xrange(_size291):
15835 
            _elem296 = Order()
15836 
            _elem296.read(iprot)
15837 
            self.success.append(_elem296)
4295 varun.gupt 15838 
          iprot.readListEnd()
15839 
        else:
15840 
          iprot.skip(ftype)
15841 
      else:
15842 
        iprot.skip(ftype)
15843 
      iprot.readFieldEnd()
15844 
    iprot.readStructEnd()
15845 
 
15846 
  def write(self, oprot):
15847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15849 
      return
15850 
    oprot.writeStructBegin('getOrdersForItemIds_result')
15851 
    if self.success is not None:
15852 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15853 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4789 rajveer 15854 
      for iter297 in self.success:
15855 
        iter297.write(oprot)
4295 varun.gupt 15856 
      oprot.writeListEnd()
15857 
      oprot.writeFieldEnd()
15858 
    oprot.writeFieldStop()
15859 
    oprot.writeStructEnd()
15860 
 
15861 
  def validate(self):
15862 
    return
15863 
 
15864 
 
15865 
  def __repr__(self):
15866 
    L = ['%s=%r' % (key, value)
15867 
      for key, value in self.__dict__.iteritems()]
15868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15869 
 
15870 
  def __eq__(self, other):
15871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15872 
 
15873 
  def __ne__(self, other):
15874 
    return not (self == other)
15875 
 
4247 rajveer 15876 
class markOrderCancellationRequestReceived_args:
15877 
  """
15878 
  Attributes:
15879 
   - orderId
15880 
  """
15881 
 
15882 
  thrift_spec = (
15883 
    None, # 0
15884 
    (1, TType.I64, 'orderId', None, None, ), # 1
15885 
  )
15886 
 
15887 
  def __init__(self, orderId=None,):
15888 
    self.orderId = orderId
15889 
 
15890 
  def read(self, iprot):
15891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15893 
      return
15894 
    iprot.readStructBegin()
15895 
    while True:
15896 
      (fname, ftype, fid) = iprot.readFieldBegin()
15897 
      if ftype == TType.STOP:
15898 
        break
15899 
      if fid == 1:
15900 
        if ftype == TType.I64:
15901 
          self.orderId = iprot.readI64();
15902 
        else:
15903 
          iprot.skip(ftype)
15904 
      else:
15905 
        iprot.skip(ftype)
15906 
      iprot.readFieldEnd()
15907 
    iprot.readStructEnd()
15908 
 
15909 
  def write(self, oprot):
15910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15912 
      return
15913 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
15914 
    if self.orderId is not None:
15915 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15916 
      oprot.writeI64(self.orderId)
15917 
      oprot.writeFieldEnd()
15918 
    oprot.writeFieldStop()
15919 
    oprot.writeStructEnd()
15920 
 
15921 
  def validate(self):
15922 
    return
15923 
 
15924 
 
15925 
  def __repr__(self):
15926 
    L = ['%s=%r' % (key, value)
15927 
      for key, value in self.__dict__.iteritems()]
15928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15929 
 
15930 
  def __eq__(self, other):
15931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15932 
 
15933 
  def __ne__(self, other):
15934 
    return not (self == other)
15935 
 
15936 
class markOrderCancellationRequestReceived_result:
15937 
  """
15938 
  Attributes:
15939 
   - ex
15940 
  """
15941 
 
15942 
  thrift_spec = (
15943 
    None, # 0
15944 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15945 
  )
15946 
 
15947 
  def __init__(self, ex=None,):
15948 
    self.ex = ex
15949 
 
15950 
  def read(self, iprot):
15951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15953 
      return
15954 
    iprot.readStructBegin()
15955 
    while True:
15956 
      (fname, ftype, fid) = iprot.readFieldBegin()
15957 
      if ftype == TType.STOP:
15958 
        break
15959 
      if fid == 1:
15960 
        if ftype == TType.STRUCT:
15961 
          self.ex = TransactionServiceException()
15962 
          self.ex.read(iprot)
15963 
        else:
15964 
          iprot.skip(ftype)
15965 
      else:
15966 
        iprot.skip(ftype)
15967 
      iprot.readFieldEnd()
15968 
    iprot.readStructEnd()
15969 
 
15970 
  def write(self, oprot):
15971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15973 
      return
15974 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
15975 
    if self.ex is not None:
15976 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15977 
      self.ex.write(oprot)
15978 
      oprot.writeFieldEnd()
15979 
    oprot.writeFieldStop()
15980 
    oprot.writeStructEnd()
15981 
 
15982 
  def validate(self):
15983 
    return
15984 
 
15985 
 
15986 
  def __repr__(self):
15987 
    L = ['%s=%r' % (key, value)
15988 
      for key, value in self.__dict__.iteritems()]
15989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15990 
 
15991 
  def __eq__(self, other):
15992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15993 
 
15994 
  def __ne__(self, other):
15995 
    return not (self == other)
15996 
 
15997 
class markOrderCancellationRequestConfirmed_args:
15998 
  """
15999 
  Attributes:
16000 
   - orderId
16001 
  """
16002 
 
16003 
  thrift_spec = (
16004 
    None, # 0
16005 
    (1, TType.I64, 'orderId', None, None, ), # 1
16006 
  )
16007 
 
16008 
  def __init__(self, orderId=None,):
16009 
    self.orderId = orderId
16010 
 
16011 
  def read(self, iprot):
16012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16014 
      return
16015 
    iprot.readStructBegin()
16016 
    while True:
16017 
      (fname, ftype, fid) = iprot.readFieldBegin()
16018 
      if ftype == TType.STOP:
16019 
        break
16020 
      if fid == 1:
16021 
        if ftype == TType.I64:
16022 
          self.orderId = iprot.readI64();
16023 
        else:
16024 
          iprot.skip(ftype)
16025 
      else:
16026 
        iprot.skip(ftype)
16027 
      iprot.readFieldEnd()
16028 
    iprot.readStructEnd()
16029 
 
16030 
  def write(self, oprot):
16031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16033 
      return
16034 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
16035 
    if self.orderId is not None:
16036 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16037 
      oprot.writeI64(self.orderId)
16038 
      oprot.writeFieldEnd()
16039 
    oprot.writeFieldStop()
16040 
    oprot.writeStructEnd()
16041 
 
16042 
  def validate(self):
16043 
    return
16044 
 
16045 
 
16046 
  def __repr__(self):
16047 
    L = ['%s=%r' % (key, value)
16048 
      for key, value in self.__dict__.iteritems()]
16049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16050 
 
16051 
  def __eq__(self, other):
16052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16053 
 
16054 
  def __ne__(self, other):
16055 
    return not (self == other)
16056 
 
16057 
class markOrderCancellationRequestConfirmed_result:
16058 
  """
16059 
  Attributes:
16060 
   - ex
16061 
  """
16062 
 
16063 
  thrift_spec = (
16064 
    None, # 0
16065 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16066 
  )
16067 
 
16068 
  def __init__(self, ex=None,):
16069 
    self.ex = ex
16070 
 
16071 
  def read(self, iprot):
16072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16074 
      return
16075 
    iprot.readStructBegin()
16076 
    while True:
16077 
      (fname, ftype, fid) = iprot.readFieldBegin()
16078 
      if ftype == TType.STOP:
16079 
        break
16080 
      if fid == 1:
16081 
        if ftype == TType.STRUCT:
16082 
          self.ex = TransactionServiceException()
16083 
          self.ex.read(iprot)
16084 
        else:
16085 
          iprot.skip(ftype)
16086 
      else:
16087 
        iprot.skip(ftype)
16088 
      iprot.readFieldEnd()
16089 
    iprot.readStructEnd()
16090 
 
16091 
  def write(self, oprot):
16092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16094 
      return
16095 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
16096 
    if self.ex is not None:
16097 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16098 
      self.ex.write(oprot)
16099 
      oprot.writeFieldEnd()
16100 
    oprot.writeFieldStop()
16101 
    oprot.writeStructEnd()
16102 
 
16103 
  def validate(self):
16104 
    return
16105 
 
16106 
 
16107 
  def __repr__(self):
16108 
    L = ['%s=%r' % (key, value)
16109 
      for key, value in self.__dict__.iteritems()]
16110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16111 
 
16112 
  def __eq__(self, other):
16113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16114 
 
16115 
  def __ne__(self, other):
16116 
    return not (self == other)
16117 
 
16118 
class markOrderCancellationRequestDenied_args:
16119 
  """
16120 
  Attributes:
16121 
   - orderId
16122 
  """
16123 
 
16124 
  thrift_spec = (
16125 
    None, # 0
16126 
    (1, TType.I64, 'orderId', None, None, ), # 1
16127 
  )
16128 
 
16129 
  def __init__(self, orderId=None,):
16130 
    self.orderId = orderId
16131 
 
16132 
  def read(self, iprot):
16133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16135 
      return
16136 
    iprot.readStructBegin()
16137 
    while True:
16138 
      (fname, ftype, fid) = iprot.readFieldBegin()
16139 
      if ftype == TType.STOP:
16140 
        break
16141 
      if fid == 1:
16142 
        if ftype == TType.I64:
16143 
          self.orderId = iprot.readI64();
16144 
        else:
16145 
          iprot.skip(ftype)
16146 
      else:
16147 
        iprot.skip(ftype)
16148 
      iprot.readFieldEnd()
16149 
    iprot.readStructEnd()
16150 
 
16151 
  def write(self, oprot):
16152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16154 
      return
16155 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
16156 
    if self.orderId is not None:
16157 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16158 
      oprot.writeI64(self.orderId)
16159 
      oprot.writeFieldEnd()
16160 
    oprot.writeFieldStop()
16161 
    oprot.writeStructEnd()
16162 
 
16163 
  def validate(self):
16164 
    return
16165 
 
16166 
 
16167 
  def __repr__(self):
16168 
    L = ['%s=%r' % (key, value)
16169 
      for key, value in self.__dict__.iteritems()]
16170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16171 
 
16172 
  def __eq__(self, other):
16173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16174 
 
16175 
  def __ne__(self, other):
16176 
    return not (self == other)
16177 
 
16178 
class markOrderCancellationRequestDenied_result:
16179 
  """
16180 
  Attributes:
16181 
   - ex
16182 
  """
16183 
 
16184 
  thrift_spec = (
16185 
    None, # 0
16186 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16187 
  )
16188 
 
16189 
  def __init__(self, ex=None,):
16190 
    self.ex = ex
16191 
 
16192 
  def read(self, iprot):
16193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16195 
      return
16196 
    iprot.readStructBegin()
16197 
    while True:
16198 
      (fname, ftype, fid) = iprot.readFieldBegin()
16199 
      if ftype == TType.STOP:
16200 
        break
16201 
      if fid == 1:
16202 
        if ftype == TType.STRUCT:
16203 
          self.ex = TransactionServiceException()
16204 
          self.ex.read(iprot)
16205 
        else:
16206 
          iprot.skip(ftype)
16207 
      else:
16208 
        iprot.skip(ftype)
16209 
      iprot.readFieldEnd()
16210 
    iprot.readStructEnd()
16211 
 
16212 
  def write(self, oprot):
16213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16215 
      return
16216 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
16217 
    if self.ex is not None:
16218 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16219 
      self.ex.write(oprot)
16220 
      oprot.writeFieldEnd()
16221 
    oprot.writeFieldStop()
16222 
    oprot.writeStructEnd()
16223 
 
16224 
  def validate(self):
16225 
    return
16226 
 
16227 
 
16228 
  def __repr__(self):
16229 
    L = ['%s=%r' % (key, value)
16230 
      for key, value in self.__dict__.iteritems()]
16231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16232 
 
16233 
  def __eq__(self, other):
16234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16235 
 
16236 
  def __ne__(self, other):
16237 
    return not (self == other)
16238 
 
4258 rajveer 16239 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 16240 
  """
16241 
  Attributes:
4258 rajveer 16242 
   - transactionId
4247 rajveer 16243 
  """
16244 
 
16245 
  thrift_spec = (
16246 
    None, # 0
4258 rajveer 16247 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 16248 
  )
16249 
 
4258 rajveer 16250 
  def __init__(self, transactionId=None,):
16251 
    self.transactionId = transactionId
4247 rajveer 16252 
 
16253 
  def read(self, iprot):
16254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16256 
      return
16257 
    iprot.readStructBegin()
16258 
    while True:
16259 
      (fname, ftype, fid) = iprot.readFieldBegin()
16260 
      if ftype == TType.STOP:
16261 
        break
16262 
      if fid == 1:
16263 
        if ftype == TType.I64:
4258 rajveer 16264 
          self.transactionId = iprot.readI64();
4247 rajveer 16265 
        else:
16266 
          iprot.skip(ftype)
16267 
      else:
16268 
        iprot.skip(ftype)
16269 
      iprot.readFieldEnd()
16270 
    iprot.readStructEnd()
16271 
 
16272 
  def write(self, oprot):
16273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16275 
      return
4258 rajveer 16276 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
16277 
    if self.transactionId is not None:
16278 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16279 
      oprot.writeI64(self.transactionId)
4247 rajveer 16280 
      oprot.writeFieldEnd()
16281 
    oprot.writeFieldStop()
16282 
    oprot.writeStructEnd()
16283 
 
16284 
  def validate(self):
16285 
    return
16286 
 
16287 
 
16288 
  def __repr__(self):
16289 
    L = ['%s=%r' % (key, value)
16290 
      for key, value in self.__dict__.iteritems()]
16291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16292 
 
16293 
  def __eq__(self, other):
16294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16295 
 
16296 
  def __ne__(self, other):
16297 
    return not (self == other)
16298 
 
4258 rajveer 16299 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 16300 
  """
16301 
  Attributes:
16302 
   - ex
16303 
  """
16304 
 
16305 
  thrift_spec = (
16306 
    None, # 0
16307 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16308 
  )
16309 
 
16310 
  def __init__(self, ex=None,):
16311 
    self.ex = ex
16312 
 
16313 
  def read(self, iprot):
16314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16316 
      return
16317 
    iprot.readStructBegin()
16318 
    while True:
16319 
      (fname, ftype, fid) = iprot.readFieldBegin()
16320 
      if ftype == TType.STOP:
16321 
        break
16322 
      if fid == 1:
16323 
        if ftype == TType.STRUCT:
16324 
          self.ex = TransactionServiceException()
16325 
          self.ex.read(iprot)
16326 
        else:
16327 
          iprot.skip(ftype)
16328 
      else:
16329 
        iprot.skip(ftype)
16330 
      iprot.readFieldEnd()
16331 
    iprot.readStructEnd()
16332 
 
16333 
  def write(self, oprot):
16334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16336 
      return
4258 rajveer 16337 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 16338 
    if self.ex is not None:
16339 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16340 
      self.ex.write(oprot)
16341 
      oprot.writeFieldEnd()
16342 
    oprot.writeFieldStop()
16343 
    oprot.writeStructEnd()
16344 
 
16345 
  def validate(self):
16346 
    return
16347 
 
16348 
 
16349 
  def __repr__(self):
16350 
    L = ['%s=%r' % (key, value)
16351 
      for key, value in self.__dict__.iteritems()]
16352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16353 
 
16354 
  def __eq__(self, other):
16355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16356 
 
16357 
  def __ne__(self, other):
16358 
    return not (self == other)
4259 anupam.sin 16359 
 
16360 
class refundTransaction_args:
16361 
  """
16362 
  Attributes:
16363 
   - transactionId
16364 
   - refundedBy
16365 
   - reason
16366 
  """
16367 
 
16368 
  thrift_spec = (
16369 
    None, # 0
16370 
    (1, TType.I64, 'transactionId', None, None, ), # 1
16371 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
16372 
    (3, TType.STRING, 'reason', None, None, ), # 3
16373 
  )
16374 
 
16375 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
16376 
    self.transactionId = transactionId
16377 
    self.refundedBy = refundedBy
16378 
    self.reason = reason
16379 
 
16380 
  def read(self, iprot):
16381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16383 
      return
16384 
    iprot.readStructBegin()
16385 
    while True:
16386 
      (fname, ftype, fid) = iprot.readFieldBegin()
16387 
      if ftype == TType.STOP:
16388 
        break
16389 
      if fid == 1:
16390 
        if ftype == TType.I64:
16391 
          self.transactionId = iprot.readI64();
16392 
        else:
16393 
          iprot.skip(ftype)
16394 
      elif fid == 2:
16395 
        if ftype == TType.STRING:
16396 
          self.refundedBy = iprot.readString();
16397 
        else:
16398 
          iprot.skip(ftype)
16399 
      elif fid == 3:
16400 
        if ftype == TType.STRING:
16401 
          self.reason = iprot.readString();
16402 
        else:
16403 
          iprot.skip(ftype)
16404 
      else:
16405 
        iprot.skip(ftype)
16406 
      iprot.readFieldEnd()
16407 
    iprot.readStructEnd()
16408 
 
16409 
  def write(self, oprot):
16410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16412 
      return
16413 
    oprot.writeStructBegin('refundTransaction_args')
16414 
    if self.transactionId is not None:
16415 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
16416 
      oprot.writeI64(self.transactionId)
16417 
      oprot.writeFieldEnd()
16418 
    if self.refundedBy is not None:
16419 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
16420 
      oprot.writeString(self.refundedBy)
16421 
      oprot.writeFieldEnd()
16422 
    if self.reason is not None:
16423 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16424 
      oprot.writeString(self.reason)
16425 
      oprot.writeFieldEnd()
16426 
    oprot.writeFieldStop()
16427 
    oprot.writeStructEnd()
16428 
 
16429 
  def validate(self):
16430 
    return
16431 
 
16432 
 
16433 
  def __repr__(self):
16434 
    L = ['%s=%r' % (key, value)
16435 
      for key, value in self.__dict__.iteritems()]
16436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16437 
 
16438 
  def __eq__(self, other):
16439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16440 
 
16441 
  def __ne__(self, other):
16442 
    return not (self == other)
16443 
 
16444 
class refundTransaction_result:
16445 
  """
16446 
  Attributes:
16447 
   - ex
16448 
  """
16449 
 
16450 
  thrift_spec = (
16451 
    None, # 0
16452 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16453 
  )
16454 
 
16455 
  def __init__(self, ex=None,):
16456 
    self.ex = ex
16457 
 
16458 
  def read(self, iprot):
16459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16461 
      return
16462 
    iprot.readStructBegin()
16463 
    while True:
16464 
      (fname, ftype, fid) = iprot.readFieldBegin()
16465 
      if ftype == TType.STOP:
16466 
        break
16467 
      if fid == 1:
16468 
        if ftype == TType.STRUCT:
16469 
          self.ex = TransactionServiceException()
16470 
          self.ex.read(iprot)
16471 
        else:
16472 
          iprot.skip(ftype)
16473 
      else:
16474 
        iprot.skip(ftype)
16475 
      iprot.readFieldEnd()
16476 
    iprot.readStructEnd()
16477 
 
16478 
  def write(self, oprot):
16479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16481 
      return
16482 
    oprot.writeStructBegin('refundTransaction_result')
16483 
    if self.ex is not None:
16484 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16485 
      self.ex.write(oprot)
16486 
      oprot.writeFieldEnd()
16487 
    oprot.writeFieldStop()
16488 
    oprot.writeStructEnd()
16489 
 
16490 
  def validate(self):
16491 
    return
16492 
 
16493 
 
16494 
  def __repr__(self):
16495 
    L = ['%s=%r' % (key, value)
16496 
      for key, value in self.__dict__.iteritems()]
16497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16498 
 
16499 
  def __eq__(self, other):
16500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16501 
 
16502 
  def __ne__(self, other):
16503 
    return not (self == other)
4285 rajveer 16504 
 
4324 mandeep.dh 16505 
class updateShipmentAddress_args:
16506 
  """
16507 
  Attributes:
16508 
   - orderId
16509 
   - addressId
16510 
  """
16511 
 
16512 
  thrift_spec = (
16513 
    None, # 0
16514 
    (1, TType.I64, 'orderId', None, None, ), # 1
16515 
    (2, TType.I64, 'addressId', None, None, ), # 2
16516 
  )
16517 
 
16518 
  def __init__(self, orderId=None, addressId=None,):
16519 
    self.orderId = orderId
16520 
    self.addressId = addressId
16521 
 
16522 
  def read(self, iprot):
16523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16525 
      return
16526 
    iprot.readStructBegin()
16527 
    while True:
16528 
      (fname, ftype, fid) = iprot.readFieldBegin()
16529 
      if ftype == TType.STOP:
16530 
        break
16531 
      if fid == 1:
16532 
        if ftype == TType.I64:
16533 
          self.orderId = iprot.readI64();
16534 
        else:
16535 
          iprot.skip(ftype)
16536 
      elif fid == 2:
16537 
        if ftype == TType.I64:
16538 
          self.addressId = iprot.readI64();
16539 
        else:
16540 
          iprot.skip(ftype)
16541 
      else:
16542 
        iprot.skip(ftype)
16543 
      iprot.readFieldEnd()
16544 
    iprot.readStructEnd()
16545 
 
16546 
  def write(self, oprot):
16547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16549 
      return
16550 
    oprot.writeStructBegin('updateShipmentAddress_args')
16551 
    if self.orderId is not None:
16552 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16553 
      oprot.writeI64(self.orderId)
16554 
      oprot.writeFieldEnd()
16555 
    if self.addressId is not None:
16556 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
16557 
      oprot.writeI64(self.addressId)
16558 
      oprot.writeFieldEnd()
16559 
    oprot.writeFieldStop()
16560 
    oprot.writeStructEnd()
16561 
 
16562 
  def validate(self):
16563 
    return
16564 
 
16565 
 
16566 
  def __repr__(self):
16567 
    L = ['%s=%r' % (key, value)
16568 
      for key, value in self.__dict__.iteritems()]
16569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16570 
 
16571 
  def __eq__(self, other):
16572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16573 
 
16574 
  def __ne__(self, other):
16575 
    return not (self == other)
16576 
 
16577 
class updateShipmentAddress_result:
16578 
  """
16579 
  Attributes:
16580 
   - ex
16581 
  """
16582 
 
16583 
  thrift_spec = (
16584 
    None, # 0
16585 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16586 
  )
16587 
 
16588 
  def __init__(self, ex=None,):
16589 
    self.ex = ex
16590 
 
16591 
  def read(self, iprot):
16592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16594 
      return
16595 
    iprot.readStructBegin()
16596 
    while True:
16597 
      (fname, ftype, fid) = iprot.readFieldBegin()
16598 
      if ftype == TType.STOP:
16599 
        break
16600 
      if fid == 1:
16601 
        if ftype == TType.STRUCT:
16602 
          self.ex = TransactionServiceException()
16603 
          self.ex.read(iprot)
16604 
        else:
16605 
          iprot.skip(ftype)
16606 
      else:
16607 
        iprot.skip(ftype)
16608 
      iprot.readFieldEnd()
16609 
    iprot.readStructEnd()
16610 
 
16611 
  def write(self, oprot):
16612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16614 
      return
16615 
    oprot.writeStructBegin('updateShipmentAddress_result')
16616 
    if self.ex is not None:
16617 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16618 
      self.ex.write(oprot)
16619 
      oprot.writeFieldEnd()
16620 
    oprot.writeFieldStop()
16621 
    oprot.writeStructEnd()
16622 
 
16623 
  def validate(self):
16624 
    return
16625 
 
16626 
 
16627 
  def __repr__(self):
16628 
    L = ['%s=%r' % (key, value)
16629 
      for key, value in self.__dict__.iteritems()]
16630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16631 
 
16632 
  def __eq__(self, other):
16633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16634 
 
16635 
  def __ne__(self, other):
16636 
    return not (self == other)
16637 
 
4285 rajveer 16638 
class acceptOrdersForItemId_args:
16639 
  """
16640 
  Attributes:
16641 
   - itemId
16642 
   - inventory
16643 
  """
16644 
 
16645 
  thrift_spec = (
16646 
    None, # 0
16647 
    (1, TType.I64, 'itemId', None, None, ), # 1
16648 
    (2, TType.I64, 'inventory', None, None, ), # 2
16649 
  )
16650 
 
16651 
  def __init__(self, itemId=None, inventory=None,):
16652 
    self.itemId = itemId
16653 
    self.inventory = inventory
16654 
 
16655 
  def read(self, iprot):
16656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16658 
      return
16659 
    iprot.readStructBegin()
16660 
    while True:
16661 
      (fname, ftype, fid) = iprot.readFieldBegin()
16662 
      if ftype == TType.STOP:
16663 
        break
16664 
      if fid == 1:
16665 
        if ftype == TType.I64:
16666 
          self.itemId = iprot.readI64();
16667 
        else:
16668 
          iprot.skip(ftype)
16669 
      elif fid == 2:
16670 
        if ftype == TType.I64:
16671 
          self.inventory = iprot.readI64();
16672 
        else:
16673 
          iprot.skip(ftype)
16674 
      else:
16675 
        iprot.skip(ftype)
16676 
      iprot.readFieldEnd()
16677 
    iprot.readStructEnd()
16678 
 
16679 
  def write(self, oprot):
16680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16682 
      return
16683 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
16684 
    if self.itemId is not None:
16685 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16686 
      oprot.writeI64(self.itemId)
16687 
      oprot.writeFieldEnd()
16688 
    if self.inventory is not None:
16689 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
16690 
      oprot.writeI64(self.inventory)
16691 
      oprot.writeFieldEnd()
16692 
    oprot.writeFieldStop()
16693 
    oprot.writeStructEnd()
16694 
 
16695 
  def validate(self):
16696 
    return
16697 
 
16698 
 
16699 
  def __repr__(self):
16700 
    L = ['%s=%r' % (key, value)
16701 
      for key, value in self.__dict__.iteritems()]
16702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16703 
 
16704 
  def __eq__(self, other):
16705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16706 
 
16707 
  def __ne__(self, other):
16708 
    return not (self == other)
16709 
 
16710 
class acceptOrdersForItemId_result:
16711 
  """
16712 
  Attributes:
16713 
   - success
16714 
   - ex
16715 
  """
16716 
 
16717 
  thrift_spec = (
16718 
    (0, TType.BOOL, 'success', None, None, ), # 0
16719 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16720 
  )
16721 
 
16722 
  def __init__(self, success=None, ex=None,):
16723 
    self.success = success
16724 
    self.ex = ex
16725 
 
16726 
  def read(self, iprot):
16727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16729 
      return
16730 
    iprot.readStructBegin()
16731 
    while True:
16732 
      (fname, ftype, fid) = iprot.readFieldBegin()
16733 
      if ftype == TType.STOP:
16734 
        break
16735 
      if fid == 0:
16736 
        if ftype == TType.BOOL:
16737 
          self.success = iprot.readBool();
16738 
        else:
16739 
          iprot.skip(ftype)
16740 
      elif fid == 1:
16741 
        if ftype == TType.STRUCT:
16742 
          self.ex = TransactionServiceException()
16743 
          self.ex.read(iprot)
16744 
        else:
16745 
          iprot.skip(ftype)
16746 
      else:
16747 
        iprot.skip(ftype)
16748 
      iprot.readFieldEnd()
16749 
    iprot.readStructEnd()
16750 
 
16751 
  def write(self, oprot):
16752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16754 
      return
16755 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
16756 
    if self.success is not None:
16757 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16758 
      oprot.writeBool(self.success)
16759 
      oprot.writeFieldEnd()
16760 
    if self.ex is not None:
16761 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16762 
      self.ex.write(oprot)
16763 
      oprot.writeFieldEnd()
16764 
    oprot.writeFieldStop()
16765 
    oprot.writeStructEnd()
16766 
 
16767 
  def validate(self):
16768 
    return
16769 
 
16770 
 
16771 
  def __repr__(self):
16772 
    L = ['%s=%r' % (key, value)
16773 
      for key, value in self.__dict__.iteritems()]
16774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16775 
 
16776 
  def __eq__(self, other):
16777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16778 
 
16779 
  def __ne__(self, other):
16780 
    return not (self == other)
4303 rajveer 16781 
 
16782 
class markOrdersAsPORaised_args:
16783 
  """
16784 
  Attributes:
16785 
   - vendorId
16786 
   - itemId
16787 
   - quantity
16788 
   - estimate
4369 rajveer 16789 
   - isReminder
4303 rajveer 16790 
  """
16791 
 
16792 
  thrift_spec = (
16793 
    None, # 0
16794 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16795 
    (2, TType.I64, 'itemId', None, None, ), # 2
16796 
    (3, TType.I64, 'quantity', None, None, ), # 3
16797 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16798 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16799 
  )
16800 
 
4369 rajveer 16801 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16802 
    self.vendorId = vendorId
16803 
    self.itemId = itemId
16804 
    self.quantity = quantity
16805 
    self.estimate = estimate
4369 rajveer 16806 
    self.isReminder = isReminder
4303 rajveer 16807 
 
16808 
  def read(self, iprot):
16809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16811 
      return
16812 
    iprot.readStructBegin()
16813 
    while True:
16814 
      (fname, ftype, fid) = iprot.readFieldBegin()
16815 
      if ftype == TType.STOP:
16816 
        break
16817 
      if fid == 1:
16818 
        if ftype == TType.I64:
16819 
          self.vendorId = iprot.readI64();
16820 
        else:
16821 
          iprot.skip(ftype)
16822 
      elif fid == 2:
16823 
        if ftype == TType.I64:
16824 
          self.itemId = iprot.readI64();
16825 
        else:
16826 
          iprot.skip(ftype)
16827 
      elif fid == 3:
16828 
        if ftype == TType.I64:
16829 
          self.quantity = iprot.readI64();
16830 
        else:
16831 
          iprot.skip(ftype)
16832 
      elif fid == 4:
16833 
        if ftype == TType.I64:
16834 
          self.estimate = iprot.readI64();
16835 
        else:
16836 
          iprot.skip(ftype)
4369 rajveer 16837 
      elif fid == 5:
16838 
        if ftype == TType.BOOL:
16839 
          self.isReminder = iprot.readBool();
16840 
        else:
16841 
          iprot.skip(ftype)
4303 rajveer 16842 
      else:
16843 
        iprot.skip(ftype)
16844 
      iprot.readFieldEnd()
16845 
    iprot.readStructEnd()
16846 
 
16847 
  def write(self, oprot):
16848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16850 
      return
16851 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
16852 
    if self.vendorId is not None:
16853 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
16854 
      oprot.writeI64(self.vendorId)
16855 
      oprot.writeFieldEnd()
16856 
    if self.itemId is not None:
16857 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16858 
      oprot.writeI64(self.itemId)
16859 
      oprot.writeFieldEnd()
16860 
    if self.quantity is not None:
16861 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
16862 
      oprot.writeI64(self.quantity)
16863 
      oprot.writeFieldEnd()
16864 
    if self.estimate is not None:
16865 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
16866 
      oprot.writeI64(self.estimate)
16867 
      oprot.writeFieldEnd()
4369 rajveer 16868 
    if self.isReminder is not None:
16869 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
16870 
      oprot.writeBool(self.isReminder)
16871 
      oprot.writeFieldEnd()
4303 rajveer 16872 
    oprot.writeFieldStop()
16873 
    oprot.writeStructEnd()
16874 
 
16875 
  def validate(self):
16876 
    return
16877 
 
16878 
 
16879 
  def __repr__(self):
16880 
    L = ['%s=%r' % (key, value)
16881 
      for key, value in self.__dict__.iteritems()]
16882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16883 
 
16884 
  def __eq__(self, other):
16885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16886 
 
16887 
  def __ne__(self, other):
16888 
    return not (self == other)
16889 
 
16890 
class markOrdersAsPORaised_result:
16891 
  """
16892 
  Attributes:
16893 
   - ex
16894 
  """
16895 
 
16896 
  thrift_spec = (
16897 
    None, # 0
16898 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16899 
  )
16900 
 
16901 
  def __init__(self, ex=None,):
16902 
    self.ex = ex
16903 
 
16904 
  def read(self, iprot):
16905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16907 
      return
16908 
    iprot.readStructBegin()
16909 
    while True:
16910 
      (fname, ftype, fid) = iprot.readFieldBegin()
16911 
      if ftype == TType.STOP:
16912 
        break
16913 
      if fid == 1:
16914 
        if ftype == TType.STRUCT:
16915 
          self.ex = TransactionServiceException()
16916 
          self.ex.read(iprot)
16917 
        else:
16918 
          iprot.skip(ftype)
16919 
      else:
16920 
        iprot.skip(ftype)
16921 
      iprot.readFieldEnd()
16922 
    iprot.readStructEnd()
16923 
 
16924 
  def write(self, oprot):
16925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16927 
      return
16928 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
16929 
    if self.ex is not None:
16930 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16931 
      self.ex.write(oprot)
16932 
      oprot.writeFieldEnd()
16933 
    oprot.writeFieldStop()
16934 
    oprot.writeStructEnd()
16935 
 
16936 
  def validate(self):
16937 
    return
16938 
 
16939 
 
16940 
  def __repr__(self):
16941 
    L = ['%s=%r' % (key, value)
16942 
      for key, value in self.__dict__.iteritems()]
16943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16944 
 
16945 
  def __eq__(self, other):
16946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16947 
 
16948 
  def __ne__(self, other):
16949 
    return not (self == other)
16950 
 
16951 
class markOrdersAsReversalInitiated_args:
16952 
  """
16953 
  Attributes:
16954 
   - vendorId
16955 
   - itemId
16956 
   - quantity
16957 
   - estimate
4369 rajveer 16958 
   - isReminder
4303 rajveer 16959 
  """
16960 
 
16961 
  thrift_spec = (
16962 
    None, # 0
16963 
    (1, TType.I64, 'vendorId', None, None, ), # 1
16964 
    (2, TType.I64, 'itemId', None, None, ), # 2
16965 
    (3, TType.I64, 'quantity', None, None, ), # 3
16966 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 16967 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 16968 
  )
16969 
 
4369 rajveer 16970 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 16971 
    self.vendorId = vendorId
16972 
    self.itemId = itemId
16973 
    self.quantity = quantity
16974 
    self.estimate = estimate
4369 rajveer 16975 
    self.isReminder = isReminder
4303 rajveer 16976 
 
16977 
  def read(self, iprot):
16978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16980 
      return
16981 
    iprot.readStructBegin()
16982 
    while True:
16983 
      (fname, ftype, fid) = iprot.readFieldBegin()
16984 
      if ftype == TType.STOP:
16985 
        break
16986 
      if fid == 1:
16987 
        if ftype == TType.I64:
16988 
          self.vendorId = iprot.readI64();
16989 
        else:
16990 
          iprot.skip(ftype)
16991 
      elif fid == 2:
16992 
        if ftype == TType.I64:
16993 
          self.itemId = iprot.readI64();
16994 
        else:
16995 
          iprot.skip(ftype)
16996 
      elif fid == 3:
16997 
        if ftype == TType.I64:
16998 
          self.quantity = iprot.readI64();
16999 
        else:
17000 
          iprot.skip(ftype)
17001 
      elif fid == 4:
17002 
        if ftype == TType.I64:
17003 
          self.estimate = iprot.readI64();
17004 
        else:
17005 
          iprot.skip(ftype)
4369 rajveer 17006 
      elif fid == 5:
17007 
        if ftype == TType.BOOL:
17008 
          self.isReminder = iprot.readBool();
17009 
        else:
17010 
          iprot.skip(ftype)
4303 rajveer 17011 
      else:
17012 
        iprot.skip(ftype)
17013 
      iprot.readFieldEnd()
17014 
    iprot.readStructEnd()
17015 
 
17016 
  def write(self, oprot):
17017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17019 
      return
17020 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
17021 
    if self.vendorId is not None:
17022 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17023 
      oprot.writeI64(self.vendorId)
17024 
      oprot.writeFieldEnd()
17025 
    if self.itemId is not None:
17026 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17027 
      oprot.writeI64(self.itemId)
17028 
      oprot.writeFieldEnd()
17029 
    if self.quantity is not None:
17030 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
17031 
      oprot.writeI64(self.quantity)
17032 
      oprot.writeFieldEnd()
17033 
    if self.estimate is not None:
17034 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
17035 
      oprot.writeI64(self.estimate)
17036 
      oprot.writeFieldEnd()
4369 rajveer 17037 
    if self.isReminder is not None:
17038 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
17039 
      oprot.writeBool(self.isReminder)
17040 
      oprot.writeFieldEnd()
4303 rajveer 17041 
    oprot.writeFieldStop()
17042 
    oprot.writeStructEnd()
17043 
 
17044 
  def validate(self):
17045 
    return
17046 
 
17047 
 
17048 
  def __repr__(self):
17049 
    L = ['%s=%r' % (key, value)
17050 
      for key, value in self.__dict__.iteritems()]
17051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17052 
 
17053 
  def __eq__(self, other):
17054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17055 
 
17056 
  def __ne__(self, other):
17057 
    return not (self == other)
17058 
 
17059 
class markOrdersAsReversalInitiated_result:
17060 
  """
17061 
  Attributes:
17062 
   - ex
17063 
  """
17064 
 
17065 
  thrift_spec = (
17066 
    None, # 0
17067 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17068 
  )
17069 
 
17070 
  def __init__(self, ex=None,):
17071 
    self.ex = ex
17072 
 
17073 
  def read(self, iprot):
17074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17076 
      return
17077 
    iprot.readStructBegin()
17078 
    while True:
17079 
      (fname, ftype, fid) = iprot.readFieldBegin()
17080 
      if ftype == TType.STOP:
17081 
        break
17082 
      if fid == 1:
17083 
        if ftype == TType.STRUCT:
17084 
          self.ex = TransactionServiceException()
17085 
          self.ex.read(iprot)
17086 
        else:
17087 
          iprot.skip(ftype)
17088 
      else:
17089 
        iprot.skip(ftype)
17090 
      iprot.readFieldEnd()
17091 
    iprot.readStructEnd()
17092 
 
17093 
  def write(self, oprot):
17094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17096 
      return
17097 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
17098 
    if self.ex is not None:
17099 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17100 
      self.ex.write(oprot)
17101 
      oprot.writeFieldEnd()
17102 
    oprot.writeFieldStop()
17103 
    oprot.writeStructEnd()
17104 
 
17105 
  def validate(self):
17106 
    return
17107 
 
17108 
 
17109 
  def __repr__(self):
17110 
    L = ['%s=%r' % (key, value)
17111 
      for key, value in self.__dict__.iteritems()]
17112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17113 
 
17114 
  def __eq__(self, other):
17115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17116 
 
17117 
  def __ne__(self, other):
17118 
    return not (self == other)
17119 
 
17120 
class markOrdersAsNotAvailabke_args:
17121 
  """
17122 
  Attributes:
17123 
   - vendorId
17124 
   - itemId
17125 
   - quantity
17126 
   - estimate
4369 rajveer 17127 
   - isReminder
4303 rajveer 17128 
  """
17129 
 
17130 
  thrift_spec = (
17131 
    None, # 0
17132 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17133 
    (2, TType.I64, 'itemId', None, None, ), # 2
17134 
    (3, TType.I64, 'quantity', None, None, ), # 3
17135 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 17136 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 17137 
  )
17138 
 
4369 rajveer 17139 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 17140 
    self.vendorId = vendorId
17141 
    self.itemId = itemId
17142 
    self.quantity = quantity
17143 
    self.estimate = estimate
4369 rajveer 17144 
    self.isReminder = isReminder
4303 rajveer 17145 
 
17146 
  def read(self, iprot):
17147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17149 
      return
17150 
    iprot.readStructBegin()
17151 
    while True:
17152 
      (fname, ftype, fid) = iprot.readFieldBegin()
17153 
      if ftype == TType.STOP:
17154 
        break
17155 
      if fid == 1:
17156 
        if ftype == TType.I64:
17157 
          self.vendorId = iprot.readI64();
17158 
        else:
17159 
          iprot.skip(ftype)
17160 
      elif fid == 2:
17161 
        if ftype == TType.I64:
17162 
          self.itemId = iprot.readI64();
17163 
        else:
17164 
          iprot.skip(ftype)
17165 
      elif fid == 3:
17166 
        if ftype == TType.I64:
17167 
          self.quantity = iprot.readI64();
17168 
        else:
17169 
          iprot.skip(ftype)
17170 
      elif fid == 4:
17171 
        if ftype == TType.I64:
17172 
          self.estimate = iprot.readI64();
17173 
        else:
17174 
          iprot.skip(ftype)
4369 rajveer 17175 
      elif fid == 5:
17176 
        if ftype == TType.BOOL:
17177 
          self.isReminder = iprot.readBool();
17178 
        else:
17179 
          iprot.skip(ftype)
4303 rajveer 17180 
      else:
17181 
        iprot.skip(ftype)
17182 
      iprot.readFieldEnd()
17183 
    iprot.readStructEnd()
17184 
 
17185 
  def write(self, oprot):
17186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17188 
      return
17189 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
17190 
    if self.vendorId is not None:
17191 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17192 
      oprot.writeI64(self.vendorId)
17193 
      oprot.writeFieldEnd()
17194 
    if self.itemId is not None:
17195 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
17196 
      oprot.writeI64(self.itemId)
17197 
      oprot.writeFieldEnd()
17198 
    if self.quantity is not None:
17199 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
17200 
      oprot.writeI64(self.quantity)
17201 
      oprot.writeFieldEnd()
17202 
    if self.estimate is not None:
17203 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
17204 
      oprot.writeI64(self.estimate)
17205 
      oprot.writeFieldEnd()
4369 rajveer 17206 
    if self.isReminder is not None:
17207 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
17208 
      oprot.writeBool(self.isReminder)
17209 
      oprot.writeFieldEnd()
4303 rajveer 17210 
    oprot.writeFieldStop()
17211 
    oprot.writeStructEnd()
17212 
 
17213 
  def validate(self):
17214 
    return
17215 
 
17216 
 
17217 
  def __repr__(self):
17218 
    L = ['%s=%r' % (key, value)
17219 
      for key, value in self.__dict__.iteritems()]
17220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17221 
 
17222 
  def __eq__(self, other):
17223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17224 
 
17225 
  def __ne__(self, other):
17226 
    return not (self == other)
17227 
 
17228 
class markOrdersAsNotAvailabke_result:
17229 
  """
17230 
  Attributes:
17231 
   - ex
17232 
  """
17233 
 
17234 
  thrift_spec = (
17235 
    None, # 0
17236 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17237 
  )
17238 
 
17239 
  def __init__(self, ex=None,):
17240 
    self.ex = ex
17241 
 
17242 
  def read(self, iprot):
17243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17245 
      return
17246 
    iprot.readStructBegin()
17247 
    while True:
17248 
      (fname, ftype, fid) = iprot.readFieldBegin()
17249 
      if ftype == TType.STOP:
17250 
        break
17251 
      if fid == 1:
17252 
        if ftype == TType.STRUCT:
17253 
          self.ex = TransactionServiceException()
17254 
          self.ex.read(iprot)
17255 
        else:
17256 
          iprot.skip(ftype)
17257 
      else:
17258 
        iprot.skip(ftype)
17259 
      iprot.readFieldEnd()
17260 
    iprot.readStructEnd()
17261 
 
17262 
  def write(self, oprot):
17263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17265 
      return
17266 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
17267 
    if self.ex is not None:
17268 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17269 
      self.ex.write(oprot)
17270 
      oprot.writeFieldEnd()
17271 
    oprot.writeFieldStop()
17272 
    oprot.writeStructEnd()
17273 
 
17274 
  def validate(self):
17275 
    return
17276 
 
17277 
 
17278 
  def __repr__(self):
17279 
    L = ['%s=%r' % (key, value)
17280 
      for key, value in self.__dict__.iteritems()]
17281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17282 
 
17283 
  def __eq__(self, other):
17284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17285 
 
17286 
  def __ne__(self, other):
17287 
    return not (self == other)
4369 rajveer 17288 
 
17289 
class markOrdersAsTimeout_args:
17290 
  """
17291 
  Attributes:
17292 
   - vendorId
17293 
  """
17294 
 
17295 
  thrift_spec = (
17296 
    None, # 0
17297 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17298 
  )
17299 
 
17300 
  def __init__(self, vendorId=None,):
17301 
    self.vendorId = vendorId
17302 
 
17303 
  def read(self, iprot):
17304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17306 
      return
17307 
    iprot.readStructBegin()
17308 
    while True:
17309 
      (fname, ftype, fid) = iprot.readFieldBegin()
17310 
      if ftype == TType.STOP:
17311 
        break
17312 
      if fid == 1:
17313 
        if ftype == TType.I64:
17314 
          self.vendorId = iprot.readI64();
17315 
        else:
17316 
          iprot.skip(ftype)
17317 
      else:
17318 
        iprot.skip(ftype)
17319 
      iprot.readFieldEnd()
17320 
    iprot.readStructEnd()
17321 
 
17322 
  def write(self, oprot):
17323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17325 
      return
17326 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
17327 
    if self.vendorId is not None:
17328 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17329 
      oprot.writeI64(self.vendorId)
17330 
      oprot.writeFieldEnd()
17331 
    oprot.writeFieldStop()
17332 
    oprot.writeStructEnd()
17333 
 
17334 
  def validate(self):
17335 
    return
17336 
 
17337 
 
17338 
  def __repr__(self):
17339 
    L = ['%s=%r' % (key, value)
17340 
      for key, value in self.__dict__.iteritems()]
17341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17342 
 
17343 
  def __eq__(self, other):
17344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17345 
 
17346 
  def __ne__(self, other):
17347 
    return not (self == other)
17348 
 
17349 
class markOrdersAsTimeout_result:
17350 
  """
17351 
  Attributes:
17352 
   - success
17353 
   - ex
17354 
  """
17355 
 
17356 
  thrift_spec = (
17357 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
17358 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17359 
  )
17360 
 
17361 
  def __init__(self, success=None, ex=None,):
17362 
    self.success = success
17363 
    self.ex = ex
17364 
 
17365 
  def read(self, iprot):
17366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17368 
      return
17369 
    iprot.readStructBegin()
17370 
    while True:
17371 
      (fname, ftype, fid) = iprot.readFieldBegin()
17372 
      if ftype == TType.STOP:
17373 
        break
17374 
      if fid == 0:
17375 
        if ftype == TType.MAP:
17376 
          self.success = {}
4789 rajveer 17377 
          (_ktype299, _vtype300, _size298 ) = iprot.readMapBegin()
17378 
          for _i302 in xrange(_size298):
17379 
            _key303 = iprot.readI32();
17380 
            _val304 = TimeoutSummary()
17381 
            _val304.read(iprot)
17382 
            self.success[_key303] = _val304
4369 rajveer 17383 
          iprot.readMapEnd()
17384 
        else:
17385 
          iprot.skip(ftype)
17386 
      elif fid == 1:
17387 
        if ftype == TType.STRUCT:
17388 
          self.ex = TransactionServiceException()
17389 
          self.ex.read(iprot)
17390 
        else:
17391 
          iprot.skip(ftype)
17392 
      else:
17393 
        iprot.skip(ftype)
17394 
      iprot.readFieldEnd()
17395 
    iprot.readStructEnd()
17396 
 
17397 
  def write(self, oprot):
17398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17400 
      return
17401 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
17402 
    if self.success is not None:
17403 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17404 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
4789 rajveer 17405 
      for kiter305,viter306 in self.success.items():
17406 
        oprot.writeI32(kiter305)
17407 
        viter306.write(oprot)
4369 rajveer 17408 
      oprot.writeMapEnd()
17409 
      oprot.writeFieldEnd()
17410 
    if self.ex is not None:
17411 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17412 
      self.ex.write(oprot)
17413 
      oprot.writeFieldEnd()
17414 
    oprot.writeFieldStop()
17415 
    oprot.writeStructEnd()
17416 
 
17417 
  def validate(self):
17418 
    return
17419 
 
17420 
 
17421 
  def __repr__(self):
17422 
    L = ['%s=%r' % (key, value)
17423 
      for key, value in self.__dict__.iteritems()]
17424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17425 
 
17426 
  def __eq__(self, other):
17427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17428 
 
17429 
  def __ne__(self, other):
17430 
    return not (self == other)
4386 anupam.sin 17431 
 
4662 rajveer 17432 
class markOrderAsLostInTransit_args:
17433 
  """
17434 
  Attributes:
17435 
   - orderId
17436 
  """
17437 
 
17438 
  thrift_spec = (
17439 
    None, # 0
17440 
    (1, TType.I64, 'orderId', None, None, ), # 1
17441 
  )
17442 
 
17443 
  def __init__(self, orderId=None,):
17444 
    self.orderId = orderId
17445 
 
17446 
  def read(self, iprot):
17447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17449 
      return
17450 
    iprot.readStructBegin()
17451 
    while True:
17452 
      (fname, ftype, fid) = iprot.readFieldBegin()
17453 
      if ftype == TType.STOP:
17454 
        break
17455 
      if fid == 1:
17456 
        if ftype == TType.I64:
17457 
          self.orderId = iprot.readI64();
17458 
        else:
17459 
          iprot.skip(ftype)
17460 
      else:
17461 
        iprot.skip(ftype)
17462 
      iprot.readFieldEnd()
17463 
    iprot.readStructEnd()
17464 
 
17465 
  def write(self, oprot):
17466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17468 
      return
17469 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
17470 
    if self.orderId is not None:
17471 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17472 
      oprot.writeI64(self.orderId)
17473 
      oprot.writeFieldEnd()
17474 
    oprot.writeFieldStop()
17475 
    oprot.writeStructEnd()
17476 
 
17477 
  def validate(self):
17478 
    return
17479 
 
17480 
 
17481 
  def __repr__(self):
17482 
    L = ['%s=%r' % (key, value)
17483 
      for key, value in self.__dict__.iteritems()]
17484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17485 
 
17486 
  def __eq__(self, other):
17487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17488 
 
17489 
  def __ne__(self, other):
17490 
    return not (self == other)
17491 
 
17492 
class markOrderAsLostInTransit_result:
17493 
  """
17494 
  Attributes:
17495 
   - success
17496 
   - ex
17497 
  """
17498 
 
17499 
  thrift_spec = (
17500 
    (0, TType.BOOL, 'success', None, None, ), # 0
17501 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17502 
  )
17503 
 
17504 
  def __init__(self, success=None, ex=None,):
17505 
    self.success = success
17506 
    self.ex = ex
17507 
 
17508 
  def read(self, iprot):
17509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17511 
      return
17512 
    iprot.readStructBegin()
17513 
    while True:
17514 
      (fname, ftype, fid) = iprot.readFieldBegin()
17515 
      if ftype == TType.STOP:
17516 
        break
17517 
      if fid == 0:
17518 
        if ftype == TType.BOOL:
17519 
          self.success = iprot.readBool();
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('markOrderAsLostInTransit_result')
17538 
    if self.success is not None:
17539 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17540 
      oprot.writeBool(self.success)
17541 
      oprot.writeFieldEnd()
17542 
    if self.ex is not None:
17543 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17544 
      self.ex.write(oprot)
17545 
      oprot.writeFieldEnd()
17546 
    oprot.writeFieldStop()
17547 
    oprot.writeStructEnd()
17548 
 
17549 
  def validate(self):
17550 
    return
17551 
 
17552 
 
17553 
  def __repr__(self):
17554 
    L = ['%s=%r' % (key, value)
17555 
      for key, value in self.__dict__.iteritems()]
17556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17557 
 
17558 
  def __eq__(self, other):
17559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17560 
 
17561 
  def __ne__(self, other):
17562 
    return not (self == other)
17563 
 
4386 anupam.sin 17564 
class getOrderForAwb_args:
17565 
  """
17566 
  Attributes:
17567 
   - awb
17568 
  """
17569 
 
17570 
  thrift_spec = (
17571 
    None, # 0
17572 
    (1, TType.STRING, 'awb', None, None, ), # 1
17573 
  )
17574 
 
17575 
  def __init__(self, awb=None,):
17576 
    self.awb = awb
17577 
 
17578 
  def read(self, iprot):
17579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17581 
      return
17582 
    iprot.readStructBegin()
17583 
    while True:
17584 
      (fname, ftype, fid) = iprot.readFieldBegin()
17585 
      if ftype == TType.STOP:
17586 
        break
17587 
      if fid == 1:
17588 
        if ftype == TType.STRING:
17589 
          self.awb = iprot.readString();
17590 
        else:
17591 
          iprot.skip(ftype)
17592 
      else:
17593 
        iprot.skip(ftype)
17594 
      iprot.readFieldEnd()
17595 
    iprot.readStructEnd()
17596 
 
17597 
  def write(self, oprot):
17598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17600 
      return
17601 
    oprot.writeStructBegin('getOrderForAwb_args')
17602 
    if self.awb is not None:
17603 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
17604 
      oprot.writeString(self.awb)
17605 
      oprot.writeFieldEnd()
17606 
    oprot.writeFieldStop()
17607 
    oprot.writeStructEnd()
17608 
 
17609 
  def validate(self):
17610 
    return
17611 
 
17612 
 
17613 
  def __repr__(self):
17614 
    L = ['%s=%r' % (key, value)
17615 
      for key, value in self.__dict__.iteritems()]
17616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17617 
 
17618 
  def __eq__(self, other):
17619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17620 
 
17621 
  def __ne__(self, other):
17622 
    return not (self == other)
17623 
 
17624 
class getOrderForAwb_result:
17625 
  """
17626 
  Attributes:
17627 
   - success
17628 
   - ex
17629 
  """
17630 
 
17631 
  thrift_spec = (
17632 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17633 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17634 
  )
17635 
 
17636 
  def __init__(self, success=None, ex=None,):
17637 
    self.success = success
17638 
    self.ex = ex
17639 
 
17640 
  def read(self, iprot):
17641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17643 
      return
17644 
    iprot.readStructBegin()
17645 
    while True:
17646 
      (fname, ftype, fid) = iprot.readFieldBegin()
17647 
      if ftype == TType.STOP:
17648 
        break
17649 
      if fid == 0:
17650 
        if ftype == TType.STRUCT:
17651 
          self.success = Order()
17652 
          self.success.read(iprot)
17653 
        else:
17654 
          iprot.skip(ftype)
17655 
      elif fid == 1:
17656 
        if ftype == TType.STRUCT:
17657 
          self.ex = TransactionServiceException()
17658 
          self.ex.read(iprot)
17659 
        else:
17660 
          iprot.skip(ftype)
17661 
      else:
17662 
        iprot.skip(ftype)
17663 
      iprot.readFieldEnd()
17664 
    iprot.readStructEnd()
17665 
 
17666 
  def write(self, oprot):
17667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17669 
      return
17670 
    oprot.writeStructBegin('getOrderForAwb_result')
17671 
    if self.success is not None:
17672 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17673 
      self.success.write(oprot)
17674 
      oprot.writeFieldEnd()
17675 
    if self.ex is not None:
17676 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17677 
      self.ex.write(oprot)
17678 
      oprot.writeFieldEnd()
17679 
    oprot.writeFieldStop()
17680 
    oprot.writeStructEnd()
17681 
 
17682 
  def validate(self):
17683 
    return
17684 
 
17685 
 
17686 
  def __repr__(self):
17687 
    L = ['%s=%r' % (key, value)
17688 
      for key, value in self.__dict__.iteritems()]
17689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17690 
 
17691 
  def __eq__(self, other):
17692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17693 
 
17694 
  def __ne__(self, other):
17695 
    return not (self == other)
4506 phani.kuma 17696 
 
17697 
class getOrdersForProviderForStatus_args:
17698 
  """
17699 
  Attributes:
17700 
   - logistics_provider_id
17701 
   - order_status
17702 
  """
17703 
 
17704 
  thrift_spec = (
17705 
    None, # 0
17706 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
17707 
    (2, TType.I32, 'order_status', None, None, ), # 2
17708 
  )
17709 
 
17710 
  def __init__(self, logistics_provider_id=None, order_status=None,):
17711 
    self.logistics_provider_id = logistics_provider_id
17712 
    self.order_status = order_status
17713 
 
17714 
  def read(self, iprot):
17715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17717 
      return
17718 
    iprot.readStructBegin()
17719 
    while True:
17720 
      (fname, ftype, fid) = iprot.readFieldBegin()
17721 
      if ftype == TType.STOP:
17722 
        break
17723 
      if fid == 1:
17724 
        if ftype == TType.I64:
17725 
          self.logistics_provider_id = iprot.readI64();
17726 
        else:
17727 
          iprot.skip(ftype)
17728 
      elif fid == 2:
17729 
        if ftype == TType.I32:
17730 
          self.order_status = iprot.readI32();
17731 
        else:
17732 
          iprot.skip(ftype)
17733 
      else:
17734 
        iprot.skip(ftype)
17735 
      iprot.readFieldEnd()
17736 
    iprot.readStructEnd()
17737 
 
17738 
  def write(self, oprot):
17739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17741 
      return
17742 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
17743 
    if self.logistics_provider_id is not None:
17744 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
17745 
      oprot.writeI64(self.logistics_provider_id)
17746 
      oprot.writeFieldEnd()
17747 
    if self.order_status is not None:
17748 
      oprot.writeFieldBegin('order_status', TType.I32, 2)
17749 
      oprot.writeI32(self.order_status)
17750 
      oprot.writeFieldEnd()
17751 
    oprot.writeFieldStop()
17752 
    oprot.writeStructEnd()
17753 
 
17754 
  def validate(self):
17755 
    return
17756 
 
17757 
 
17758 
  def __repr__(self):
17759 
    L = ['%s=%r' % (key, value)
17760 
      for key, value in self.__dict__.iteritems()]
17761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17762 
 
17763 
  def __eq__(self, other):
17764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17765 
 
17766 
  def __ne__(self, other):
17767 
    return not (self == other)
17768 
 
17769 
class getOrdersForProviderForStatus_result:
17770 
  """
17771 
  Attributes:
17772 
   - success
17773 
   - ex
17774 
  """
17775 
 
17776 
  thrift_spec = (
17777 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17778 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17779 
  )
17780 
 
17781 
  def __init__(self, success=None, ex=None,):
17782 
    self.success = success
17783 
    self.ex = ex
17784 
 
17785 
  def read(self, iprot):
17786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17788 
      return
17789 
    iprot.readStructBegin()
17790 
    while True:
17791 
      (fname, ftype, fid) = iprot.readFieldBegin()
17792 
      if ftype == TType.STOP:
17793 
        break
17794 
      if fid == 0:
17795 
        if ftype == TType.LIST:
17796 
          self.success = []
4789 rajveer 17797 
          (_etype310, _size307) = iprot.readListBegin()
17798 
          for _i311 in xrange(_size307):
17799 
            _elem312 = Order()
17800 
            _elem312.read(iprot)
17801 
            self.success.append(_elem312)
4506 phani.kuma 17802 
          iprot.readListEnd()
17803 
        else:
17804 
          iprot.skip(ftype)
17805 
      elif fid == 1:
17806 
        if ftype == TType.STRUCT:
17807 
          self.ex = TransactionServiceException()
17808 
          self.ex.read(iprot)
17809 
        else:
17810 
          iprot.skip(ftype)
17811 
      else:
17812 
        iprot.skip(ftype)
17813 
      iprot.readFieldEnd()
17814 
    iprot.readStructEnd()
17815 
 
17816 
  def write(self, oprot):
17817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17819 
      return
17820 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
17821 
    if self.success is not None:
17822 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17823 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4789 rajveer 17824 
      for iter313 in self.success:
17825 
        iter313.write(oprot)
4506 phani.kuma 17826 
      oprot.writeListEnd()
17827 
      oprot.writeFieldEnd()
17828 
    if self.ex is not None:
17829 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17830 
      self.ex.write(oprot)
17831 
      oprot.writeFieldEnd()
17832 
    oprot.writeFieldStop()
17833 
    oprot.writeStructEnd()
17834 
 
17835 
  def validate(self):
17836 
    return
17837 
 
17838 
 
17839 
  def __repr__(self):
17840 
    L = ['%s=%r' % (key, value)
17841 
      for key, value in self.__dict__.iteritems()]
17842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17843 
 
17844 
  def __eq__(self, other):
17845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17846 
 
17847 
  def __ne__(self, other):
17848 
    return not (self == other)
4600 varun.gupt 17849 
 
17850 
class getBilledOrdersForVendor_args:
17851 
  """
17852 
  Attributes:
17853 
   - vendorId
17854 
   - billingDateFrom
17855 
   - billingDateTo
17856 
  """
17857 
 
17858 
  thrift_spec = (
17859 
    None, # 0
17860 
    (1, TType.I64, 'vendorId', None, None, ), # 1
17861 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
17862 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
17863 
  )
17864 
 
17865 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
17866 
    self.vendorId = vendorId
17867 
    self.billingDateFrom = billingDateFrom
17868 
    self.billingDateTo = billingDateTo
17869 
 
17870 
  def read(self, iprot):
17871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17873 
      return
17874 
    iprot.readStructBegin()
17875 
    while True:
17876 
      (fname, ftype, fid) = iprot.readFieldBegin()
17877 
      if ftype == TType.STOP:
17878 
        break
17879 
      if fid == 1:
17880 
        if ftype == TType.I64:
17881 
          self.vendorId = iprot.readI64();
17882 
        else:
17883 
          iprot.skip(ftype)
17884 
      elif fid == 2:
17885 
        if ftype == TType.I64:
17886 
          self.billingDateFrom = iprot.readI64();
17887 
        else:
17888 
          iprot.skip(ftype)
17889 
      elif fid == 3:
17890 
        if ftype == TType.I64:
17891 
          self.billingDateTo = iprot.readI64();
17892 
        else:
17893 
          iprot.skip(ftype)
17894 
      else:
17895 
        iprot.skip(ftype)
17896 
      iprot.readFieldEnd()
17897 
    iprot.readStructEnd()
17898 
 
17899 
  def write(self, oprot):
17900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17902 
      return
17903 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
17904 
    if self.vendorId is not None:
17905 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
17906 
      oprot.writeI64(self.vendorId)
17907 
      oprot.writeFieldEnd()
17908 
    if self.billingDateFrom is not None:
17909 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
17910 
      oprot.writeI64(self.billingDateFrom)
17911 
      oprot.writeFieldEnd()
17912 
    if self.billingDateTo is not None:
17913 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
17914 
      oprot.writeI64(self.billingDateTo)
17915 
      oprot.writeFieldEnd()
17916 
    oprot.writeFieldStop()
17917 
    oprot.writeStructEnd()
17918 
 
17919 
  def validate(self):
17920 
    return
17921 
 
17922 
 
17923 
  def __repr__(self):
17924 
    L = ['%s=%r' % (key, value)
17925 
      for key, value in self.__dict__.iteritems()]
17926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17927 
 
17928 
  def __eq__(self, other):
17929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17930 
 
17931 
  def __ne__(self, other):
17932 
    return not (self == other)
17933 
 
17934 
class getBilledOrdersForVendor_result:
17935 
  """
17936 
  Attributes:
17937 
   - success
17938 
   - ex
17939 
  """
17940 
 
17941 
  thrift_spec = (
17942 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17943 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17944 
  )
17945 
 
17946 
  def __init__(self, success=None, ex=None,):
17947 
    self.success = success
17948 
    self.ex = ex
17949 
 
17950 
  def read(self, iprot):
17951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17953 
      return
17954 
    iprot.readStructBegin()
17955 
    while True:
17956 
      (fname, ftype, fid) = iprot.readFieldBegin()
17957 
      if ftype == TType.STOP:
17958 
        break
17959 
      if fid == 0:
17960 
        if ftype == TType.LIST:
17961 
          self.success = []
4789 rajveer 17962 
          (_etype317, _size314) = iprot.readListBegin()
17963 
          for _i318 in xrange(_size314):
17964 
            _elem319 = Order()
17965 
            _elem319.read(iprot)
17966 
            self.success.append(_elem319)
4600 varun.gupt 17967 
          iprot.readListEnd()
17968 
        else:
17969 
          iprot.skip(ftype)
17970 
      elif fid == 1:
17971 
        if ftype == TType.STRUCT:
17972 
          self.ex = TransactionServiceException()
17973 
          self.ex.read(iprot)
17974 
        else:
17975 
          iprot.skip(ftype)
17976 
      else:
17977 
        iprot.skip(ftype)
17978 
      iprot.readFieldEnd()
17979 
    iprot.readStructEnd()
17980 
 
17981 
  def write(self, oprot):
17982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17984 
      return
17985 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
17986 
    if self.success is not None:
17987 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17988 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4789 rajveer 17989 
      for iter320 in self.success:
17990 
        iter320.write(oprot)
4600 varun.gupt 17991 
      oprot.writeListEnd()
17992 
      oprot.writeFieldEnd()
17993 
    if self.ex is not None:
17994 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17995 
      self.ex.write(oprot)
17996 
      oprot.writeFieldEnd()
17997 
    oprot.writeFieldStop()
17998 
    oprot.writeStructEnd()
17999 
 
18000 
  def validate(self):
18001 
    return
18002 
 
18003 
 
18004 
  def __repr__(self):
18005 
    L = ['%s=%r' % (key, value)
18006 
      for key, value in self.__dict__.iteritems()]
18007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18008 
 
18009 
  def __eq__(self, other):
18010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18011 
 
18012 
  def __ne__(self, other):
18013 
    return not (self == other)
18014 
 
4607 rajveer 18015 
class getSlippedSippingDateOrders_args:
18016 
 
18017 
  thrift_spec = (
18018 
  )
18019 
 
18020 
  def read(self, iprot):
18021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18023 
      return
18024 
    iprot.readStructBegin()
18025 
    while True:
18026 
      (fname, ftype, fid) = iprot.readFieldBegin()
18027 
      if ftype == TType.STOP:
18028 
        break
18029 
      else:
18030 
        iprot.skip(ftype)
18031 
      iprot.readFieldEnd()
18032 
    iprot.readStructEnd()
18033 
 
18034 
  def write(self, oprot):
18035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18037 
      return
18038 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
18039 
    oprot.writeFieldStop()
18040 
    oprot.writeStructEnd()
18041 
 
18042 
  def validate(self):
18043 
    return
18044 
 
18045 
 
18046 
  def __repr__(self):
18047 
    L = ['%s=%r' % (key, value)
18048 
      for key, value in self.__dict__.iteritems()]
18049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18050 
 
18051 
  def __eq__(self, other):
18052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18053 
 
18054 
  def __ne__(self, other):
18055 
    return not (self == other)
18056 
 
18057 
class getSlippedSippingDateOrders_result:
18058 
  """
18059 
  Attributes:
18060 
   - success
18061 
   - ex
18062 
  """
18063 
 
18064 
  thrift_spec = (
18065 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18066 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18067 
  )
18068 
 
18069 
  def __init__(self, success=None, ex=None,):
18070 
    self.success = success
18071 
    self.ex = ex
18072 
 
18073 
  def read(self, iprot):
18074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18076 
      return
18077 
    iprot.readStructBegin()
18078 
    while True:
18079 
      (fname, ftype, fid) = iprot.readFieldBegin()
18080 
      if ftype == TType.STOP:
18081 
        break
18082 
      if fid == 0:
18083 
        if ftype == TType.LIST:
18084 
          self.success = []
4789 rajveer 18085 
          (_etype324, _size321) = iprot.readListBegin()
18086 
          for _i325 in xrange(_size321):
18087 
            _elem326 = Order()
18088 
            _elem326.read(iprot)
18089 
            self.success.append(_elem326)
4607 rajveer 18090 
          iprot.readListEnd()
18091 
        else:
18092 
          iprot.skip(ftype)
18093 
      elif fid == 1:
18094 
        if ftype == TType.STRUCT:
18095 
          self.ex = TransactionServiceException()
18096 
          self.ex.read(iprot)
18097 
        else:
18098 
          iprot.skip(ftype)
18099 
      else:
18100 
        iprot.skip(ftype)
18101 
      iprot.readFieldEnd()
18102 
    iprot.readStructEnd()
18103 
 
18104 
  def write(self, oprot):
18105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18107 
      return
18108 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
18109 
    if self.success is not None:
18110 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18111 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4789 rajveer 18112 
      for iter327 in self.success:
18113 
        iter327.write(oprot)
4607 rajveer 18114 
      oprot.writeListEnd()
18115 
      oprot.writeFieldEnd()
18116 
    if self.ex is not None:
18117 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18118 
      self.ex.write(oprot)
18119 
      oprot.writeFieldEnd()
18120 
    oprot.writeFieldStop()
18121 
    oprot.writeStructEnd()
18122 
 
18123 
  def validate(self):
18124 
    return
18125 
 
18126 
 
18127 
  def __repr__(self):
18128 
    L = ['%s=%r' % (key, value)
18129 
      for key, value in self.__dict__.iteritems()]
18130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18131 
 
18132 
  def __eq__(self, other):
18133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18134 
 
18135 
  def __ne__(self, other):
18136 
    return not (self == other)
18137 
 
4709 rajveer 18138 
class getCancelledOrders_args:
18139 
  """
18140 
  Attributes:
18141 
   - cancelDateFrom
18142 
   - cancelDateTo
18143 
  """
18144 
 
18145 
  thrift_spec = (
18146 
    None, # 0
18147 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
18148 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
18149 
  )
18150 
 
18151 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
18152 
    self.cancelDateFrom = cancelDateFrom
18153 
    self.cancelDateTo = cancelDateTo
18154 
 
18155 
  def read(self, iprot):
18156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18158 
      return
18159 
    iprot.readStructBegin()
18160 
    while True:
18161 
      (fname, ftype, fid) = iprot.readFieldBegin()
18162 
      if ftype == TType.STOP:
18163 
        break
18164 
      if fid == 1:
18165 
        if ftype == TType.I64:
18166 
          self.cancelDateFrom = iprot.readI64();
18167 
        else:
18168 
          iprot.skip(ftype)
18169 
      elif fid == 2:
18170 
        if ftype == TType.I64:
18171 
          self.cancelDateTo = iprot.readI64();
18172 
        else:
18173 
          iprot.skip(ftype)
18174 
      else:
18175 
        iprot.skip(ftype)
18176 
      iprot.readFieldEnd()
18177 
    iprot.readStructEnd()
18178 
 
18179 
  def write(self, oprot):
18180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18182 
      return
18183 
    oprot.writeStructBegin('getCancelledOrders_args')
18184 
    if self.cancelDateFrom is not None:
18185 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
18186 
      oprot.writeI64(self.cancelDateFrom)
18187 
      oprot.writeFieldEnd()
18188 
    if self.cancelDateTo is not None:
18189 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
18190 
      oprot.writeI64(self.cancelDateTo)
18191 
      oprot.writeFieldEnd()
18192 
    oprot.writeFieldStop()
18193 
    oprot.writeStructEnd()
18194 
 
18195 
  def validate(self):
18196 
    return
18197 
 
18198 
 
18199 
  def __repr__(self):
18200 
    L = ['%s=%r' % (key, value)
18201 
      for key, value in self.__dict__.iteritems()]
18202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18203 
 
18204 
  def __eq__(self, other):
18205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18206 
 
18207 
  def __ne__(self, other):
18208 
    return not (self == other)
18209 
 
18210 
class getCancelledOrders_result:
18211 
  """
18212 
  Attributes:
18213 
   - success
18214 
   - ex
18215 
  """
18216 
 
18217 
  thrift_spec = (
18218 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18219 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18220 
  )
18221 
 
18222 
  def __init__(self, success=None, ex=None,):
18223 
    self.success = success
18224 
    self.ex = ex
18225 
 
18226 
  def read(self, iprot):
18227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18229 
      return
18230 
    iprot.readStructBegin()
18231 
    while True:
18232 
      (fname, ftype, fid) = iprot.readFieldBegin()
18233 
      if ftype == TType.STOP:
18234 
        break
18235 
      if fid == 0:
18236 
        if ftype == TType.LIST:
18237 
          self.success = []
4789 rajveer 18238 
          (_etype331, _size328) = iprot.readListBegin()
18239 
          for _i332 in xrange(_size328):
18240 
            _elem333 = Order()
18241 
            _elem333.read(iprot)
18242 
            self.success.append(_elem333)
4709 rajveer 18243 
          iprot.readListEnd()
18244 
        else:
18245 
          iprot.skip(ftype)
18246 
      elif fid == 1:
18247 
        if ftype == TType.STRUCT:
18248 
          self.ex = TransactionServiceException()
18249 
          self.ex.read(iprot)
18250 
        else:
18251 
          iprot.skip(ftype)
18252 
      else:
18253 
        iprot.skip(ftype)
18254 
      iprot.readFieldEnd()
18255 
    iprot.readStructEnd()
18256 
 
18257 
  def write(self, oprot):
18258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18260 
      return
18261 
    oprot.writeStructBegin('getCancelledOrders_result')
18262 
    if self.success is not None:
18263 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18264 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4789 rajveer 18265 
      for iter334 in self.success:
18266 
        iter334.write(oprot)
4709 rajveer 18267 
      oprot.writeListEnd()
18268 
      oprot.writeFieldEnd()
18269 
    if self.ex is not None:
18270 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18271 
      self.ex.write(oprot)
18272 
      oprot.writeFieldEnd()
18273 
    oprot.writeFieldStop()
18274 
    oprot.writeStructEnd()
18275 
 
18276 
  def validate(self):
18277 
    return
18278 
 
18279 
 
18280 
  def __repr__(self):
18281 
    L = ['%s=%r' % (key, value)
18282 
      for key, value in self.__dict__.iteritems()]
18283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18284 
 
18285 
  def __eq__(self, other):
18286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18287 
 
18288 
  def __ne__(self, other):
18289 
    return not (self == other)
18290 
 
4600 varun.gupt 18291 
class saveBluedartSettlements_args:
18292 
  """
18293 
  Attributes:
18294 
   - mapAWBAndAmount
18295 
  """
18296 
 
18297 
  thrift_spec = (
18298 
    None, # 0
18299 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
18300 
  )
18301 
 
18302 
  def __init__(self, mapAWBAndAmount=None,):
18303 
    self.mapAWBAndAmount = mapAWBAndAmount
18304 
 
18305 
  def read(self, iprot):
18306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18308 
      return
18309 
    iprot.readStructBegin()
18310 
    while True:
18311 
      (fname, ftype, fid) = iprot.readFieldBegin()
18312 
      if ftype == TType.STOP:
18313 
        break
18314 
      if fid == 1:
18315 
        if ftype == TType.MAP:
18316 
          self.mapAWBAndAmount = {}
4789 rajveer 18317 
          (_ktype336, _vtype337, _size335 ) = iprot.readMapBegin()
18318 
          for _i339 in xrange(_size335):
18319 
            _key340 = iprot.readI64();
18320 
            _val341 = iprot.readDouble();
18321 
            self.mapAWBAndAmount[_key340] = _val341
4600 varun.gupt 18322 
          iprot.readMapEnd()
18323 
        else:
18324 
          iprot.skip(ftype)
18325 
      else:
18326 
        iprot.skip(ftype)
18327 
      iprot.readFieldEnd()
18328 
    iprot.readStructEnd()
18329 
 
18330 
  def write(self, oprot):
18331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18333 
      return
18334 
    oprot.writeStructBegin('saveBluedartSettlements_args')
18335 
    if self.mapAWBAndAmount is not None:
18336 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
18337 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
4789 rajveer 18338 
      for kiter342,viter343 in self.mapAWBAndAmount.items():
18339 
        oprot.writeI64(kiter342)
18340 
        oprot.writeDouble(viter343)
4600 varun.gupt 18341 
      oprot.writeMapEnd()
18342 
      oprot.writeFieldEnd()
18343 
    oprot.writeFieldStop()
18344 
    oprot.writeStructEnd()
18345 
 
18346 
  def validate(self):
18347 
    return
18348 
 
18349 
 
18350 
  def __repr__(self):
18351 
    L = ['%s=%r' % (key, value)
18352 
      for key, value in self.__dict__.iteritems()]
18353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18354 
 
18355 
  def __eq__(self, other):
18356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18357 
 
18358 
  def __ne__(self, other):
18359 
    return not (self == other)
18360 
 
18361 
class saveBluedartSettlements_result:
18362 
  """
18363 
  Attributes:
18364 
   - ex
18365 
  """
18366 
 
18367 
  thrift_spec = (
18368 
    None, # 0
18369 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18370 
  )
18371 
 
18372 
  def __init__(self, ex=None,):
18373 
    self.ex = ex
18374 
 
18375 
  def read(self, iprot):
18376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18378 
      return
18379 
    iprot.readStructBegin()
18380 
    while True:
18381 
      (fname, ftype, fid) = iprot.readFieldBegin()
18382 
      if ftype == TType.STOP:
18383 
        break
18384 
      if fid == 1:
18385 
        if ftype == TType.STRUCT:
18386 
          self.ex = TransactionServiceException()
18387 
          self.ex.read(iprot)
18388 
        else:
18389 
          iprot.skip(ftype)
18390 
      else:
18391 
        iprot.skip(ftype)
18392 
      iprot.readFieldEnd()
18393 
    iprot.readStructEnd()
18394 
 
18395 
  def write(self, oprot):
18396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18398 
      return
18399 
    oprot.writeStructBegin('saveBluedartSettlements_result')
18400 
    if self.ex is not None:
18401 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18402 
      self.ex.write(oprot)
18403 
      oprot.writeFieldEnd()
18404 
    oprot.writeFieldStop()
18405 
    oprot.writeStructEnd()
18406 
 
18407 
  def validate(self):
18408 
    return
18409 
 
18410 
 
18411 
  def __repr__(self):
18412 
    L = ['%s=%r' % (key, value)
18413 
      for key, value in self.__dict__.iteritems()]
18414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18415 
 
18416 
  def __eq__(self, other):
18417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18418 
 
18419 
  def __ne__(self, other):
18420 
    return not (self == other)
18421 
 
18422 
class savePaymentSettlements_args:
18423 
  """
18424 
  Attributes:
18425 
   - settlementDate
18426 
   - paymentGatewayId
18427 
   - paymentId
18428 
   - serviceTax
18429 
   - otherCharges
18430 
   - netCollection
18431 
  """
18432 
 
18433 
  thrift_spec = (
18434 
    None, # 0
18435 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
18436 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
18437 
    (3, TType.I64, 'paymentId', None, None, ), # 3
18438 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
18439 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
18440 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
18441 
  )
18442 
 
18443 
  def __init__(self, settlementDate=None, paymentGatewayId=None, paymentId=None, serviceTax=None, otherCharges=None, netCollection=None,):
18444 
    self.settlementDate = settlementDate
18445 
    self.paymentGatewayId = paymentGatewayId
18446 
    self.paymentId = paymentId
18447 
    self.serviceTax = serviceTax
18448 
    self.otherCharges = otherCharges
18449 
    self.netCollection = netCollection
18450 
 
18451 
  def read(self, iprot):
18452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18454 
      return
18455 
    iprot.readStructBegin()
18456 
    while True:
18457 
      (fname, ftype, fid) = iprot.readFieldBegin()
18458 
      if ftype == TType.STOP:
18459 
        break
18460 
      if fid == 1:
18461 
        if ftype == TType.I64:
18462 
          self.settlementDate = iprot.readI64();
18463 
        else:
18464 
          iprot.skip(ftype)
18465 
      elif fid == 2:
18466 
        if ftype == TType.I64:
18467 
          self.paymentGatewayId = iprot.readI64();
18468 
        else:
18469 
          iprot.skip(ftype)
18470 
      elif fid == 3:
18471 
        if ftype == TType.I64:
18472 
          self.paymentId = iprot.readI64();
18473 
        else:
18474 
          iprot.skip(ftype)
18475 
      elif fid == 4:
18476 
        if ftype == TType.DOUBLE:
18477 
          self.serviceTax = iprot.readDouble();
18478 
        else:
18479 
          iprot.skip(ftype)
18480 
      elif fid == 5:
18481 
        if ftype == TType.DOUBLE:
18482 
          self.otherCharges = iprot.readDouble();
18483 
        else:
18484 
          iprot.skip(ftype)
18485 
      elif fid == 6:
18486 
        if ftype == TType.DOUBLE:
18487 
          self.netCollection = iprot.readDouble();
18488 
        else:
18489 
          iprot.skip(ftype)
18490 
      else:
18491 
        iprot.skip(ftype)
18492 
      iprot.readFieldEnd()
18493 
    iprot.readStructEnd()
18494 
 
18495 
  def write(self, oprot):
18496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18498 
      return
18499 
    oprot.writeStructBegin('savePaymentSettlements_args')
18500 
    if self.settlementDate is not None:
18501 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
18502 
      oprot.writeI64(self.settlementDate)
18503 
      oprot.writeFieldEnd()
18504 
    if self.paymentGatewayId is not None:
18505 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
18506 
      oprot.writeI64(self.paymentGatewayId)
18507 
      oprot.writeFieldEnd()
18508 
    if self.paymentId is not None:
18509 
      oprot.writeFieldBegin('paymentId', TType.I64, 3)
18510 
      oprot.writeI64(self.paymentId)
18511 
      oprot.writeFieldEnd()
18512 
    if self.serviceTax is not None:
18513 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
18514 
      oprot.writeDouble(self.serviceTax)
18515 
      oprot.writeFieldEnd()
18516 
    if self.otherCharges is not None:
18517 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
18518 
      oprot.writeDouble(self.otherCharges)
18519 
      oprot.writeFieldEnd()
18520 
    if self.netCollection is not None:
18521 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
18522 
      oprot.writeDouble(self.netCollection)
18523 
      oprot.writeFieldEnd()
18524 
    oprot.writeFieldStop()
18525 
    oprot.writeStructEnd()
18526 
 
18527 
  def validate(self):
18528 
    return
18529 
 
18530 
 
18531 
  def __repr__(self):
18532 
    L = ['%s=%r' % (key, value)
18533 
      for key, value in self.__dict__.iteritems()]
18534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18535 
 
18536 
  def __eq__(self, other):
18537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18538 
 
18539 
  def __ne__(self, other):
18540 
    return not (self == other)
18541 
 
18542 
class savePaymentSettlements_result:
18543 
  """
18544 
  Attributes:
18545 
   - ex
18546 
  """
18547 
 
18548 
  thrift_spec = (
18549 
    None, # 0
18550 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18551 
  )
18552 
 
18553 
  def __init__(self, ex=None,):
18554 
    self.ex = ex
18555 
 
18556 
  def read(self, iprot):
18557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18559 
      return
18560 
    iprot.readStructBegin()
18561 
    while True:
18562 
      (fname, ftype, fid) = iprot.readFieldBegin()
18563 
      if ftype == TType.STOP:
18564 
        break
18565 
      if fid == 1:
18566 
        if ftype == TType.STRUCT:
18567 
          self.ex = TransactionServiceException()
18568 
          self.ex.read(iprot)
18569 
        else:
18570 
          iprot.skip(ftype)
18571 
      else:
18572 
        iprot.skip(ftype)
18573 
      iprot.readFieldEnd()
18574 
    iprot.readStructEnd()
18575 
 
18576 
  def write(self, oprot):
18577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18579 
      return
18580 
    oprot.writeStructBegin('savePaymentSettlements_result')
18581 
    if self.ex is not None:
18582 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18583 
      self.ex.write(oprot)
18584 
      oprot.writeFieldEnd()
18585 
    oprot.writeFieldStop()
18586 
    oprot.writeStructEnd()
18587 
 
18588 
  def validate(self):
18589 
    return
18590 
 
18591 
 
18592 
  def __repr__(self):
18593 
    L = ['%s=%r' % (key, value)
18594 
      for key, value in self.__dict__.iteritems()]
18595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18596 
 
18597 
  def __eq__(self, other):
18598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18599 
 
18600 
  def __ne__(self, other):
18601 
    return not (self == other)
18602 
 
18603 
class saveEBSSettlementSummary_args:
18604 
  """
18605 
  Attributes:
18606 
   - settlementId
18607 
   - settlementDate
18608 
   - transactionDateFrom
18609 
   - transactionDateTo
18610 
   - amount
18611 
  """
18612 
 
18613 
  thrift_spec = (
18614 
    None, # 0
18615 
    (1, TType.I64, 'settlementId', None, None, ), # 1
18616 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
18617 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
18618 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
18619 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
18620 
  )
18621 
 
18622 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
18623 
    self.settlementId = settlementId
18624 
    self.settlementDate = settlementDate
18625 
    self.transactionDateFrom = transactionDateFrom
18626 
    self.transactionDateTo = transactionDateTo
18627 
    self.amount = amount
18628 
 
18629 
  def read(self, iprot):
18630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18632 
      return
18633 
    iprot.readStructBegin()
18634 
    while True:
18635 
      (fname, ftype, fid) = iprot.readFieldBegin()
18636 
      if ftype == TType.STOP:
18637 
        break
18638 
      if fid == 1:
18639 
        if ftype == TType.I64:
18640 
          self.settlementId = iprot.readI64();
18641 
        else:
18642 
          iprot.skip(ftype)
18643 
      elif fid == 2:
18644 
        if ftype == TType.I64:
18645 
          self.settlementDate = iprot.readI64();
18646 
        else:
18647 
          iprot.skip(ftype)
18648 
      elif fid == 3:
18649 
        if ftype == TType.I64:
18650 
          self.transactionDateFrom = iprot.readI64();
18651 
        else:
18652 
          iprot.skip(ftype)
18653 
      elif fid == 4:
18654 
        if ftype == TType.I64:
18655 
          self.transactionDateTo = iprot.readI64();
18656 
        else:
18657 
          iprot.skip(ftype)
18658 
      elif fid == 5:
18659 
        if ftype == TType.DOUBLE:
18660 
          self.amount = iprot.readDouble();
18661 
        else:
18662 
          iprot.skip(ftype)
18663 
      else:
18664 
        iprot.skip(ftype)
18665 
      iprot.readFieldEnd()
18666 
    iprot.readStructEnd()
18667 
 
18668 
  def write(self, oprot):
18669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18671 
      return
18672 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
18673 
    if self.settlementId is not None:
18674 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
18675 
      oprot.writeI64(self.settlementId)
18676 
      oprot.writeFieldEnd()
18677 
    if self.settlementDate is not None:
18678 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
18679 
      oprot.writeI64(self.settlementDate)
18680 
      oprot.writeFieldEnd()
18681 
    if self.transactionDateFrom is not None:
18682 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
18683 
      oprot.writeI64(self.transactionDateFrom)
18684 
      oprot.writeFieldEnd()
18685 
    if self.transactionDateTo is not None:
18686 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
18687 
      oprot.writeI64(self.transactionDateTo)
18688 
      oprot.writeFieldEnd()
18689 
    if self.amount is not None:
18690 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
18691 
      oprot.writeDouble(self.amount)
18692 
      oprot.writeFieldEnd()
18693 
    oprot.writeFieldStop()
18694 
    oprot.writeStructEnd()
18695 
 
18696 
  def validate(self):
18697 
    return
18698 
 
18699 
 
18700 
  def __repr__(self):
18701 
    L = ['%s=%r' % (key, value)
18702 
      for key, value in self.__dict__.iteritems()]
18703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18704 
 
18705 
  def __eq__(self, other):
18706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18707 
 
18708 
  def __ne__(self, other):
18709 
    return not (self == other)
18710 
 
18711 
class saveEBSSettlementSummary_result:
18712 
  """
18713 
  Attributes:
18714 
   - ex
18715 
  """
18716 
 
18717 
  thrift_spec = (
18718 
    None, # 0
18719 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18720 
  )
18721 
 
18722 
  def __init__(self, ex=None,):
18723 
    self.ex = ex
18724 
 
18725 
  def read(self, iprot):
18726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18728 
      return
18729 
    iprot.readStructBegin()
18730 
    while True:
18731 
      (fname, ftype, fid) = iprot.readFieldBegin()
18732 
      if ftype == TType.STOP:
18733 
        break
18734 
      if fid == 1:
18735 
        if ftype == TType.STRUCT:
18736 
          self.ex = TransactionServiceException()
18737 
          self.ex.read(iprot)
18738 
        else:
18739 
          iprot.skip(ftype)
18740 
      else:
18741 
        iprot.skip(ftype)
18742 
      iprot.readFieldEnd()
18743 
    iprot.readStructEnd()
18744 
 
18745 
  def write(self, oprot):
18746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18748 
      return
18749 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
18750 
    if self.ex is not None:
18751 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18752 
      self.ex.write(oprot)
18753 
      oprot.writeFieldEnd()
18754 
    oprot.writeFieldStop()
18755 
    oprot.writeStructEnd()
18756 
 
18757 
  def validate(self):
18758 
    return
18759 
 
18760 
 
18761 
  def __repr__(self):
18762 
    L = ['%s=%r' % (key, value)
18763 
      for key, value in self.__dict__.iteritems()]
18764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18765 
 
18766 
  def __eq__(self, other):
18767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18768 
 
18769 
  def __ne__(self, other):
18770 
    return not (self == other)
18771 
 
18772 
class getSettlementForPaymentId_args:
18773 
  """
18774 
  Attributes:
18775 
   - paymentId
18776 
  """
18777 
 
18778 
  thrift_spec = (
18779 
    None, # 0
18780 
    (1, TType.I64, 'paymentId', None, None, ), # 1
18781 
  )
18782 
 
18783 
  def __init__(self, paymentId=None,):
18784 
    self.paymentId = paymentId
18785 
 
18786 
  def read(self, iprot):
18787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18789 
      return
18790 
    iprot.readStructBegin()
18791 
    while True:
18792 
      (fname, ftype, fid) = iprot.readFieldBegin()
18793 
      if ftype == TType.STOP:
18794 
        break
18795 
      if fid == 1:
18796 
        if ftype == TType.I64:
18797 
          self.paymentId = iprot.readI64();
18798 
        else:
18799 
          iprot.skip(ftype)
18800 
      else:
18801 
        iprot.skip(ftype)
18802 
      iprot.readFieldEnd()
18803 
    iprot.readStructEnd()
18804 
 
18805 
  def write(self, oprot):
18806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18808 
      return
18809 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
18810 
    if self.paymentId is not None:
18811 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
18812 
      oprot.writeI64(self.paymentId)
18813 
      oprot.writeFieldEnd()
18814 
    oprot.writeFieldStop()
18815 
    oprot.writeStructEnd()
18816 
 
18817 
  def validate(self):
18818 
    return
18819 
 
18820 
 
18821 
  def __repr__(self):
18822 
    L = ['%s=%r' % (key, value)
18823 
      for key, value in self.__dict__.iteritems()]
18824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18825 
 
18826 
  def __eq__(self, other):
18827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18828 
 
18829 
  def __ne__(self, other):
18830 
    return not (self == other)
18831 
 
18832 
class getSettlementForPaymentId_result:
18833 
  """
18834 
  Attributes:
18835 
   - success
18836 
   - ex
18837 
  """
18838 
 
18839 
  thrift_spec = (
18840 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
18841 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18842 
  )
18843 
 
18844 
  def __init__(self, success=None, ex=None,):
18845 
    self.success = success
18846 
    self.ex = ex
18847 
 
18848 
  def read(self, iprot):
18849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18851 
      return
18852 
    iprot.readStructBegin()
18853 
    while True:
18854 
      (fname, ftype, fid) = iprot.readFieldBegin()
18855 
      if ftype == TType.STOP:
18856 
        break
18857 
      if fid == 0:
18858 
        if ftype == TType.STRUCT:
18859 
          self.success = PaymentSettlement()
18860 
          self.success.read(iprot)
18861 
        else:
18862 
          iprot.skip(ftype)
18863 
      elif fid == 1:
18864 
        if ftype == TType.STRUCT:
18865 
          self.ex = TransactionServiceException()
18866 
          self.ex.read(iprot)
18867 
        else:
18868 
          iprot.skip(ftype)
18869 
      else:
18870 
        iprot.skip(ftype)
18871 
      iprot.readFieldEnd()
18872 
    iprot.readStructEnd()
18873 
 
18874 
  def write(self, oprot):
18875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18877 
      return
18878 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
18879 
    if self.success is not None:
18880 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18881 
      self.success.write(oprot)
18882 
      oprot.writeFieldEnd()
18883 
    if self.ex is not None:
18884 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18885 
      self.ex.write(oprot)
18886 
      oprot.writeFieldEnd()
18887 
    oprot.writeFieldStop()
18888 
    oprot.writeStructEnd()
18889 
 
18890 
  def validate(self):
18891 
    return
18892 
 
18893 
 
18894 
  def __repr__(self):
18895 
    L = ['%s=%r' % (key, value)
18896 
      for key, value in self.__dict__.iteritems()]
18897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18898 
 
18899 
  def __eq__(self, other):
18900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18901 
 
18902 
  def __ne__(self, other):
18903 
    return not (self == other)
18904 
 
18905 
class getEBSSettlementSummaries_args:
18906 
 
18907 
  thrift_spec = (
18908 
  )
18909 
 
18910 
  def read(self, iprot):
18911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18913 
      return
18914 
    iprot.readStructBegin()
18915 
    while True:
18916 
      (fname, ftype, fid) = iprot.readFieldBegin()
18917 
      if ftype == TType.STOP:
18918 
        break
18919 
      else:
18920 
        iprot.skip(ftype)
18921 
      iprot.readFieldEnd()
18922 
    iprot.readStructEnd()
18923 
 
18924 
  def write(self, oprot):
18925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18927 
      return
18928 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
18929 
    oprot.writeFieldStop()
18930 
    oprot.writeStructEnd()
18931 
 
18932 
  def validate(self):
18933 
    return
18934 
 
18935 
 
18936 
  def __repr__(self):
18937 
    L = ['%s=%r' % (key, value)
18938 
      for key, value in self.__dict__.iteritems()]
18939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18940 
 
18941 
  def __eq__(self, other):
18942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18943 
 
18944 
  def __ne__(self, other):
18945 
    return not (self == other)
18946 
 
18947 
class getEBSSettlementSummaries_result:
18948 
  """
18949 
  Attributes:
18950 
   - success
18951 
   - ex
18952 
  """
18953 
 
18954 
  thrift_spec = (
18955 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
18956 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18957 
  )
18958 
 
18959 
  def __init__(self, success=None, ex=None,):
18960 
    self.success = success
18961 
    self.ex = ex
18962 
 
18963 
  def read(self, iprot):
18964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18966 
      return
18967 
    iprot.readStructBegin()
18968 
    while True:
18969 
      (fname, ftype, fid) = iprot.readFieldBegin()
18970 
      if ftype == TType.STOP:
18971 
        break
18972 
      if fid == 0:
18973 
        if ftype == TType.MAP:
18974 
          self.success = {}
4789 rajveer 18975 
          (_ktype345, _vtype346, _size344 ) = iprot.readMapBegin()
18976 
          for _i348 in xrange(_size344):
18977 
            _key349 = iprot.readI64();
18978 
            _val350 = iprot.readString();
18979 
            self.success[_key349] = _val350
4600 varun.gupt 18980 
          iprot.readMapEnd()
18981 
        else:
18982 
          iprot.skip(ftype)
18983 
      elif fid == 1:
18984 
        if ftype == TType.STRUCT:
18985 
          self.ex = TransactionServiceException()
18986 
          self.ex.read(iprot)
18987 
        else:
18988 
          iprot.skip(ftype)
18989 
      else:
18990 
        iprot.skip(ftype)
18991 
      iprot.readFieldEnd()
18992 
    iprot.readStructEnd()
18993 
 
18994 
  def write(self, oprot):
18995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18997 
      return
18998 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
18999 
    if self.success is not None:
19000 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19001 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
4789 rajveer 19002 
      for kiter351,viter352 in self.success.items():
19003 
        oprot.writeI64(kiter351)
19004 
        oprot.writeString(viter352)
4600 varun.gupt 19005 
      oprot.writeMapEnd()
19006 
      oprot.writeFieldEnd()
19007 
    if self.ex is not None:
19008 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19009 
      self.ex.write(oprot)
19010 
      oprot.writeFieldEnd()
19011 
    oprot.writeFieldStop()
19012 
    oprot.writeStructEnd()
19013 
 
19014 
  def validate(self):
19015 
    return
19016 
 
19017 
 
19018 
  def __repr__(self):
19019 
    L = ['%s=%r' % (key, value)
19020 
      for key, value in self.__dict__.iteritems()]
19021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19022 
 
19023 
  def __eq__(self, other):
19024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19025 
 
19026 
  def __ne__(self, other):
19027 
    return not (self == other)
19028 
 
19029 
class markEBSSettlementUploaded_args:
19030 
  """
19031 
  Attributes:
19032 
   - settlementId
19033 
  """
19034 
 
19035 
  thrift_spec = (
19036 
    None, # 0
19037 
    (1, TType.I64, 'settlementId', None, None, ), # 1
19038 
  )
19039 
 
19040 
  def __init__(self, settlementId=None,):
19041 
    self.settlementId = settlementId
19042 
 
19043 
  def read(self, iprot):
19044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19046 
      return
19047 
    iprot.readStructBegin()
19048 
    while True:
19049 
      (fname, ftype, fid) = iprot.readFieldBegin()
19050 
      if ftype == TType.STOP:
19051 
        break
19052 
      if fid == 1:
19053 
        if ftype == TType.I64:
19054 
          self.settlementId = iprot.readI64();
19055 
        else:
19056 
          iprot.skip(ftype)
19057 
      else:
19058 
        iprot.skip(ftype)
19059 
      iprot.readFieldEnd()
19060 
    iprot.readStructEnd()
19061 
 
19062 
  def write(self, oprot):
19063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19065 
      return
19066 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
19067 
    if self.settlementId is not None:
19068 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
19069 
      oprot.writeI64(self.settlementId)
19070 
      oprot.writeFieldEnd()
19071 
    oprot.writeFieldStop()
19072 
    oprot.writeStructEnd()
19073 
 
19074 
  def validate(self):
19075 
    return
19076 
 
19077 
 
19078 
  def __repr__(self):
19079 
    L = ['%s=%r' % (key, value)
19080 
      for key, value in self.__dict__.iteritems()]
19081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19082 
 
19083 
  def __eq__(self, other):
19084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19085 
 
19086 
  def __ne__(self, other):
19087 
    return not (self == other)
19088 
 
19089 
class markEBSSettlementUploaded_result:
19090 
  """
19091 
  Attributes:
19092 
   - ex
19093 
  """
19094 
 
19095 
  thrift_spec = (
19096 
    None, # 0
19097 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19098 
  )
19099 
 
19100 
  def __init__(self, ex=None,):
19101 
    self.ex = ex
19102 
 
19103 
  def read(self, iprot):
19104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19106 
      return
19107 
    iprot.readStructBegin()
19108 
    while True:
19109 
      (fname, ftype, fid) = iprot.readFieldBegin()
19110 
      if ftype == TType.STOP:
19111 
        break
19112 
      if fid == 1:
19113 
        if ftype == TType.STRUCT:
19114 
          self.ex = TransactionServiceException()
19115 
          self.ex.read(iprot)
19116 
        else:
19117 
          iprot.skip(ftype)
19118 
      else:
19119 
        iprot.skip(ftype)
19120 
      iprot.readFieldEnd()
19121 
    iprot.readStructEnd()
19122 
 
19123 
  def write(self, oprot):
19124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19126 
      return
19127 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
19128 
    if self.ex is not None:
19129 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19130 
      self.ex.write(oprot)
19131 
      oprot.writeFieldEnd()
19132 
    oprot.writeFieldStop()
19133 
    oprot.writeStructEnd()
19134 
 
19135 
  def validate(self):
19136 
    return
19137 
 
19138 
 
19139 
  def __repr__(self):
19140 
    L = ['%s=%r' % (key, value)
19141 
      for key, value in self.__dict__.iteritems()]
19142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19143 
 
19144 
  def __eq__(self, other):
19145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19146 
 
19147 
  def __ne__(self, other):
19148 
    return not (self == other)
19149 
 
19150 
class getEBSSettlementDate_args:
19151 
  """
19152 
  Attributes:
19153 
   - settlementId
19154 
  """
19155 
 
19156 
  thrift_spec = (
19157 
    None, # 0
19158 
    (1, TType.I64, 'settlementId', None, None, ), # 1
19159 
  )
19160 
 
19161 
  def __init__(self, settlementId=None,):
19162 
    self.settlementId = settlementId
19163 
 
19164 
  def read(self, iprot):
19165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19167 
      return
19168 
    iprot.readStructBegin()
19169 
    while True:
19170 
      (fname, ftype, fid) = iprot.readFieldBegin()
19171 
      if ftype == TType.STOP:
19172 
        break
19173 
      if fid == 1:
19174 
        if ftype == TType.I64:
19175 
          self.settlementId = iprot.readI64();
19176 
        else:
19177 
          iprot.skip(ftype)
19178 
      else:
19179 
        iprot.skip(ftype)
19180 
      iprot.readFieldEnd()
19181 
    iprot.readStructEnd()
19182 
 
19183 
  def write(self, oprot):
19184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19186 
      return
19187 
    oprot.writeStructBegin('getEBSSettlementDate_args')
19188 
    if self.settlementId is not None:
19189 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
19190 
      oprot.writeI64(self.settlementId)
19191 
      oprot.writeFieldEnd()
19192 
    oprot.writeFieldStop()
19193 
    oprot.writeStructEnd()
19194 
 
19195 
  def validate(self):
19196 
    return
19197 
 
19198 
 
19199 
  def __repr__(self):
19200 
    L = ['%s=%r' % (key, value)
19201 
      for key, value in self.__dict__.iteritems()]
19202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19203 
 
19204 
  def __eq__(self, other):
19205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19206 
 
19207 
  def __ne__(self, other):
19208 
    return not (self == other)
19209 
 
19210 
class getEBSSettlementDate_result:
19211 
  """
19212 
  Attributes:
19213 
   - success
19214 
   - ex
19215 
  """
19216 
 
19217 
  thrift_spec = (
19218 
    (0, TType.I64, 'success', None, None, ), # 0
19219 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19220 
  )
19221 
 
19222 
  def __init__(self, success=None, ex=None,):
19223 
    self.success = success
19224 
    self.ex = ex
19225 
 
19226 
  def read(self, iprot):
19227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19229 
      return
19230 
    iprot.readStructBegin()
19231 
    while True:
19232 
      (fname, ftype, fid) = iprot.readFieldBegin()
19233 
      if ftype == TType.STOP:
19234 
        break
19235 
      if fid == 0:
19236 
        if ftype == TType.I64:
19237 
          self.success = iprot.readI64();
19238 
        else:
19239 
          iprot.skip(ftype)
19240 
      elif fid == 1:
19241 
        if ftype == TType.STRUCT:
19242 
          self.ex = TransactionServiceException()
19243 
          self.ex.read(iprot)
19244 
        else:
19245 
          iprot.skip(ftype)
19246 
      else:
19247 
        iprot.skip(ftype)
19248 
      iprot.readFieldEnd()
19249 
    iprot.readStructEnd()
19250 
 
19251 
  def write(self, oprot):
19252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19254 
      return
19255 
    oprot.writeStructBegin('getEBSSettlementDate_result')
19256 
    if self.success is not None:
19257 
      oprot.writeFieldBegin('success', TType.I64, 0)
19258 
      oprot.writeI64(self.success)
19259 
      oprot.writeFieldEnd()
19260 
    if self.ex is not None:
19261 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19262 
      self.ex.write(oprot)
19263 
      oprot.writeFieldEnd()
19264 
    oprot.writeFieldStop()
19265 
    oprot.writeStructEnd()
19266 
 
19267 
  def validate(self):
19268 
    return
19269 
 
19270 
 
19271 
  def __repr__(self):
19272 
    L = ['%s=%r' % (key, value)
19273 
      for key, value in self.__dict__.iteritems()]
19274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19275 
 
19276 
  def __eq__(self, other):
19277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19278 
 
19279 
  def __ne__(self, other):
19280 
    return not (self == other)
4715 varun.gupt 19281 
 
19282 
class getSettlementsByDate_args:
19283 
  """
19284 
  Attributes:
19285 
   - settlementDateFrom
19286 
   - settlementDateTo
19287 
   - isRefund
19288 
  """
19289 
 
19290 
  thrift_spec = (
19291 
    None, # 0
19292 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
19293 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
19294 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
19295 
  )
19296 
 
19297 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
19298 
    self.settlementDateFrom = settlementDateFrom
19299 
    self.settlementDateTo = settlementDateTo
19300 
    self.isRefund = isRefund
19301 
 
19302 
  def read(self, iprot):
19303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19305 
      return
19306 
    iprot.readStructBegin()
19307 
    while True:
19308 
      (fname, ftype, fid) = iprot.readFieldBegin()
19309 
      if ftype == TType.STOP:
19310 
        break
19311 
      if fid == 1:
19312 
        if ftype == TType.I64:
19313 
          self.settlementDateFrom = iprot.readI64();
19314 
        else:
19315 
          iprot.skip(ftype)
19316 
      elif fid == 2:
19317 
        if ftype == TType.I64:
19318 
          self.settlementDateTo = iprot.readI64();
19319 
        else:
19320 
          iprot.skip(ftype)
19321 
      elif fid == 3:
19322 
        if ftype == TType.BOOL:
19323 
          self.isRefund = iprot.readBool();
19324 
        else:
19325 
          iprot.skip(ftype)
19326 
      else:
19327 
        iprot.skip(ftype)
19328 
      iprot.readFieldEnd()
19329 
    iprot.readStructEnd()
19330 
 
19331 
  def write(self, oprot):
19332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19334 
      return
19335 
    oprot.writeStructBegin('getSettlementsByDate_args')
19336 
    if self.settlementDateFrom is not None:
19337 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
19338 
      oprot.writeI64(self.settlementDateFrom)
19339 
      oprot.writeFieldEnd()
19340 
    if self.settlementDateTo is not None:
19341 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
19342 
      oprot.writeI64(self.settlementDateTo)
19343 
      oprot.writeFieldEnd()
19344 
    if self.isRefund is not None:
19345 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
19346 
      oprot.writeBool(self.isRefund)
19347 
      oprot.writeFieldEnd()
19348 
    oprot.writeFieldStop()
19349 
    oprot.writeStructEnd()
19350 
 
19351 
  def validate(self):
19352 
    return
19353 
 
19354 
 
19355 
  def __repr__(self):
19356 
    L = ['%s=%r' % (key, value)
19357 
      for key, value in self.__dict__.iteritems()]
19358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19359 
 
19360 
  def __eq__(self, other):
19361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19362 
 
19363 
  def __ne__(self, other):
19364 
    return not (self == other)
19365 
 
19366 
class getSettlementsByDate_result:
19367 
  """
19368 
  Attributes:
19369 
   - success
19370 
   - ex
19371 
  """
19372 
 
19373 
  thrift_spec = (
19374 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
19375 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19376 
  )
19377 
 
19378 
  def __init__(self, success=None, ex=None,):
19379 
    self.success = success
19380 
    self.ex = ex
19381 
 
19382 
  def read(self, iprot):
19383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19385 
      return
19386 
    iprot.readStructBegin()
19387 
    while True:
19388 
      (fname, ftype, fid) = iprot.readFieldBegin()
19389 
      if ftype == TType.STOP:
19390 
        break
19391 
      if fid == 0:
19392 
        if ftype == TType.LIST:
19393 
          self.success = []
4789 rajveer 19394 
          (_etype356, _size353) = iprot.readListBegin()
19395 
          for _i357 in xrange(_size353):
19396 
            _elem358 = PaymentSettlement()
19397 
            _elem358.read(iprot)
19398 
            self.success.append(_elem358)
4715 varun.gupt 19399 
          iprot.readListEnd()
19400 
        else:
19401 
          iprot.skip(ftype)
19402 
      elif fid == 1:
19403 
        if ftype == TType.STRUCT:
19404 
          self.ex = TransactionServiceException()
19405 
          self.ex.read(iprot)
19406 
        else:
19407 
          iprot.skip(ftype)
19408 
      else:
19409 
        iprot.skip(ftype)
19410 
      iprot.readFieldEnd()
19411 
    iprot.readStructEnd()
19412 
 
19413 
  def write(self, oprot):
19414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19416 
      return
19417 
    oprot.writeStructBegin('getSettlementsByDate_result')
19418 
    if self.success is not None:
19419 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19420 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4789 rajveer 19421 
      for iter359 in self.success:
19422 
        iter359.write(oprot)
4715 varun.gupt 19423 
      oprot.writeListEnd()
19424 
      oprot.writeFieldEnd()
19425 
    if self.ex is not None:
19426 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19427 
      self.ex.write(oprot)
19428 
      oprot.writeFieldEnd()
19429 
    oprot.writeFieldStop()
19430 
    oprot.writeStructEnd()
19431 
 
19432 
  def validate(self):
19433 
    return
19434 
 
19435 
 
19436 
  def __repr__(self):
19437 
    L = ['%s=%r' % (key, value)
19438 
      for key, value in self.__dict__.iteritems()]
19439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19440 
 
19441 
  def __eq__(self, other):
19442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19443 
 
19444 
  def __ne__(self, other):
19445 
    return not (self == other)
19446 
 
19447 
class getReshippedOrderIds_args:
19448 
  """
19449 
  Attributes:
19450 
   - orderIds
19451 
  """
19452 
 
19453 
  thrift_spec = (
19454 
    None, # 0
19455 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
19456 
  )
19457 
 
19458 
  def __init__(self, orderIds=None,):
19459 
    self.orderIds = orderIds
19460 
 
19461 
  def read(self, iprot):
19462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19464 
      return
19465 
    iprot.readStructBegin()
19466 
    while True:
19467 
      (fname, ftype, fid) = iprot.readFieldBegin()
19468 
      if ftype == TType.STOP:
19469 
        break
19470 
      if fid == 1:
19471 
        if ftype == TType.LIST:
19472 
          self.orderIds = []
4789 rajveer 19473 
          (_etype363, _size360) = iprot.readListBegin()
19474 
          for _i364 in xrange(_size360):
19475 
            _elem365 = iprot.readI64();
19476 
            self.orderIds.append(_elem365)
4715 varun.gupt 19477 
          iprot.readListEnd()
19478 
        else:
19479 
          iprot.skip(ftype)
19480 
      else:
19481 
        iprot.skip(ftype)
19482 
      iprot.readFieldEnd()
19483 
    iprot.readStructEnd()
19484 
 
19485 
  def write(self, oprot):
19486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19488 
      return
19489 
    oprot.writeStructBegin('getReshippedOrderIds_args')
19490 
    if self.orderIds is not None:
19491 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
19492 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
4789 rajveer 19493 
      for iter366 in self.orderIds:
19494 
        oprot.writeI64(iter366)
4715 varun.gupt 19495 
      oprot.writeListEnd()
19496 
      oprot.writeFieldEnd()
19497 
    oprot.writeFieldStop()
19498 
    oprot.writeStructEnd()
19499 
 
19500 
  def validate(self):
19501 
    return
19502 
 
19503 
 
19504 
  def __repr__(self):
19505 
    L = ['%s=%r' % (key, value)
19506 
      for key, value in self.__dict__.iteritems()]
19507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19508 
 
19509 
  def __eq__(self, other):
19510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19511 
 
19512 
  def __ne__(self, other):
19513 
    return not (self == other)
19514 
 
19515 
class getReshippedOrderIds_result:
19516 
  """
19517 
  Attributes:
19518 
   - success
19519 
   - ex
19520 
  """
19521 
 
19522 
  thrift_spec = (
19523 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19524 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19525 
  )
19526 
 
19527 
  def __init__(self, success=None, ex=None,):
19528 
    self.success = success
19529 
    self.ex = ex
19530 
 
19531 
  def read(self, iprot):
19532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19534 
      return
19535 
    iprot.readStructBegin()
19536 
    while True:
19537 
      (fname, ftype, fid) = iprot.readFieldBegin()
19538 
      if ftype == TType.STOP:
19539 
        break
19540 
      if fid == 0:
19541 
        if ftype == TType.LIST:
19542 
          self.success = []
4789 rajveer 19543 
          (_etype370, _size367) = iprot.readListBegin()
19544 
          for _i371 in xrange(_size367):
19545 
            _elem372 = iprot.readI64();
19546 
            self.success.append(_elem372)
4715 varun.gupt 19547 
          iprot.readListEnd()
19548 
        else:
19549 
          iprot.skip(ftype)
19550 
      elif fid == 1:
19551 
        if ftype == TType.STRUCT:
19552 
          self.ex = TransactionServiceException()
19553 
          self.ex.read(iprot)
19554 
        else:
19555 
          iprot.skip(ftype)
19556 
      else:
19557 
        iprot.skip(ftype)
19558 
      iprot.readFieldEnd()
19559 
    iprot.readStructEnd()
19560 
 
19561 
  def write(self, oprot):
19562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19564 
      return
19565 
    oprot.writeStructBegin('getReshippedOrderIds_result')
19566 
    if self.success is not None:
19567 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19568 
      oprot.writeListBegin(TType.I64, len(self.success))
4789 rajveer 19569 
      for iter373 in self.success:
19570 
        oprot.writeI64(iter373)
4715 varun.gupt 19571 
      oprot.writeListEnd()
19572 
      oprot.writeFieldEnd()
19573 
    if self.ex is not None:
19574 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19575 
      self.ex.write(oprot)
19576 
      oprot.writeFieldEnd()
19577 
    oprot.writeFieldStop()
19578 
    oprot.writeStructEnd()
19579 
 
19580 
  def validate(self):
19581 
    return
19582 
 
19583 
 
19584 
  def __repr__(self):
19585 
    L = ['%s=%r' % (key, value)
19586 
      for key, value in self.__dict__.iteritems()]
19587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19588 
 
19589 
  def __eq__(self, other):
19590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19591 
 
19592 
  def __ne__(self, other):
19593 
    return not (self == other)
4757 mandeep.dh 19594 
 
19595 
class updateOrdersAsPORaised_args:
19596 
  """
19597 
  Attributes:
19598 
   - itemIdQuantityMap
19599 
   - purchaseOrderId
19600 
   - warehouseId
19601 
  """
19602 
 
19603 
  thrift_spec = (
19604 
    None, # 0
19605 
    (1, TType.MAP, 'itemIdQuantityMap', (TType.I64,None,TType.I64,None), None, ), # 1
19606 
    (2, TType.I64, 'purchaseOrderId', None, None, ), # 2
19607 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
19608 
  )
19609 
 
19610 
  def __init__(self, itemIdQuantityMap=None, purchaseOrderId=None, warehouseId=None,):
19611 
    self.itemIdQuantityMap = itemIdQuantityMap
19612 
    self.purchaseOrderId = purchaseOrderId
19613 
    self.warehouseId = warehouseId
19614 
 
19615 
  def read(self, iprot):
19616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19618 
      return
19619 
    iprot.readStructBegin()
19620 
    while True:
19621 
      (fname, ftype, fid) = iprot.readFieldBegin()
19622 
      if ftype == TType.STOP:
19623 
        break
19624 
      if fid == 1:
19625 
        if ftype == TType.MAP:
19626 
          self.itemIdQuantityMap = {}
4789 rajveer 19627 
          (_ktype375, _vtype376, _size374 ) = iprot.readMapBegin()
19628 
          for _i378 in xrange(_size374):
19629 
            _key379 = iprot.readI64();
19630 
            _val380 = iprot.readI64();
19631 
            self.itemIdQuantityMap[_key379] = _val380
4757 mandeep.dh 19632 
          iprot.readMapEnd()
19633 
        else:
19634 
          iprot.skip(ftype)
19635 
      elif fid == 2:
19636 
        if ftype == TType.I64:
19637 
          self.purchaseOrderId = iprot.readI64();
19638 
        else:
19639 
          iprot.skip(ftype)
19640 
      elif fid == 3:
19641 
        if ftype == TType.I64:
19642 
          self.warehouseId = iprot.readI64();
19643 
        else:
19644 
          iprot.skip(ftype)
19645 
      else:
19646 
        iprot.skip(ftype)
19647 
      iprot.readFieldEnd()
19648 
    iprot.readStructEnd()
19649 
 
19650 
  def write(self, oprot):
19651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19653 
      return
19654 
    oprot.writeStructBegin('updateOrdersAsPORaised_args')
19655 
    if self.itemIdQuantityMap is not None:
19656 
      oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
19657 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
4789 rajveer 19658 
      for kiter381,viter382 in self.itemIdQuantityMap.items():
19659 
        oprot.writeI64(kiter381)
19660 
        oprot.writeI64(viter382)
4757 mandeep.dh 19661 
      oprot.writeMapEnd()
19662 
      oprot.writeFieldEnd()
19663 
    if self.purchaseOrderId is not None:
19664 
      oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
19665 
      oprot.writeI64(self.purchaseOrderId)
19666 
      oprot.writeFieldEnd()
19667 
    if self.warehouseId is not None:
19668 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
19669 
      oprot.writeI64(self.warehouseId)
19670 
      oprot.writeFieldEnd()
19671 
    oprot.writeFieldStop()
19672 
    oprot.writeStructEnd()
19673 
 
19674 
  def validate(self):
19675 
    return
19676 
 
19677 
 
19678 
  def __repr__(self):
19679 
    L = ['%s=%r' % (key, value)
19680 
      for key, value in self.__dict__.iteritems()]
19681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19682 
 
19683 
  def __eq__(self, other):
19684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19685 
 
19686 
  def __ne__(self, other):
19687 
    return not (self == other)
19688 
 
19689 
class updateOrdersAsPORaised_result:
19690 
  """
19691 
  Attributes:
19692 
   - ex
19693 
  """
19694 
 
19695 
  thrift_spec = (
19696 
    None, # 0
19697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19698 
  )
19699 
 
19700 
  def __init__(self, ex=None,):
19701 
    self.ex = ex
19702 
 
19703 
  def read(self, iprot):
19704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19706 
      return
19707 
    iprot.readStructBegin()
19708 
    while True:
19709 
      (fname, ftype, fid) = iprot.readFieldBegin()
19710 
      if ftype == TType.STOP:
19711 
        break
19712 
      if fid == 1:
19713 
        if ftype == TType.STRUCT:
19714 
          self.ex = TransactionServiceException()
19715 
          self.ex.read(iprot)
19716 
        else:
19717 
          iprot.skip(ftype)
19718 
      else:
19719 
        iprot.skip(ftype)
19720 
      iprot.readFieldEnd()
19721 
    iprot.readStructEnd()
19722 
 
19723 
  def write(self, oprot):
19724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19726 
      return
19727 
    oprot.writeStructBegin('updateOrdersAsPORaised_result')
19728 
    if self.ex is not None:
19729 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19730 
      self.ex.write(oprot)
19731 
      oprot.writeFieldEnd()
19732 
    oprot.writeFieldStop()
19733 
    oprot.writeStructEnd()
19734 
 
19735 
  def validate(self):
19736 
    return
19737 
 
19738 
 
19739 
  def __repr__(self):
19740 
    L = ['%s=%r' % (key, value)
19741 
      for key, value in self.__dict__.iteritems()]
19742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19743 
 
19744 
  def __eq__(self, other):
19745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19746 
 
19747 
  def __ne__(self, other):
19748 
    return not (self == other)